boost/format/internals.hpp

   1 // ----------------------------------------------------------------------------
   2 // internals.hpp :  internal structs : stream_format_state, format_item.
   3 //                  included by format.hpp
   4 // ----------------------------------------------------------------------------
   5
   6 //  Copyright Samuel Krempp 2003. Use, modification, and distribution are
   7 //  subject to the Boost Software License, Version 1.0. (See accompanying
   8 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   9
  10 //  See http://www.boost.org/libs/format for library home page
  11
  12 // ----------------------------------------------------------------------------
  13
  14 #ifndef BOOST_FORMAT_INTERNALS_HPP
  15 #define BOOST_FORMAT_INTERNALS_HPP
  16
  17
  18 #include <string>
  19 #include <boost/assert.hpp>
  20 #include <boost/optional.hpp>
  21 #include <boost/limits.hpp>
  22 #include <boost/format/detail/compat_workarounds.hpp>
  23 #include <boost/format/alt_sstream.hpp> // used as a dummy stream
  24
  25 namespace boost {
  26 namespace io {
  27 namespace detail {
  28
  29
  30 //---- stream_format_state --------------------------------------------------//
  31
  32 //   set of params that define the format state of a stream
  33     template<class Ch, class Tr>
  34     struct stream_format_state
  35     {
  36         typedef BOOST_IO_STD basic_ios<Ch, Tr>   basic_ios;
  37
  38         stream_format_state(Ch fill)                 { reset(fill); }
  39 //        stream_format_state(const basic_ios& os)     { set_by_stream(os); }
  40
  41         void reset(Ch fill);                     //- sets to default state.
  42         void set_by_stream(const basic_ios& os); //- sets to os's state.
  43         void apply_on(basic_ios & os,            //- applies format_state to the stream
  44                       boost::io::detail::locale_t * loc_default = 0) const;
  45         template<class T>
  46         void apply_manip(T manipulator)          //- modifies state by applying manipulator
  47             { apply_manip_body<Ch, Tr, T>( *this, manipulator) ; }
  48
  49         // --- data ---
  50         std::streamsize width_;
  51         std::streamsize precision_;
  52         Ch fill_;
  53         std::ios_base::fmtflags flags_;
  54         std::ios_base::iostate  rdstate_;
  55         std::ios_base::iostate  exceptions_;
  56         boost::optional<boost::io::detail::locale_t>  loc_;
  57     };
  58
  59
  60 //---- format_item  ---------------------------------------------------------//
  61
  62 //   stores all parameters that can be specified in format strings
  63     template<class Ch, class Tr, class Alloc>
  64     struct format_item
  65     {
  66         enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 };
  67                          // 1. if zeropad is set, all other bits are not,
  68                          // 2. if tabulation is set, all others are not.
  69                          // centered and spacepad can be mixed freely.
  70         enum arg_values { argN_no_posit   = -1, // non-positional directive. will set argN later
  71                           argN_tabulation = -2, // tabulation directive. (no argument read)
  72                           argN_ignored    = -3  // ignored directive. (no argument read)
  73         };
  74         typedef BOOST_IO_STD basic_ios<Ch, Tr>                    basic_ios;
  75         typedef detail::stream_format_state<Ch, Tr>               stream_format_state;
  76         typedef ::std::basic_string<Ch, Tr, Alloc>                string_type;
  77
  78         format_item(Ch fill) :argN_(argN_no_posit), fmtstate_(fill),
  79                               truncate_(max_streamsize()), pad_scheme_(0)  {}
  80         void reset(Ch fill);
  81         void compute_states(); // sets states  according to truncate and pad_scheme.
  82
  83         static std::streamsize max_streamsize() {
  84             return (std::numeric_limits<std::streamsize>::max)();
  85         }
  86
  87         // --- data ---
  88         int         argN_;  //- argument number (starts at 0,  eg : %1 => argN=0)
  89                             //  negative values for items that don't process an argument
  90         string_type  res_;      //- result of the formatting of this item
  91         string_type  appendix_; //- piece of string between this item and the next
  92
  93         stream_format_state fmtstate_;// set by parsing, is only affected by modify_item
  94
  95         std::streamsize truncate_;//- is set for directives like %.5s that ask truncation
  96         unsigned int pad_scheme_;//- several possible padding schemes can mix. see pad_values
  97     };
  98
  99
 100
 101 //--- Definitions  ------------------------------------------------------------
 102
 103 // -   stream_format_state:: -------------------------------------------------
 104     template<class Ch, class Tr>
 105     void stream_format_state<Ch,Tr>:: apply_on (basic_ios & os,
 106                       boost::io::detail::locale_t * loc_default) const {
 107         // set the state of this stream according to our params
 108         if(width_ != -1)
 109             os.width(width_);
 110         if(precision_ != -1)
 111             os.precision(precision_);
 112         if(fill_ != 0)
 113             os.fill(fill_);
 114         os.flags(flags_);
 115         os.clear(rdstate_);
 116         os.exceptions(exceptions_);
 117 #if !defined(BOOST_NO_STD_LOCALE)
 118         if(loc_)
 119             os.imbue(loc_.get());
 120         else if(loc_default)
 121             os.imbue(*loc_default);
 122 #else
 123         (void) loc_default; // keep compiler quiet if we don't support locales
 124 #endif
 125     }
 126
 127     template<class Ch, class Tr>
 128     void stream_format_state<Ch,Tr>:: set_by_stream(const basic_ios& os) {
 129         // set our params according to the state of this stream
 130         flags_ = os.flags();
 131         width_ = os.width();
 132         precision_ = os.precision();
 133         fill_ = os.fill();
 134         rdstate_ = os.rdstate();
 135         exceptions_ = os.exceptions();
 136     }
 137
 138
 139     template<class Ch, class Tr, class T>
 140     void apply_manip_body( stream_format_state<Ch, Tr>& self,
 141                            T manipulator) {
 142         // modify our params according to the manipulator
 143         basic_oaltstringstream<Ch, Tr>  ss;
 144         self.apply_on( ss );
 145         ss << manipulator;
 146         self.set_by_stream( ss );
 147     }
 148
 149     template<class Ch, class Tr> inline
 150     void stream_format_state<Ch,Tr>:: reset(Ch fill) {
 151         // set our params to standard's default state.   cf 27.4.4.1 of the C++ norm
 152         width_=0; precision_=6;
 153         fill_=fill; // default is widen(' '), but we cant compute it without the locale
 154         flags_ = std::ios_base::dec | std::ios_base::skipws;
 155         // the adjust_field part is left equal to 0, which means right.
 156         exceptions_ = std::ios_base::goodbit;
 157         rdstate_ = std::ios_base::goodbit;
 158     }
 159
 160
 161 // ---   format_item:: --------------------------------------------------------
 162
 163     template<class Ch, class Tr, class Alloc>
 164     void format_item<Ch, Tr, Alloc>::
 165     reset (Ch fill) {
 166         argN_=argN_no_posit; truncate_ = max_streamsize(); pad_scheme_ =0;
 167         res_.resize(0); appendix_.resize(0);
 168         fmtstate_.reset(fill);
 169     }
 170
 171     template<class Ch, class Tr, class Alloc>
 172     void format_item<Ch, Tr, Alloc>::
 173     compute_states() {
 174         // reflect pad_scheme_   on  fmt_state_
 175         //   because some pad_schemes has complex consequences on several state params.
 176         if(pad_scheme_ & zeropad) {
 177             // ignore zeropad in left alignment :
 178             if(fmtstate_.flags_ & std::ios_base::left) {
 179               BOOST_ASSERT(!(fmtstate_.flags_ &(std::ios_base::adjustfield ^std::ios_base::left)));
 180               // only left bit might be set. (not right, nor internal)
 181               pad_scheme_ = pad_scheme_ & (~zeropad);
 182             }
 183             else {
 184                 pad_scheme_ &= ~spacepad; // printf ignores spacepad when zeropadding
 185                 fmtstate_.fill_='0';
 186                 fmtstate_.flags_ = (fmtstate_.flags_ & ~std::ios_base::adjustfield)
 187                     | std::ios_base::internal;
 188                 // removes all adjustfield bits, and adds internal.
 189             }
 190         }
 191         if(pad_scheme_ & spacepad) {
 192             if(fmtstate_.flags_ & std::ios_base::showpos)
 193                 pad_scheme_ &= ~spacepad;
 194         }
 195     }
 196
 197
 198 } } } // namespaces boost :: io :: detail
 199
 200
 201 #endif // BOOST_FORMAT_INTERNALS_HPP