// ---------------------------------------------------------------------------- | |
// internals.hpp : internal structs : stream_format_state, format_item. | |
// included by format.hpp | |
// ---------------------------------------------------------------------------- | |
// Copyright Samuel Krempp 2003. Use, modification, and distribution are | |
// subject to the Boost Software License, Version 1.0. (See accompanying | |
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
// See http://www.boost.org/libs/format for library home page | |
// ---------------------------------------------------------------------------- | |
#ifndef BOOST_FORMAT_INTERNALS_HPP | |
#define BOOST_FORMAT_INTERNALS_HPP | |
#include <string> | |
#include <boost/assert.hpp> | |
#include <boost/optional.hpp> | |
#include <boost/limits.hpp> | |
#include <boost/format/detail/compat_workarounds.hpp> | |
#include <boost/format/alt_sstream.hpp> // used as a dummy stream | |
namespace boost { | |
namespace io { | |
namespace detail { | |
//---- stream_format_state --------------------------------------------------// | |
// set of params that define the format state of a stream | |
template<class Ch, class Tr> | |
struct stream_format_state | |
{ | |
typedef BOOST_IO_STD basic_ios<Ch, Tr> basic_ios; | |
stream_format_state(Ch fill) { reset(fill); } | |
// stream_format_state(const basic_ios& os) { set_by_stream(os); } | |
void reset(Ch fill); //- sets to default state. | |
void set_by_stream(const basic_ios& os); //- sets to os's state. | |
void apply_on(basic_ios & os, //- applies format_state to the stream | |
boost::io::detail::locale_t * loc_default = 0) const; | |
template<class T> | |
void apply_manip(T manipulator) //- modifies state by applying manipulator | |
{ apply_manip_body<Ch, Tr, T>( *this, manipulator) ; } | |
// --- data --- | |
std::streamsize width_; | |
std::streamsize precision_; | |
Ch fill_; | |
std::ios_base::fmtflags flags_; | |
std::ios_base::iostate rdstate_; | |
std::ios_base::iostate exceptions_; | |
boost::optional<boost::io::detail::locale_t> loc_; | |
}; | |
//---- format_item ---------------------------------------------------------// | |
// stores all parameters that can be specified in format strings | |
template<class Ch, class Tr, class Alloc> | |
struct format_item | |
{ | |
enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 }; | |
// 1. if zeropad is set, all other bits are not, | |
// 2. if tabulation is set, all others are not. | |
// centered and spacepad can be mixed freely. | |
enum arg_values { argN_no_posit = -1, // non-positional directive. will set argN later | |
argN_tabulation = -2, // tabulation directive. (no argument read) | |
argN_ignored = -3 // ignored directive. (no argument read) | |
}; | |
typedef BOOST_IO_STD basic_ios<Ch, Tr> basic_ios; | |
typedef detail::stream_format_state<Ch, Tr> stream_format_state; | |
typedef ::std::basic_string<Ch, Tr, Alloc> string_type; | |
format_item(Ch fill) :argN_(argN_no_posit), fmtstate_(fill), | |
truncate_(max_streamsize()), pad_scheme_(0) {} | |
void reset(Ch fill); | |
void compute_states(); // sets states according to truncate and pad_scheme. | |
static std::streamsize max_streamsize() { | |
return (std::numeric_limits<std::streamsize>::max)(); | |
} | |
// --- data --- | |
int argN_; //- argument number (starts at 0, eg : %1 => argN=0) | |
// negative values for items that don't process an argument | |
string_type res_; //- result of the formatting of this item | |
string_type appendix_; //- piece of string between this item and the next | |
stream_format_state fmtstate_;// set by parsing, is only affected by modify_item | |
std::streamsize truncate_;//- is set for directives like %.5s that ask truncation | |
unsigned int pad_scheme_;//- several possible padding schemes can mix. see pad_values | |
}; | |
//--- Definitions ------------------------------------------------------------ | |
// - stream_format_state:: ------------------------------------------------- | |
template<class Ch, class Tr> | |
void stream_format_state<Ch,Tr>:: apply_on (basic_ios & os, | |
boost::io::detail::locale_t * loc_default) const { | |
// set the state of this stream according to our params | |
if(width_ != -1) | |
os.width(width_); | |
if(precision_ != -1) | |
os.precision(precision_); | |
if(fill_ != 0) | |
os.fill(fill_); | |
os.flags(flags_); | |
os.clear(rdstate_); | |
os.exceptions(exceptions_); | |
#if !defined(BOOST_NO_STD_LOCALE) | |
if(loc_) | |
os.imbue(loc_.get()); | |
else if(loc_default) | |
os.imbue(*loc_default); | |
#else | |
(void) loc_default; // keep compiler quiet if we don't support locales | |
#endif | |
} | |
template<class Ch, class Tr> | |
void stream_format_state<Ch,Tr>:: set_by_stream(const basic_ios& os) { | |
// set our params according to the state of this stream | |
flags_ = os.flags(); | |
width_ = os.width(); | |
precision_ = os.precision(); | |
fill_ = os.fill(); | |
rdstate_ = os.rdstate(); | |
exceptions_ = os.exceptions(); | |
} | |
template<class Ch, class Tr, class T> | |
void apply_manip_body( stream_format_state<Ch, Tr>& self, | |
T manipulator) { | |
// modify our params according to the manipulator | |
basic_oaltstringstream<Ch, Tr> ss; | |
self.apply_on( ss ); | |
ss << manipulator; | |
self.set_by_stream( ss ); | |
} | |
template<class Ch, class Tr> inline | |
void stream_format_state<Ch,Tr>:: reset(Ch fill) { | |
// set our params to standard's default state. cf 27.4.4.1 of the C++ norm | |
width_=0; precision_=6; | |
fill_=fill; // default is widen(' '), but we cant compute it without the locale | |
flags_ = std::ios_base::dec | std::ios_base::skipws; | |
// the adjust_field part is left equal to 0, which means right. | |
exceptions_ = std::ios_base::goodbit; | |
rdstate_ = std::ios_base::goodbit; | |
} | |
// --- format_item:: -------------------------------------------------------- | |
template<class Ch, class Tr, class Alloc> | |
void format_item<Ch, Tr, Alloc>:: | |
reset (Ch fill) { | |
argN_=argN_no_posit; truncate_ = max_streamsize(); pad_scheme_ =0; | |
res_.resize(0); appendix_.resize(0); | |
fmtstate_.reset(fill); | |
} | |
template<class Ch, class Tr, class Alloc> | |
void format_item<Ch, Tr, Alloc>:: | |
compute_states() { | |
// reflect pad_scheme_ on fmt_state_ | |
// because some pad_schemes has complex consequences on several state params. | |
if(pad_scheme_ & zeropad) { | |
// ignore zeropad in left alignment : | |
if(fmtstate_.flags_ & std::ios_base::left) { | |
BOOST_ASSERT(!(fmtstate_.flags_ &(std::ios_base::adjustfield ^std::ios_base::left))); | |
// only left bit might be set. (not right, nor internal) | |
pad_scheme_ = pad_scheme_ & (~zeropad); | |
} | |
else { | |
pad_scheme_ &= ~spacepad; // printf ignores spacepad when zeropadding | |
fmtstate_.fill_='0'; | |
fmtstate_.flags_ = (fmtstate_.flags_ & ~std::ios_base::adjustfield) | |
| std::ios_base::internal; | |
// removes all adjustfield bits, and adds internal. | |
} | |
} | |
if(pad_scheme_ & spacepad) { | |
if(fmtstate_.flags_ & std::ios_base::showpos) | |
pad_scheme_ &= ~spacepad; | |
} | |
} | |
} } } // namespaces boost :: io :: detail | |
#endif // BOOST_FORMAT_INTERNALS_HPP |