| // ---------------------------------------------------------------------------- |
| // 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 |