1 #ifndef BOOST_ARCHIVE_DINKUMWARE_HPP
2 #define BOOST_ARCHIVE_DINKUMWARE_HPP
3
4 // MS compatible compilers support #pragma once
5 #if defined(_MSC_VER)
6 # pragma once
7 #endif
8
9 /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
10 // dinkumware.hpp:
11
12 // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
13 // Use, modification and distribution is subject to the Boost Software
14 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
15 // http://www.boost.org/LICENSE_1_0.txt)
16
17 // See http://www.boost.org for updates, documentation, and revision history.
18
19 // this file adds a couple of things that are missing from the dinkumware
20 // implementation of the standard library.
21
22 #include <iterator>
23 #include <string>
24
25 #include <boost/config.hpp>
26 #include <boost/cstdint.hpp>
27
28 namespace std {
29
30 // define i/o operators for 64 bit integers
31 template<class CharType>
32 basic_ostream<CharType> &
operator <<(basic_ostream<CharType> & os,boost::uint64_t t)33 operator<<(basic_ostream<CharType> & os, boost::uint64_t t){
34 // octal rendering of 64 bit number would be 22 octets + eos
35 CharType d[23];
36 unsigned int radix;
37
38 if(os.flags() & (int)std::ios_base::hex)
39 radix = 16;
40 else
41 if(os.flags() & (int)std::ios_base::oct)
42 radix = 8;
43 else
44 //if(s.flags() & (int)std::ios_base::dec)
45 radix = 10;
46 unsigned int i = 0;
47 do{
48 unsigned int j = t % radix;
49 d[i++] = j + ((j < 10) ? '0' : ('a' - 10));
50 t /= radix;
51 }
52 while(t > 0);
53 d[i--] = '\0';
54
55 // reverse digits
56 unsigned int j = 0;
57 while(j < i){
58 CharType k = d[i];
59 d[i] = d[j];
60 d[j] = k;
61 --i;++j;
62 }
63 os << d;
64 return os;
65
66 }
67
68 template<class CharType>
69 basic_ostream<CharType> &
operator <<(basic_ostream<CharType> & os,boost::int64_t t)70 operator<<(basic_ostream<CharType> &os, boost::int64_t t){
71 if(0 <= t){
72 os << static_cast<boost::uint64_t>(t);
73 }
74 else{
75 os.put('-');
76 os << -t;
77 }
78 return os;
79 }
80
81 template<class CharType>
82 basic_istream<CharType> &
operator >>(basic_istream<CharType> & is,boost::int64_t & t)83 operator>>(basic_istream<CharType> &is, boost::int64_t & t){
84 CharType d;
85 do{
86 d = is.get();
87 }
88 while(::isspace(d));
89 bool negative = (d == '-');
90 if(negative)
91 d = is.get();
92 unsigned int radix;
93 if(is.flags() & (int)std::ios_base::hex)
94 radix = 16;
95 else
96 if(is.flags() & (int)std::ios_base::oct)
97 radix = 8;
98 else
99 //if(s.flags() & (int)std::ios_base::dec)
100 radix = 10;
101 t = 0;
102 do{
103 if('0' <= d && d <= '9')
104 t = t * radix + (d - '0');
105 else
106 if('a' <= d && d <= 'f')
107 t = t * radix + (d - 'a' + 10);
108 else
109 break;
110 d = is.get();
111 }
112 while(!is.fail());
113 // restore the delimiter
114 is.putback(d);
115 is.clear();
116 if(negative)
117 t = -t;
118 return is;
119 }
120
121 template<class CharType>
122 basic_istream<CharType> &
operator >>(basic_istream<CharType> & is,boost::uint64_t & t)123 operator>>(basic_istream<CharType> &is, boost::uint64_t & t){
124 boost::int64_t it;
125 is >> it;
126 t = it;
127 return is;
128 }
129
130 //#endif
131
132 template<>
133 class back_insert_iterator<basic_string<char> > : public
134 iterator<output_iterator_tag, char>
135 {
136 public:
137 typedef basic_string<char> container_type;
138 typedef container_type::reference reference;
139
back_insert_iterator(container_type & s)140 explicit back_insert_iterator(container_type & s)
141 : container(& s)
142 {} // construct with container
143
operator =(container_type::const_reference Val_)144 back_insert_iterator<container_type> & operator=(
145 container_type::const_reference Val_
146 ){ // push value into container
147 //container->push_back(Val_);
148 *container += Val_;
149 return (*this);
150 }
151
operator *()152 back_insert_iterator<container_type> & operator*(){
153 return (*this);
154 }
155
operator ++()156 back_insert_iterator<container_type> & operator++(){
157 // pretend to preincrement
158 return (*this);
159 }
160
operator ++(int)161 back_insert_iterator<container_type> operator++(int){
162 // pretend to postincrement
163 return (*this);
164 }
165
166 protected:
167 container_type *container; // pointer to container
168 };
169
170 template<char>
back_inserter(basic_string<char> & s)171 inline back_insert_iterator<basic_string<char> > back_inserter(
172 basic_string<char> & s
173 ){
174 return (std::back_insert_iterator<basic_string<char> >(s));
175 }
176
177 template<>
178 class back_insert_iterator<basic_string<wchar_t> > : public
179 iterator<output_iterator_tag, wchar_t>
180 {
181 public:
182 typedef basic_string<wchar_t> container_type;
183 typedef container_type::reference reference;
184
back_insert_iterator(container_type & s)185 explicit back_insert_iterator(container_type & s)
186 : container(& s)
187 {} // construct with container
188
operator =(container_type::const_reference Val_)189 back_insert_iterator<container_type> & operator=(
190 container_type::const_reference Val_
191 ){ // push value into container
192 //container->push_back(Val_);
193 *container += Val_;
194 return (*this);
195 }
196
operator *()197 back_insert_iterator<container_type> & operator*(){
198 return (*this);
199 }
200
operator ++()201 back_insert_iterator<container_type> & operator++(){
202 // pretend to preincrement
203 return (*this);
204 }
205
operator ++(int)206 back_insert_iterator<container_type> operator++(int){
207 // pretend to postincrement
208 return (*this);
209 }
210
211 protected:
212 container_type *container; // pointer to container
213 };
214
215 template<wchar_t>
back_inserter(basic_string<wchar_t> & s)216 inline back_insert_iterator<basic_string<wchar_t> > back_inserter(
217 basic_string<wchar_t> & s
218 ){
219 return (std::back_insert_iterator<basic_string<wchar_t> >(s));
220 }
221
222 } // namespace std
223
224 #endif //BOOST_ARCHIVE_DINKUMWARE_HPP
225