// and Karl Nelson's ofstream
// ----------------------------------------------------------------------------
-// feed_args.hpp : functions for processing each argument
+// feed_args.hpp : functions for processing each argument
// (feed, feed_manip, and distribute)
// ----------------------------------------------------------------------------
namespace boost {
namespace io {
namespace detail {
-namespace {
+namespace {
template<class Tr, class Ch> inline
- void empty_buf(BOOST_IO_STD basic_ostringstream<Ch,Tr> & os) {
- static const std::basic_string<Ch, Tr> emptyStr; // avoids 2 cases ( "" and L"" )
- os.str(emptyStr);
+ void empty_buf(BOOST_IO_STD basic_ostringstream<Ch,Tr> & os) {
+ static const std::basic_string<Ch, Tr> emptyStr;
+ os.str(emptyStr);
}
template<class Ch, class Tr>
- void do_fill( std::basic_string<Ch,Tr> & s,
- std::streamsize w,
- const Ch c,
- std::ios_base::fmtflags f,
- bool center)
+ void do_pad( std::basic_string<Ch,Tr> & s,
+ std::streamsize w,
+ const Ch c,
+ std::ios_base::fmtflags f,
+ bool center)
+ // applies centered / left / right padding to the string s.
+ // Effects : string s is padded.
{
std::streamsize n=w-s.size();
if(n<=0) {
return;
}
- if(center)
+ if(center)
{
- s.reserve(w); // allocate once for the 2 inserts
- const std::streamsize n1 = n /2, n0 = n - n1;
- s.insert(s.begin(), n0, c);
- s.append(n1, c);
- }
- else
+ s.reserve(w); // allocate once for the 2 inserts
+ const std::streamsize n1 = n /2, n0 = n - n1;
+ s.insert(s.begin(), n0, c);
+ s.append(n1, c);
+ }
+ else
{
- if(f & std::ios_base::left) {
- s.append(n, c);
- }
- else {
- s.insert(s.begin(), n, c);
- }
+ if(f & std::ios_base::left) {
+ s.append(n, c);
+ }
+ else {
+ s.insert(s.begin(), n, c);
+ }
}
- } // -do_fill(..)
+ } // -do_pad(..)
-#if !defined(BOOST_MSVC) || BOOST_MSVC > 1300
+#if BOOST_WORKAROUND( BOOST_MSVC, <= 1300)
+// MSVC needs to be tricked to disambiguate this simple overload..
+// the trick is in "boost/format/msvc_disambiguater.hpp"
+
+ template< class Ch, class Tr, class T> inline
+ void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const T& x ) {
+ disambiguater<Ch, Tr, T>::put_head(os, x, 1L);
+ }
+ template< class Ch, class Tr, class T> inline
+ void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const T& x ) {
+ disambiguater<Ch, Tr, T>::put_last(os, x, 1L);
+ }
+
+#else
+
template< class Ch, class Tr, class T> inline
void put_head(BOOST_IO_STD basic_ostream<Ch, Tr>& , const T& ) {
}
os << group_last(x.a1_); // this selects the last element
}
-#ifdef BOOST_OVERLOAD_FOR_NON_CONST
+#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST
template< class Ch, class Tr, class T> inline
void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& , T& ) {
}
os << x ;
}
#endif
-
-#else // MSVC needs to be tricked to disambiguate this simple overload..
- // the trick is in "boost/format/msvc_disambiguater.hpp"
-
- template< class Ch, class Tr, class T> inline
- void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const T& x ) {
- disambiguater<Ch, Tr, T>::put_head(os, x, 1L);
- }
- template< class Ch, class Tr, class T> inline
- void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const T& x ) {
- disambiguater<Ch, Tr, T>::put_last(os, x, 1L);
- }
-
#endif // -msvc workaround
+
+template< class Ch, class Tr, class T>
+void put( T x,
+ const format_item<Ch, Tr>& specs,
+ std::basic_string<Ch, Tr> & res,
+ BOOST_IO_STD basic_ostringstream<Ch, Tr>& oss_ )
+{
+ // does the actual conversion of x, with given params, into a string
+ // using the *supplied* strinstream. (the stream state is important)
+
+ typedef std::basic_string<Ch, Tr> string_t;
+ typedef format_item<Ch, Tr> format_item_t;
+
+ stream_format_state<Ch, Tr> prev_state(oss_);
+
+ specs.state_.apply_on(oss_);
+
+ // in case x is a group, apply the manip part of it,
+ // in order to find width
+ put_head( oss_, x );
+ empty_buf( oss_);
+
+ const std::streamsize w=oss_.width();
+ const std::ios_base::fmtflags fl=oss_.flags();
+ const bool internal = (fl & std::ios_base::internal) != 0;
+ const bool two_stepped_padding = internal
+ && ! ( specs.pad_scheme_ & format_item_t::spacepad )
+ && specs.truncate_ < 0 ;
+
+
+ if(! two_stepped_padding)
+ {
+ if(w>0) // handle simple padding via do_pad, not natively in stream
+ oss_.width(0);
+ put_last( oss_, x);
+ res = oss_.str();
+
+ if (specs.truncate_ >= 0 && static_cast<unsigned int>(specs.truncate_) < res.size() )
+ res.erase(specs.truncate_);
+
+ // complex pads :
+ if(specs.pad_scheme_ & format_item_t::spacepad)
+ {
+ if( res.size()==0 || ( res[0]!='+' && res[0]!='-' ))
+ {
+ res.insert(res.begin(), 1, ' '); // insert 1 space at pos 0
+ }
+ }
+ if(w > 0) // need do_pad
+ {
+ do_pad(res,w,oss_.fill(), fl, (specs.pad_scheme_ & format_item_t::centered) !=0 );
+ }
+ }
+ else // 2-stepped padding
+ {
+ put_last( oss_, x); // oss_.width() may result in padding.
+ res = oss_.str();
+
+ if (specs.truncate_ >= 0)
+ res.erase(specs.truncate_);
+
+ if( res.size() - w > 0)
+ { // length w exceeded
+ // either it was multi-output with first output padding up all width..
+ // either it was one big arg and we are fine.
+ empty_buf( oss_);
+ oss_.width(0);
+ put_last(oss_, x );
+ string_t tmp = oss_.str(); // minimal-length output
+ std::streamsize d;
+ if( (d=w - tmp.size()) <=0 )
+ {
+ // minimal length is already >= w, so no padding (cool!)
+ res.swap(tmp);
+ }
+ else
+ { // hum.. we need to pad (it was necessarily multi-output)
+ typedef typename string_t::size_type size_type;
+ size_type i = 0;
+ while( i<tmp.size() && tmp[i] == res[i] ) // find where we should pad.
+ ++i;
+ tmp.insert(i, static_cast<size_type>( d ), oss_.fill());
+ res.swap( tmp );
+ }
+ }
+ else
+ { // okay, only one thing was printed and padded, so res is fine.
+ }
+ }
- template< class Ch, class Tr, class T>
- void put( T x,
- const format_item<Ch, Tr>& specs,
- std::basic_string<Ch, Tr> & res,
- BOOST_IO_STD basic_ostringstream<Ch, Tr>& oss_ )
- {
- // does the actual conversion of x, with given params, into a string
- // using the *supplied* strinstream. (the stream state is important)
-
- typedef std::basic_string<Ch, Tr> string_t;
- typedef format_item<Ch, Tr> format_item_t;
-
- stream_format_state<Ch, Tr> prev_state(oss_);
-
- specs.state_.apply_on(oss_);
-
- // in case x is a group, apply the manip part of it,
- // in order to find width
- put_head( oss_, x );
- empty_buf( oss_);
-
- const std::streamsize w=oss_.width();
- const std::ios_base::fmtflags fl=oss_.flags();
- const bool internal = (fl & std::ios_base::internal) != 0;
- const bool two_phased_filling = internal
- && ! ( specs.pad_scheme_ & format_item_t::spacepad )
- && specs.truncate_ < 0 ;
-
- if( w > 0)
- {
- if(two_phased_filling)
- { } // in this case, let the stream do the padding, and later on, we'll do our hack..
- else {
- oss_.width(0);
- }
- }
-
- put_last( oss_, x);
- res = oss_.str();
-
- if (specs.truncate_ >= 0)
- res.erase(specs.truncate_);
-
- // complex fills :
-
- if(specs.pad_scheme_ & format_item_t::spacepad)
- {
- if( res.size()==0 || ( res[0]!='+' && res[0]!='-' ))
- {
- res.insert(res.begin(), 1, ' '); // insert 1 space at pos 0
- }
- }
-
- if(two_phased_filling)
- {
- if( res.size() - w > 0)
- {
- // either it was one big arg and we have nothing to do about it,
- // either it was multi-output with first output filling up all width..
- empty_buf( oss_);
- oss_.width(0);
- put_last(oss_, x );
- string_t tmp = oss_.str(); // minimal-length output
- std::streamsize d;
- if( (d=w - tmp.size()) >0 ) // hum.. then we need to pad.
- {
- typedef typename string_t::size_type size_type;
- size_type i = 0;
- while( i<tmp.size() && tmp[i] == res[i] ) // find where we should pad.
- ++i;
- tmp.insert(i, static_cast<size_type>( d ), oss_.fill());
- std::swap(res, tmp );
- }
- else
- {
- // size is already >= w, so no padding (cool!)
- std::swap(res, tmp );
- }
- }
- else
- { // okay, only one thing was printed and padded, so res is fine.
- }
- }
- else if(w > 0) // other cases that need do_fill
- {
- do_fill(res,w,oss_.fill(), fl, (specs.pad_scheme_ & format_item_t::centered) !=0 );
- }
+ prev_state.apply_on(oss_);
+ empty_buf( oss_);
+ oss_.clear();
+} // end- put(..)
- prev_state.apply_on(oss_);
- empty_buf( oss_);
- oss_.clear();
- }
} // local namespace
-template< class Ch, class Tr, class T>
-void distribute(basic_format<Ch,Tr>& self, T x)
+template< class Ch, class Tr, class T>
+void distribute(basic_format<Ch,Tr>& self, T x)
// call put(x, ..) on every occurence of the current argument :
{
- if(self.cur_arg_ >= self.num_args_)
- {
- if( self.exceptions() & too_many_args_bit )
- boost::throw_exception(too_many_args()); // too many variables have been supplied !
- else return;
- }
- for(unsigned long i=0; i < self.items_.size(); ++i)
+ if(self.cur_arg_ >= self.num_args_)
+ {
+ if( self.exceptions() & too_many_args_bit )
+ boost::throw_exception(too_many_args()); // too many variables have been supplied !
+ else return;
+ }
+ for(unsigned long i=0; i < self.items_.size(); ++i)
{
if(self.items_[i].argN_ == self.cur_arg_)
- {
- put<Ch, Tr, T> (x, self.items_[i], self.items_[i].res_, self.oss_ );
- }
- }
+ {
+ put<Ch, Tr, T> (x, self.items_[i], self.items_[i].res_, self.oss_ );
+ }
+ }
}
-
-template<class Ch, class Tr, class T>
-basic_format<Ch, Tr>& feed(basic_format<Ch,Tr>& self, T x)
+template<class Ch, class Tr, class T>
+basic_format<Ch, Tr>& feed(basic_format<Ch,Tr>& self, T x)
{
if(self.dumped_) self.clear();
distribute<Ch, Tr, T> (self, x);
if(self.bound_.size() != 0)
{
while( self.cur_arg_ < self.num_args_ && self.bound_[self.cur_arg_] )
- ++self.cur_arg_;
+ ++self.cur_arg_;
}
// this arg is finished, reset the stream's format state
self.state0_.apply_on(self.oss_);
return self;
}
-
+
} // namespace detail
} // namespace io
projects / lyx.git / blobdiff