| #ifndef BOOST_ARCHIVE_DINKUMWARE_HPP |
| #define BOOST_ARCHIVE_DINKUMWARE_HPP |
| |
| // MS compatible compilers support #pragma once |
| #if defined(_MSC_VER) && (_MSC_VER >= 1020) |
| # pragma once |
| #endif |
| |
| /////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 |
| // dinkumware.hpp: |
| |
| // (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . |
| // Use, modification and distribution is 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 for updates, documentation, and revision history. |
| |
| // this file adds a couple of things that are missing from the dinkumware |
| // implementation of the standard library. |
| |
| #include <iterator> |
| #include <string> |
| |
| #include <boost/config.hpp> |
| #include <boost/cstdint.hpp> |
| |
| namespace std { |
| |
| // define i/o operators for 64 bit integers |
| template<class CharType> |
| basic_ostream<CharType> & |
| operator<<(basic_ostream<CharType> & os, boost::uint64_t t){ |
| // octal rendering of 64 bit number would be 22 octets + eos |
| CharType d[23]; |
| unsigned int radix; |
| |
| if(os.flags() & (int)std::ios_base::hex) |
| radix = 16; |
| else |
| if(os.flags() & (int)std::ios_base::oct) |
| radix = 8; |
| else |
| //if(s.flags() & (int)std::ios_base::dec) |
| radix = 10; |
| unsigned int i = 0; |
| do{ |
| unsigned int j = t % radix; |
| d[i++] = j + ((j < 10) ? '0' : ('a' - 10)); |
| t /= radix; |
| } |
| while(t > 0); |
| d[i--] = '\0'; |
| |
| // reverse digits |
| unsigned int j = 0; |
| while(j < i){ |
| CharType k = d[i]; |
| d[i] = d[j]; |
| d[j] = k; |
| --i;++j; |
| } |
| os << d; |
| return os; |
| |
| } |
| |
| template<class CharType> |
| basic_ostream<CharType> & |
| operator<<(basic_ostream<CharType> &os, boost::int64_t t){ |
| if(0 <= t){ |
| os << static_cast<boost::uint64_t>(t); |
| } |
| else{ |
| os.put('-'); |
| os << -t; |
| } |
| return os; |
| } |
| |
| template<class CharType> |
| basic_istream<CharType> & |
| operator>>(basic_istream<CharType> &is, boost::int64_t & t){ |
| CharType d; |
| do{ |
| d = is.get(); |
| } |
| while(::isspace(d)); |
| bool negative = (d == '-'); |
| if(negative) |
| d = is.get(); |
| unsigned int radix; |
| if(is.flags() & (int)std::ios_base::hex) |
| radix = 16; |
| else |
| if(is.flags() & (int)std::ios_base::oct) |
| radix = 8; |
| else |
| //if(s.flags() & (int)std::ios_base::dec) |
| radix = 10; |
| t = 0; |
| do{ |
| if('0' <= d && d <= '9') |
| t = t * radix + (d - '0'); |
| else |
| if('a' <= d && d <= 'f') |
| t = t * radix + (d - 'a' + 10); |
| else |
| break; |
| d = is.get(); |
| } |
| while(!is.fail()); |
| // restore the delimiter |
| is.putback(d); |
| is.clear(); |
| if(negative) |
| t = -t; |
| return is; |
| } |
| |
| template<class CharType> |
| basic_istream<CharType> & |
| operator>>(basic_istream<CharType> &is, boost::uint64_t & t){ |
| boost::int64_t it; |
| is >> it; |
| t = it; |
| return is; |
| } |
| |
| //#endif |
| |
| template<> |
| class back_insert_iterator<basic_string<char> > : public |
| iterator<output_iterator_tag, char> |
| { |
| public: |
| typedef basic_string<char> container_type; |
| typedef container_type::reference reference; |
| |
| explicit back_insert_iterator(container_type & s) |
| : container(& s) |
| {} // construct with container |
| |
| back_insert_iterator<container_type> & operator=( |
| container_type::const_reference Val_ |
| ){ // push value into container |
| //container->push_back(Val_); |
| *container += Val_; |
| return (*this); |
| } |
| |
| back_insert_iterator<container_type> & operator*(){ |
| return (*this); |
| } |
| |
| back_insert_iterator<container_type> & operator++(){ |
| // pretend to preincrement |
| return (*this); |
| } |
| |
| back_insert_iterator<container_type> operator++(int){ |
| // pretend to postincrement |
| return (*this); |
| } |
| |
| protected: |
| container_type *container; // pointer to container |
| }; |
| |
| template<char> |
| inline back_insert_iterator<basic_string<char> > back_inserter( |
| basic_string<char> & s |
| ){ |
| return (std::back_insert_iterator<basic_string<char> >(s)); |
| } |
| |
| template<> |
| class back_insert_iterator<basic_string<wchar_t> > : public |
| iterator<output_iterator_tag, wchar_t> |
| { |
| public: |
| typedef basic_string<wchar_t> container_type; |
| typedef container_type::reference reference; |
| |
| explicit back_insert_iterator(container_type & s) |
| : container(& s) |
| {} // construct with container |
| |
| back_insert_iterator<container_type> & operator=( |
| container_type::const_reference Val_ |
| ){ // push value into container |
| //container->push_back(Val_); |
| *container += Val_; |
| return (*this); |
| } |
| |
| back_insert_iterator<container_type> & operator*(){ |
| return (*this); |
| } |
| |
| back_insert_iterator<container_type> & operator++(){ |
| // pretend to preincrement |
| return (*this); |
| } |
| |
| back_insert_iterator<container_type> operator++(int){ |
| // pretend to postincrement |
| return (*this); |
| } |
| |
| protected: |
| container_type *container; // pointer to container |
| }; |
| |
| template<wchar_t> |
| inline back_insert_iterator<basic_string<wchar_t> > back_inserter( |
| basic_string<wchar_t> & s |
| ){ |
| return (std::back_insert_iterator<basic_string<wchar_t> >(s)); |
| } |
| |
| } // namespace std |
| |
| #endif //BOOST_ARCHIVE_DINKUMWARE_HPP |