boost/format/format_implementation.hpp

   1 // ----------------------------------------------------------------------------
   2 // format_implementation.hpp  Implementation of the basic_format class
   3 // ----------------------------------------------------------------------------
   4
   5 //  Copyright Samuel Krempp 2003. Use, modification, and distribution are
   6 //  subject to the Boost Software License, Version 1.0. (See accompanying
   7 //  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   8
   9 //  See http://www.boost.org/libs/format for library home page
  10
  11
  12 // ----------------------------------------------------------------------------
  13
  14 #ifndef BOOST_FORMAT_IMPLEMENTATION_HPP
  15 #define BOOST_FORMAT_IMPLEMENTATION_HPP
  16
  17 #include <boost/config.hpp>
  18 #include <boost/throw_exception.hpp>
  19 #include <boost/assert.hpp>
  20 #include <boost/format/format_class.hpp>
  21 #include <algorithm> // std::swap
  22
  23 namespace boost {
  24
  25 // ---  basic_format implementation -----------------------------------------//
  26
  27     template< class Ch, class Tr, class Alloc>
  28     basic_format<Ch, Tr, Alloc>:: basic_format(const Ch* s)
  29         : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
  30           exceptions_(io::all_error_bits)
  31     {
  32         if( s)
  33             parse( s );
  34     }
  35
  36 #if !defined(BOOST_NO_STD_LOCALE)
  37     template< class Ch, class Tr, class Alloc>
  38     basic_format<Ch, Tr, Alloc>:: basic_format(const Ch* s, const std::locale & loc)
  39         : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
  40           exceptions_(io::all_error_bits), loc_(loc)
  41     {
  42         if(s) parse( s );
  43     }
  44
  45     template< class Ch, class Tr, class Alloc>
  46     basic_format<Ch, Tr, Alloc>:: basic_format(const string_type& s, const std::locale & loc)
  47         : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
  48           exceptions_(io::all_error_bits), loc_(loc)
  49     {
  50         parse(s);
  51     }
  52 #endif // ! BOOST_NO_STD_LOCALE
  53     template< class Ch, class Tr, class Alloc>
  54     io::detail::locale_t basic_format<Ch, Tr, Alloc>::
  55     getloc() const {
  56         return loc_ ? loc_.get() : io::detail::locale_t();
  57     }
  58
  59     template< class Ch, class Tr, class Alloc>
  60     basic_format<Ch, Tr, Alloc>:: basic_format(const string_type& s)
  61         : style_(0), cur_arg_(0), num_args_(0), dumped_(false),
  62           exceptions_(io::all_error_bits)
  63     {
  64         parse(s);
  65     }
  66
  67     template< class Ch, class Tr, class Alloc> // just don't copy the buf_ member
  68     basic_format<Ch, Tr, Alloc>:: basic_format(const basic_format& x)
  69         : items_(x.items_), bound_(x.bound_), style_(x.style_),
  70           cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(x.dumped_),
  71           prefix_(x.prefix_), exceptions_(x.exceptions_), loc_(x.loc_)
  72     {
  73     }
  74
  75     template< class Ch, class Tr, class Alloc>  // just don't copy the buf_ member
  76     basic_format<Ch, Tr, Alloc>& basic_format<Ch, Tr, Alloc>::
  77     operator= (const basic_format& x) {
  78         if(this == &x)
  79             return *this;
  80         (basic_format<Ch, Tr, Alloc>(x)).swap(*this);
  81         return *this;
  82     }
  83     template< class Ch, class Tr, class Alloc>
  84     void  basic_format<Ch, Tr, Alloc>::
  85     swap (basic_format & x) {
  86         std::swap(exceptions_, x.exceptions_);
  87         std::swap(style_, x.style_);
  88         std::swap(cur_arg_, x.cur_arg_);
  89         std::swap(num_args_, x.num_args_);
  90         std::swap(dumped_, x.dumped_);
  91
  92         items_.swap(x.items_);
  93         prefix_.swap(x.prefix_);
  94         bound_.swap(x.bound_);
  95     }
  96
  97     template< class Ch, class Tr, class Alloc>
  98     unsigned char basic_format<Ch,Tr, Alloc>:: exceptions() const {
  99         return exceptions_;
 100     }
 101
 102     template< class Ch, class Tr, class Alloc>
 103     unsigned char basic_format<Ch,Tr, Alloc>:: exceptions(unsigned char newexcept) {
 104         unsigned char swp = exceptions_;
 105         exceptions_ = newexcept;
 106         return swp;
 107     }
 108
 109     template<class Ch, class Tr, class Alloc>
 110     void basic_format<Ch, Tr, Alloc>::
 111     make_or_reuse_data (std::size_t nbitems) {
 112 #if !defined(BOOST_NO_STD_LOCALE)
 113         Ch fill = ( BOOST_USE_FACET(std::ctype<Ch>, getloc()) ). widen(' ');
 114 #else
 115         Ch fill = ' ';
 116 #endif
 117         if(items_.size() == 0)
 118             items_.assign( nbitems, format_item_t(fill) );
 119         else {
 120             if(nbitems>items_.size())
 121                 items_.resize(nbitems, format_item_t(fill));
 122             bound_.resize(0);
 123             for(std::size_t i=0; i < nbitems; ++i)
 124                 items_[i].reset(fill); //  strings are resized, instead of reallocated
 125         }
 126         prefix_.resize(0);
 127     }
 128
 129     template< class Ch, class Tr, class Alloc>
 130     basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>::
 131     clear () {
 132         // empty the string buffers (except bound arguments)
 133         // and make the format object ready for formatting a new set of arguments
 134
 135         BOOST_ASSERT( bound_.size()==0 || num_args_ == static_cast<int>(bound_.size()) );
 136
 137         for(unsigned long i=0; i<items_.size(); ++i) {
 138             // clear converted strings only if the corresponding argument is not  bound :
 139             if( bound_.size()==0 || items_[i].argN_<0 || !bound_[ items_[i].argN_ ] )
 140                 items_[i].res_.resize(0);
 141         }
 142         cur_arg_=0; dumped_=false;
 143         // maybe first arg is bound:
 144         if(bound_.size() != 0) {
 145             for(; cur_arg_ < num_args_ && bound_[cur_arg_]; ++cur_arg_)
 146                 {}
 147         }
 148         return *this;
 149     }
 150
 151     template< class Ch, class Tr, class Alloc>
 152     basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>::
 153     clear_binds () {
 154         // remove all binds, then clear()
 155         bound_.resize(0);
 156         clear();
 157         return *this;
 158     }
 159
 160     template< class Ch, class Tr, class Alloc>
 161     basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>::
 162     clear_bind (int argN) {
 163         // remove the bind of ONE argument then clear()
 164         if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] ) {
 165             if( exceptions() & io::out_of_range_bit)
 166                 boost::throw_exception(io::out_of_range(argN, 1, num_args_+1 ) );
 167             else return *this;
 168         }
 169         bound_[argN-1]=false;
 170         clear();
 171         return *this;
 172     }
 173
 174     template< class Ch, class Tr, class Alloc>
 175     int basic_format<Ch,Tr, Alloc>::
 176     bound_args() const {
 177         if(bound_.size()==0)
 178             return 0;
 179         int n=0;
 180         for(int i=0; i<num_args_ ; ++i)
 181             if(bound_[i])
 182                 ++n;
 183         return n;
 184     }
 185
 186     template< class Ch, class Tr, class Alloc>
 187     int basic_format<Ch,Tr, Alloc>::
 188     fed_args() const {
 189         if(bound_.size()==0)
 190             return cur_arg_;
 191         int n=0;
 192         for(int i=0; i<cur_arg_ ; ++i)
 193             if(!bound_[i])
 194                 ++n;
 195         return n;
 196     }
 197
 198     template< class Ch, class Tr, class Alloc>
 199     int basic_format<Ch,Tr, Alloc>::
 200     cur_arg() const {
 201       return cur_arg_+1; }
 202
 203     template< class Ch, class Tr, class Alloc>
 204     int basic_format<Ch,Tr, Alloc>::
 205     remaining_args() const {
 206         if(bound_.size()==0)
 207             return num_args_-cur_arg_;
 208         int n=0;
 209         for(int i=cur_arg_; i<num_args_ ; ++i)
 210             if(!bound_[i])
 211                 ++n;
 212         return n;
 213     }
 214
 215     template< class Ch, class Tr, class Alloc>
 216     typename basic_format<Ch, Tr, Alloc>::string_type
 217     basic_format<Ch,Tr, Alloc>::
 218     str () const {
 219         if(items_.size()==0)
 220             return prefix_;
 221         if( cur_arg_ < num_args_)
 222             if( exceptions() & io::too_few_args_bit )
 223                 // not enough variables supplied
 224                 boost::throw_exception(io::too_few_args(cur_arg_, num_args_));
 225
 226         unsigned long i;
 227         string_type res;
 228         res.reserve(size());
 229         res += prefix_;
 230         for(i=0; i < items_.size(); ++i) {
 231             const format_item_t& item = items_[i];
 232             res += item.res_;
 233             if( item.argN_ == format_item_t::argN_tabulation) {
 234                 BOOST_ASSERT( item.pad_scheme_ & format_item_t::tabulation);
 235                 if( static_cast<size_type>(item.fmtstate_.width_) > res.size() )
 236                     res.append( static_cast<size_type>(item.fmtstate_.width_) - res.size(),
 237                                         item.fmtstate_.fill_ );
 238             }
 239             res += item.appendix_;
 240         }
 241         dumped_=true;
 242         return res;
 243     }
 244     template< class Ch, class Tr, class Alloc>
 245     typename std::basic_string<Ch, Tr, Alloc>::size_type  basic_format<Ch,Tr, Alloc>::
 246     size () const {
 247 #ifdef BOOST_MSVC
 248        // If std::min<unsigned> or std::max<unsigned> are already instantiated
 249        // at this point then we get a blizzard of warning messages when we call
 250        // those templates with std::size_t as arguments.  Weird and very annoyning...
 251 #pragma warning(push)
 252 #pragma warning(disable:4267)
 253 #endif
 254         BOOST_USING_STD_MAX();
 255         size_type sz = prefix_.size();
 256         unsigned long i;
 257         for(i=0; i < items_.size(); ++i) {
 258             const format_item_t& item = items_[i];
 259             sz += item.res_.size();
 260             if( item.argN_ == format_item_t::argN_tabulation)
 261                 sz = max BOOST_PREVENT_MACRO_SUBSTITUTION (sz,
 262                                         static_cast<size_type>(item.fmtstate_.width_) );
 263             sz += item.appendix_.size();
 264         }
 265         return sz;
 266 #ifdef BOOST_MSVC
 267 #pragma warning(pop)
 268 #endif
 269     }
 270
 271 namespace io {
 272 namespace detail {
 273
 274     template<class Ch, class Tr, class Alloc, class T>
 275     basic_format<Ch, Tr, Alloc>&
 276     bind_arg_body (basic_format<Ch, Tr, Alloc>& self, int argN, const T& val) {
 277         // bind one argument to a fixed value
 278         // this is persistent over clear() calls, thus also over str() and <<
 279         if(self.dumped_)
 280             self.clear(); // needed because we will modify cur_arg_
 281         if(argN<1 || argN > self.num_args_) {
 282             if( self.exceptions() & io::out_of_range_bit )
 283                 boost::throw_exception(io::out_of_range(argN, 1, self.num_args_+1 ) );
 284             else return self;
 285         }
 286         if(self.bound_.size()==0)
 287             self.bound_.assign(self.num_args_,false);
 288         else
 289             BOOST_ASSERT( self.num_args_ == static_cast<signed int>(self.bound_.size()) );
 290         int o_cur_arg = self.cur_arg_;
 291         self.cur_arg_ = argN-1; // arrays begin at 0
 292
 293         self.bound_[self.cur_arg_]=false; // if already set, we unset and re-sets..
 294         self.operator%(val); // put val at the right place, because cur_arg is set
 295
 296
 297         // Now re-position cur_arg before leaving :
 298         self.cur_arg_ = o_cur_arg;
 299         self.bound_[argN-1]=true;
 300         if(self.cur_arg_ == argN-1 ) {
 301             // hum, now this arg is bound, so move to next free arg
 302             while(self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_])
 303                 ++self.cur_arg_;
 304         }
 305         // In any case, we either have all args, or are on an unbound arg :
 306         BOOST_ASSERT( self.cur_arg_ >= self.num_args_ || ! self.bound_[self.cur_arg_]);
 307         return self;
 308     }
 309
 310     template<class Ch, class Tr, class Alloc, class T> basic_format<Ch, Tr, Alloc>&
 311     modify_item_body (basic_format<Ch, Tr, Alloc>& self, int itemN, T manipulator) {
 312         // applies a manipulator to the format_item describing a given directive.
 313         // this is a permanent change, clear or reset won't cancel that.
 314         if(itemN<1 || itemN > static_cast<signed int>(self.items_.size() )) {
 315             if( self.exceptions() & io::out_of_range_bit )
 316                 boost::throw_exception(io::out_of_range(itemN, 1, static_cast<int>(self.items_.size()) ));
 317             else return self;
 318         }
 319         self.items_[itemN-1].fmtstate_. template apply_manip<T> ( manipulator );
 320         return self;
 321     }
 322
 323 } // namespace detail
 324 } // namespace io
 325 } // namespace boost
 326
 327
 328
 329 #endif  // BOOST_FORMAT_IMPLEMENTATION_HPP