~ubuntu-branches/ubuntu/wily/bombono-dvd/wily

« back to all changes in this revision

Viewing changes to libs/boost-lib/boost/format/internals.hpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessio Treglia
  • Date: 2010-03-12 08:42:05 UTC
  • mto: This revision was merged to the branch mainline in revision 4.
  • Revision ID: james.westby@ubuntu.com-20100312084205-kugmzrqqv7zm3k7n
Tags: upstream-0.5.5
Import upstream version 0.5.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
// ----------------------------------------------------------------------------
 
2
// internals.hpp :  internal structs : stream_format_state, format_item. 
 
3
//                  included by format.hpp
 
4
// ----------------------------------------------------------------------------
 
5
 
 
6
//  Copyright Samuel Krempp 2003. Use, modification, and distribution are
 
7
//  subject to the Boost Software License, Version 1.0. (See accompanying
 
8
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
9
 
 
10
//  See http://www.boost.org/libs/format for library home page
 
11
 
 
12
// ----------------------------------------------------------------------------
 
13
 
 
14
#ifndef BOOST_FORMAT_INTERNALS_HPP
 
15
#define BOOST_FORMAT_INTERNALS_HPP
 
16
 
 
17
 
 
18
#include <string>
 
19
#include <boost/assert.hpp>
 
20
#include <boost/optional.hpp>
 
21
#include <boost/limits.hpp>
 
22
#include <boost/format/detail/compat_workarounds.hpp>
 
23
#include <boost/format/alt_sstream.hpp> // used as a dummy stream
 
24
 
 
25
namespace boost {
 
26
namespace io {
 
27
namespace detail {
 
28
 
 
29
 
 
30
//---- stream_format_state --------------------------------------------------//
 
31
 
 
32
//   set of params that define the format state of a stream
 
33
    template<class Ch, class Tr> 
 
34
    struct stream_format_state 
 
35
    {
 
36
        typedef BOOST_IO_STD basic_ios<Ch, Tr>   basic_ios;
 
37
 
 
38
        stream_format_state(Ch fill)                 { reset(fill); }
 
39
//        stream_format_state(const basic_ios& os)     { set_by_stream(os); }
 
40
 
 
41
        void reset(Ch fill);                     //- sets to default state.
 
42
        void set_by_stream(const basic_ios& os); //- sets to os's state.
 
43
        void apply_on(basic_ios & os,            //- applies format_state to the stream
 
44
                      boost::io::detail::locale_t * loc_default = 0) const;
 
45
        template<class T> 
 
46
        void apply_manip(T manipulator)          //- modifies state by applying manipulator
 
47
            { apply_manip_body<Ch, Tr, T>( *this, manipulator) ; }
 
48
 
 
49
        // --- data ---
 
50
        std::streamsize width_;
 
51
        std::streamsize precision_;
 
52
        Ch fill_; 
 
53
        std::ios_base::fmtflags flags_;
 
54
        std::ios_base::iostate  rdstate_;
 
55
        std::ios_base::iostate  exceptions_;
 
56
        boost::optional<boost::io::detail::locale_t>  loc_;
 
57
    };  
 
58
 
 
59
 
 
60
//---- format_item  ---------------------------------------------------------//
 
61
 
 
62
//   stores all parameters that can be specified in format strings
 
63
    template<class Ch, class Tr, class Alloc>  
 
64
    struct format_item 
 
65
    {     
 
66
        enum pad_values { zeropad = 1, spacepad =2, centered=4, tabulation = 8 };
 
67
                         // 1. if zeropad is set, all other bits are not, 
 
68
                         // 2. if tabulation is set, all others are not.
 
69
                         // centered and spacepad can be mixed freely.
 
70
        enum arg_values { argN_no_posit   = -1, // non-positional directive. will set argN later
 
71
                          argN_tabulation = -2, // tabulation directive. (no argument read) 
 
72
                          argN_ignored    = -3  // ignored directive. (no argument read)
 
73
        };
 
74
        typedef BOOST_IO_STD basic_ios<Ch, Tr>                    basic_ios;
 
75
        typedef detail::stream_format_state<Ch, Tr>               stream_format_state;
 
76
        typedef ::std::basic_string<Ch, Tr, Alloc>                string_type;
 
77
 
 
78
        format_item(Ch fill) :argN_(argN_no_posit), fmtstate_(fill), 
 
79
                              truncate_(max_streamsize()), pad_scheme_(0)  {}
 
80
        void reset(Ch fill);
 
81
        void compute_states(); // sets states  according to truncate and pad_scheme.
 
82
 
 
83
        static std::streamsize max_streamsize() { 
 
84
            return (std::numeric_limits<std::streamsize>::max)();
 
85
        }
 
86
 
 
87
        // --- data ---
 
88
        int         argN_;  //- argument number (starts at 0,  eg : %1 => argN=0)
 
89
                            //  negative values for items that don't process an argument
 
90
        string_type  res_;      //- result of the formatting of this item
 
91
        string_type  appendix_; //- piece of string between this item and the next
 
92
 
 
93
        stream_format_state fmtstate_;// set by parsing, is only affected by modify_item
 
94
 
 
95
        std::streamsize truncate_;//- is set for directives like %.5s that ask truncation
 
96
        unsigned int pad_scheme_;//- several possible padding schemes can mix. see pad_values
 
97
    }; 
 
98
 
 
99
 
 
100
 
 
101
//--- Definitions  ------------------------------------------------------------
 
102
 
 
103
// -   stream_format_state:: -------------------------------------------------
 
104
    template<class Ch, class Tr>
 
105
    void stream_format_state<Ch,Tr>:: apply_on (basic_ios & os,
 
106
                      boost::io::detail::locale_t * loc_default) const {
 
107
        // set the state of this stream according to our params
 
108
        if(width_ != -1)
 
109
            os.width(width_);
 
110
        if(precision_ != -1)
 
111
            os.precision(precision_);
 
112
        if(fill_ != 0)
 
113
            os.fill(fill_);
 
114
        os.flags(flags_);
 
115
        os.clear(rdstate_);
 
116
        os.exceptions(exceptions_);
 
117
#if !defined(BOOST_NO_STD_LOCALE)
 
118
        if(loc_)
 
119
            os.imbue(loc_.get());
 
120
        else if(loc_default)
 
121
            os.imbue(*loc_default);
 
122
#endif        
 
123
    }
 
124
 
 
125
    template<class Ch, class Tr>
 
126
    void stream_format_state<Ch,Tr>:: set_by_stream(const basic_ios& os) {
 
127
        // set our params according to the state of this stream
 
128
        flags_ = os.flags();
 
129
        width_ = os.width();
 
130
        precision_ = os.precision();
 
131
        fill_ = os.fill();
 
132
        rdstate_ = os.rdstate();
 
133
        exceptions_ = os.exceptions();
 
134
    }
 
135
 
 
136
 
 
137
    template<class Ch, class Tr, class T>
 
138
    void apply_manip_body( stream_format_state<Ch, Tr>& self,
 
139
                           T manipulator) {
 
140
        // modify our params according to the manipulator
 
141
        basic_oaltstringstream<Ch, Tr>  ss;
 
142
        self.apply_on( ss );
 
143
        ss << manipulator;
 
144
        self.set_by_stream( ss );
 
145
    }
 
146
 
 
147
    template<class Ch, class Tr> inline
 
148
    void stream_format_state<Ch,Tr>:: reset(Ch fill) {
 
149
        // set our params to standard's default state.   cf � 27.4.4.1 of the C++ norm
 
150
        width_=0; precision_=6; 
 
151
        fill_=fill; // default is widen(' '), but we cant compute it without the locale
 
152
        flags_ = std::ios_base::dec | std::ios_base::skipws; 
 
153
        // the adjust_field part is left equal to 0, which means right.
 
154
        exceptions_ = std::ios_base::goodbit;
 
155
        rdstate_ = std::ios_base::goodbit;
 
156
    }
 
157
 
 
158
 
 
159
// ---   format_item:: --------------------------------------------------------
 
160
 
 
161
    template<class Ch, class Tr, class Alloc> 
 
162
    void format_item<Ch, Tr, Alloc>:: 
 
163
    reset (Ch fill) { 
 
164
        argN_=argN_no_posit; truncate_ = max_streamsize(); pad_scheme_ =0; 
 
165
        res_.resize(0); appendix_.resize(0);
 
166
        fmtstate_.reset(fill);
 
167
    }
 
168
 
 
169
    template<class Ch, class Tr, class Alloc> 
 
170
    void format_item<Ch, Tr, Alloc>:: 
 
171
    compute_states() {
 
172
        // reflect pad_scheme_   on  fmt_state_
 
173
        //   because some pad_schemes has complex consequences on several state params.
 
174
        if(pad_scheme_ & zeropad) {
 
175
            // ignore zeropad in left alignment :
 
176
            if(fmtstate_.flags_ & std::ios_base::left) {
 
177
              BOOST_ASSERT(!(fmtstate_.flags_ &(std::ios_base::adjustfield ^std::ios_base::left)));
 
178
              // only left bit might be set. (not right, nor internal)
 
179
              pad_scheme_ = pad_scheme_ & (~zeropad); 
 
180
            }
 
181
            else { 
 
182
                pad_scheme_ &= ~spacepad; // printf ignores spacepad when zeropadding
 
183
                fmtstate_.fill_='0'; 
 
184
                fmtstate_.flags_ = (fmtstate_.flags_ & ~std::ios_base::adjustfield) 
 
185
                    | std::ios_base::internal;
 
186
                // removes all adjustfield bits, and adds internal.
 
187
            }
 
188
        }
 
189
        if(pad_scheme_ & spacepad) {
 
190
            if(fmtstate_.flags_ & std::ios_base::showpos)
 
191
                pad_scheme_ &= ~spacepad;
 
192
        }
 
193
    }
 
194
 
 
195
 
 
196
} } } // namespaces boost :: io :: detail
 
197
 
 
198
 
 
199
#endif // BOOST_FORMAT_INTERNALS_HPP