aboutsummaryrefslogtreecommitdiff
path: root/boost/format
diff options
context:
space:
mode:
Diffstat (limited to 'boost/format')
-rw-r--r--boost/format/Makefile.am3
-rw-r--r--boost/format/feed_args.hpp69
-rw-r--r--boost/format/format_class.hpp43
-rw-r--r--boost/format/format_fwd.hpp16
-rw-r--r--boost/format/format_implementation.cc (renamed from boost/format/format_implementation.hpp)46
-rw-r--r--boost/format/free_funcs.cc (renamed from boost/format/free_funcs.hpp)17
-rw-r--r--boost/format/group.hpp44
-rw-r--r--boost/format/internals.hpp48
-rw-r--r--boost/format/internals_fwd.hpp24
-rw-r--r--boost/format/parsing.cc (renamed from boost/format/parsing.hpp)113
10 files changed, 198 insertions, 225 deletions
diff --git a/boost/format/Makefile.am b/boost/format/Makefile.am
new file mode 100644
index 000000000..43a44a216
--- /dev/null
+++ b/boost/format/Makefile.am
@@ -0,0 +1,3 @@
+noinst_LIBRARIES = libformat.a
+
+libformat_a_SOURCES = format_implementation.cc free_funcs.cc parsing.cc
diff --git a/boost/format/feed_args.hpp b/boost/format/feed_args.hpp
index 2e678ca3b..ba107dce6 100644
--- a/boost/format/feed_args.hpp
+++ b/boost/format/feed_args.hpp
@@ -31,17 +31,16 @@ namespace io {
namespace detail {
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;
+ inline
+ void empty_buf(BOOST_IO_STD ostringstream & os) {
+ static const std::string emptyStr;
os.str(emptyStr);
}
- template<class Ch, class Tr>
- void do_pad( std::basic_string<Ch,Tr> & s,
+ void do_pad( std::string & s,
std::streamsize w,
- const Ch c,
- std::ios_base::fmtflags f,
+ const char c,
+ std::ios::fmtflags f,
bool center)
// applies centered / left / right padding to the string s.
// Effects : string s is padded.
@@ -59,7 +58,7 @@ namespace {
}
else
{
- if(f & std::ios_base::left) {
+ if(f & std::ios::left) {
s.append(n, c);
}
else {
@@ -69,32 +68,32 @@ namespace {
} // -do_pad(..)
- template< class Ch, class Tr, class T> inline
- void put_head(BOOST_IO_STD basic_ostream<Ch, Tr>& , const T& ) {
+ template<class T> inline
+ void put_head(BOOST_IO_STD ostream& , const T& ) {
}
- template< class Ch, class Tr, class T> inline
- void put_head( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const group1<T>& x ) {
+ template<class T> inline
+ void put_head( BOOST_IO_STD ostream& os, const group1<T>& x ) {
os << group_head(x.a1_); // send the first N-1 items, not the last
}
- template< class Ch, class Tr, class T> inline
- void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const T& x ) {
+ template<class T> inline
+ void put_last( BOOST_IO_STD ostream& os, const T& x ) {
os << x ;
}
- template< class Ch, class Tr, class T> inline
- void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, const group1<T>& x ) {
+ template<class T> inline
+ void put_last( BOOST_IO_STD ostream& os, const group1<T>& x ) {
os << group_last(x.a1_); // this selects the last element
}
#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& ) {
+ template<class T> inline
+ void put_head( BOOST_IO_STD ostream& , T& ) {
}
- template< class Ch, class Tr, class T> inline
- void put_last( BOOST_IO_STD basic_ostream<Ch, Tr>& os, T& x ) {
+ template<class T> inline
+ void put_last( BOOST_IO_STD ostream& os, T& x ) {
os << x ;
}
#endif
@@ -102,19 +101,19 @@ namespace {
-template< class Ch, class Tr, class T>
+template<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_ )
+ const format_item& specs,
+ std::string & res,
+ BOOST_IO_STD ostringstream& 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;
+ typedef std::string string_t;
+ typedef format_item format_item_t;
- stream_format_state<Ch, Tr> prev_state(oss_);
+ stream_format_state prev_state(oss_);
specs.state_.apply_on(oss_);
@@ -124,8 +123,8 @@ void put( T 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 std::ios::fmtflags fl=oss_.flags();
+ const bool internal = (fl & std::ios::internal) != 0;
const bool two_stepped_padding = internal
&& ! ( specs.pad_scheme_ & format_item_t::spacepad )
&& specs.truncate_ < 0 ;
@@ -203,8 +202,8 @@ void put( T x,
-template< class Ch, class Tr, class T>
-void distribute(basic_format<Ch,Tr>& self, T x)
+template<class T>
+void distribute(basic_format& self, T x)
// call put(x, ..) on every occurence of the current argument :
{
if(self.cur_arg_ >= self.num_args_)
@@ -217,16 +216,16 @@ void distribute(basic_format<Ch,Tr>& self, T x)
{
if(self.items_[i].argN_ == self.cur_arg_)
{
- put<Ch, Tr, T> (x, self.items_[i], self.items_[i].res_, self.oss_ );
+ put<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 T>
+basic_format& feed(basic_format& self, T x)
{
if(self.dumped_) self.clear();
- distribute<Ch, Tr, T> (self, x);
+ distribute<T> (self, x);
++self.cur_arg_;
if(self.bound_.size() != 0)
{
diff --git a/boost/format/format_class.hpp b/boost/format/format_class.hpp
index 9126bfad3..6875623ac 100644
--- a/boost/format/format_class.hpp
+++ b/boost/format/format_class.hpp
@@ -30,26 +30,21 @@
namespace boost {
-template<class Ch, class Tr>
class basic_format
{
public:
- typedef Ch CharT; // those 2 are necessary for borland compatibilty,
- typedef Tr Traits; // in the body of the operator% template.
-
-
- typedef std::basic_string<Ch, Tr> string_t;
- typedef BOOST_IO_STD basic_ostringstream<Ch, Tr> internal_stream_t;
+ typedef std::string string_t;
+ typedef BOOST_IO_STD ostringstream internal_stream_t;
private:
- typedef BOOST_IO_STD basic_ostream<Ch, Tr> stream_t;
- typedef io::detail::stream_format_state<Ch, Tr> stream_format_state;
- typedef io::detail::format_item<Ch, Tr> format_item_t;
+ typedef BOOST_IO_STD ostream stream_t;
+ typedef io::detail::stream_format_state stream_format_state;
+ typedef io::detail::format_item format_item_t;
public:
- basic_format(const Ch* str);
+ basic_format(const char* str);
basic_format(const string_t& s);
#ifndef BOOST_NO_STD_LOCALE
- basic_format(const Ch* str, const std::locale & loc);
+ basic_format(const char* str, const std::locale & loc);
basic_format(const string_t& s, const std::locale & loc);
#endif // no locale
basic_format(const basic_format& x);
@@ -60,13 +55,13 @@ public:
// pass arguments through those operators :
template<class T> basic_format& operator%(const T& x)
{
- return io::detail::feed<CharT, Traits, const T&>(*this,x);
+ return io::detail::feed<const T&>(*this,x);
}
#ifndef BOOST_NO_OVERLOAD_FOR_NON_CONST
template<class T> basic_format& operator%(T& x)
{
- return io::detail::feed<CharT, Traits, T&>(*this,x);
+ return io::detail::feed<T&>(*this,x);
}
#endif
@@ -93,21 +88,21 @@ public:
// final output
string_t str() const;
- friend BOOST_IO_STD basic_ostream<Ch, Tr>&
- operator<< <Ch, Tr> ( BOOST_IO_STD basic_ostream<Ch, Tr>& , const basic_format& );
+ friend BOOST_IO_STD ostream&
+ operator<< ( BOOST_IO_STD ostream& , const basic_format& );
- template<class Ch2, class Tr2, class T> friend basic_format<Ch2, Tr2>&
- io::detail::feed(basic_format<Ch2,Tr2>&, T);
+ template<class T> friend basic_format&
+ io::detail::feed(basic_format&, T);
- template<class Ch2, class Tr2, class T> friend
- void io::detail::distribute(basic_format<Ch2,Tr2>&, T);
+ template<class T> friend
+ void io::detail::distribute(basic_format&, T);
- template<class Ch2, class Tr2, class T> friend
- basic_format<Ch2, Tr2>& io::detail::modify_item_body(basic_format<Ch2, Tr2>&, int, const T&);
+ template<class T> friend
+ basic_format& io::detail::modify_item_body(basic_format&, int, const T&);
- template<class Ch2, class Tr2, class T> friend
- basic_format<Ch2, Tr2>& io::detail::bind_arg_body(basic_format<Ch2, Tr2>&, int, const T&);
+ template<class T> friend
+ basic_format& io::detail::bind_arg_body(basic_format&, int, const T&);
// make the members private only if the friend templates are supported
private:
diff --git a/boost/format/format_fwd.hpp b/boost/format/format_fwd.hpp
index bad2f7238..97c55f668 100644
--- a/boost/format/format_fwd.hpp
+++ b/boost/format/format_fwd.hpp
@@ -24,13 +24,9 @@
namespace boost {
-template<class charT, class Traits = BOOST_IO_STD char_traits<charT> > class basic_format;
+class basic_format;
-typedef basic_format<char > format;
-
-#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_STD_WSTREAMBUF)
-typedef basic_format<wchar_t > wformat;
-#endif
+typedef basic_format format;
namespace io {
enum format_error_bits { bad_format_string_bit = 1,
@@ -39,15 +35,13 @@ enum format_error_bits { bad_format_string_bit = 1,
all_error_bits = 255, no_error_bits=0 };
// Convertion: format to string
-template<class Ch, class Tr>
-std::basic_string<Ch, Tr> str(const basic_format<Ch, Tr>& ) ;
+std::string str(const basic_format& ) ;
} // namespace io
-template< class Ch, class Tr>
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>&, const basic_format<Ch, Tr>&);
+BOOST_IO_STD ostream&
+operator<<( BOOST_IO_STD ostream&, const basic_format&);
} // namespace boost
diff --git a/boost/format/format_implementation.hpp b/boost/format/format_implementation.cc
index 58372bb13..41cb5fc9f 100644
--- a/boost/format/format_implementation.hpp
+++ b/boost/format/format_implementation.cc
@@ -22,13 +22,12 @@
//#include <boost/throw_exception.hpp>
//#include <boost/assert.hpp>
-#include <boost/format/format_class.hpp>
+#include <boost/format.hpp>
namespace boost {
// -------- format:: -------------------------------------------
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const Ch* str)
+basic_format::basic_format(const char* str)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@@ -39,8 +38,7 @@ basic_format<Ch, Tr> ::basic_format(const Ch* str)
}
#ifndef BOOST_NO_STD_LOCALE
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const Ch* str, const std::locale & loc)
+basic_format::basic_format(const char* str, const std::locale & loc)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@@ -51,8 +49,7 @@ basic_format<Ch, Tr> ::basic_format(const Ch* str, const std::locale & loc)
parse( str );
}
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const string_t& s, const std::locale & loc)
+basic_format::basic_format(const string_t& s, const std::locale & loc)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@@ -62,8 +59,7 @@ basic_format<Ch, Tr> ::basic_format(const string_t& s, const std::locale & loc)
}
#endif //BOOST_NO_STD_LOCALE
-template< class Ch, class Tr>
-basic_format<Ch, Tr> ::basic_format(const string_t& s)
+basic_format::basic_format(const string_t& s)
: style_(0), cur_arg_(0), num_args_(0), dumped_(false),
items_(), oss_(), exceptions_(io::all_error_bits)
{
@@ -71,8 +67,7 @@ basic_format<Ch, Tr> ::basic_format(const string_t& s)
parse(s);
}
-template< class Ch, class Tr>
-basic_format<Ch, Tr> :: basic_format(const basic_format& x)
+basic_format:: basic_format(const basic_format& x)
: style_(x.style_), cur_arg_(x.cur_arg_), num_args_(x.num_args_), dumped_(false),
items_(x.items_), prefix_(x.prefix_), bound_(x.bound_),
oss_(), // <- we obviously can't copy x.oss_
@@ -81,8 +76,7 @@ basic_format<Ch, Tr> :: basic_format(const basic_format& x)
state0_.apply_on(oss_);
}
-template< class Ch, class Tr>
-basic_format<Ch, Tr>& basic_format<Ch, Tr> ::operator= (const basic_format& x)
+basic_format& basic_format::operator= (const basic_format& x)
{
if(this == &x)
return *this;
@@ -102,14 +96,12 @@ basic_format<Ch, Tr>& basic_format<Ch, Tr> ::operator= (const basic_format& x)
}
-template< class Ch, class Tr>
-unsigned char basic_format<Ch,Tr> ::exceptions() const
+unsigned char basic_format::exceptions() const
{
return exceptions_;
}
-template< class Ch, class Tr>
-unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept)
+unsigned char basic_format::exceptions(unsigned char newexcept)
{
unsigned char swp = exceptions_;
exceptions_ = newexcept;
@@ -117,8 +109,7 @@ unsigned char basic_format<Ch,Tr> ::exceptions(unsigned char newexcept)
}
-template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear()
+basic_format& basic_format ::clear()
// empty the string buffers (except bound arguments, see clear_binds() )
// and make the format object ready for formatting a new set of arguments
{
@@ -138,8 +129,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear()
return *this;
}
-template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds()
+basic_format& basic_format ::clear_binds()
// cancel all bindings, and clear()
{
bound_.resize(0);
@@ -147,8 +137,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_binds()
return *this;
}
-template< class Ch, class Tr>
-basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN)
+basic_format& basic_format::clear_bind(int argN)
// cancel the binding of ONE argument, and clear()
{
if(argN<1 || argN > num_args_ || bound_.size()==0 || !bound_[argN-1] )
@@ -164,8 +153,7 @@ basic_format<Ch,Tr>& basic_format<Ch,Tr> ::clear_bind(int argN)
-template< class Ch, class Tr>
-std::basic_string<Ch,Tr> basic_format<Ch,Tr> ::str() const
+std::string basic_format::str() const
{
dumped_=true;
if(items_.size()==0)
@@ -201,8 +189,8 @@ std::basic_string<Ch,Tr> basic_format<Ch,Tr> ::str() const
namespace io {
namespace detail {
-template<class Ch, class Tr, class T>
-basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
+template<class T>
+basic_format& bind_arg_body( basic_format& self,
int argN,
const T& val)
// bind one argument to a fixed value
@@ -239,8 +227,8 @@ basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
return self;
}
-template<class Ch, class Tr, class T>
-basic_format<Ch, Tr>& modify_item_body( basic_format<Ch, Tr>& self,
+template<class T>
+basic_format& modify_item_body( basic_format& self,
int itemN,
const T& manipulator)
// applies a manipulator to the format_item describing a given directive.
diff --git a/boost/format/free_funcs.hpp b/boost/format/free_funcs.cc
index d552e8baa..b2ac01774 100644
--- a/boost/format/free_funcs.hpp
+++ b/boost/format/free_funcs.cc
@@ -19,27 +19,26 @@
#ifndef BOOST_FORMAT_FUNCS_HPP
#define BOOST_FORMAT_FUNCS_HPP
-#include "boost/format/format_class.hpp"
+#include "boost/format.hpp"
//#include "boost/throw_exception.hpp"
namespace boost {
namespace io {
- template<class Ch, class Tr> inline
- std::basic_string<Ch, Tr> str(const basic_format<Ch, Tr>& f)
+ inline
+ std::string str(const basic_format& f)
// adds up all pieces of strings and converted items, and return the formatted string
{
return f.str();
}
} // - namespace io
-template< class Ch, class Tr>
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
- const boost::basic_format<Ch, Tr>& f)
+BOOST_IO_STD ostream&
+operator<<( BOOST_IO_STD ostream& os,
+ const boost::basic_format& f)
// effect: "return os << str(f);" but we can try to do it faster
{
- typedef boost::basic_format<Ch, Tr> format_t;
+ typedef boost::basic_format format_t;
if(f.items_.size()==0)
os << f.prefix_;
else {
@@ -53,7 +52,7 @@ operator<<( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
os << f.prefix_;
for(unsigned long i=0; i<f.items_.size(); ++i)
{
- const typename format_t::format_item_t& item = f.items_[i];
+ const format_t::format_item_t& item = f.items_[i];
os << item.res_;
os << item.appendix_;
diff --git a/boost/format/group.hpp b/boost/format/group.hpp
index d7785427e..ac63f3f0b 100644
--- a/boost/format/group.hpp
+++ b/boost/format/group.hpp
@@ -45,8 +45,8 @@ struct group0
template <class Ch, class Tr>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << ( BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << ( BOOST_IO_STD ostream& os,
const group0& )
{
return os;
@@ -63,8 +63,8 @@ struct group1
template <class Ch, class Tr, class T1>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group1<T1>& x)
{
os << x.a1_;
@@ -86,8 +86,8 @@ struct group2
template <class Ch, class Tr, class T1,class T2>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group2<T1,T2>& x)
{
os << x.a1_<< x.a2_;
@@ -107,8 +107,8 @@ struct group3
template <class Ch, class Tr, class T1,class T2,class T3>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group3<T1,T2,T3>& x)
{
os << x.a1_<< x.a2_<< x.a3_;
@@ -129,8 +129,8 @@ struct group4
template <class Ch, class Tr, class T1,class T2,class T3,class T4>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group4<T1,T2,T3,T4>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_;
@@ -152,8 +152,8 @@ struct group5
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group5<T1,T2,T3,T4,T5>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_;
@@ -176,8 +176,8 @@ struct group6
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group6<T1,T2,T3,T4,T5,T6>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_;
@@ -201,8 +201,8 @@ struct group7
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group7<T1,T2,T3,T4,T5,T6,T7>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_;
@@ -227,8 +227,8 @@ struct group8
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group8<T1,T2,T3,T4,T5,T6,T7,T8>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_;
@@ -254,8 +254,8 @@ struct group9
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group9<T1,T2,T3,T4,T5,T6,T7,T8,T9>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_;
@@ -282,8 +282,8 @@ struct group10
template <class Ch, class Tr, class T1,class T2,class T3,class T4,class T5,class T6,class T7,class T8,class T9,class T10>
inline
-BOOST_IO_STD basic_ostream<Ch, Tr>&
-operator << (BOOST_IO_STD basic_ostream<Ch, Tr>& os,
+BOOST_IO_STD ostream&
+operator << (BOOST_IO_STD ostream& os,
const group10<T1,T2,T3,T4,T5,T6,T7,T8,T9,T10>& x)
{
os << x.a1_<< x.a2_<< x.a3_<< x.a4_<< x.a5_<< x.a6_<< x.a7_<< x.a8_<< x.a9_<< x.a10_;
diff --git a/boost/format/internals.hpp b/boost/format/internals.hpp
index 52448b731..d25eb4c86 100644
--- a/boost/format/internals.hpp
+++ b/boost/format/internals.hpp
@@ -33,22 +33,21 @@ namespace detail {
// --------------
// set of params that define the format state of a stream
-template<class Ch, class Tr>
struct stream_format_state
{
- typedef BOOST_IO_STD basic_ios<Ch, Tr> basic_ios;
+ typedef std::ios basic_ios;
std::streamsize width_;
std::streamsize precision_;
- Ch fill_;
- std::ios_base::fmtflags flags_;
+ char fill_;
+ std::ios::fmtflags flags_;
- stream_format_state() : width_(-1), precision_(-1), fill_(0), flags_(std::ios_base::dec) {}
+ stream_format_state() : width_(-1), precision_(-1), fill_(0), flags_(std::ios::dec) {}
stream_format_state(basic_ios& os) {set_by_stream(os); }
void apply_on(basic_ios & os) const; //- applies format_state to the stream
template<class T> void apply_manip(T manipulator) //- modifies state by applying manipulator.
- { apply_manip_body<Ch, Tr, T>( *this, manipulator) ; }
+ { apply_manip_body<T>( *this, manipulator) ; }
void reset(); //- sets to default state.
void set_by_stream(const basic_ios& os); //- sets to os's state.
};
@@ -58,7 +57,6 @@ struct stream_format_state
// --------------
// format_item : stores all parameters that can be defined by directives in the format-string
-template<class Ch, class Tr>
struct format_item
{
enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 };
@@ -67,10 +65,10 @@ struct format_item
argN_tabulation = -2, // tabulation directive. (no argument read)
argN_ignored = -3 // ignored directive. (no argument read)
};
- typedef BOOST_IO_STD basic_ios<Ch, Tr> basic_ios;
- typedef detail::stream_format_state<Ch, Tr> stream_format_state;
- typedef std::basic_string<Ch, Tr> string_t;
- typedef BOOST_IO_STD basic_ostringstream<Ch, Tr> internal_stream_t;
+ typedef BOOST_IO_STD ios basic_ios;
+ typedef detail::stream_format_state stream_format_state;
+ typedef std::string string_t;
+ typedef BOOST_IO_STD ostringstream internal_stream_t;
int argN_; //- argument number (starts at 0, eg : %1 => argN=0)
@@ -98,8 +96,8 @@ struct format_item
// -----------------------------------------------------------
// --- stream_format_state:: -------------------------------------------
-template<class Ch, class Tr> inline
-void stream_format_state<Ch,Tr> ::apply_on(basic_ios & os) const
+inline
+void stream_format_state::apply_on(basic_ios & os) const
// set the state of this stream according to our params
{
if(width_ != -1)
@@ -111,8 +109,8 @@ void stream_format_state<Ch,Tr> ::apply_on(basic_ios & os) const
os.flags(flags_);
}
-template<class Ch, class Tr> inline
-void stream_format_state<Ch,Tr> ::set_by_stream(const basic_ios& os)
+inline
+void stream_format_state::set_by_stream(const basic_ios& os)
// set our params according to the state of this stream
{
flags_ = os.flags();
@@ -121,42 +119,42 @@ void stream_format_state<Ch,Tr> ::set_by_stream(const basic_ios& os)
fill_ = os.fill();
}
-template<class Ch, class Tr, class T> inline
-void apply_manip_body( stream_format_state<Ch, Tr>& self,
+template<class T> inline
+void apply_manip_body( stream_format_state& self,
T manipulator)
// modify our params according to the manipulator
{
- BOOST_IO_STD basic_stringstream<Ch, Tr> ss;
+ BOOST_IO_STD stringstream ss;
self.apply_on( ss );
ss << manipulator;
self.set_by_stream( ss );
}
-template<class Ch, class Tr> inline
-void stream_format_state<Ch,Tr> ::reset()
+inline
+void stream_format_state::reset()
// set our params to standard's default state
{
width_=-1; precision_=-1; fill_=0;
- flags_ = std::ios_base::dec;
+ flags_ = std::ios::dec;
}
// --- format_items:: -------------------------------------------
-template<class Ch, class Tr> inline
-void format_item<Ch, Tr> ::compute_states()
+inline
+void format_item::compute_states()
// reflect pad_scheme_ on state_ and ref_state_
// because some pad_schemes has complex consequences on several state params.
{
if(pad_scheme_ & zeropad)
{
- if(ref_state_.flags_ & std::ios_base::left)
+ if(ref_state_.flags_ & std::ios::left)
{
pad_scheme_ = pad_scheme_ & (~zeropad); // ignore zeropad in left alignment
}
else
{
ref_state_.fill_='0';
- ref_state_.flags_ |= std::ios_base::internal;
+ ref_state_.flags_ |= std::ios::internal;
}
}
state_ = ref_state_;
diff --git a/boost/format/internals_fwd.hpp b/boost/format/internals_fwd.hpp
index f260e6dec..a8ebf7c3a 100644
--- a/boost/format/internals_fwd.hpp
+++ b/boost/format/internals_fwd.hpp
@@ -26,8 +26,8 @@ namespace boost {
namespace io {
namespace detail {
- template<class Ch, class Tr> struct stream_format_state;
- template<class Ch, class Tr> struct format_item;
+ struct stream_format_state;
+ struct format_item;
}
@@ -37,24 +37,24 @@ namespace detail {
// but MSVC have problems with template member functions :
// defined in format_implementation.hpp :
- template<class Ch, class Tr, class T>
- basic_format<Ch, Tr>& modify_item_body( basic_format<Ch, Tr>& self,
+ template<class T>
+ basic_format& modify_item_body( basic_format& self,
int itemN, const T& manipulator);
- template<class Ch, class Tr, class T>
- basic_format<Ch, Tr>& bind_arg_body( basic_format<Ch, Tr>& self,
+ template<class T>
+ basic_format& bind_arg_body( basic_format& self,
int argN, const T& val);
- template<class Ch, class Tr, class T>
- void apply_manip_body( stream_format_state<Ch, Tr>& self,
+ template<class T>
+ void apply_manip_body( stream_format_state& self,
T manipulator);
// argument feeding (defined in feed_args.hpp ) :
- template<class Ch, class Tr, class T>
- void distribute(basic_format<Ch,Tr>& self, T x);
+ template<class T>
+ void distribute(basic_format& self, T x);
- template<class Ch, class Tr, class T>
- basic_format<Ch, Tr>& feed(basic_format<Ch,Tr>& self, T x);
+ template<class T>
+ basic_format& feed(basic_format& self, T x);
} // namespace detail
diff --git a/boost/format/parsing.hpp b/boost/format/parsing.cc
index a461314f9..1e12dea9b 100644
--- a/boost/format/parsing.hpp
+++ b/boost/format/parsing.cc
@@ -22,7 +22,7 @@
#define BOOST_FORMAT_PARSING_HPP
-#include <boost/format/format_class.hpp>
+#include <boost/format.hpp>
//#include <boost/throw_exception.hpp>
//#include <boost/assert.hpp>
@@ -31,8 +31,8 @@ namespace boost {
namespace io {
namespace detail {
- template<class Ch, class Stream> inline
- bool wrap_isdigit(Ch c, Stream &os)
+ template<class Stream> inline
+ bool wrap_isdigit(char c, Stream &os)
{
#ifndef BOOST_NO_LOCALE_ISIDIGIT
return std::isdigit(c, os.rdbuf()->getloc() );
@@ -42,10 +42,10 @@ namespace detail {
#endif
} //end- wrap_isdigit(..)
- template<class Res, class Ch, class Tr> inline
- Res str2int(const std::basic_string<Ch, Tr>& s,
- typename std::basic_string<Ch, Tr>::size_type start,
- BOOST_IO_STD basic_ios<Ch,Tr> &os,
+ template<class Res> inline
+ Res str2int(const std::string& s,
+ std::string::size_type start,
+ BOOST_IO_STD ios &os,
const Res = Res(0) )
// Input : char string, with starting index
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
@@ -54,7 +54,7 @@ namespace detail {
{
Res n = 0;
while(start<s.size() && wrap_isdigit(s[start], os) ) {
- char cur_ch = os.narrow( s[start], 0);
+ char cur_ch = s[start];
BOOST_ASSERT(cur_ch != 0 ); // since we called isdigit, this should not happen.
n *= 10;
n += cur_ch - '0'; // 22.2.1.1.2 of the C++ standard
@@ -63,10 +63,9 @@ namespace detail {
return n;
}
- template<class Ch, class Tr>
- void skip_asterisk(const std::basic_string<Ch,Tr> & buf,
- typename std::basic_string<Ch,Tr>::size_type * pos_p,
- BOOST_IO_STD basic_ios<Ch, Tr> &os)
+ void skip_asterisk(const std::string & buf,
+ std::string::size_type * pos_p,
+ BOOST_IO_STD ios &os)
// skip printf's "asterisk-fields" directives in the format-string buf
// Input : char string, with starting index *pos_p
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
@@ -76,10 +75,10 @@ namespace detail {
using namespace std;
BOOST_ASSERT( pos_p != 0);
if(*pos_p >= buf.size() ) return;
- if(buf[ *pos_p]==os.widen('*')) {
+ if(buf[ *pos_p]=='*') {
++ (*pos_p);
while (*pos_p < buf.size() && wrap_isdigit(buf[*pos_p],os)) ++(*pos_p);
- if(buf[*pos_p]==os.widen('$')) ++(*pos_p);
+ if(buf[*pos_p]=='$') ++(*pos_p);
}
}
@@ -95,11 +94,10 @@ namespace detail {
- template<class Ch, class Tr>
- bool parse_printf_directive(const std::basic_string<Ch, Tr> & buf,
- typename std::basic_string<Ch, Tr>::size_type * pos_p,
- detail::format_item<Ch, Tr> * fpar,
- BOOST_IO_STD basic_ios<Ch,Tr> &os,
+ bool parse_printf_directive(const std::string & buf,
+ std::string::size_type * pos_p,
+ detail::format_item * fpar,
+ BOOST_IO_STD ios &os,
unsigned char exceptions)
// Input : a 'printf-directive' in the format-string, starting at buf[ *pos_p ]
// a basic_ios& merely to call its widen/narrow member function in the desired locale.
@@ -109,14 +107,14 @@ namespace detail {
// Effects : - *pos_p is incremented so that buf[*pos_p] is the first char after the directive
// - *fpar is set with the parameters read in the directive
{
- typedef format_item<Ch, Tr> format_item_t;
+ typedef format_item format_item_t;
BOOST_ASSERT( pos_p != 0);
- typename std::basic_string<Ch, Tr>::size_type &i1 = *pos_p,
+ std::string::size_type &i1 = *pos_p,
i0;
fpar->argN_ = format_item_t::argN_no_posit; // if no positional-directive
bool in_brackets=false;
- if(buf[i1]==os.widen('|'))
+ if(buf[i1]=='|')
{
in_brackets=true;
if( ++i1 >= buf.size() ) {
@@ -126,7 +124,7 @@ namespace detail {
}
// the flag '0' would be picked as a digit for argument order, but here it's a flag :
- if(buf[i1]==os.widen('0'))
+ if(buf[i1]=='0')
goto parse_flags;
// handle argument order (%2$d) or possibly width specification: %2d
@@ -142,7 +140,7 @@ namespace detail {
int n=str2int(buf,i0, os, int(0) );
// %N% case : this is already the end of the directive
- if( buf[i1] == os.widen('%') )
+ if( buf[i1] == '%' )
{
fpar->argN_ = n-1;
++i1;
@@ -152,7 +150,7 @@ namespace detail {
else return true;
}
- if ( buf[i1]==os.widen('$') )
+ if ( buf[i1]=='$' )
{
fpar->argN_ = n-1;
++i1;
@@ -171,14 +169,14 @@ namespace detail {
while ( i1 <buf.size()) // as long as char is one of + - = # 0 l h or ' '
{
// misc switches
- switch (os.narrow(buf[i1], 0))
+ switch (buf[i1])
{
case '\'' : break; // no effect yet. (painful to implement)
case 'l':
case 'h': // short/long modifier : for printf-comaptibility (no action needed)
break;
case '-':
- fpar->ref_state_.flags_ |= std::ios_base::left;
+ fpar->ref_state_.flags_ |= std::ios::left;
break;
case '=':
fpar->pad_scheme_ |= format_item_t::centered;
@@ -187,7 +185,7 @@ namespace detail {
fpar->pad_scheme_ |= format_item_t::spacepad;
break;
case '+':
- fpar->ref_state_.flags_ |= std::ios_base::showpos;
+ fpar->ref_state_.flags_ |= std::ios::showpos;
break;
case '0':
fpar->pad_scheme_ |= format_item_t::zeropad;
@@ -195,7 +193,7 @@ namespace detail {
// so just add 'zeropad' flag for now, it will be processed later.
break;
case '#':
- fpar->ref_state_.flags_ |= std::ios_base::showpoint | std::ios_base::showbase;
+ fpar->ref_state_.flags_ |= std::ios::showpoint | std::ios::showbase;
break;
default:
goto parse_width;
@@ -223,7 +221,7 @@ namespace detail {
return true;
}
// handle precision spec
- if (buf[i1]==os.widen('.'))
+ if (buf[i1]=='.')
{
++i1;
skip_asterisk(buf, &i1, os);
@@ -239,51 +237,51 @@ namespace detail {
// handle formatting-type flags :
while( i1<buf.size() &&
- ( buf[i1]==os.widen('l') || buf[i1]==os.widen('L') || buf[i1]==os.widen('h')) )
+ ( buf[i1]=='l' || buf[i1]=='L' || buf[i1]=='h') )
++i1;
if( i1>=buf.size()) {
maybe_throw_exception(exceptions);
return true;
}
- if( in_brackets && buf[i1]==os.widen('|') )
+ if( in_brackets && buf[i1]=='|' )
{
++i1;
return true;
}
- switch (os.narrow(buf[i1], 0) )
+ switch (buf[i1])
{
case 'X':
- fpar->ref_state_.flags_ |= std::ios_base::uppercase;
+ fpar->ref_state_.flags_ |= std::ios::uppercase;
case 'p': // pointer => set hex.
case 'x':
- fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
- fpar->ref_state_.flags_ |= std::ios_base::hex;
+ fpar->ref_state_.flags_ &= ~std::ios::basefield;
+ fpar->ref_state_.flags_ |= std::ios::hex;
break;
case 'o':
- fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
- fpar->ref_state_.flags_ |= std::ios_base::oct;
+ fpar->ref_state_.flags_ &= ~std::ios::basefield;
+ fpar->ref_state_.flags_ |= std::ios::oct;
break;
case 'E':
- fpar->ref_state_.flags_ |= std::ios_base::uppercase;
+ fpar->ref_state_.flags_ |= std::ios::uppercase;
case 'e':
- fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
- fpar->ref_state_.flags_ |= std::ios_base::scientific;
+ fpar->ref_state_.flags_ &= ~std::ios::floatfield;
+ fpar->ref_state_.flags_ |= std::ios::scientific;
- fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
- fpar->ref_state_.flags_ |= std::ios_base::dec;
+ fpar->ref_state_.flags_ &= ~std::ios::basefield;
+ fpar->ref_state_.flags_ |= std::ios::dec;
break;
case 'f':
- fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
- fpar->ref_state_.flags_ |= std::ios_base::fixed;
+ fpar->ref_state_.flags_ &= ~std::ios::floatfield;
+ fpar->ref_state_.flags_ |= std::ios::fixed;
case 'u':
case 'd':
case 'i':
- fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
- fpar->ref_state_.flags_ |= std::ios_base::dec;
+ fpar->ref_state_.flags_ &= ~std::ios::basefield;
+ fpar->ref_state_.flags_ |= std::ios::dec;
break;
case 'T':
@@ -296,20 +294,20 @@ namespace detail {
fpar->argN_ = format_item_t::argN_tabulation;
break;
case 't':
- fpar->ref_state_.fill_ = os.widen(' ');
+ fpar->ref_state_.fill_ = ' ';
fpar->pad_scheme_ |= format_item_t::tabulation;
fpar->argN_ = format_item_t::argN_tabulation;
break;
case 'G':
- fpar->ref_state_.flags_ |= std::ios_base::uppercase;
+ fpar->ref_state_.flags_ |= std::ios::uppercase;
break;
case 'g': // 'g' conversion is default for floats.
- fpar->ref_state_.flags_ &= ~std::ios_base::basefield;
- fpar->ref_state_.flags_ |= std::ios_base::dec;
+ fpar->ref_state_.flags_ &= ~std::ios::basefield;
+ fpar->ref_state_.flags_ |= std::ios::dec;
// CLEAR all floatield flags, so stream will CHOOSE
- fpar->ref_state_.flags_ &= ~std::ios_base::floatfield;
+ fpar->ref_state_.flags_ &= ~std::ios::floatfield;
break;
case 'C':
@@ -331,7 +329,7 @@ namespace detail {
if( in_brackets )
{
- if( i1<buf.size() && buf[i1]==os.widen('|') )
+ if( i1<buf.size() && buf[i1]=='|' )
{
++i1;
return true;
@@ -348,15 +346,14 @@ namespace detail {
// -----------------------------------------------
// format :: parse(..)
-template<class Ch, class Traits>
-void basic_format<Ch, Traits> ::parse(const string_t & buf)
+void basic_format::parse(const string_t & buf)
// parse the format-string
{
using namespace std;
- const Ch arg_mark = oss_.widen('%');
+ const char arg_mark = '%';
bool ordered_args=true;
int max_argN=-1;
- typename string_t::size_type i1=0;
+ string_t::size_type i1=0;
int num_items=0;
// A: find upper_bound on num_items and allocates arrays
@@ -382,7 +379,7 @@ void basic_format<Ch, Traits> ::parse(const string_t & buf)
// B: Now the real parsing of the format string :
num_items=0;
i1 = 0;
- typename string_t::size_type i0 = i1;
+ string_t::size_type i0 = i1;
bool special_things=false;
int cur_it=0;
while( (i1=buf.find(arg_mark,i1)) != string::npos )
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 22:56:05 +0000