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) && (_MSC_VER >= 1020)

     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> & 

    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> & 

    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> & 

    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> & 

   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 

   140     explicit back_insert_iterator(container_type & s)

   141         : container(& s)

   142     {}    // construct with container

   143     

   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 

   152     back_insert_iterator<container_type> & operator*(){

   153         return (*this);

   154     }

   155 

   156     back_insert_iterator<container_type> & operator++(){

   157         // pretend to preincrement

   158         return (*this);

   159     }

   160 

   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> 

   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 

   185     explicit back_insert_iterator(container_type & s)

   186         : container(& s)

   187     {}    // construct with container

   188     

   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 

   197     back_insert_iterator<container_type> & operator*(){

   198         return (*this);

   199     }

   200 

   201     back_insert_iterator<container_type> & operator++(){

   202         // pretend to preincrement

   203         return (*this);

   204     }

   205 

   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> 

   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