// ----------------------------------------------------------------------------

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