Make <boost/detail/iomanip.hpp> include <iomanip> and put the <iomanip> functions

in the boost::detail namespace if not on clang- or intel-linux.



[SVN r68165]
This commit is contained in:
Bryce Adelstein-Lelbach
2011-01-15 02:23:46 +00:00
parent 74a47fbf05
commit e3049b1480

View File

@@ -8,218 +8,239 @@
#ifndef BOOST_DETAIL_IOMANIP_HPP #ifndef BOOST_DETAIL_IOMANIP_HPP
#define BOOST_DETAIL_IOMANIP_HPP #define BOOST_DETAIL_IOMANIP_HPP
#include <ios> #include <boost/config.hpp>
#include <istream>
#include <ostream>
namespace boost { #if (defined(BOOST_CLANG) || defined(BOOST_INTEL_LINUX)) && \
namespace detail { defined(BOOST_GNU_STDLIB)
#include <ios>
#include <istream>
#include <ostream>
//[resetiosflags namespace boost {
class resetiosflags_manip { namespace detail {
private:
std::ios_base::fmtflags mask;
public: //[resetiosflags
explicit resetiosflags_manip (std::ios_base::fmtflags m): class resetiosflags_manip {
mask(m) { } private:
std::ios_base::fmtflags mask;
template<class CharT, class Traits> public:
friend std::basic_istream<CharT, Traits>& explicit resetiosflags_manip (std::ios_base::fmtflags m):
operator>> (std::basic_istream<CharT, Traits>& is, mask(m) { }
resetiosflags_manip const& x)
{
is.unsetf(x.mask);
return is;
}
template<class CharT, class Traits> template<class CharT, class Traits>
friend std::basic_ostream<CharT, Traits>& friend std::basic_istream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os, operator>> (std::basic_istream<CharT, Traits>& is,
resetiosflags_manip const& x) resetiosflags_manip const& x)
{ {
os.unsetf(x.mask); is.unsetf(x.mask);
return os; return is;
}
};
inline resetiosflags_manip resetiosflags (std::ios_base::fmtflags mask) {
return resetiosflags_manip(mask);
}
//]
//[setiosflags
class setiosflags_manip {
private:
std::ios_base::fmtflags mask;
public:
explicit setiosflags_manip (std::ios_base::fmtflags m):
mask(m) { }
template<class CharT, class Traits>
friend std::basic_istream<CharT, Traits>&
operator>> (std::basic_istream<CharT, Traits>& is,
setiosflags_manip const& x) {
is.setf(x.mask);
return is;
}
template<class CharT, class Traits>
friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os,
setiosflags_manip const& x) {
os.setf(x.mask);
return os;
}
};
inline setiosflags_manip setiosflags (std::ios_base::fmtflags mask) {
return setiosflags_manip(mask);
}
//]
//[setbase
class setbase_manip {
private:
int base;
public:
explicit setbase_manip (int b):
base(b) { }
template<class CharT, class Traits>
friend std::basic_istream<CharT, Traits>&
operator>> (std::basic_istream<CharT, Traits>& is, setbase_manip const& x) {
using namespace std;
switch (x.base) {
case 8:
is << std::oct;
return is;
case 10:
is << std::dec;
return is;
case 16:
is << std::hex;
return is;
default:
is.setf(ios_base::fmtflags(0), ios_base::basefield);
return is;
} }
}
template <class CharT, class Traits> template<class CharT, class Traits>
friend std::basic_ostream<CharT, Traits>& friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os, setbase_manip const& x) { operator<< (std::basic_ostream<CharT, Traits>& os,
using namespace std; resetiosflags_manip const& x)
switch (x.base) { {
case 8: os.unsetf(x.mask);
os << std::oct; return os;
return os;
case 10:
os << std::dec;
return os;
case 16:
os << std::hex;
return os;
default:
os.setf(ios_base::fmtflags(0), ios_base::basefield);
return os;
} }
};
inline resetiosflags_manip resetiosflags (std::ios_base::fmtflags mask) {
return resetiosflags_manip(mask);
} }
}; //]
inline setbase_manip setbase (int base) { //[setiosflags
return setbase_manip(base); class setiosflags_manip {
} private:
//] std::ios_base::fmtflags mask;
//[setfill public:
template<class CharT> explicit setiosflags_manip (std::ios_base::fmtflags m):
class setfill_manip { mask(m) { }
private:
CharT fill;
public: template<class CharT, class Traits>
explicit setfill_manip (CharT c): friend std::basic_istream<CharT, Traits>&
fill(c) { } operator>> (std::basic_istream<CharT, Traits>& is,
setiosflags_manip const& x) {
is.setf(x.mask);
return is;
}
template<class Traits> template<class CharT, class Traits>
friend std::basic_ostream<CharT, Traits>& friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os, setfill_manip const& x) { operator<< (std::basic_ostream<CharT, Traits>& os,
os.fill(x.fill); setiosflags_manip const& x) {
return os; os.setf(x.mask);
return os;
}
};
inline setiosflags_manip setiosflags (std::ios_base::fmtflags mask) {
return setiosflags_manip(mask);
} }
}; //]
template<class CharT> //[setbase
inline setfill_manip<CharT> setfill (CharT c) { class setbase_manip {
return setfill_manip<CharT>(c); private:
} int base;
//]
//[setprecision public:
class setprecision_manip { explicit setbase_manip (int b):
private: base(b) { }
int n;
public: template<class CharT, class Traits>
explicit setprecision_manip (int n_): friend std::basic_istream<CharT, Traits>&
n(n_) { } operator>> (std::basic_istream<CharT, Traits>& is, setbase_manip const& x) {
using namespace std;
switch (x.base) {
case 8:
is << std::oct;
return is;
case 10:
is << std::dec;
return is;
case 16:
is << std::hex;
return is;
default:
is.setf(ios_base::fmtflags(0), ios_base::basefield);
return is;
}
}
template<class CharT, class Traits> template <class CharT, class Traits>
friend std::basic_istream<CharT, Traits>& friend std::basic_ostream<CharT, Traits>&
operator>> (std::basic_istream<CharT, Traits>& is, operator<< (std::basic_ostream<CharT, Traits>& os, setbase_manip const& x) {
setprecision_manip const& x) { using namespace std;
is.precision(x.n); switch (x.base) {
return is; case 8:
os << std::oct;
return os;
case 10:
os << std::dec;
return os;
case 16:
os << std::hex;
return os;
default:
os.setf(ios_base::fmtflags(0), ios_base::basefield);
return os;
}
}
};
inline setbase_manip setbase (int base) {
return setbase_manip(base);
} }
//]
template<class CharT, class Traits> //[setfill
friend std::basic_ostream<CharT, Traits>& template<class CharT>
operator<< (std::basic_ostream<CharT, Traits>& os, class setfill_manip {
setprecision_manip const& x) { private:
os.precision(x.n); CharT fill;
return os;
public:
explicit setfill_manip (CharT c):
fill(c) { }
template<class Traits>
friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os, setfill_manip const& x) {
os.fill(x.fill);
return os;
}
};
template<class CharT>
inline setfill_manip<CharT> setfill (CharT c) {
return setfill_manip<CharT>(c);
} }
}; //]
inline setprecision_manip setprecision (int n_) { //[setprecision
return setprecision_manip(n_); class setprecision_manip {
} private:
//] int n;
//[setw public:
class setw_manip { explicit setprecision_manip (int n_):
private: n(n_) { }
int n;
public: template<class CharT, class Traits>
explicit setw_manip (int n_): friend std::basic_istream<CharT, Traits>&
n(n_) { } operator>> (std::basic_istream<CharT, Traits>& is,
setprecision_manip const& x) {
is.precision(x.n);
return is;
}
template<class CharT, class Traits> template<class CharT, class Traits>
friend std::basic_istream<CharT, Traits>& friend std::basic_ostream<CharT, Traits>&
operator>> (std::basic_istream<CharT, Traits>& is, setw_manip const& x) { operator<< (std::basic_ostream<CharT, Traits>& os,
is.width(x.n); setprecision_manip const& x) {
return is; os.precision(x.n);
return os;
}
};
inline setprecision_manip setprecision (int n_) {
return setprecision_manip(n_);
} }
//]
template <class CharT, class Traits> //[setw
friend std::basic_ostream<CharT, Traits>& class setw_manip {
operator<< (std::basic_ostream<CharT, Traits>& os, setw_manip const& x) { private:
os.width(x.n); int n;
return os;
public:
explicit setw_manip (int n_):
n(n_) { }
template<class CharT, class Traits>
friend std::basic_istream<CharT, Traits>&
operator>> (std::basic_istream<CharT, Traits>& is, setw_manip const& x) {
is.width(x.n);
return is;
}
template <class CharT, class Traits>
friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os, setw_manip const& x) {
os.width(x.n);
return os;
}
};
inline setw_manip setw (int n_) {
return setw_manip(n_);
} }
}; //]
inline setw_manip setw (int n_) { } // detail
return setw_manip(n_); } // boost
}
//]
} // detail #else
} // boost #include <iomanip>
namespace boost {
namespace detail {
using ::std::resetiosflags;
using ::std::setiosflags;
using ::std::setbase;
using ::std::setfill;
using ::std::setprecision;
using ::std::setw;
} // detail
} // boost
#endif
#endif // BOOST_DETAIL_IOMANIP_HPP #endif // BOOST_DETAIL_IOMANIP_HPP