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