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>
//[resetiosflags #include <istream>
class resetiosflags_manip { #include <ostream>
private:
std::ios_base::fmtflags mask; namespace boost {
namespace detail {
public:
explicit resetiosflags_manip (std::ios_base::fmtflags m): //[resetiosflags
mask(m) { } class resetiosflags_manip {
private:
template<class CharT, class Traits> std::ios_base::fmtflags mask;
friend std::basic_istream<CharT, Traits>&
operator>> (std::basic_istream<CharT, Traits>& is, public:
resetiosflags_manip const& x) explicit resetiosflags_manip (std::ios_base::fmtflags m):
{ mask(m) { }
is.unsetf(x.mask);
return is; template<class CharT, class Traits>
} friend std::basic_istream<CharT, Traits>&
operator>> (std::basic_istream<CharT, Traits>& is,
template<class CharT, class Traits> resetiosflags_manip const& x)
friend std::basic_ostream<CharT, Traits>& {
operator<< (std::basic_ostream<CharT, Traits>& os, is.unsetf(x.mask);
resetiosflags_manip const& x) return is;
{
os.unsetf(x.mask);
return os;
}
};
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,
operator<< (std::basic_ostream<CharT, Traits>& os, setbase_manip const& x) { resetiosflags_manip const& x)
using namespace std; {
switch (x.base) { os.unsetf(x.mask);
case 8: return os;
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 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; template<class CharT, class Traits>
friend std::basic_istream<CharT, Traits>&
public: operator>> (std::basic_istream<CharT, Traits>& is,
explicit setfill_manip (CharT c): setiosflags_manip const& x) {
fill(c) { } is.setf(x.mask);
return is;
template<class Traits> }
friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os, setfill_manip const& x) { template<class CharT, class Traits>
os.fill(x.fill); friend std::basic_ostream<CharT, Traits>&
return os; 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);
} }
}; //]
template<class CharT> //[setbase
inline setfill_manip<CharT> setfill (CharT c) { class setbase_manip {
return setfill_manip<CharT>(c); private:
} int base;
//]
public:
//[setprecision explicit setbase_manip (int b):
class setprecision_manip { base(b) { }
private:
int n; template<class CharT, class Traits>
friend std::basic_istream<CharT, Traits>&
public: operator>> (std::basic_istream<CharT, Traits>& is, setbase_manip const& x) {
explicit setprecision_manip (int n_): using namespace std;
n(n_) { } switch (x.base) {
case 8:
template<class CharT, class Traits> is << std::oct;
friend std::basic_istream<CharT, Traits>& return is;
operator>> (std::basic_istream<CharT, Traits>& is, case 10:
setprecision_manip const& x) { is << std::dec;
is.precision(x.n); return is;
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>
friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os, setbase_manip const& x) {
using namespace std;
switch (x.base) {
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>
friend std::basic_ostream<CharT, Traits>& //[setfill
operator<< (std::basic_ostream<CharT, Traits>& os, template<class CharT>
setprecision_manip const& x) { class setfill_manip {
os.precision(x.n); private:
return os; CharT fill;
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;
template<class CharT, class Traits>
public: friend std::basic_istream<CharT, Traits>&
explicit setw_manip (int n_): operator>> (std::basic_istream<CharT, Traits>& is,
n(n_) { } setprecision_manip const& x) {
is.precision(x.n);
template<class CharT, class Traits> return is;
friend std::basic_istream<CharT, Traits>& }
operator>> (std::basic_istream<CharT, Traits>& is, setw_manip const& x) {
is.width(x.n); template<class CharT, class Traits>
return is; friend std::basic_ostream<CharT, Traits>&
operator<< (std::basic_ostream<CharT, Traits>& os,
setprecision_manip const& x) {
os.precision(x.n);
return os;
}
};
inline setprecision_manip setprecision (int n_) {
return setprecision_manip(n_);
} }
//]
template <class CharT, class Traits>
friend std::basic_ostream<CharT, Traits>& //[setw
operator<< (std::basic_ostream<CharT, Traits>& os, setw_manip const& x) { class setw_manip {
os.width(x.n); private:
return os; int n;
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