| // ---------------------------------------------------------------------------- | |
| // format_implementation.hpp Implementation of the basic_format class | |
| // ---------------------------------------------------------------------------- | |
| // 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_IMPLEMENTATION_HPP | |
| #define BOOST_FORMAT_IMPLEMENTATION_HPP | |
| #include <boost/config.hpp> | |
| #include <boost/throw_exception.hpp> | |
| #include <boost/assert.hpp> | |
| #include <boost/format/format_class.hpp> | |
| #include <algorithm> // std::swap | |
| namespace boost { | |
| // --- basic_format implementation -----------------------------------------// | |
| template< class Ch, class Tr, class Alloc> | |
| basic_format<Ch, Tr, Alloc>:: basic_format(const Ch* s) | |
| : style_(0), cur_arg_(0), num_args_(0), dumped_(false), | |
| exceptions_(io::all_error_bits) | |
| { | |
| if( s) | |
| parse( s ); | |
| } | |
| #if !defined(BOOST_NO_STD_LOCALE) | |
| template< class Ch, class Tr, class Alloc> | |
| basic_format<Ch, Tr, Alloc>:: basic_format(const Ch* s, const std::locale & loc) | |
| : style_(0), cur_arg_(0), num_args_(0), dumped_(false), | |
| exceptions_(io::all_error_bits), loc_(loc) | |
| { | |
| if(s) parse( s ); | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| basic_format<Ch, Tr, Alloc>:: basic_format(const string_type& s, const std::locale & loc) | |
| : style_(0), cur_arg_(0), num_args_(0), dumped_(false), | |
| exceptions_(io::all_error_bits), loc_(loc) | |
| { | |
| parse(s); | |
| } | |
| #endif // ! BOOST_NO_STD_LOCALE | |
| template< class Ch, class Tr, class Alloc> | |
| io::detail::locale_t basic_format<Ch, Tr, Alloc>:: | |
| getloc() const { | |
| return loc_ ? loc_.get() : io::detail::locale_t(); | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| basic_format<Ch, Tr, Alloc>:: basic_format(const string_type& s) | |
| : style_(0), cur_arg_(0), num_args_(0), dumped_(false), | |
| exceptions_(io::all_error_bits) | |
| { | |
| parse(s); | |
| } | |
| template< class Ch, class Tr, class Alloc> // just don't copy the buf_ member | |
| basic_format<Ch, Tr, Alloc>:: basic_format(const basic_format& x) | |
| : items_(x.items_), bound_(x.bound_), style_(x.style_), | |
| cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(x.dumped_), | |
| prefix_(x.prefix_), exceptions_(x.exceptions_), loc_(x.loc_) | |
| { | |
| } | |
| template< class Ch, class Tr, class Alloc> // just don't copy the buf_ member | |
| basic_format<Ch, Tr, Alloc>& basic_format<Ch, Tr, Alloc>:: | |
| operator= (const basic_format& x) { | |
| if(this == &x) | |
| return *this; | |
| (basic_format<Ch, Tr, Alloc>(x)).swap(*this); | |
| return *this; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| void basic_format<Ch, Tr, Alloc>:: | |
| swap (basic_format & x) { | |
| std::swap(exceptions_, x.exceptions_); | |
| std::swap(style_, x.style_); | |
| std::swap(cur_arg_, x.cur_arg_); | |
| std::swap(num_args_, x.num_args_); | |
| std::swap(dumped_, x.dumped_); | |
| items_.swap(x.items_); | |
| prefix_.swap(x.prefix_); | |
| bound_.swap(x.bound_); | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| unsigned char basic_format<Ch,Tr, Alloc>:: exceptions() const { | |
| return exceptions_; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| unsigned char basic_format<Ch,Tr, Alloc>:: exceptions(unsigned char newexcept) { | |
| unsigned char swp = exceptions_; | |
| exceptions_ = newexcept; | |
| return swp; | |
| } | |
| template<class Ch, class Tr, class Alloc> | |
| void basic_format<Ch, Tr, Alloc>:: | |
| make_or_reuse_data (std::size_t nbitems) { | |
| #if !defined(BOOST_NO_STD_LOCALE) | |
| Ch fill = ( BOOST_USE_FACET(std::ctype<Ch>, getloc()) ). widen(' '); | |
| #else | |
| Ch fill = ' '; | |
| #endif | |
| if(items_.size() == 0) | |
| items_.assign( nbitems, format_item_t(fill) ); | |
| else { | |
| if(nbitems>items_.size()) | |
| items_.resize(nbitems, format_item_t(fill)); | |
| bound_.resize(0); | |
| for(std::size_t i=0; i < nbitems; ++i) | |
| items_[i].reset(fill); // strings are resized, instead of reallocated | |
| } | |
| prefix_.resize(0); | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>:: | |
| clear () { | |
| // empty the string buffers (except bound arguments) | |
| // and make the format object ready for formatting a new set of arguments | |
| BOOST_ASSERT( bound_.size()==0 || num_args_ == static_cast<int>(bound_.size()) ); | |
| for(unsigned long i=0; i<items_.size(); ++i) { | |
| // clear converted strings only if the corresponding argument is not bound : | |
| if( bound_.size()==0 || items_[i].argN_<0 || !bound_[ items_[i].argN_ ] ) | |
| items_[i].res_.resize(0); | |
| } | |
| cur_arg_=0; dumped_=false; | |
| // maybe first arg is bound: | |
| if(bound_.size() != 0) { | |
| for(; cur_arg_ < num_args_ && bound_[cur_arg_]; ++cur_arg_) | |
| {} | |
| } | |
| return *this; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>:: | |
| clear_binds () { | |
| // remove all binds, then clear() | |
| bound_.resize(0); | |
| clear(); | |
| return *this; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| basic_format<Ch,Tr, Alloc>& basic_format<Ch,Tr, Alloc>:: | |
| clear_bind (int argN) { | |
| // remove the bind of ONE argument then clear() | |
| if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] ) { | |
| if( exceptions() & io::out_of_range_bit) | |
| boost::throw_exception(io::out_of_range(argN, 1, num_args_+1 ) ); | |
| else return *this; | |
| } | |
| bound_[argN-1]=false; | |
| clear(); | |
| return *this; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| int basic_format<Ch,Tr, Alloc>:: | |
| bound_args() const { | |
| if(bound_.size()==0) | |
| return 0; | |
| int n=0; | |
| for(int i=0; i<num_args_ ; ++i) | |
| if(bound_[i]) | |
| ++n; | |
| return n; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| int basic_format<Ch,Tr, Alloc>:: | |
| fed_args() const { | |
| if(bound_.size()==0) | |
| return cur_arg_; | |
| int n=0; | |
| for(int i=0; i<cur_arg_ ; ++i) | |
| if(!bound_[i]) | |
| ++n; | |
| return n; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| int basic_format<Ch,Tr, Alloc>:: | |
| cur_arg() const { | |
| return cur_arg_+1; } | |
| template< class Ch, class Tr, class Alloc> | |
| int basic_format<Ch,Tr, Alloc>:: | |
| remaining_args() const { | |
| if(bound_.size()==0) | |
| return num_args_-cur_arg_; | |
| int n=0; | |
| for(int i=cur_arg_; i<num_args_ ; ++i) | |
| if(!bound_[i]) | |
| ++n; | |
| return n; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| typename basic_format<Ch, Tr, Alloc>::string_type | |
| basic_format<Ch,Tr, Alloc>:: | |
| str () const { | |
| if(items_.size()==0) | |
| return prefix_; | |
| if( cur_arg_ < num_args_) | |
| if( exceptions() & io::too_few_args_bit ) | |
| // not enough variables supplied | |
| boost::throw_exception(io::too_few_args(cur_arg_, num_args_)); | |
| unsigned long i; | |
| string_type res; | |
| res.reserve(size()); | |
| res += prefix_; | |
| for(i=0; i < items_.size(); ++i) { | |
| const format_item_t& item = items_[i]; | |
| res += item.res_; | |
| if( item.argN_ == format_item_t::argN_tabulation) { | |
| BOOST_ASSERT( item.pad_scheme_ & format_item_t::tabulation); | |
| if( static_cast<size_type>(item.fmtstate_.width_) > res.size() ) | |
| res.append( static_cast<size_type>(item.fmtstate_.width_) - res.size(), | |
| item.fmtstate_.fill_ ); | |
| } | |
| res += item.appendix_; | |
| } | |
| dumped_=true; | |
| return res; | |
| } | |
| template< class Ch, class Tr, class Alloc> | |
| typename std::basic_string<Ch, Tr, Alloc>::size_type basic_format<Ch,Tr, Alloc>:: | |
| size () const { | |
| #ifdef BOOST_MSVC | |
| // If std::min<unsigned> or std::max<unsigned> are already instantiated | |
| // at this point then we get a blizzard of warning messages when we call | |
| // those templates with std::size_t as arguments. Weird and very annoyning... | |
| #pragma warning(push) | |
| #pragma warning(disable:4267) | |
| #endif | |
| BOOST_USING_STD_MAX(); | |
| size_type sz = prefix_.size(); | |
| unsigned long i; | |
| for(i=0; i < items_.size(); ++i) { | |
| const format_item_t& item = items_[i]; | |
| sz += item.res_.size(); | |
| if( item.argN_ == format_item_t::argN_tabulation) | |
| sz = max BOOST_PREVENT_MACRO_SUBSTITUTION (sz, | |
| static_cast<size_type>(item.fmtstate_.width_) ); | |
| sz += item.appendix_.size(); | |
| } | |
| return sz; | |
| #ifdef BOOST_MSVC | |
| #pragma warning(pop) | |
| #endif | |
| } | |
| namespace io { | |
| namespace detail { | |
| template<class Ch, class Tr, class Alloc, class T> | |
| basic_format<Ch, Tr, Alloc>& | |
| bind_arg_body (basic_format<Ch, Tr, Alloc>& self, int argN, const T& val) { | |
| // bind one argument to a fixed value | |
| // this is persistent over clear() calls, thus also over str() and << | |
| if(self.dumped_) | |
| self.clear(); // needed because we will modify cur_arg_ | |
| if(argN<1 || argN > self.num_args_) { | |
| if( self.exceptions() & io::out_of_range_bit ) | |
| boost::throw_exception(io::out_of_range(argN, 1, self.num_args_+1 ) ); | |
| else return self; | |
| } | |
| if(self.bound_.size()==0) | |
| self.bound_.assign(self.num_args_,false); | |
| else | |
| BOOST_ASSERT( self.num_args_ == static_cast<signed int>(self.bound_.size()) ); | |
| int o_cur_arg = self.cur_arg_; | |
| self.cur_arg_ = argN-1; // arrays begin at 0 | |
| self.bound_[self.cur_arg_]=false; // if already set, we unset and re-sets.. | |
| self.operator%(val); // put val at the right place, because cur_arg is set | |
| // Now re-position cur_arg before leaving : | |
| self.cur_arg_ = o_cur_arg; | |
| self.bound_[argN-1]=true; | |
| if(self.cur_arg_ == argN-1 ) { | |
| // hum, now this arg is bound, so move to next free arg | |
| while(self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_]) | |
| ++self.cur_arg_; | |
| } | |
| // In any case, we either have all args, or are on an unbound arg : | |
| BOOST_ASSERT( self.cur_arg_ >= self.num_args_ || ! self.bound_[self.cur_arg_]); | |
| return self; | |
| } | |
| template<class Ch, class Tr, class Alloc, class T> basic_format<Ch, Tr, Alloc>& | |
| modify_item_body (basic_format<Ch, Tr, Alloc>& self, int itemN, T manipulator) { | |
| // applies a manipulator to the format_item describing a given directive. | |
| // this is a permanent change, clear or reset won't cancel that. | |
| if(itemN<1 || itemN > static_cast<signed int>(self.items_.size() )) { | |
| if( self.exceptions() & io::out_of_range_bit ) | |
| boost::throw_exception(io::out_of_range(itemN, 1, static_cast<int>(self.items_.size()) )); | |
| else return self; | |
| } | |
| self.items_[itemN-1].fmtstate_. template apply_manip<T> ( manipulator ); | |
| return self; | |
| } | |
| } // namespace detail | |
| } // namespace io | |
| } // namespace boost | |
| #endif // BOOST_FORMAT_IMPLEMENTATION_HPP |