#ifndef BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP

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

 // basic_text_oprimitive.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.

 // archives stored as text - note these ar templated on the basic

 // stream templates to accommodate wide (and other?) kind of characters

 //

 // note the fact that on libraries without wide characters, ostream is

 // is not a specialization of basic_ostream which in fact is not defined

 // in such cases.   So we can't use basic_ostream<OStream::char_type> but rather

 // use two template parameters

 #include <iomanip>

 #include <locale>

 #include <cstddef> // size_t

 #include <cmath> // isnan

 #include <cassert>

 #include <boost/config.hpp>

 #include <boost/detail/workaround.hpp>

 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)

 #include <boost/archive/dinkumware.hpp>

 #endif

 #if defined(BOOST_NO_STDC_NAMESPACE)

 namespace std{ 

     using ::size_t;

     #if ! defined(BOOST_DINKUMWARE_STDLIB) && ! defined(__SGI_STL_PORT)

         using ::locale;

     #endif

 } // namespace std

 #endif

 #include <boost/limits.hpp>

 #include <boost/io/ios_state.hpp>

 #include <boost/scoped_ptr.hpp>

 #include <boost/throw_exception.hpp>

 #include <boost/archive/archive_exception.hpp>

 #include <boost/archive/detail/abi_prefix.hpp> // must be the last header

 namespace boost {

 namespace archive {

 class save_access;

 /////////////////////////////////////////////////////////////////////////

 // class basic_text_oprimitive - output of prmitives to stream

 template<class OStream>

 class basic_text_oprimitive

 {

 #ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS

 protected:

 #else

 public:

 #endif

     OStream &os;

     io::ios_flags_saver flags_saver;

     io::ios_precision_saver precision_saver;

     boost::scoped_ptr<std::locale> archive_locale;

     io::basic_ios_locale_saver<

         BOOST_DEDUCED_TYPENAME OStream::char_type, BOOST_DEDUCED_TYPENAME OStream::traits_type

     > locale_saver;

     // default saving of primitives.

     template<class T>

     void save(const T &t){

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << t;

     }

     /////////////////////////////////////////////////////////

     // fundamental types that need special treatment

     void save(const bool t){

         // trap usage of invalid uninitialized boolean which would

         // otherwise crash on load.

         int i = t;

         assert(0 == i || 1 == i);

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << t;

     }

     void save(const signed char t)

     {

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << static_cast<short int>(t);

     }

     void save(const unsigned char t)

     {

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << static_cast<short unsigned int>(t);

     }

     void save(const char t)

     {

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << static_cast<short int>(t);

     }

     #ifndef BOOST_NO_INTRINSIC_WCHAR_T

     void save(const wchar_t t)

     {

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << static_cast<int>(t);

     }

     #endif

     void save(const float t)

     {

         // must be a user mistake - can't serialize un-initialized data

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << std::setprecision(std::numeric_limits<float>::digits10 + 2);

         os << t;

     }

     void save(const double t)

     {

         // must be a user mistake - can't serialize un-initialized data

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os << std::setprecision(std::numeric_limits<double>::digits10 + 2);

         os << t;

     }

     BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())

     basic_text_oprimitive(OStream & os, bool no_codecvt);

     BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) 

     ~basic_text_oprimitive();

 public:

     // unformatted append of one character

     void put(int c){

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         os.put(c);

     }

     // unformatted append of null terminated string

     void put(const char * s){

         if(os.fail())

             boost::throw_exception(archive_exception(archive_exception::stream_error));

         while('\0' != *s)

             os.put(*s++);

     }

     BOOST_ARCHIVE_OR_WARCHIVE_DECL(void) 

     save_binary(const void *address, std::size_t count);

 };

 } //namespace boost 

 } //namespace archive 

 #include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas

 #endif // BOOST_ARCHIVE_BASIC_TEXT_OPRIMITIVE_HPP