PageRenderTime 65ms CodeModel.GetById 36ms app.highlight 24ms RepoModel.GetById 1ms app.codeStats 0ms

/src/contrib/boost/format/format_implementation.hpp

http://pythonocc.googlecode.com/
C++ Header | 288 lines | 227 code | 35 blank | 26 comment | 51 complexity | e82317cedd43f8b42224b0133667b54b MD5 | raw file
  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
 23namespace 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_(false),
 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    typename basic_format<Ch, Tr, Alloc>::string_type 
176    basic_format<Ch,Tr, Alloc>:: 
177    str () const {
178        if(items_.size()==0)
179            return prefix_;
180        if( cur_arg_ < num_args_)
181            if( exceptions() & io::too_few_args_bit )
182                // not enough variables supplied
183                boost::throw_exception(io::too_few_args(cur_arg_, num_args_)); 
184
185        unsigned long i;
186        string_type res;
187        res.reserve(size());
188        res += prefix_;
189        for(i=0; i < items_.size(); ++i) {
190            const format_item_t& item = items_[i];
191            res += item.res_;
192            if( item.argN_ == format_item_t::argN_tabulation) { 
193                BOOST_ASSERT( item.pad_scheme_ & format_item_t::tabulation);
194                if( static_cast<size_type>(item.fmtstate_.width_) > res.size() )
195                    res.append( static_cast<size_type>(item.fmtstate_.width_) - res.size(),
196                                        item.fmtstate_.fill_ );
197            }
198            res += item.appendix_;
199        }
200        dumped_=true;
201        return res;
202    }
203    template< class Ch, class Tr, class Alloc>
204    typename std::basic_string<Ch, Tr, Alloc>::size_type  basic_format<Ch,Tr, Alloc>:: 
205    size () const {
206#ifdef BOOST_MSVC
207       // If std::min<unsigned> or std::max<unsigned> are already instantiated
208       // at this point then we get a blizzard of warning messages when we call
209       // those templates with std::size_t as arguments.  Weird and very annoyning...
210#pragma warning(push)
211#pragma warning(disable:4267)
212#endif
213        BOOST_USING_STD_MAX();
214        size_type sz = prefix_.size();
215        unsigned long i;
216        for(i=0; i < items_.size(); ++i) {
217            const format_item_t& item = items_[i];
218            sz += item.res_.size();
219            if( item.argN_ == format_item_t::argN_tabulation)
220                sz = max BOOST_PREVENT_MACRO_SUBSTITUTION (sz,
221                                        static_cast<size_type>(item.fmtstate_.width_) );
222            sz += item.appendix_.size();
223        }
224        return sz;
225#ifdef BOOST_MSVC
226#pragma warning(pop)
227#endif
228    }
229
230namespace io {
231namespace detail {
232
233    template<class Ch, class Tr, class Alloc, class T> 
234    basic_format<Ch, Tr, Alloc>&  
235    bind_arg_body (basic_format<Ch, Tr, Alloc>& self, int argN, const T& val) {
236        // bind one argument to a fixed value
237        // this is persistent over clear() calls, thus also over str() and <<
238        if(self.dumped_) 
239            self.clear(); // needed because we will modify cur_arg_
240        if(argN<1 || argN > self.num_args_) {
241            if( self.exceptions() & io::out_of_range_bit )
242                boost::throw_exception(io::out_of_range(argN, 1, self.num_args_+1 ) );
243            else return self;
244        }
245        if(self.bound_.size()==0) 
246            self.bound_.assign(self.num_args_,false);
247        else 
248            BOOST_ASSERT( self.num_args_ == static_cast<signed int>(self.bound_.size()) );
249        int o_cur_arg = self.cur_arg_;
250        self.cur_arg_ = argN-1; // arrays begin at 0
251
252        self.bound_[self.cur_arg_]=false; // if already set, we unset and re-sets..
253        self.operator%(val); // put val at the right place, because cur_arg is set
254    
255
256        // Now re-position cur_arg before leaving :
257        self.cur_arg_ = o_cur_arg; 
258        self.bound_[argN-1]=true;
259        if(self.cur_arg_ == argN-1 ) {
260            // hum, now this arg is bound, so move to next free arg
261            while(self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_])   
262                ++self.cur_arg_;
263        }
264        // In any case, we either have all args, or are on a non-binded arg :
265        BOOST_ASSERT( self.cur_arg_ >= self.num_args_ || ! self.bound_[self.cur_arg_]);
266        return self;
267    }
268
269    template<class Ch, class Tr, class Alloc, class T> basic_format<Ch, Tr, Alloc>&
270    modify_item_body (basic_format<Ch, Tr, Alloc>& self, int itemN, T manipulator) {
271        // applies a manipulator to the format_item describing a given directive.
272        // this is a permanent change, clear or reset won't cancel that.
273        if(itemN<1 || itemN > static_cast<signed int>(self.items_.size() )) {
274            if( self.exceptions() & io::out_of_range_bit ) 
275                boost::throw_exception(io::out_of_range(itemN, 1, static_cast<int>(self.items_.size()) ));
276            else return self;
277        }
278        self.items_[itemN-1].fmtstate_. template apply_manip<T> ( manipulator );
279        return self;
280    }
281
282} // namespace detail
283} // namespace io
284} // namespace boost
285
286
287
288#endif  // BOOST_FORMAT_IMPLEMENTATION_HPP