|
|
Boost-Commit : |
From: troy_at_[hidden]
Date: 2008-07-01 12:53:37
Author: troy
Date: 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
New Revision: 46968
URL: http://svn.boost.org/trac/boost/changeset/46968
Log:
use modularize targets, not externals to manage modularization
Added:
branches/CMake/release/libs/serialization/include/boost/archive/
branches/CMake/release/libs/serialization/include/boost/archive/add_facet.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/archive_exception.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_archive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_iprimitive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_oprimitive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_streambuf_locale_saver.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_text_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_text_iprimitive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_text_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_text_oprimitive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_archive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/binary_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/binary_iarchive_impl.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/binary_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/binary_oarchive_impl.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/binary_wiarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/binary_woarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/codecvt_null.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/
branches/CMake/release/libs/serialization/include/boost/archive/detail/abi_prefix.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/abi_suffix.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/archive_pointer_iserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/archive_pointer_oserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/auto_link_archive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/auto_link_warchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_archive_impl.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_config.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_iserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_oserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_pointer_iserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_pointer_oserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_serializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_serializer_map.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/common_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/common_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/decl.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/interface_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/interface_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/iserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/oserializer.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/polymorphic_iarchive_route.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/polymorphic_oarchive_route.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/register_archive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/detail/utf8_codecvt_facet.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/dinkumware.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/
branches/CMake/release/libs/serialization/include/boost/archive/impl/archive_pointer_iserializer.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/archive_pointer_oserializer.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_iarchive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_iprimitive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_oarchive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_oprimitive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_iarchive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_iprimitive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_oarchive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_oprimitive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_grammar.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_iarchive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_oarchive.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/text_iarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/text_oarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/text_wiarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/text_woarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_iarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_oarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_wiarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_woarchive_impl.ipp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/
branches/CMake/release/libs/serialization/include/boost/archive/iterators/base64_exception.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/base64_from_binary.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/binary_from_base64.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/dataflow.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/dataflow_exception.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/escape.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/head_iterator.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/insert_linebreaks.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/istream_iterator.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/mb_from_wchar.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/ostream_iterator.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/remove_whitespace.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/transform_width.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/unescape.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/wchar_from_mb.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_escape.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_unescape.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_unescape_exception.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_binary_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_binary_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_wiarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_woarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_wiarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_woarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/shared_ptr_helper.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/text_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/text_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/text_wiarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/text_woarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/tmpdir.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/wcslen.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/xml_archive_exception.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/xml_iarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/xml_oarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/xml_wiarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/archive/xml_woarchive.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/
branches/CMake/release/libs/serialization/include/boost/serialization/access.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/array.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/assume_abstract.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/base_object.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/binary_object.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/collection_size_type.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/collection_traits.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/collections_load_imp.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/collections_save_imp.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/complex.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/config.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/deque.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/detail/
branches/CMake/release/libs/serialization/include/boost/serialization/detail/get_data.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_count_132.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_ptr_132.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_ptr_nmt_132.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/detail/stack_constructor.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/ephemeral.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/export.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info_no_rtti.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info_typeid.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/factory.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/force_include.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/hash_collections_load_imp.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/hash_collections_save_imp.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/hash_map.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/hash_set.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/is_bitwise_serializable.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/level.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/level_enum.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/list.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/map.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/nvp.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/optional.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/scoped_ptr.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/serialization.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/set.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/shared_ptr.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/shared_ptr_132.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/singleton.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/slist.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/split_free.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/split_member.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/string.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/tracking.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/tracking_enum.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/traits.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/type_info_implementation.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/utility.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/valarray.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/variant.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/vector.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/version.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/void_cast.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/void_cast_fwd.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/weak_ptr.hpp (contents, props changed)
branches/CMake/release/libs/serialization/include/boost/serialization/wrapper.hpp (contents, props changed)
Properties modified:
branches/CMake/release/libs/serialization/include/boost/ (props changed)
Added: branches/CMake/release/libs/serialization/include/boost/archive/add_facet.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/add_facet.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,55 @@
+#ifndef BOOST_ARCHIVE_ADD_FACET_HPP
+#define BOOST_ARCHIVE_ADD_FACET_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
+// add_facet.hpp
+
+// (C) Copyright 2003 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.
+
+#include <locale>
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+// does STLport uses native STL for locales?
+#if (defined(__SGI_STL_PORT)&& defined(_STLP_NO_OWN_IOSTREAMS))
+// and this native STL lib is old Dinkumware (has not defined _CPPLIB_VER)
+# if (defined(_YVALS) && !defined(__IBMCPP__)) || !defined(_CPPLIB_VER)
+# define BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
+# endif
+#endif
+
+namespace boost {
+namespace archive {
+
+template<class Facet>
+inline std::locale *
+add_facet(const std::locale &l, Facet * f){
+ return
+ #if defined BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
+ // std namespace used for native locale
+ new std::locale(std::_Addfac(l, f));
+ #elif BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) // old Dinkumwar
+ // std namespace used for native locale
+ new std::locale(std::_Addfac(l, f));
+ #else
+ // standard compatible
+ new std::locale(l, f);
+ #endif
+}
+
+} // namespace archive
+} // namespace boost
+
+#undef BOOST_ARCHIVE_OLD_DINKUMWARE_BENEATH_STLPORT
+
+#endif // BOOST_ARCHIVE_ADD_FACET_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/archive_exception.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/archive_exception.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,115 @@
+#ifndef BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ARCHIVE_EXCEPTION_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
+// archive/archive_exception.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.
+
+#include <exception>
+#include <cassert>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by archives
+//
+class archive_exception :
+ public virtual std::exception
+{
+public:
+ typedef enum {
+ no_exception, // initialized without code
+ other_exception, // any excepton not listed below
+ unregistered_class, // attempt to serialize a pointer of an
+ // an unregistered class
+ invalid_signature, // first line of archive does not contain
+ // expected string
+ unsupported_version,// archive created with library version
+ // subsequent to this one
+ pointer_conflict, // an attempt has been made to directly
+ // serialization::detail an object
+ // after having already serialzed the same
+ // object through a pointer. Were this permited,
+ // it the archive load would result in the
+ // creation of an extra copy of the obect.
+ incompatible_native_format, // attempt to read native binary format
+ // on incompatible platform
+ array_size_too_short,// array being loaded doesn't fit in array allocated
+ stream_error, // i/o error on stream
+ invalid_class_name, // class name greater than the maximum permitted.
+ // most likely a corrupted archive or an attempt
+ // to insert virus via buffer overrun method.
+ unregistered_cast // base - derived relationship not registered with
+ // void_cast_register
+ } exception_code;
+ exception_code code;
+ archive_exception(exception_code c) :
+ code(c)
+ {}
+ virtual const char *what( ) const throw( )
+ {
+ const char *msg = "programming error";
+ switch(code){
+ case no_exception:
+ msg = "uninitialized exception";
+ break;
+ case unregistered_class:
+ msg = "unregistered class";
+ break;
+ case invalid_signature:
+ msg = "invalid signature";
+ break;
+ case unsupported_version:
+ msg = "unsupported version";
+ break;
+ case pointer_conflict:
+ msg = "pointer conflict";
+ break;
+ case incompatible_native_format:
+ msg = "incompatible native format";
+ break;
+ case array_size_too_short:
+ msg = "array size too short";
+ break;
+ case stream_error:
+ msg = "stream error";
+ break;
+ case invalid_class_name:
+ msg = "class name too long";
+ break;
+ case unregistered_cast:
+ msg = "unregistered void cast";
+ break;
+ case other_exception:
+ // if get here - it indicates a derived exception
+ // was sliced by passing by value in catch
+ msg = "unknown derived exception";
+ break;
+ default:
+ assert(false);
+ break;
+ }
+ return msg;
+ }
+protected:
+ archive_exception() :
+ code(no_exception)
+ {}
+};
+
+}// namespace archive
+}// namespace boost
+
+#endif //BOOST_ARCHIVE_ARCHIVE_EXCEPTION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_archive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_archive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,120 @@
+#ifndef BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_ARCHIVE_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_archive.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.
+
+#include <boost/config.hpp>
+#include <boost/strong_typedef.hpp>
+#include <boost/noncopyable.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+BOOST_STRONG_TYPEDEF(unsigned int, version_type)
+BOOST_STRONG_TYPEDEF(int, class_id_type)
+BOOST_STRONG_TYPEDEF(int, class_id_optional_type)
+BOOST_STRONG_TYPEDEF(int, class_id_reference_type)
+BOOST_STRONG_TYPEDEF(unsigned int, object_id_type)
+BOOST_STRONG_TYPEDEF(unsigned int, object_reference_type)
+
+struct tracking_type {
+ typedef bool value_type;
+ bool t;
+ explicit tracking_type(const bool t_ = false)
+ : t(t_)
+ {};
+ tracking_type(const tracking_type & t_)
+ : t(t_.t)
+ {}
+ operator bool () const {
+ return t;
+ };
+ operator bool & () {
+ return t;
+ };
+ tracking_type & operator=(const bool t_){
+ t = t_;
+ return *this;
+ }
+ bool operator==(const tracking_type & rhs) const {
+ return t == rhs.t;
+ }
+ bool operator==(const bool & rhs) const {
+ return t == rhs;
+ }
+ tracking_type & operator=(const tracking_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+};
+
+struct class_name_type : private boost::noncopyable {
+ char *t;
+ operator const char * & () const {
+ return const_cast<const char * &>(t);
+ }
+ operator char * () {
+ return t;
+ }
+ explicit class_name_type(const char *key_)
+ : t(const_cast<char *>(key_)){}
+ explicit class_name_type(char *key_)
+ : t(key_){}
+ class_name_type & operator=(const class_name_type & rhs){
+ t = rhs.t;
+ return *this;
+ }
+};
+
+enum archive_flags {
+ no_header = 1, // suppress archive header info
+ no_codecvt = 2, // suppress alteration of codecvt facet
+ no_xml_tag_checking = 4, // suppress checking of xml tags
+ no_tracking = 8, // suppress ALL tracking
+ flags_last = 8
+};
+
+#define NULL_POINTER_TAG class_id_type(-1)
+
+BOOST_ARCHIVE_DECL(const char *)
+ARCHIVE_SIGNATURE();
+
+BOOST_ARCHIVE_DECL(unsigned char)
+ARCHIVE_VERSION();
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#include <boost/serialization/level.hpp>
+
+// set implementation level to primitive for all types
+// used internally by the serialization library
+
+BOOST_CLASS_IMPLEMENTATION(boost::archive::version_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_reference_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_id_optional_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::class_name_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::object_id_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::object_reference_type, primitive_type)
+BOOST_CLASS_IMPLEMENTATION(boost::archive::tracking_type, primitive_type)
+
+#endif //BOOST_ARCHIVE_BASIC_ARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,125 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_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_binary_iarchive.hpp
+//
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
+
+// (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.
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/pfto.hpp>
+
+#include <boost/archive/detail/common_iarchive.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_binary_iarchive - read serialized objects from a input binary stream
+template<class Archive>
+class basic_binary_iarchive :
+ public detail::common_iarchive<Archive>
+{
+protected:
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+public:
+#elif defined(BOOST_MSVC)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_iarchive<Archive>;
+#else
+ friend class detail::interface_iarchive<Archive>;
+#endif
+ // intermediate level to support override of operators
+ // fot templates in the absence of partial function
+ // template ordering. If we get here pass to base class
+ // note extra nonsense to sneak it pass the borland compiers
+ typedef detail::common_iarchive<Archive> detail_common_iarchive;
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int version){
+ this->detail_common_iarchive::load_override(t, static_cast<int>(version));
+ }
+ // binary files don't include the optional information
+ void load_override(class_id_optional_type & /* t */, int){}
+
+ // the following have been overridden to provide specific sizes
+ // for these pseudo prmitive types.
+ void load_override(version_type & t, int){
+ // upto 255 versions
+ unsigned char x=0;
+ * this->This() >> x;
+ t = version_type(x);
+ }
+ void load_override(class_id_type & t, int){
+ // upto 32K classes
+ int_least16_t x=0;
+ * this->This() >> x;
+ t = class_id_type(x);
+ }
+ void load_override(class_id_reference_type & t, int){
+ // upto 32K classes
+ int_least16_t x=0;
+ * this->This() >> x;
+ t = class_id_reference_type(x);
+ }
+ void load_override(object_id_type & t, int){
+ // upto 2G objects
+ uint_least32_t x=0;
+ * this->This() >> x;
+ t = object_id_type(x);
+ }
+ void load_override(object_reference_type & t, int){
+ // upto 2G objects
+ uint_least32_t x=0;
+ * this->This() >> x;
+ t = object_reference_type(x);
+ }
+ void load_override(tracking_type & t, int){
+ char x=0;
+ * this->This() >> x;
+ t = (0 != x);
+ }
+ void load_override(serialization::collection_size_type & t, int){
+ unsigned int x=0;
+ * this->This() >> x;
+ t = serialization::collection_size_type(x);
+ }
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_override(class_name_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ init();
+
+ basic_binary_iarchive(unsigned int flags) :
+ detail::common_iarchive<Archive>(flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_iprimitive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_iprimitive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,177 @@
+#ifndef BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER)
+#pragma warning( disable : 4800 )
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iprimitive.hpp
+//
+// archives stored as native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATED ON
+
+// (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.
+
+#include <iosfwd>
+#include <cassert>
+#include <locale>
+#include <cstring> // std::memcpy
+#include <cstddef> // std::size_t
+#include <streambuf> // basic_streambuf
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/throw_exception.hpp>
+//#include <boost/limits.hpp>
+//#include <boost/io/ios_state.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////////
+// class binary_iarchive - read serialized objects from a input binary stream
+template<class Archive, class Elem, class Tr>
+class basic_binary_iprimitive
+{
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+ friend class load_access;
+protected:
+#else
+public:
+#endif
+ std::basic_streambuf<Elem, Tr> & m_sb;
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+
+ #ifndef BOOST_NO_STD_LOCALE
+ boost::scoped_ptr<std::locale> archive_locale;
+ basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+ #endif
+
+ // main template for serilization of primitive types
+ template<class T>
+ void load(T & t){
+ load_binary(& t, sizeof(T));
+ }
+
+ /////////////////////////////////////////////////////////
+ // fundamental types that need special treatment
+
+ // trap usage of invalid uninitialized boolean
+ void load(bool & t){
+ load_binary(& t, sizeof(t));
+ int i = t;
+ assert(0 == i || 1 == i);
+ (void)i; // warning suppression for release builds.
+ }
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load(std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load(char * t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load(wchar_t * t);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ init();
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ basic_binary_iprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~basic_binary_iprimitive();
+public:
+ // we provide an optimized load for all fundamental types
+ //typedef serialization::is_bitwise_serializable<mpl::_1>
+ // use_array_optimization;
+ struct use_array_optimization {
+ template <class T>
+ struct apply : public serialization::is_bitwise_serializable<T> {};
+ };
+
+ // the optimized load_array dispatches to load_binary
+ template <class ValueType>
+ void load_array(serialization::array<ValueType>& a, unsigned int)
+ {
+ load_binary(a.address(),a.count()*sizeof(ValueType));
+ }
+
+ void
+ load_binary(void *address, std::size_t count);
+};
+
+template<class Archive, class Elem, class Tr>
+inline void
+basic_binary_iprimitive<Archive, Elem, Tr>::load_binary(
+ void *address,
+ std::size_t count
+){
+ // note: an optimizer should eliminate the following for char files
+ std::streamsize s = count / sizeof(Elem);
+ std::streamsize scount = m_sb.sgetn(
+ static_cast<Elem *>(address),
+ s
+ );
+ if(scount != static_cast<std::streamsize>(s))
+ boost::throw_exception(
+ archive_exception(archive_exception::stream_error)
+ );
+ // note: an optimizer should eliminate the following for char files
+ s = count % sizeof(Elem);
+ if(0 < s){
+// if(is.fail())
+// boost::throw_exception(archive_exception(archive_exception::stream_error));
+ Elem t;
+ scount = m_sb.sgetn(& t, 1);
+ if(scount != 1)
+ boost::throw_exception(
+ archive_exception(archive_exception::stream_error)
+ );
+ std::memcpy(static_cast<char*>(address) + (count - s), &t, s);
+ }
+}
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
+
+#endif // BOOST_ARCHIVE_BINARY_IPRIMITIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,123 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_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_binary_oarchive.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 native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
+
+#include <boost/config.hpp>
+#include <boost/pfto.hpp>
+
+#include <boost/detail/workaround.hpp>
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/string.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// class basic_binary_oarchive - write serialized objects to a binary output stream
+// note: this archive has no pretensions to portability. Archive format
+// may vary across machine architectures and compilers. About the only
+// guarentee is that an archive created with this code will be readable
+// by a program built with the same tools for the same machne. This class
+// does have the virtue of buiding the smalles archive in the minimum amount
+// of time. So under some circumstances it may be he right choice.
+template<class Archive>
+class basic_binary_oarchive :
+ public archive::detail::common_oarchive<Archive>
+{
+protected:
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+public:
+#elif defined(BOOST_MSVC)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+#else
+ friend class detail::interface_oarchive<Archive>;
+#endif
+ // any datatype not specifed below will be handled by base class
+ typedef detail::common_oarchive<Archive> detail_common_oarchive;
+ template<class T>
+ void save_override(const T & t, BOOST_PFTO int version){
+ this->detail_common_oarchive::save_override(t, static_cast<int>(version));
+ }
+
+ // binary files don't include the optional information
+ void save_override(const class_id_optional_type & /* t */, int){}
+
+ void save_override(const version_type & t, int){
+ // upto 255 versions
+ // note:t.t resolves borland ambguity
+ const unsigned char x = t.t;
+ * this->This() << x;
+ }
+ void save_override(const class_id_type & t, int){
+ // upto 32K classes
+ const int_least16_t x = t.t;
+ * this->This() << x;
+ }
+ void save_override(const class_id_reference_type & t, int){
+ // upto 32K classes
+ const int_least16_t x = t.t;
+ * this->This() << x;
+ }
+ void save_override(const object_id_type & t, int){
+ // upto 2G objects
+ const uint_least32_t x = t.t;
+ * this->This() << x;
+ }
+ void save_override(const object_reference_type & t, int){
+ // upto 2G objects
+ uint_least32_t x = t.t;
+ * this->This() << x;
+ }
+ void save_override(const tracking_type & t, int){
+ const char x = t.t;
+ * this->This() << x;
+ }
+
+ // explicitly convert to char * to avoid compile ambiguities
+ void save_override(const class_name_type & t, int){
+ const std::string s(t);
+ * this->This() << s;
+ }
+
+ void save_override(const serialization::collection_size_type & t, int){
+ // for backward compatibility, 64 bit integer or variable length integer would be preferred
+ unsigned int x = t.t;
+ * this->This() << x;
+ }
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ init();
+
+ basic_binary_oarchive(unsigned int flags) :
+ detail::common_oarchive<Archive>(flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_oprimitive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_binary_oprimitive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,173 @@
+#ifndef BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_BINARY_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_binary_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 native binary - this should be the fastest way
+// to archive the state of a group of obects. It makes no attempt to
+// convert to any canonical form.
+
+// IN GENERAL, ARCHIVES CREATED WITH THIS CLASS WILL NOT BE READABLE
+// ON PLATFORM APART FROM THE ONE THEY ARE CREATE ON
+
+#include <iosfwd>
+#include <cassert>
+#include <locale>
+#include <streambuf> // basic_streambuf
+#include <string>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+//#include <boost/limits.hpp>
+//#include <boost/io/ios_state.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/archive/basic_streambuf_locale_saver.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_binary_oprimitive - binary output of prmitives
+
+template<class Archive, class Elem, class Tr>
+class basic_binary_oprimitive
+{
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+ friend class save_access;
+protected:
+#else
+public:
+#endif
+ std::basic_streambuf<Elem, Tr> & m_sb;
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+ #ifndef BOOST_NO_STD_LOCALE
+ boost::scoped_ptr<std::locale> archive_locale;
+ basic_streambuf_locale_saver<Elem, Tr> locale_saver;
+ #endif
+ // default saving of primitives.
+ template<class T>
+ void save(const T & t)
+ {
+ save_binary(& t, sizeof(T));
+ }
+
+ /////////////////////////////////////////////////////////
+ // fundamental types that need special treatment
+
+ // trap usage of invalid uninitialized boolean which would
+ // otherwise crash on load.
+ void save(const bool t){
+ assert(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
+ save_binary(& t, sizeof(t));
+ }
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save(const std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save(const char * t);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save(const wchar_t * t);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ init();
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ basic_binary_oprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~basic_binary_oprimitive();
+public:
+
+ // we provide an optimized save for all fundamental types
+ // typedef serialization::is_bitwise_serializable<mpl::_1>
+ // use_array_optimization;
+ // workaround without using mpl lambdas
+ struct use_array_optimization {
+ template <class T>
+ struct apply : public serialization::is_bitwise_serializable<T> {};
+ };
+
+
+ // the optimized save_array dispatches to save_binary
+ template <class ValueType>
+ void save_array(serialization::array<ValueType> const& a, unsigned int)
+ {
+ save_binary(a.address(),a.count()*sizeof(ValueType));
+ }
+
+ void save_binary(const void *address, std::size_t count);
+};
+
+template<class Archive, class Elem, class Tr>
+inline void
+basic_binary_oprimitive<Archive, Elem, Tr>::save_binary(
+ const void *address,
+ std::size_t count
+){
+ //assert(
+ // static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)()) >= count
+ //);
+ // note: if the following assertions fail
+ // a likely cause is that the output stream is set to "text"
+ // mode where by cr characters recieve special treatment.
+ // be sure that the output stream is opened with ios::binary
+ //if(os.fail())
+ // boost::throw_exception(archive_exception(archive_exception::stream_error));
+ // figure number of elements to output - round up
+ count = ( count + sizeof(Elem) - 1)
+ / sizeof(Elem);
+ std::streamsize scount = m_sb.sputn(
+ static_cast<const Elem *>(address),
+ count
+ );
+ if(count != static_cast<std::size_t>(scount))
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+ //os.write(
+ // static_cast<const BOOST_DEDUCED_TYPENAME OStream::char_type *>(address),
+ // count
+ //);
+ //assert(os.good());
+}
+
+} //namespace boost
+} //namespace archive
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
+
+#endif // BOOST_ARCHIVE_BASIC_BINARY_OPRIMITIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_streambuf_locale_saver.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_streambuf_locale_saver.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,60 @@
+#ifndef BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
+#define BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_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_streambuf_local_saver.hpp
+
+// (C) Copyright 2005 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.
+
+// note derived from boost/io/ios_state.hpp
+// Copyright 2002, 2005 Daryle Walker. Use, modification, and distribution
+// are subject to the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or a copy at <http://www.boost.org/LICENSE_1_0.txt>.)
+
+// See <http://www.boost.org/libs/io/> for the library's home page.
+
+#ifndef BOOST_NO_STD_LOCALE
+
+#include <locale> // for std::locale
+#include <streambuf> // for std::basic_streambuf
+
+namespace boost{
+namespace archive{
+
+template < typename Ch, class Tr >
+class basic_streambuf_locale_saver
+{
+public:
+ typedef ::std::basic_streambuf<Ch, Tr> state_type;
+ typedef ::std::locale aspect_type;
+ explicit basic_streambuf_locale_saver( state_type &s )
+ : s_save_( s ), a_save_( s.getloc() )
+ {}
+ basic_streambuf_locale_saver( state_type &s, aspect_type const &a )
+ : s_save_( s ), a_save_( s.pubimbue(a) )
+ {}
+ ~basic_streambuf_locale_saver()
+ { this->restore(); }
+ void restore()
+ { s_save_.pubimbue( a_save_ ); }
+private:
+ state_type & s_save_;
+ aspect_type const a_save_;
+};
+
+} // archive
+} // boost
+
+#endif // BOOST_NO_STD_LOCALE
+#endif // BOOST_ARCHIVE_BASIC_STREAMBUF_LOCALE_SAVER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_text_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_text_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,84 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_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_iarchive.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<IStream::char_type> but rather
+// use two template parameters
+
+#include <boost/config.hpp>
+#include <boost/pfto.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/common_iarchive.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_iarchive - read serialized objects from a input text stream
+template<class Archive>
+class basic_text_iarchive :
+ public detail::common_iarchive<Archive>
+{
+protected:
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+public:
+#elif defined(BOOST_MSVC)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_iarchive<Archive>;
+#else
+ friend class detail::interface_iarchive<Archive>;
+#endif
+ // intermediate level to support override of operators
+ // fot templates in the absence of partial function
+ // template ordering
+ typedef detail::common_iarchive<Archive> detail_common_iarchive;
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int)
+ {
+ this->detail_common_iarchive::load_override(t, 0);
+ }
+ // text file don't include the optional information
+ void load_override(class_id_optional_type & /*t*/, int){}
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_override(class_name_type & t, int);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ init(void);
+
+ basic_text_iarchive(unsigned int flags) :
+ detail::common_iarchive<Archive>(flags)
+ {}
+ ~basic_text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_text_iprimitive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_text_iprimitive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,134 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_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_iprimitive.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<IStream::char_type> but rather
+// use two template parameters
+
+#include <cassert>
+#include <locale>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#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/detail/workaround.hpp>
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/throw_exception.hpp>
+#include <boost/limits.hpp>
+#include <boost/io/ios_state.hpp>
+#include <boost/scoped_ptr.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_iarchive - load serialized objects from a input text stream
+template<class IStream>
+class basic_text_iprimitive
+{
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+protected:
+#else
+public:
+#endif
+ IStream &is;
+ io::ios_flags_saver flags_saver;
+ io::ios_precision_saver precision_saver;
+
+ #ifndef BOOST_NO_STD_LOCALE
+ boost::scoped_ptr<std::locale> archive_locale;
+ io::basic_ios_locale_saver<
+ BOOST_DEDUCED_TYPENAME IStream::char_type, BOOST_DEDUCED_TYPENAME IStream::traits_type
+ > locale_saver;
+ #endif
+
+ template<class T>
+ void load(T & t)
+ {
+ if(is.fail())
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+ is >> t;
+ }
+ void load(unsigned char & t)
+ {
+ if(is.fail())
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+ unsigned short int i;
+ is >> i;
+ t = static_cast<unsigned char>(i);
+ }
+ void load(signed char & t)
+ {
+ if(is.fail())
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+ signed short int i;
+ is >> i;
+ t = static_cast<signed char>(i);
+ }
+ void load(char & t)
+ {
+ if(is.fail())
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+ short int i;
+ is >> i;
+ t = static_cast<char>(i);
+ }
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ void load(wchar_t & t)
+ {
+ if(is.fail())
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+ unsigned i;
+ is >> i;
+ t = static_cast<wchar_t>(i);
+ }
+ #endif
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ basic_text_iprimitive(IStream &is, bool no_codecvt);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~basic_text_iprimitive();
+public:
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_binary(void *address, std::size_t count);
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pop pragams
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_IPRIMITIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_text_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_text_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,134 @@
+#ifndef BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_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_oarchive.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 <cassert>
+#include <boost/config.hpp>
+#include <boost/pfto.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/common_oarchive.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class basic_text_oarchive
+template<class Archive>
+class basic_text_oarchive :
+ public detail::common_oarchive<Archive>
+{
+protected:
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) \
+|| BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560))
+public:
+#elif defined(BOOST_MSVC)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+#else
+ friend class detail::interface_oarchive<Archive>;
+#endif
+ enum {
+ none,
+ eol,
+ space
+ } delimiter;
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ newtoken();
+
+ void newline(){
+ delimiter = eol;
+ }
+
+ // default processing - kick back to base class. Note the
+ // extra stuff to get it passed borland compilers
+ typedef detail::common_oarchive<Archive> detail_common_oarchive;
+ template<class T>
+ void save_override(T & t, BOOST_PFTO int){
+ this->detail_common_oarchive::save_override(t, 0);
+ }
+
+ // start new objects on a new line
+ void save_override(const object_id_type & t, int){
+ this->This()->newline();
+ // note extra .t to funciton with Borland 5.51 compiler
+ // and invoke prmitive to underlying value
+ this->This()->save(t.t);
+ }
+
+ void save_override(const object_reference_type & t, int){
+ this->This()->newline();
+ // note extra .t to funciton with Borland 5.51 compiler
+ // and invoke prmitive to underlying value
+ this->This()->save(t.t);
+ }
+
+ // note the following four overrides are necessary for some borland
+ // compilers(5.51) which don't handle BOOST_STRONG_TYPE properly.
+ void save_override(const version_type & t, int){
+ // note:t.t resolves borland ambguity
+ const unsigned int x = t.t;
+ * this->This() << x;
+ }
+ void save_override(const class_id_type & t, int){
+ // note:t.t resolves borland ambguity
+ const int x = t.t;
+ * this->This() << x;
+ }
+ void save_override(const class_id_reference_type & t, int){
+ // note:t.t resolves borland ambguity
+ const int x = t.t;
+ * this->This() << x;
+ }
+
+ // text file don't include the optional information
+ void save_override(const class_id_optional_type & /* t */, int){}
+
+ void save_override(const class_name_type & t, int){
+ const std::string s(t);
+ * this->This() << s;
+ }
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ init();
+
+ basic_text_oarchive(unsigned int flags) :
+ detail::common_oarchive<Archive>(flags),
+ delimiter(none)
+ {}
+ ~basic_text_oarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_TEXT_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_text_oprimitive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_text_oprimitive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,169 @@
+#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 <cmath> // isnan
+#include <cassert>
+#include <cstddef> // size_t
+
+#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;
+
+ #ifndef BOOST_NO_STD_LOCALE
+ 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;
+ #endif
+
+ // 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.
+ assert(0 == static_cast<int>(t) || 1 == static_cast<int>(t));
+ 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
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_archive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_archive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,67 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_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_xml_archive.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.
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+// constant strings used in xml i/o
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+OBJECT_ID();
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+OBJECT_REFERENCE();
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+CLASS_ID();
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+CLASS_ID_REFERENCE();
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+CLASS_NAME();
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+TRACKING();
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+VERSION();
+
+extern
+BOOST_ARCHIVE_DECL(const char *)
+SIGNATURE();
+
+}// namespace archive
+}// namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_TEXT_ARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,118 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_IARCHIVE_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_xml_iarchive.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.
+
+#include <boost/config.hpp>
+#include <boost/pfto.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/common_iarchive.hpp>
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+/////////////////////////////////////////////////////////////////////////
+// class xml_iarchive - read serialized objects from a input text stream
+template<class Archive>
+class basic_xml_iarchive :
+ public detail::common_iarchive<Archive>
+{
+protected:
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+public:
+#elif defined(BOOST_MSVC)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+#else
+ friend class detail::interface_oarchive<Archive>;
+#endif
+ unsigned int depth;
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_start(const char *name);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_end(const char *name);
+
+ // Anything not an attribute and not a name-value pair is an
+ // should be trapped here.
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int)
+ {
+ // If your program fails to compile here, its most likely due to
+ // not specifying an nvp wrapper around the variable to
+ // be serialized.
+ BOOST_MPL_ASSERT((serialization::is_wrapper<T>));
+ this->detail_common_iarchive::load_override(t, 0);
+ }
+
+ // Anything not an attribute - see below - should be a name value
+ // pair and be processed here
+ typedef detail::common_iarchive<Archive> detail_common_iarchive;
+ template<class T>
+ void load_override(
+ #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ const
+ #endif
+ boost::serialization::nvp<T> & t,
+ int
+ ){
+ load_start(t.name());
+ this->detail_common_iarchive::load_override(t.value(), 0);
+ load_end(t.name());
+ }
+
+ // specific overrides for attributes - handle as
+ // primitives. These are not name-value pairs
+ // so they have to be intercepted here and passed on to load.
+ // although the class_id is included in the xml text file in order
+ // to make the file self describing, it isn't used when loading
+ // an xml archive. So we can skip it here. Note: we MUST override
+ // it otherwise it will be loaded as a normal primitive w/o tag and
+ // leaving the archive in an undetermined state
+ void load_override(class_id_optional_type & /* t */, int){}
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_override(object_id_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_override(version_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_override(class_id_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ load_override(tracking_type & t, int);
+ // class_name_type can't be handled here as it depends upon the
+ // char type used by the stream. So require the derived implementation
+ // handle this.
+ // void load_override(class_name_type & t, int);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ basic_xml_iarchive(unsigned int flags);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~basic_xml_iarchive();
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/basic_xml_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,137 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_XML_OARCHIVE_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_xml_oarchive.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.
+
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/common_oarchive.hpp>
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/string.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// class basic_xml_oarchive - write serialized objects to a xml output stream
+template<class Archive>
+class basic_xml_oarchive :
+ public detail::common_oarchive<Archive>
+{
+protected:
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+public:
+#elif defined(BOOST_MSVC)
+ // for some inexplicable reason insertion of "class" generates compile erro
+ // on msvc 7.1
+ friend detail::interface_oarchive<Archive>;
+ friend class save_access;
+#else
+ friend class detail::interface_oarchive<Archive>;
+ friend class save_access;
+#endif
+ // special stuff for xml output
+ unsigned int depth;
+ bool indent_next;
+ bool pending_preamble;
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ indent();
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ init();
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ write_attribute(
+ const char *attribute_name,
+ int t,
+ const char *conjunction = "=\""
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ write_attribute(
+ const char *attribute_name,
+ const char *key
+ );
+ // helpers used below
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_start(const char *name);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_end(const char *name);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ end_preamble();
+
+ // Anything not an attribute and not a name-value pair is an
+ // error and should be trapped here.
+ template<class T>
+ void save_override(T & t, BOOST_PFTO int)
+ {
+ // If your program fails to compile here, its most likely due to
+ // not specifying an nvp wrapper around the variable to
+ // be serialized.
+ BOOST_MPL_ASSERT((serialization::is_wrapper<T>));
+ this->detail_common_oarchive::save_override(t, 0);
+ }
+
+ // special treatment for name-value pairs.
+ typedef detail::common_oarchive<Archive> detail_common_oarchive;
+ template<class T>
+ void save_override(
+ #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ const
+ #endif
+ ::boost::serialization::nvp<T> & t,
+ int
+ ){
+ save_start(t.name());
+ this->detail_common_oarchive::save_override(t.const_value(), 0);
+ save_end(t.name());
+ }
+
+ // specific overrides for attributes - not name value pairs so we
+ // want to trap them before the above "fall through"
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const object_id_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const object_reference_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const version_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const class_id_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const class_id_optional_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const class_id_reference_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const class_name_type & t, int);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+ save_override(const tracking_type & t, int);
+
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ basic_xml_oarchive(unsigned int flags);
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~basic_xml_oarchive();
+};
+
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_XML_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/binary_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/binary_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,93 @@
+#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_IARCHIVE_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
+// binary_iarchive.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.
+
+#include <istream>
+#include <boost/archive/binary_iarchive_impl.hpp>
+
+namespace boost {
+namespace archive {
+
+// do not derive from the classes below. If you want to extend this functionality
+// via inhertance, derived from text_iarchive_impl instead. This will
+// preserve correct static polymorphism.
+
+// same as binary_iarchive below - without the shared_ptr_helper
+class naked_binary_iarchive :
+ public binary_iarchive_impl<
+ boost::archive::naked_binary_iarchive,
+ std::istream::char_type,
+ std::istream::traits_type
+ >
+{
+public:
+ naked_binary_iarchive(std::istream & is, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ naked_binary_iarchive, std::istream::char_type, std::istream::traits_type
+ >(is, flags)
+ {}
+ naked_binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ naked_binary_iarchive, std::istream::char_type, std::istream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// note special treatment of shared_ptr. This type needs a special
+// structure associated with every archive. We created a "mix-in"
+// class to provide this functionality. Since shared_ptr holds a
+// special esteem in the boost library - we included it here by default.
+#include <boost/archive/shared_ptr_helper.hpp>
+
+namespace boost {
+namespace archive {
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from binary_iarchive_impl instead. This will
+// preserve correct static polymorphism.
+class binary_iarchive :
+ public binary_iarchive_impl<
+ boost::archive::binary_iarchive,
+ std::istream::char_type,
+ std::istream::traits_type
+ >,
+ public detail::shared_ptr_helper
+{
+public:
+ binary_iarchive(std::istream & is, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_iarchive, std::istream::char_type, std::istream::traits_type
+ >(is, flags)
+ {}
+ binary_iarchive(std::streambuf & bsb, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_iarchive, std::istream::char_type, std::istream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_iarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_iarchive)
+
+#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/binary_iarchive_impl.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/binary_iarchive_impl.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,87 @@
+#ifndef BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_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
+// binary_iarchive_impl.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.
+
+#include <istream>
+#include <boost/pfto.hpp>
+#include <boost/archive/basic_binary_iprimitive.hpp>
+#include <boost/archive/basic_binary_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+template<class Archive, class Elem, class Tr>
+class binary_iarchive_impl :
+ public basic_binary_iprimitive<Archive, Elem, Tr>,
+ public basic_binary_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_binary_iarchive<Archive>;
+ friend class load_access;
+protected:
+#endif
+ // note: the following should not needed - but one compiler (vc 7.1)
+ // fails to compile one test (test_shared_ptr) without it !!!
+ // make this protected so it can be called from a derived archive
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int){
+ this->basic_binary_iarchive<Archive>::load_override(t, 0L);
+ }
+ void init(unsigned int flags){
+ if(0 != (flags & no_header))
+ return;
+ #if ! defined(__MWERKS__)
+ this->basic_binary_iarchive<Archive>::init();
+ this->basic_binary_iprimitive<Archive, Elem, Tr>::init();
+ #else
+ basic_binary_iarchive<Archive>::init();
+ basic_binary_iprimitive<Archive, Elem, Tr>::init();
+ #endif
+ }
+ binary_iarchive_impl(
+ std::basic_streambuf<Elem, Tr> & bsb,
+ unsigned int flags
+ ) :
+ basic_binary_iprimitive<Archive, Elem, Tr>(
+ bsb,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_iarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+ binary_iarchive_impl(
+ std::basic_istream<Elem, Tr> & is,
+ unsigned int flags
+ ) :
+ basic_binary_iprimitive<Archive, Elem, Tr>(
+ * is.rdbuf(),
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_iarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+};
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_BINARY_IARCHIVE_IMPL_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/binary_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/binary_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,55 @@
+#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_OARCHIVE_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
+// binary_oarchive.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.
+
+#include <ostream>
+#include <boost/archive/binary_oarchive_impl.hpp>
+
+namespace boost {
+namespace archive {
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from binary_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class binary_oarchive :
+ public binary_oarchive_impl<
+ binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+ >
+{
+public:
+ binary_oarchive(std::ostream & os, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+ >(os, flags)
+ {}
+ binary_oarchive(std::streambuf & bsb, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_oarchive, std::ostream::char_type, std::ostream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+typedef binary_oarchive naked_binary_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_oarchive)
+BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(boost::archive::binary_oarchive)
+
+#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/binary_oarchive_impl.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/binary_oarchive_impl.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,87 @@
+#ifndef BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_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
+// binary_oarchive_impl.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.
+
+#include <ostream>
+#include <boost/pfto.hpp>
+#include <boost/archive/basic_binary_oprimitive.hpp>
+#include <boost/archive/basic_binary_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+template<class Archive, class Elem, class Tr>
+class binary_oarchive_impl :
+ public basic_binary_oprimitive<Archive, Elem, Tr>,
+ public basic_binary_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_binary_oarchive<Archive>;
+ friend class save_access;
+protected:
+#endif
+ // note: the following should not needed - but one compiler (vc 7.1)
+ // fails to compile one test (test_shared_ptr) without it !!!
+ // make this protected so it can be called from a derived archive
+ template<class T>
+ void save_override(T & t, BOOST_PFTO int){
+ this->basic_binary_oarchive<Archive>::save_override(t, 0L);
+ }
+ void init(unsigned int flags) {
+ if(0 != (flags & no_header))
+ return;
+ #if ! defined(__MWERKS__)
+ this->basic_binary_oarchive<Archive>::init();
+ this->basic_binary_oprimitive<Archive, Elem, Tr>::init();
+ #else
+ basic_binary_oarchive<Archive>::init();
+ basic_binary_oprimitive<Archive, Elem, Tr>::init();
+ #endif
+ }
+ binary_oarchive_impl(
+ std::basic_streambuf<Elem, Tr> & bsb,
+ unsigned int flags
+ ) :
+ basic_binary_oprimitive<Archive, Elem, Tr>(
+ bsb,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_oarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+ binary_oarchive_impl(
+ std::basic_ostream<Elem, Tr> & os,
+ unsigned int flags
+ ) :
+ basic_binary_oprimitive<Archive, Elem, Tr>(
+ * os.rdbuf(),
+ 0 != (flags & no_codecvt)
+ ),
+ basic_binary_oarchive<Archive>(flags)
+ {
+ init(flags);
+ }
+};
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_BINARY_OARCHIVE_IMPL_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/binary_wiarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/binary_wiarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,92 @@
+#ifndef BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_WIARCHIVE_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
+// binary_wiarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream> // wistream
+#include <boost/archive/binary_iarchive_impl.hpp>
+
+namespace boost {
+namespace archive {
+
+// same as binary_wiarchive below - without the shared_ptr_helper
+class naked_binary_wiarchive :
+ public binary_iarchive_impl<
+ boost::archive::naked_binary_wiarchive,
+ std::wistream::char_type,
+ std::wistream::traits_type
+ >
+{
+public:
+ naked_binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ naked_binary_wiarchive,
+ std::wistream::char_type,
+ std::wistream::traits_type
+ >(is, flags)
+ {}
+ naked_binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ naked_binary_wiarchive,
+ std::wistream::char_type,
+ std::wistream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// note special treatment of shared_ptr. This type needs a special
+// structure associated with every archive. We created a "mix-in"
+// class to provide this functionality. Since shared_ptr holds a
+// special esteem in the boost library - we included it here by default.
+#include <boost/archive/shared_ptr_helper.hpp>
+
+namespace boost {
+namespace archive {
+
+class binary_wiarchive :
+ public binary_iarchive_impl<
+ binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+ >
+{
+public:
+ binary_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+ >(is, flags)
+ {}
+ binary_wiarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
+ binary_iarchive_impl<
+ binary_wiarchive, std::wistream::char_type, std::wistream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_wiarchive)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_BINARY_WIARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/binary_woarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/binary_woarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,60 @@
+#ifndef BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_BINARY_WOARCHIVE_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
+// binary_woarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <ostream>
+#include <boost/archive/binary_oarchive_impl.hpp>
+
+namespace boost {
+namespace archive {
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from binary_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class binary_woarchive :
+ public binary_oarchive_impl<
+ binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+ >
+{
+public:
+ binary_woarchive(std::wostream & os, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+ >(os, flags)
+ {}
+ binary_woarchive(std::wstreambuf & bsb, unsigned int flags = 0) :
+ binary_oarchive_impl<
+ binary_woarchive, std::wostream::char_type, std::wostream::traits_type
+ >(bsb, flags)
+ {}
+};
+
+typedef binary_woarchive naked_binary_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::binary_woarchive)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_BINARY_WOARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/codecvt_null.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/codecvt_null.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,83 @@
+#ifndef BOOST_ARCHIVE_CODECVT_NULL_HPP
+#define BOOST_ARCHIVE_CODECVT_NULL_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
+// codecvt_null.hpp:
+
+// (C) Copyright 2004 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.
+
+#include <locale>
+#include <cstddef> // NULL, size_t
+#include <cwchar> // for mbstate_t
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+ using ::codecvt;
+ using ::mbstate_t;
+ using ::size_t
+#endif
+
+namespace boost {
+namespace archive {
+
+template<class Ch>
+class codecvt_null;
+
+template<>
+class codecvt_null<char> : public std::codecvt<char, char, std::mbstate_t>
+{
+ virtual bool do_always_noconv() const throw() {
+ return true;
+ }
+public:
+ explicit codecvt_null(std::size_t no_locale_manage = 0) :
+ std::codecvt<char, char, std::mbstate_t>(no_locale_manage)
+ {}
+};
+
+template<>
+class codecvt_null<wchar_t> : public std::codecvt<wchar_t, char, std::mbstate_t>
+{
+ virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
+ do_out(
+ std::mbstate_t & state,
+ const wchar_t * first1,
+ const wchar_t * last1,
+ const wchar_t * & next1,
+ char * first2,
+ char * last2,
+ char * & next2
+ ) const;
+ virtual BOOST_WARCHIVE_DECL(std::codecvt_base::result)
+ do_in(
+ std::mbstate_t & state,
+ const char * first1,
+ const char * last1,
+ const char * & next1,
+ wchar_t * first2,
+ wchar_t * last2,
+ wchar_t * & next2
+ ) const;
+ virtual int do_encoding( ) const throw( ){
+ return sizeof(wchar_t) / sizeof(char);
+ }
+ virtual int do_max_length( ) const throw( ){
+ return do_encoding();
+ }
+};
+
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_ARCHIVE_CODECVT_NULL_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/abi_prefix.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/abi_prefix.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,20 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_prefix.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.
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/abi_suffix.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/abi_suffix.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,19 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// abi_suffix.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.
+
+#if defined( __BORLANDC__ )
+#pragma nopushoptwarn
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/archive_pointer_iserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/archive_pointer_iserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,92 @@
+#ifndef BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP
+#define BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_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
+// archive_pointer_iserializer.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.
+
+#include <cassert>
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/detail/basic_serializer.hpp>
+#include <boost/archive/detail/basic_pointer_iserializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+template<class Archive>
+class archive_pointer_iserializer :
+ public basic_pointer_iserializer {
+protected:
+ explicit BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ archive_pointer_iserializer(
+ const boost::serialization::extended_type_info & eti
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~archive_pointer_iserializer();
+public:
+ virtual const basic_iserializer & get_basic_serializer() const
+ // mscvc 6.0 requires template functions to be implemented. For this
+ // reason we can't make abstract.
+ #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || defined(__MWERKS__)
+ {
+ assert(false);
+ return *static_cast<const basic_iserializer *>(NULL);
+ }
+ #else
+ = 0;
+ #endif
+ virtual void load_object_ptr(
+ basic_iarchive & ar,
+ void * & x,
+ const unsigned int file_version
+ ) const
+ #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || defined(__MWERKS__)
+ {
+ assert(false);
+ }
+ #else
+ = 0;
+ #endif
+ // return the type_extended load pointer corresponding to a given
+ // type_info. returns NULL if there is no such instance. This
+ // would indicate that the no object of the specified type was loaded
+ // any where in the code.
+ static BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_iserializer *)
+ find(
+ const boost::serialization::extended_type_info & eti
+ );
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_ARCHIVE_POINTER_ISERIALIZER_POINTER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/archive_pointer_oserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/archive_pointer_oserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,66 @@
+#ifndef BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP
+#define BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_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
+// archive_pointer_oserializer.hpp: extenstion of type_info required for
+// serialization.
+
+// (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.
+
+#include <boost/config.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+#include <boost/archive/detail/basic_pointer_oserializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+template<class Archive>
+class archive_pointer_oserializer :
+ public basic_pointer_oserializer {
+protected:
+ explicit BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ archive_pointer_oserializer(
+ const boost::serialization::extended_type_info & eti
+ );
+ BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~archive_pointer_oserializer();
+public:
+ // return the type_extended save pointer corresponding to a give
+ // type_info. returns NULL, if there is no such instance. This
+ // would indicate that the no object of the specified type was saved
+ // any where in the code.
+ static BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_oserializer *)
+ find(
+ const boost::serialization::extended_type_info & eti
+ );
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_ARCHIVE_POINTER_OSERIALIZER_POINTER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/auto_link_archive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/auto_link_archive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,48 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_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
+// auto_link_archive.hpp
+//
+// (c) Copyright Robert Ramey 2004
+// 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 library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+// enable automatic library variant selection ------------------------------//
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&& !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \
+&& !defined(BOOST_SERIALIZATION_SOURCE)
+
+ // Set the name of our library, this will get undef'ed by auto_link.hpp
+ // once it's done with it:
+ //
+ #define BOOST_LIB_NAME boost_serialization
+ //
+ // If we're importing code from a dll, then tell auto_link.hpp about it:
+ //
+ #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+ # define BOOST_DYN_LINK
+ #endif
+ //
+ // And include the header that does the work:
+ //
+ #include <boost/config/auto_link.hpp>
+#endif // auto-linking disabled
+
+#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/auto_link_warchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/auto_link_warchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,47 @@
+#ifndef BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_AUTO_LINK_WARCHIVE_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
+// auto_link_warchive.hpp
+//
+// (c) Copyright Robert Ramey 2004
+// 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 library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+// enable automatic library variant selection ------------------------------//
+
+#include <boost/archive/detail/decl.hpp>
+
+#if !defined(BOOST_WARCHIVE_SOURCE) \
+&& !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB)
+
+// Set the name of our library, this will get undef'ed by auto_link.hpp
+// once it's done with it:
+//
+#define BOOST_LIB_NAME boost_wserialization
+//
+// If we're importing code from a dll, then tell auto_link.hpp about it:
+//
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+# define BOOST_DYN_LINK
+#endif
+//
+// And include the header that does the work:
+//
+#include <boost/config/auto_link.hpp>
+#endif // auto-linking disabled
+
+#endif // ARCHIVE_DETAIL_AUTO_LINK_ARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_archive_impl.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_archive_impl.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,48 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_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_archive_impl.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.
+
+// can't use this - much as I'd like to as borland doesn't support it
+// #include <boost/scoped_ptr.hpp>
+
+#include <set>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+//////////////////////////////////////////////////////////////////////
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_archive_impl
+{
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_DETAIL_BASIC_ARCHIVE_IMPL_HPP
+
+
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_config.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_config.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,45 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// basic_config.hpp ---------------------------------------------//
+
+// (c) Copyright Robert Ramey 2004
+// 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 library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_DECLSPEC // defined in config system
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_ARCHIVE_DYN_LINK
+// if they want just this one to be dynamically linked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ARCHIVE_DYN_LINK)
+// export if this is our own source, otherwise import:
+#ifdef BOOST_ARCHIVE_SOURCE
+# define BOOST_ARCHIVE_DECL __declspec(dllexport)
+#else
+# define BOOST_ARCHIVE_DECL __declspec(dllimport)
+#endif // BOOST_ARCHIVE_SOURCE
+#endif // DYN_LINK
+#endif // BOOST_HAS_DECLSPEC
+//
+// if BOOST_ARCHIVE_DECL isn't defined yet define it now:
+#ifndef BOOST_ARCHIVE_DECL
+#define BOOST_ARCHIVE_DECL
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_BASIC_CONFIG_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,108 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_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_iarchive.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.
+
+// can't use this - much as I'd like to as borland doesn't support it
+// #include <boost/scoped_ptr.hpp>
+
+#include <boost/config.hpp>
+#include <boost/type_traits/broken_compiler_spec.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+#include <boost/archive/basic_archive.hpp>
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class basic_iarchive_impl;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+//////////////////////////////////////////////////////////////////////
+// class basic_iarchive - read serialized objects from a input stream
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive
+{
+ friend class basic_iarchive_impl;
+ // hide implementation of this class to minimize header conclusion
+ // in client code. I couldn't used scoped pointer with borland
+ // boost::scoped_ptr<basic_iarchive_impl> pimpl;
+ basic_iarchive_impl * pimpl;
+
+ virtual void vload(version_type &t) = 0;
+ virtual void vload(object_id_type &t) = 0;
+ virtual void vload(class_id_type &t) = 0;
+ virtual void vload(class_id_optional_type &t) = 0;
+ virtual void vload(class_name_type &t) = 0;
+ virtual void vload(tracking_type &t) = 0;
+protected:
+ basic_iarchive(unsigned int flags);
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_iarchive();
+public:
+ // note: NOT part of the public API.
+ void next_object_pointer(void *t);
+ void register_basic_serializer(
+ const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */ basic_iserializer & bis
+ );
+ void load_object(
+ void *t,
+ const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */ basic_iserializer & bis
+ );
+ const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */ basic_pointer_iserializer *
+ load_pointer(
+ void * & t,
+ const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */
+ basic_pointer_iserializer * bpis_ptr,
+ const /* BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) */
+ basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & eti
+ )
+ );
+ // real public API starts here
+ void
+ set_library_version(unsigned int archive_library_version);
+ unsigned int
+ get_library_version() const;
+ unsigned int
+ get_flags() const;
+ void
+ reset_object_address(const void * new_address, const void * old_address);
+ void
+ delete_created_pointers();
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+// required by smart_cast for compilers not implementing
+// partial template specialization
+BOOST_TT_BROKEN_COMPILER_SPEC(
+ boost::archive::detail::basic_iarchive
+)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_DETAIL_BASIC_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_iserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_iserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,86 @@
+#ifndef BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_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_iserializer.hpp: extenstion of type_info required for serialization.
+
+// (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.
+
+#include <cstdlib> // NULL
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/decl.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer :
+ public basic_serializer
+{
+private:
+ basic_pointer_iserializer *m_bpis;
+protected:
+ explicit basic_iserializer(
+ const boost::serialization::extended_type_info & type
+ );
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_iserializer();
+public:
+ bool serialized_as_pointer() const {
+ return m_bpis != NULL;
+ }
+ void set_bpis(basic_pointer_iserializer *bpis){
+ m_bpis = bpis;
+ }
+ const basic_pointer_iserializer * get_bpis_ptr() const {
+ return m_bpis;
+ }
+ virtual void load_object_data(
+ basic_iarchive & ar,
+ void *x,
+ const unsigned int file_version
+ ) const = 0;
+ // returns true if class_info should be saved
+ virtual bool class_info() const = 0 ;
+ // returns true if objects should be tracked
+ virtual bool tracking(const unsigned int) const = 0 ;
+ // returns class version
+ virtual unsigned int version() const = 0 ;
+ // returns true if this class is polymorphic
+ virtual bool is_polymorphic() const = 0;
+ virtual void destroy(/*const*/ void *address) const = 0 ;
+};
+
+} // namespae detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_BASIC_ISERIALIZER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,103 @@
+#ifndef BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_BASIC_OARCHIVE_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_oarchive.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.
+
+#include <boost/config.hpp>
+#include <cstddef> // NULL
+#include <boost/type_traits/broken_compiler_spec.hpp>
+
+// can't use this - much as I'd like to as borland doesn't support it
+// #include <boost/scoped_ptr.hpp>
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive_impl;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+//////////////////////////////////////////////////////////////////////
+// class basic_oarchive - write serialized objects to an output stream
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive
+{
+ friend class basic_oarchive_impl;
+ // hide implementation of this class to minimize header conclusion
+ // in client code. note: borland can't use scoped_ptr
+ //boost::scoped_ptr<basic_oarchive_impl> pimpl;
+ basic_oarchive_impl * pimpl;
+
+ // overload these to bracket object attributes. Used to implement
+ // xml archives
+ virtual void vsave(const version_type t) = 0;
+ virtual void vsave(const object_id_type t) = 0;
+ virtual void vsave(const object_reference_type t) = 0;
+ virtual void vsave(const class_id_type t) = 0;
+ virtual void vsave(const class_id_optional_type t) = 0;
+ virtual void vsave(const class_id_reference_type t) = 0;
+ virtual void vsave(const class_name_type & t) = 0;
+ virtual void vsave(const tracking_type t) = 0;
+protected:
+ basic_oarchive(unsigned int flags = 0);
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_oarchive();
+public:
+ // note: NOT part of the public interface
+ void register_basic_serializer(
+ const basic_oserializer & bos
+ );
+ void save_object(
+ const void *x,
+ const basic_oserializer & bos
+ );
+ void save_pointer(
+ const void * t,
+ const basic_pointer_oserializer * bpos_ptr
+ );
+ void save_null_pointer(){
+ vsave(NULL_POINTER_TAG);
+ }
+ // real public interface starts here
+ void end_preamble(); // default implementation does nothing
+ unsigned int get_library_version() const;
+ unsigned int get_flags() const;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+// required by smart_cast for compilers not implementing
+// partial template specialization
+BOOST_TT_BROKEN_COMPILER_SPEC(
+ boost::archive::detail::basic_oarchive
+)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif //BOOST_ARCHIVE_BASIC_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_oserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_oserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,83 @@
+#ifndef BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
+#define BOOST_SERIALIZATION_BASIC_OSERIALIZER_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_oserializer.hpp: extenstion of type_info required for serialization.
+
+// (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.
+
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer :
+ public basic_serializer
+{
+private:
+ basic_pointer_oserializer *m_bpos;
+protected:
+ explicit basic_oserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_oserializer();
+public:
+ bool serialized_as_pointer() const {
+ return m_bpos != NULL;
+ }
+ void set_bpos(basic_pointer_oserializer *bpos){
+ m_bpos = bpos;
+ }
+ const basic_pointer_oserializer * get_bpos() const {
+ return m_bpos;
+ }
+ virtual void save_object_data(
+ basic_oarchive & ar, const void * x
+ ) const = 0;
+ // returns true if class_info should be saved
+ virtual bool class_info() const = 0;
+ // returns true if objects should be tracked
+ virtual bool tracking(const unsigned int flags) const = 0;
+ // returns class version
+ virtual unsigned int version() const = 0;
+ // returns true if this class is polymorphic
+ virtual bool is_polymorphic() const = 0;
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_BASIC_OSERIALIZER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_pointer_iserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_pointer_iserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,64 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_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_pointer_oserializer.hpp: extenstion of type_info required for
+// serialization.
+
+// (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.
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+// forward declarations
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer
+ : public basic_serializer {
+protected:
+ explicit basic_pointer_iserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_pointer_iserializer();
+public:
+ virtual const basic_iserializer & get_basic_serializer() const = 0;
+ virtual void load_object_ptr(
+ basic_iarchive & ar,
+ void * & x,
+ const unsigned int file_version
+ ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_ISERIALIZER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_pointer_oserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_pointer_oserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,62 @@
+#ifndef BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_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_pointer_oserializer.hpp: extenstion of type_info required for
+// serialization.
+
+// (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.
+#include <boost/config.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/basic_serializer.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oarchive;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer :
+ public basic_serializer {
+protected:
+ explicit basic_pointer_oserializer(
+ const boost::serialization::extended_type_info & type_
+ );
+public:
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~basic_pointer_oserializer();
+ virtual const basic_oserializer & get_basic_serializer() const = 0;
+ virtual void save_object_ptr(
+ basic_oarchive & ar,
+ const void * x
+ ) const = 0;
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_BASIC_POINTER_OSERIALIZER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_serializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_serializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,63 @@
+#ifndef BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
+#define BOOST_ARCHIVE_BASIC_SERIALIZER_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_serializer.hpp: extenstion of type_info required for serialization.
+
+// (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.
+
+#include <cassert>
+#include <cstddef> // NULL
+
+#include <boost/noncopyable.hpp>
+#include <boost/config.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_serializer : private boost::noncopyable
+{
+ const boost::serialization::extended_type_info & m_eti;
+protected:
+ explicit basic_serializer(
+ const boost::serialization::extended_type_info & eti
+ ) :
+ m_eti(eti)
+ {
+ assert(NULL != & eti);
+ }
+public:
+ const boost::serialization::extended_type_info & get_eti() const {
+ return m_eti;
+ }
+};
+
+inline bool
+operator<(const basic_serializer & lhs, const basic_serializer & rhs) {
+ return & lhs.get_eti() < & rhs.get_eti();
+}
+
+class basic_serializer_arg : public basic_serializer {
+public:
+ basic_serializer_arg(const serialization::extended_type_info & eti) :
+ basic_serializer(eti)
+ {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_BASIC_SERIALIZER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_serializer_map.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/basic_serializer_map.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,59 @@
+#ifndef BOOST_TYPEINFO_EXTENDED_MAP_HPP
+#define BOOST_TYPEINFO_EXTENDED_MAP_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_serializer_map.hpp: extenstion of type_info required for serialization.
+
+// (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.
+
+#include <set>
+
+#include <boost/config.hpp>
+#include <boost/utility.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+}
+
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_serializer;
+
+bool operator<(const basic_serializer & lhs, const basic_serializer & rhs);
+
+struct BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) type_info_pointer_compare
+{
+ bool operator()(
+ const basic_serializer * lhs, const basic_serializer * rhs
+ ) const {
+ return *lhs < *rhs;
+ }
+};
+
+typedef BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) std::set<
+ const basic_serializer *,
+ type_info_pointer_compare
+> basic_serializer_map;
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_TYPEINFO_EXTENDED_MAP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/common_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/common_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,77 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_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
+// common_iarchive.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.
+
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/interface_iarchive.hpp>
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/pfto.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+class common_iarchive :
+ public basic_iarchive,
+ public interface_iarchive<Archive>
+{
+ friend class interface_iarchive<Archive>;
+private:
+ virtual void vload(version_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(object_id_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(class_id_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(class_id_optional_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(tracking_type & t){
+ * this->This() >> t;
+ }
+ virtual void vload(class_name_type &s){
+ * this->This() >> s;
+ }
+protected:
+ // default processing - invoke serialization library
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int){
+ archive::load(* this->This(), t);
+ }
+ // default implementations of functions which emit start/end tags for
+ // archive types that require them.
+ void load_start(const char * /*name*/){}
+ void load_end(const char * /*name*/){}
+ // default archive initialization
+ common_iarchive(unsigned int flags = 0) :
+ basic_iarchive(flags),
+ interface_iarchive<Archive>()
+ {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_IARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/common_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/common_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,78 @@
+#ifndef BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_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
+// common_oarchive.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.
+
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/interface_oarchive.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+// note: referred to as Curiously Recurring Template Patter (CRTP)
+template<class Archive>
+class common_oarchive :
+ public basic_oarchive,
+ public interface_oarchive<Archive>
+{
+ friend class interface_oarchive<Archive>;
+private:
+ virtual void vsave(const version_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const object_id_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const object_reference_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_id_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_id_reference_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_id_optional_type t){
+ * this->This() << t;
+ }
+ virtual void vsave(const class_name_type & t){
+ * this->This() << t;
+ }
+ virtual void vsave(const tracking_type t){
+ * this->This() << t;
+ }
+protected:
+ // default processing - invoke serialization library
+ template<class T>
+ void save_override(T & t, BOOST_PFTO int){
+ archive::save(* this->This(), t);
+ }
+ void save_start(const char * /*name*/){}
+ void save_end(const char * /*name*/){}
+ common_oarchive(unsigned int flags = 0) :
+ basic_oarchive(flags),
+ interface_oarchive<Archive>()
+ {}
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_COMMON_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/decl.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/decl.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,79 @@
+#ifndef BOOST_ARCHIVE_DETAIL_DECL_HPP
+#define BOOST_ARCHIVE_DETAIL_DECL_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
+// decl.hpp
+//
+// (c) Copyright Robert Ramey 2004
+// 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 library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+
+#if defined(BOOST_HAS_DECLSPEC)
+ #if (defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK))
+ #if defined(BOOST_ARCHIVE_SOURCE)
+ #if defined(__BORLANDC__)
+ #define BOOST_ARCHIVE_DECL(T) T __export
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
+ #else
+ #define BOOST_ARCHIVE_DECL(T) __declspec(dllexport) T
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
+ #endif
+ #else
+ #if defined(__BORLANDC__)
+ #define BOOST_ARCHIVE_DECL(T) T __import
+ #else
+ #define BOOST_ARCHIVE_DECL(T) __declspec(dllimport) T
+ #endif
+ #endif
+ #if defined(BOOST_WARCHIVE_SOURCE)
+ #if defined(__BORLANDC__)
+ #define BOOST_WARCHIVE_DECL(T) T __export
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __export
+ #else
+ #define BOOST_WARCHIVE_DECL(T) __declspec(dllexport) T
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllexport) T
+ #endif
+ #else
+ #if defined(__BORLANDC__)
+ #define BOOST_WARCHIVE_DECL(T) T __import
+ #else
+ #define BOOST_WARCHIVE_DECL(T) __declspec(dllimport) T
+ #endif
+ #endif
+ #if !defined(BOOST_WARCHIVE_SOURCE) && !defined(BOOST_ARCHIVE_SOURCE)
+ #if defined(__BORLANDC__)
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T __import
+ #else
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) __declspec(dllimport) T
+ #endif
+ #endif
+ #endif
+#endif // BOOST_HAS_DECLSPEC
+
+#if ! defined(BOOST_ARCHIVE_DECL)
+ #define BOOST_ARCHIVE_DECL(T) T
+#endif
+#if ! defined(BOOST_WARCHIVE_DECL)
+ #define BOOST_WARCHIVE_DECL(T) T
+#endif
+#if ! defined(BOOST_ARCHIVE_OR_WARCHIVE_DECL)
+ #define BOOST_ARCHIVE_OR_WARCHIVE_DECL(T) T
+#endif
+
+#endif // BOOST_ARCHIVE_DETAIL_DECL_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/interface_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/interface_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,78 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_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
+// interface_iarchive.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.
+#include <string>
+#include <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+
+template<class Archive>
+class interface_iarchive
+{
+protected:
+ interface_iarchive(){};
+public:
+ /////////////////////////////////////////////////////////
+ // archive public interface
+ typedef mpl::bool_<true> is_loading;
+ typedef mpl::bool_<false> is_saving;
+
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+
+ template<class T>
+ const basic_pointer_iserializer *
+ register_type(T * = NULL){
+ const basic_pointer_iserializer & bpis =
+ boost::serialization::singleton<
+ pointer_iserializer<Archive, T>
+ >::get_const_instance();
+ this->This()->register_basic_serializer(bpis.get_basic_serializer());
+ return & bpis;
+ }
+ template<class T>
+ Archive & operator>>(T & t){
+ this->This()->load_override(t, 0);
+ return * this->This();
+ }
+
+ // the & operator
+ template<class T>
+ Archive & operator&(T & t){
+ return *(this->This()) >> t;
+ }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/interface_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/interface_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,85 @@
+#ifndef BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_HPP
+#define BOOST_ARCHIVE_DETAIL_INTERFACE_OARCHIVE_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
+// interface_oarchive.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.
+#include <string>
+#include <cstddef> // NULL
+#include <boost/cstdint.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+
+template<class Archive>
+class interface_oarchive
+{
+protected:
+ interface_oarchive(){};
+public:
+ /////////////////////////////////////////////////////////
+ // archive public interface
+ typedef mpl::bool_<false> is_loading;
+ typedef mpl::bool_<true> is_saving;
+
+ // return a pointer to the most derived class
+ Archive * This(){
+ return static_cast<Archive *>(this);
+ }
+
+ template<class T>
+ const basic_pointer_oserializer *
+ register_type(const T * = NULL){
+ const basic_pointer_oserializer & bpos =
+ boost::serialization::singleton<
+ pointer_oserializer<Archive, T>
+ >::get_const_instance();
+ this->This()->register_basic_serializer(bpos.get_basic_serializer());
+ return & bpos;
+ }
+
+ template<class T>
+ Archive & operator<<(T & t){
+ this->This()->save_override(t, 0);
+ return * this->This();
+ }
+
+ // the & operator
+ template<class T>
+ Archive & operator&(T & t){
+ #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ return * this->This() << const_cast<const T &>(t);
+ #else
+ return * this->This() << t;
+ #endif
+ }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_INTERFACE_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/iserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/iserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,549 @@
+#ifndef BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+#define BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// iserializer.hpp: interface for serialization system.
+
+// (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.
+
+#include <new> // for placement new
+#include <memory> // for auto_ptr
+#include <cstddef> // size_t, NULL
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+#include <boost/throw_exception.hpp>
+#include <boost/smart_cast.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/static_warning.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/less.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/bool.hpp>
+
+ #ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #include <boost/serialization/extended_type_info_typeid.hpp>
+ #endif
+// the following is need only for dynamic cast of polymorphic pointers
+#include <boost/archive/detail/basic_iarchive.hpp>
+#include <boost/archive/detail/basic_iserializer.hpp>
+#include <boost/archive/detail/archive_pointer_iserializer.hpp>
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives. Needed because
+// some compilers don't handle friend templates completely
+class load_access {
+public:
+ template<class Archive, class T>
+ static void load_primitive(Archive &ar, T &t){
+ ar.load(t);
+ }
+};
+
+namespace detail {
+
+template<class Archive, class T>
+class iserializer : public basic_iserializer
+{
+private:
+ virtual void destroy(/*const*/ void *address) const {
+ boost::serialization::access::destroy(static_cast<T *>(address));
+ }
+ // private constructor to inhibit any existence other than the
+ // static one
+public:
+ explicit iserializer() :
+ basic_iserializer(
+ boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance()
+ )
+ {}
+ virtual BOOST_DLLEXPORT void load_object_data(
+ basic_iarchive & ar,
+ void *x,
+ const unsigned int file_version
+ ) const BOOST_USED;
+ virtual bool class_info() const {
+ return boost::serialization::implementation_level<T>::value
+ >= boost::serialization::object_class_info;
+ }
+ virtual bool tracking(const unsigned int /* flags */) const {
+ return boost::serialization::tracking_level<T>::value
+ == boost::serialization::track_always
+ || ( boost::serialization::tracking_level<T>::value
+ == boost::serialization::track_selectively
+ && serialized_as_pointer());
+ }
+ virtual unsigned int version() const {
+ return ::boost::serialization::version<T>::value;
+ }
+ virtual bool is_polymorphic() const {
+ return boost::is_polymorphic<T>::value;
+ }
+ virtual ~iserializer(){};
+};
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void iserializer<Archive, T>::load_object_data(
+ basic_iarchive & ar,
+ void *x,
+ const unsigned int file_version
+) const {
+ // make sure call is routed through the higest interface that might
+ // be specialized by the user.
+ boost::serialization::serialize_adl(
+ boost::smart_cast_reference<Archive &>(ar),
+ * static_cast<T *>(x),
+ file_version
+ );
+}
+
+template<class Archive, class T>
+class pointer_iserializer
+ : public archive_pointer_iserializer<Archive>
+{
+private:
+ virtual const basic_iserializer & get_basic_serializer() const {
+ return boost::serialization::singleton<
+ iserializer<Archive, T>
+ >::get_const_instance();
+ }
+ BOOST_DLLEXPORT virtual void load_object_ptr(
+ basic_iarchive & ar,
+ void * & x,
+ const unsigned int file_version
+ ) const BOOST_USED;
+public:
+ pointer_iserializer();
+};
+
+// note trick to be sure that operator new is using class specific
+// version if such exists. Due to Peter Dimov.
+// note: the following fails if T has no default constructor.
+// otherwise it would have been ideal
+//struct heap_allocator : public T
+//{
+// T * invoke(){
+// return ::new(sizeof(T));
+// }
+//}
+
+// note: this should really be a member of the load_ptr function
+// below but some compilers still complain about this.
+template<class T>
+struct heap_allocator
+{
+ #if 0
+ // note: this fails on msvc 7.0 and gcc 3.2
+ template <class U, U x> struct test;
+ typedef char* yes;
+ typedef int* no;
+ template <class U>
+ yes has_op_new(U*, test<void* (*)(std::size_t), &U::operator new>* = 0);
+ no has_op_new(...);
+
+ template<class U>
+ T * new_operator(U);
+
+ T * new_operator(yes){
+ return (T::operator new)(sizeof(T));
+ }
+ T * new_operator(no){
+ return static_cast<T *>(operator new(sizeof(T)));
+ }
+ static T * invoke(){
+ return new_operator(has_op_new(static_cast<T *>(NULL)));
+ }
+ #else
+ // while this doesn't handle operator new overload for class T
+ static T * invoke(){
+ return static_cast<T *>(operator new(sizeof(T)));
+ }
+ #endif
+};
+
+// due to Martin Ecker
+template <typename T>
+class auto_ptr_with_deleter
+{
+public:
+ explicit auto_ptr_with_deleter(T* p) :
+ m_p(p)
+ {}
+ ~auto_ptr_with_deleter(){
+ if (m_p)
+ boost::serialization::access::destroy(m_p);
+ }
+ T* get() const {
+ return m_p;
+ }
+
+ T* release() {
+ T* p = m_p;
+ m_p = NULL;
+ return p;
+ }
+private:
+ T* m_p;
+};
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_iserializer<Archive, T>::load_object_ptr(
+ basic_iarchive & ar,
+ void * & x,
+ const unsigned int file_version
+) const
+{
+ Archive & ar_impl = boost::smart_cast_reference<Archive &>(ar);
+
+ auto_ptr_with_deleter<T> ap(heap_allocator<T>::invoke());
+ if(NULL == ap.get())
+ boost::throw_exception(std::bad_alloc()) ;
+
+ T * t = ap.get();
+ x = t;
+
+ // catch exception during load_construct_data so that we don't
+ // automatically delete the t which is most likely not fully
+ // constructed
+ BOOST_TRY {
+ // this addresses an obscure situtation that occurs when
+ // load_constructor de-serializes something through a pointer.
+ ar.next_object_pointer(t);
+ boost::serialization::load_construct_data_adl<Archive, T>(
+ ar_impl,
+ t,
+ file_version
+ );
+ }
+ BOOST_CATCH(...){
+ ap.release();
+ BOOST_RETHROW;
+ }
+ BOOST_CATCH_END
+
+ ar_impl >> boost::serialization::make_nvp(NULL, * t);
+ ap.release();
+}
+
+template<class Archive, class T>
+pointer_iserializer<Archive, T>::pointer_iserializer() :
+ archive_pointer_iserializer<Archive>(
+ boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance()
+ )
+{
+ boost::serialization::singleton<
+ iserializer<Archive, T>
+ >::get_mutable_instance().set_bpis(this);
+}
+
+template<class Archive, class T>
+struct load_non_pointer_type {
+ // note this bounces the call right back to the archive
+ // with no runtime overhead
+ struct load_primitive {
+ static void invoke(Archive & ar, T & t){
+ load_access::load_primitive(ar, t);
+ }
+ };
+ // note this bounces the call right back to the archive
+ // with no runtime overhead
+ struct load_only {
+ static void invoke(Archive & ar, T & t){
+ // short cut to user's serializer
+ // make sure call is routed through the higest interface that might
+ // be specialized by the user.
+ boost::serialization::serialize_adl(
+ ar, t, boost::serialization::version<T>::value
+ );
+ }
+ };
+
+ // note this save class information including version
+ // and serialization level to the archive
+ struct load_standard {
+ static void invoke(Archive &ar, T &t){
+ //BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
+ // borland - for some reason T is const here - even though
+ // its not called that way - so fix it her
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type typex;
+ void * x = & const_cast<typex &>(t);
+ ar.load_object(
+ x,
+ boost::serialization::singleton<
+ iserializer<Archive, T>
+ >::get_const_instance()
+ );
+ }
+ };
+
+ struct load_conditional {
+ static void invoke(Archive &ar, T &t){
+ //if(0 == (ar.get_flags() & no_tracking))
+ load_standard::invoke(ar, t);
+ //else
+ // load_only::invoke(ar, t);
+ }
+ };
+
+ typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // if its primitive
+ mpl::equal_to<
+ boost::serialization::implementation_level<T>,
+ mpl::int_<boost::serialization::primitive_type>
+ >,
+ mpl::identity<load_primitive>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // class info / version
+ mpl::greater_equal<
+ boost::serialization::implementation_level<T>,
+ mpl::int_<boost::serialization::object_class_info>
+ >,
+ // do standard load
+ mpl::identity<load_standard>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // no tracking
+ mpl::equal_to<
+ boost::serialization::tracking_level<T>,
+ mpl::int_<boost::serialization::track_never>
+ >,
+ // do a fast load
+ mpl::identity<load_only>,
+ // else
+ // do a fast load only tracking is turned off
+ mpl::identity<load_conditional>
+ > > >::type typex;
+
+ static void invoke(Archive & ar, T &t){
+ // check that we're not trying to serialize something that
+ // has been marked not to be serialized. If this your program
+ // traps here, you've tried to serialize a class whose trait
+ // has been marked "non-serializable". Either reset the trait
+ // (see level.hpp) or change program not to serialize items of this class
+ BOOST_STATIC_ASSERT((
+ mpl::greater_equal<
+ boost::serialization::implementation_level<T>,
+ mpl::int_<boost::serialization::primitive_type>
+ >::value
+ ));
+ typex::invoke(ar, t);
+ }
+};
+
+template<class Archive, class Tptr>
+struct load_pointer_type {
+ template<class T>
+ struct abstract
+ {
+ static const basic_pointer_iserializer * register_type(Archive & /* ar */){
+ // it has? to be polymorphic
+ BOOST_STATIC_ASSERT(boost::is_polymorphic<T>::value);
+ return static_cast<basic_pointer_iserializer *>(NULL);
+ }
+ };
+
+ template<class T>
+ struct non_abstract
+ {
+ static const basic_pointer_iserializer * register_type(Archive & ar){
+ return ar.register_type(static_cast<T *>(NULL));
+ }
+ };
+
+ template<class T>
+ static const basic_pointer_iserializer * register_type(Archive &ar, T & /*t*/){
+ // there should never be any need to load an abstract polymorphic
+ // class pointer. Inhibiting code generation for this
+ // permits abstract base classes to be used - note: exception
+ // virtual serialize functions used for plug-ins
+ typedef BOOST_DEDUCED_TYPENAME
+ mpl::eval_if<
+ boost::serialization::is_abstract<const T>,
+ mpl::identity<abstract<T> >,
+ mpl::identity<non_abstract<T> >
+ >::type typex;
+ return typex::register_type(ar);
+ }
+
+ template<class T>
+ static T * pointer_tweak(
+ const boost::serialization::extended_type_info & eti,
+ void * t,
+ T &
+ ) {
+ // tweak the pointer back to the base class
+ return static_cast<T *>(
+ boost::serialization::void_upcast(
+ eti,
+ boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance(),
+ t
+ )
+ );
+ }
+
+ static void invoke(Archive & ar, Tptr & t){
+ const basic_pointer_iserializer * bpis_ptr = register_type(ar, *t);
+ const basic_pointer_iserializer * newbpis_ptr = ar.load_pointer(
+ * reinterpret_cast<void **>(&t),
+ bpis_ptr,
+ archive_pointer_iserializer<Archive>::find
+ );
+ // if the pointer isn't that of the base class
+ if(newbpis_ptr != bpis_ptr){
+ t = pointer_tweak(newbpis_ptr->get_eti(), t, *t);
+ }
+ }
+};
+
+template<class Archive, class T>
+struct load_enum_type {
+ static void invoke(Archive &ar, T &t){
+ // convert integers to correct enum to load
+ int i;
+ ar >> boost::serialization::make_nvp(NULL, i);
+ t = static_cast<T>(i);
+ }
+};
+
+template<class Archive, class T>
+struct load_array_type {
+ static void invoke(Archive &ar, T &t){
+ typedef BOOST_DEDUCED_TYPENAME remove_extent<T>::type value_type;
+
+ // convert integers to correct enum to load
+ int current_count = sizeof(t) / (
+ static_cast<char *>(static_cast<void *>(&t[1]))
+ - static_cast<char *>(static_cast<void *>(&t[0]))
+ );
+ int count;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ if(count > current_count)
+ boost::throw_exception(archive::archive_exception(
+ boost::archive::archive_exception::array_size_too_short
+ ));
+ ar >> serialization::make_array(static_cast<value_type*>(&t[0]),count);
+ }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void load(Archive &ar, T &t){
+ // if this assertion trips. It means we're trying to load a
+ // const object with a compiler that doesn't have correct
+ // funtion template ordering. On other compilers, this is
+ // handled below.
+ BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer<T>,
+ mpl::identity<detail::load_pointer_type<Archive, T> >
+ ,//else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array<T>,
+ mpl::identity<detail::load_array_type<Archive, T> >
+ ,//else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum<T>,
+ mpl::identity<detail::load_enum_type<Archive, T> >
+ ,//else
+ mpl::identity<detail::load_non_pointer_type<Archive, T> >
+ >
+ >
+ >::type typex;
+ typex::invoke(ar, t);
+}
+
+// BORLAND
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+// borland has a couple of problems
+// a) if function is partiall specialized - see below
+// const paramters are transformed to non-const ones
+// b) implementation of base_object can't be made to work
+// correctly which results in all base_object s being const.
+// So, strip off the const for borland. This breaks the trap
+// for loading const objects - but I see no alternative
+template<class Archive, class T>
+inline void load(Archive &ar, const T & t){
+ load(ar, const_cast<T &>(t));
+}
+#endif
+
+// let wrappers through.
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+template<class Archive, class T>
+inline void load_wrapper(Archive &ar, const T&t, mpl::true_){
+ boost::archive::load(ar, const_cast<T&>(t));
+}
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+template<class Archive, class T>
+inline void load(Archive &ar, const T&t){
+ load_wrapper(ar,t,serialization::is_wrapper<T>());
+}
+#endif
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_DETAIL_ISERIALIZER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/oserializer.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/oserializer.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,540 @@
+#ifndef BOOST_ARCHIVE_OSERIALIZER_HPP
+#define BOOST_ARCHIVE_OSERIALIZER_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#pragma inline_depth(511)
+#pragma inline_recursion(on)
+#endif
+
+#if defined(__MWERKS__)
+#pragma inline_depth(511)
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// oserializer.hpp: interface for serialization system.
+
+// (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.
+
+#include <cassert>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/smart_cast.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/static_warning.hpp>
+
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_enum.hpp>
+//#include <boost/type_traits/is_volatile.hpp>
+#include <boost/type_traits/is_const.hpp>
+//#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_extent.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/and.hpp>
+//#include <boost/mpl/less.hpp>
+#include <boost/mpl/greater_equal.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/identity.hpp>
+//#include <boost/mpl/list.hpp>
+//#include <boost/mpl/empty.hpp>
+#include <boost/mpl/not.hpp>
+
+ #ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #include <boost/serialization/extended_type_info_typeid.hpp>
+ #endif
+// the following is need only for dynamic cast of polymorphic pointers
+#include <boost/archive/detail/basic_oarchive.hpp>
+#include <boost/archive/detail/basic_oserializer.hpp>
+#include <boost/archive/detail/archive_pointer_oserializer.hpp>
+
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/void_cast.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/singleton.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+
+namespace boost {
+
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+
+namespace archive {
+
+// an accessor to permit friend access to archives. Needed because
+// some compilers don't handle friend templates completely
+class save_access {
+public:
+ template<class Archive>
+ static void end_preamble(Archive & ar){
+ ar.end_preamble();
+ }
+ template<class Archive, class T>
+ static void save_primitive(Archive & ar, const T & t){
+ ar.end_preamble();
+ ar.save(t);
+ }
+};
+
+namespace detail {
+
+template<class Archive, class T>
+class oserializer : public basic_oserializer
+{
+private:
+ // private constructor to inhibit any existence other than the
+ // static one
+public:
+ explicit BOOST_DLLEXPORT oserializer() :
+ basic_oserializer(
+ boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance()
+ )
+ {}
+ virtual BOOST_DLLEXPORT void save_object_data(
+ basic_oarchive & ar,
+ const void *x
+ ) const BOOST_USED;
+ virtual bool class_info() const {
+ return boost::serialization::implementation_level<T>::value
+ >= boost::serialization::object_class_info;
+ }
+ virtual bool tracking(const unsigned int /* flags */) const {
+ return boost::serialization::tracking_level<T>::value == boost::serialization::track_always
+ || (boost::serialization::tracking_level<T>::value == boost::serialization::track_selectively
+ && serialized_as_pointer());
+ }
+ virtual unsigned int version() const {
+ return ::boost::serialization::version<T>::value;
+ }
+ virtual bool is_polymorphic() const {
+ return boost::is_polymorphic<T>::value;
+ }
+ virtual ~oserializer(){}
+};
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void oserializer<Archive, T>::save_object_data(
+ basic_oarchive & ar,
+ const void *x
+) const {
+ // make sure call is routed through the highest interface that might
+ // be specialized by the user.
+ BOOST_STATIC_ASSERT(boost::is_const<T>::value == false);
+ boost::serialization::serialize_adl(
+ boost::smart_cast_reference<Archive &>(ar),
+ * static_cast<T *>(const_cast<void *>(x)),
+ version()
+ );
+}
+
+template<class Archive, class T>
+class pointer_oserializer
+ : public archive_pointer_oserializer<Archive>
+{
+ const basic_oserializer & get_basic_serializer() const;
+private:
+ virtual BOOST_DLLEXPORT void save_object_ptr(
+ basic_oarchive & ar,
+ const void * x
+ ) const BOOST_USED;
+public:
+ explicit BOOST_DLLEXPORT pointer_oserializer() BOOST_USED;
+};
+
+template<class Archive, class T>
+const basic_oserializer &
+pointer_oserializer<Archive, T>::get_basic_serializer() const {
+ return boost::serialization::singleton<
+ oserializer<Archive, T>
+ >::get_const_instance();
+}
+
+template<class Archive, class T>
+BOOST_DLLEXPORT void pointer_oserializer<Archive, T>::save_object_ptr(
+ basic_oarchive & ar,
+ const void * x
+) const {
+ assert(NULL != x);
+ // make sure call is routed through the highest interface that might
+ // be specialized by the user.
+ T * t = static_cast<T *>(const_cast<void *>(x));
+ const unsigned int file_version = boost::serialization::version<T>::value;
+ Archive & ar_impl = boost::smart_cast_reference<Archive &>(ar);
+ boost::serialization::save_construct_data_adl<Archive, T>(
+ ar_impl,
+ t,
+ file_version
+ );
+ ar_impl << boost::serialization::make_nvp(NULL, * t);
+}
+
+template<class Archive, class T>
+BOOST_DLLEXPORT pointer_oserializer<Archive, T>::pointer_oserializer() :
+ archive_pointer_oserializer<Archive>(
+ boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance()
+ )
+{
+ // make sure appropriate member function is instantiated
+ boost::serialization::singleton<
+ oserializer<Archive, T>
+ >::get_mutable_instance().set_bpos(this);
+}
+
+template<class Archive, class T>
+struct save_non_pointer_type {
+ // note this bounces the call right back to the archive
+ // with no runtime overhead
+ struct save_primitive {
+ static void invoke(Archive & ar, const T & t){
+ save_access::save_primitive(ar, t);
+ }
+ };
+ // same as above but passes through serialization
+ struct save_only {
+ static void invoke(Archive & ar, const T & t){
+ // make sure call is routed through the highest interface that might
+ // be specialized by the user.
+ boost::serialization::serialize_adl(
+ ar,
+ const_cast<T &>(t),
+ ::boost::serialization::version<T>::value
+ );
+ }
+ };
+ // adds class information to the archive. This includes
+ // serialization level and class version
+ struct save_standard {
+ static void invoke(Archive &ar, const T & t){
+ ar.save_object(
+ & t,
+ boost::serialization::singleton<
+ oserializer<Archive, T>
+ >::get_const_instance()
+ );
+ }
+ };
+
+ // adds class information to the archive. This includes
+ // serialization level and class version
+ struct save_conditional {
+ static void invoke(Archive &ar, const T &t){
+ //if(0 == (ar.get_flags() & no_tracking))
+ save_standard::invoke(ar, t);
+ //else
+ // save_only::invoke(ar, t);
+ }
+ };
+
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // if its primitive
+ mpl::equal_to<
+ boost::serialization::implementation_level<T>,
+ mpl::int_<boost::serialization::primitive_type>
+ >,
+ mpl::identity<save_primitive>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // class info / version
+ mpl::greater_equal<
+ boost::serialization::implementation_level<T>,
+ mpl::int_<boost::serialization::object_class_info>
+ >,
+ // do standard save
+ mpl::identity<save_standard>,
+ // else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // no tracking
+ mpl::equal_to<
+ boost::serialization::tracking_level<T>,
+ mpl::int_<boost::serialization::track_never>
+ >,
+ // do a fast save
+ mpl::identity<save_only>,
+ // else
+ // do a fast save only tracking is turned off
+ mpl::identity<save_conditional>
+ > > >::type typex;
+
+ static void invoke(Archive & ar, const T & t){
+ // check that we're not trying to serialize something that
+ // has been marked not to be serialized. If this your program
+ // traps here, you've tried to serialize a class whose trait
+ // has been marked "non-serializable". Either reset the trait
+ // (see level.hpp) or change program not to serialize items of this class
+ BOOST_STATIC_ASSERT((
+ mpl::greater_equal<
+ boost::serialization::implementation_level<T>,
+ mpl::int_<boost::serialization::primitive_type>
+ >::value
+ ));
+ typex::invoke(ar, t);
+ };
+};
+
+template<class Archive, class TPtr>
+struct save_pointer_type {
+ template<class T>
+ struct abstract
+ {
+ static const basic_pointer_oserializer * register_type(Archive & /* ar */){
+ // it has? to be polymorphic
+ BOOST_STATIC_ASSERT(boost::is_polymorphic<T>::value);
+ return NULL;
+ }
+ };
+
+ template<class T>
+ struct non_abstract
+ {
+ static const basic_pointer_oserializer * register_type(Archive & ar){
+ return ar.register_type(static_cast<T *>(NULL));
+ }
+ };
+
+ template<class T>
+ static const basic_pointer_oserializer * register_type(Archive &ar, T & /*t*/){
+ // there should never be any need to save an abstract polymorphic
+ // class pointer. Inhibiting code generation for this
+ // permits abstract base classes to be used - note: exception
+ // virtual serialize functions used for plug-ins
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ boost::serialization::is_abstract<T>,
+ mpl::identity<abstract<T> >,
+ mpl::identity<non_abstract<T> >
+ >::type typex;
+ return typex::register_type(ar);
+ }
+
+ template<class T>
+ struct non_polymorphic
+ {
+ static void save(
+ Archive &ar,
+ T & t
+ ){
+ const basic_pointer_oserializer & bpos =
+ boost::serialization::singleton<
+ pointer_oserializer<Archive, T>
+ >::get_const_instance();
+ // save the requested pointer type
+ ar.save_pointer(& t, & bpos);
+ }
+ };
+
+ template<class T>
+ struct polymorphic
+ {
+ static void save(
+ Archive &ar,
+ T & t
+ ){
+ BOOST_DEDUCED_TYPENAME
+ boost::serialization::type_info_implementation<T>::type
+ const & i = boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance();
+
+ boost::serialization::extended_type_info const * const this_type = & i;
+
+ // retrieve the true type of the object pointed to
+ // if this assertion fails its an error in this library
+ assert(NULL != this_type);
+
+ const boost::serialization::extended_type_info * true_type =
+ i.get_derived_extended_type_info(t);
+
+ // note:if this exception is thrown, be sure that derived pointer
+ // is either registered or exported.
+ if(NULL == true_type){
+ boost::throw_exception(
+ archive_exception(archive_exception::unregistered_class)
+ );
+ }
+
+ // if its not a pointer to a more derived type
+ const void *vp = static_cast<const void *>(&t);
+ if(*this_type == *true_type){
+ const basic_pointer_oserializer * bpos = register_type(ar, t);
+ ar.save_pointer(vp, bpos);
+ return;
+ }
+ // convert pointer to more derived type. if this is thrown
+ // it means that the base/derived relationship hasn't be registered
+ vp = serialization::void_downcast(*true_type, *this_type, &t);
+ if(NULL == vp){
+ boost::throw_exception(
+ archive_exception(archive_exception::unregistered_cast)
+ );
+ }
+
+ // since true_type is valid, and this only gets made if the
+ // pointer oserializer object has been created, this should never
+ // fail
+ const basic_pointer_oserializer * bpos
+ = archive_pointer_oserializer<Archive>::find(* true_type);
+ assert(NULL != bpos);
+ if(NULL == bpos)
+ boost::throw_exception(
+ archive_exception(archive_exception::unregistered_class)
+ );
+ ar.save_pointer(vp, bpos);
+ }
+ };
+
+ // out of line selector works around borland quirk
+ template<class T>
+ struct conditional {
+ typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_polymorphic<T>,
+ mpl::identity<polymorphic<T> >,
+ mpl::identity<non_polymorphic<T> >
+ >::type type;
+ };
+
+ // used to convert TPtr in to a pointer to a T
+ template<class T>
+ static void save(
+ Archive & ar,
+ const T & t
+ ){
+ conditional<T>::type::save(ar, const_cast<T &>(t));
+ }
+
+ template<class T>
+ static void const_check(T & t){
+ BOOST_STATIC_ASSERT(! boost::is_const<T>::value);
+ }
+
+ static void invoke(Archive &ar, const TPtr t){
+ #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ // if your program traps here, its because you tried to do
+ // something like ar << t where t is a pointer to a const value
+ // void f3(A const* a, text_oarchive& oa)
+ // {
+ // oa << a;
+ // }
+ // with a compiler which doesn't support remove_const
+ // const_check(* t);
+ #else
+ // otherwise remove the const
+ #endif
+ register_type(ar, * t);
+ if(NULL == t){
+ basic_oarchive & boa = boost::smart_cast_reference<basic_oarchive &>(ar);
+ boa.save_null_pointer();
+ save_access::end_preamble(ar);
+ return;
+ }
+ save(ar, * t);
+ };
+};
+
+template<class Archive, class T>
+struct save_enum_type
+{
+ static void invoke(Archive &ar, const T &t){
+ // convert enum to integers on save
+ const int i = static_cast<int>(t);
+ ar << boost::serialization::make_nvp(NULL, i);
+ }
+};
+
+template<class Archive, class T>
+struct save_array_type
+{
+ static void invoke(Archive &ar, const T &t){
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_extent<T>::type value_type;
+
+ save_access::end_preamble(ar);
+ // consider alignment
+ int count = sizeof(t) / (
+ static_cast<const char *>(static_cast<const void *>(&t[1]))
+ - static_cast<const char *>(static_cast<const void *>(&t[0]))
+ );
+ ar << BOOST_SERIALIZATION_NVP(count);
+ ar << serialization::make_array(static_cast<value_type const*>(&t[0]),count);
+ }
+};
+
+} // detail
+
+template<class Archive, class T>
+inline void save(Archive & ar, const T &t){
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_pointer<T>,
+ mpl::identity<detail::save_pointer_type<Archive, T> >,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_enum<T>,
+ mpl::identity<detail::save_enum_type<Archive, T> >,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<is_array<T>,
+ mpl::identity<detail::save_array_type<Archive, T> >,
+ //else
+ mpl::identity<detail::save_non_pointer_type<Archive, T> >
+ >
+ >
+ >::type typex;
+ typex::invoke(ar, t);
+}
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+template<class T>
+struct check_tracking {
+ typedef BOOST_DEDUCED_TYPENAME mpl::if_<
+ // if its never tracked.
+ BOOST_DEDUCED_TYPENAME mpl::equal_to<
+ serialization::tracking_level<T>,
+ mpl::int_<serialization::track_never>
+ >,
+ // it better not be a pointer
+ mpl::not_<is_pointer<T> >,
+ //else
+ // otherwise if it might be tracked. So there shouldn't
+ // be any problem making a const
+ is_const<T>
+ >::type typex;
+ BOOST_STATIC_CONSTANT(bool, value = typex::value);
+};
+
+template<class Archive, class T>
+inline void save(Archive & ar, T &t){
+ // if your program traps here, it indicates that your doing one of the following:
+ // a) serializing an object of a type marked "track_never" through a pointer.
+ // b) saving an non-const object of a type not markd "track_never)
+ // Either of these conditions may be an indicator of an error usage of the
+ // serialization library and should be double checked. See documentation on
+ // object tracking. Also, see the "rationale" section of the documenation
+ // for motivation for this checking.
+ BOOST_STATIC_WARNING(check_tracking<T>::value);
+ save(ar, const_cast<const T &>(t));
+}
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_OSERIALIZER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/polymorphic_iarchive_route.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/polymorphic_iarchive_route.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,196 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_ROUTE_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
+// polymorphic_iarchive_route.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.
+
+#include <string>
+#include <ostream>
+#include <cstddef>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/noncopyable.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/archive/polymorphic_iarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_iserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_iserializer;
+
+template<class ArchiveImplementation>
+class polymorphic_iarchive_route :
+ public polymorphic_iarchive,
+ // note: gcc dynamic cross cast fails if the the derivation below is
+ // not public. I think this is a mistake.
+ public /*protected*/ ArchiveImplementation,
+ private boost::noncopyable
+{
+private:
+ // these are used by the serialization library.
+ virtual void load_object(
+ void *t,
+ const basic_iserializer & bis
+ ){
+ ArchiveImplementation::load_object(t, bis);
+ }
+ virtual const basic_pointer_iserializer * load_pointer(
+ void * & t,
+ const basic_pointer_iserializer * bpis_ptr,
+ const basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & type
+ )
+ ){
+ return ArchiveImplementation::load_pointer(t, bpis_ptr, finder);
+ }
+ virtual void set_library_version(unsigned int archive_library_version){
+ ArchiveImplementation::set_library_version(archive_library_version);
+ }
+ virtual unsigned int get_library_version() const{
+ return ArchiveImplementation::get_library_version();
+ }
+ virtual unsigned int get_flags() const {
+ return ArchiveImplementation::get_flags();
+ }
+ virtual void delete_created_pointers(){
+ ArchiveImplementation::delete_created_pointers();
+ }
+ virtual void reset_object_address(
+ const void * new_address,
+ const void * old_address
+ ){
+ ArchiveImplementation::reset_object_address(new_address, old_address);
+ }
+ virtual void load_binary(void * t, std::size_t size){
+ ArchiveImplementation::load_binary(t, size);
+ }
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void load(bool & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(char & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(signed char & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned char & t){
+ ArchiveImplementation::load(t);
+ }
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void load(wchar_t & t){
+ ArchiveImplementation::load(t);
+ }
+ #endif
+ #endif
+ virtual void load(short & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned short & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(int & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned int & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(long & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(unsigned long & t){
+ ArchiveImplementation::load(t);
+ }
+ #if !defined(BOOST_NO_INTRINSIC_INT64_T)
+ virtual void load(boost::int64_t & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(boost::uint64_t & t){
+ ArchiveImplementation::load(t);
+ }
+ #endif
+ virtual void load(float & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(double & t){
+ ArchiveImplementation::load(t);
+ }
+ virtual void load(std::string & t){
+ ArchiveImplementation::load(t);
+ }
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void load(std::wstring & t){
+ ArchiveImplementation::load(t);
+ }
+ #endif
+ // used for xml and other tagged formats default does nothing
+ virtual void load_start(const char * name){
+ ArchiveImplementation::load_start(name);
+ }
+ virtual void load_end(const char * name){
+ ArchiveImplementation::load_end(name);
+ }
+
+ virtual void register_basic_serializer(const basic_iserializer & bis){
+ ArchiveImplementation::register_basic_serializer(bis);
+ }
+public:
+ // this can't be inheriteded because they appear in mulitple
+ // parents
+ typedef mpl::bool_<true> is_loading;
+ typedef mpl::bool_<false> is_saving;
+ // the >> operator
+ template<class T>
+ polymorphic_iarchive & operator>>(T & t){
+ return polymorphic_iarchive::operator>>(t);
+ }
+
+ // the & operator
+ template<class T>
+ polymorphic_iarchive & operator&(T & t){
+ return polymorphic_iarchive::operator&(t);
+ }
+
+ // all current archives take a stream as constructor argument
+ template <class _Elem, class _Tr>
+ polymorphic_iarchive_route(
+ std::basic_istream<_Elem, _Tr> & is,
+ unsigned int flags = 0
+ ) :
+ ArchiveImplementation(is, flags)
+ {}
+ virtual ~polymorphic_iarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_IARCHIVE_DISPATCH_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/polymorphic_oarchive_route.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/polymorphic_oarchive_route.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,184 @@
+#ifndef BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_HPP
+#define BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_ROUTE_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
+// polymorphic_oarchive_route.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.
+
+#include <string>
+#include <ostream>
+#include <boost/noncopyable.hpp>
+#include <boost/cstdint.hpp>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/polymorphic_oarchive.hpp>
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail{
+
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_oserializer;
+class BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY()) basic_pointer_oserializer;
+
+template<class ArchiveImplementation>
+class polymorphic_oarchive_route :
+ public polymorphic_oarchive,
+ // note: gcc dynamic cross cast fails if the the derivation below is
+ // not public. I think this is a mistake.
+ public /*protected*/ ArchiveImplementation,
+ private boost::noncopyable
+{
+private:
+ // these are used by the serialization library.
+ virtual void save_object(
+ const void *x,
+ const detail::basic_oserializer & bos
+ ){
+ ArchiveImplementation::save_object(x, bos);
+ }
+ virtual void save_pointer(
+ const void * t,
+ const detail::basic_pointer_oserializer * bpos_ptr
+ ){
+ ArchiveImplementation::save_pointer(t, bpos_ptr);
+ }
+ virtual void save_null_pointer(){
+ ArchiveImplementation::save_null_pointer();
+ }
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void save(const bool t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const char t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const signed char t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned char t){
+ ArchiveImplementation::save(t);
+ }
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void save(const wchar_t t){
+ ArchiveImplementation::save(t);
+ }
+ #endif
+ #endif
+ virtual void save(const short t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned short t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const int t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned int t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const long t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const unsigned long t){
+ ArchiveImplementation::save(t);
+ }
+ #if !defined(BOOST_NO_INTRINSIC_INT64_T)
+ virtual void save(const boost::int64_t t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const boost::uint64_t t){
+ ArchiveImplementation::save(t);
+ }
+ #endif
+ virtual void save(const float t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const double t){
+ ArchiveImplementation::save(t);
+ }
+ virtual void save(const std::string & t){
+ ArchiveImplementation::save(t);
+ }
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void save(const std::wstring & t){
+ ArchiveImplementation::save(t);
+ }
+ #endif
+ virtual unsigned int get_library_version() const{
+ return ArchiveImplementation::get_library_version();
+ }
+ virtual unsigned int get_flags() const {
+ return ArchiveImplementation::get_flags();
+ }
+ virtual void save_binary(const void * t, std::size_t size){
+ ArchiveImplementation::save_binary(t, size);
+ }
+ // used for xml and other tagged formats default does nothing
+ virtual void save_start(const char * name){
+ ArchiveImplementation::save_start(name);
+ }
+ virtual void save_end(const char * name){
+ ArchiveImplementation::save_end(name);
+ }
+ virtual void end_preamble(){
+ ArchiveImplementation::end_preamble();
+ }
+ virtual void register_basic_serializer(const detail::basic_oserializer & bos){
+ ArchiveImplementation::register_basic_serializer(bos);
+ }
+public:
+ // this can't be inheriteded because they appear in mulitple
+ // parents
+ typedef mpl::bool_<false> is_loading;
+ typedef mpl::bool_<true> is_saving;
+ // the << operator
+ template<class T>
+ polymorphic_oarchive & operator<<(T & t){
+ return polymorphic_oarchive::operator<<(t);
+ }
+ // the & operator
+ template<class T>
+ polymorphic_oarchive & operator&(T & t){
+ return polymorphic_oarchive::operator&(t);
+ }
+ // all current archives take a stream as constructor argument
+ template <class _Elem, class _Tr>
+ polymorphic_oarchive_route(
+ std::basic_ostream<_Elem, _Tr> & os,
+ unsigned int flags = 0
+ ) :
+ ArchiveImplementation(os, flags)
+ {}
+ virtual ~polymorphic_oarchive_route(){};
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_DETAIL_POLYMORPHIC_OARCHIVE_DISPATCH_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/register_archive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/register_archive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,53 @@
+// Copyright David Abrahams 2006. Distributed under 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)
+#ifndef BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+# define BOOST_ARCHIVE_DETAIL_REGISTER_ARCHIVE_DWA2006521_HPP
+
+namespace boost { namespace archive { namespace detail {
+
+// No instantiate_ptr_serialization overloads generated by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE that lexically follow the call
+// will be seen *unless* they are in an associated namespace of one of
+// the arguments, so we pass one of these along to make sure this
+// namespace is considered. See temp.dep.candidate (14.6.4.2) in the
+// standard.
+struct adl_tag {};
+
+template <class Archive, class Serializable>
+struct ptr_serialization_support;
+
+// We could've just used ptr_serialization_support, above, but using
+// it with only a forward declaration causes vc6/7 to complain about a
+// missing instantiate member, even if it has one. This is just a
+// friendly layer of indirection.
+template <class Archive, class Serializable>
+struct _ptr_serialization_support
+ : ptr_serialization_support<Archive,Serializable>
+{
+ typedef int type;
+};
+
+// This function gets called, but its only purpose is to participate
+// in overload resolution with the functions declared by
+// BOOST_SERIALIZATION_REGISTER_ARCHIVE, below.
+template <class Serializable>
+void instantiate_ptr_serialization(Serializable*, int, adl_tag ) {}
+
+// The function declaration generated by this macro never actually
+// gets called, but its return type gets instantiated, and that's
+// enough to cause registration of serialization functions between
+// Archive and any exported Serializable type. See also:
+// boost/serialization/export.hpp
+# define BOOST_SERIALIZATION_REGISTER_ARCHIVE(Archive) \
+namespace boost { namespace archive { namespace detail { \
+ \
+template <class Serializable> \
+BOOST_DEDUCED_TYPENAME _ptr_serialization_support<Archive, Serializable>::type \
+instantiate_ptr_serialization( Serializable*, Archive*, adl_tag ); \
+ \
+}}}
+
+}}} // namespace boost::archive::detail
+
+#endif // BOOST_ARCHIVE_DETAIL_INSTANTIATE_SERIALIZE_DWA2006521_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/detail/utf8_codecvt_facet.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/detail/utf8_codecvt_facet.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,21 @@
+// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia_at_[hidden])
+// Andrew Lumsdaine, Indiana University (lums_at_[hidden]).
+// Distributed under 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)
+
+#ifndef BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+#define BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
+
+#define BOOST_UTF8_BEGIN_NAMESPACE \
+ namespace boost { namespace archive { namespace detail {
+#define BOOST_UTF8_DECL
+#define BOOST_UTF8_END_NAMESPACE }}}
+
+#include <boost/detail/utf8_codecvt_facet.hpp>
+
+#undef BOOST_UTF8_END_NAMESPACE
+#undef BOOST_UTF8_DECL
+#undef BOOST_UTF8_BEGIN_NAMESPACE
+
+#endif // BOOST_ARCHIVE_DETAIL_UTF8_CODECVT_FACET_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/dinkumware.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/dinkumware.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,224 @@
+#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
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/archive_pointer_iserializer.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/archive_pointer_iserializer.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,82 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// pointer_iserializer.ipp:
+
+// (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.
+
+#include <utility>
+#include <cassert>
+#include <cstddef>
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/serialization/singleton.hpp>
+#include <boost/archive/detail/basic_serializer_map.hpp>
+#include <boost/archive/detail/archive_pointer_iserializer.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+namespace { // anon
+ template<class Archive>
+ class iserializer_map : public basic_serializer_map
+ {
+ };
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_pointer_iserializer<Archive>::archive_pointer_iserializer(
+ const boost::serialization::extended_type_info & eti
+) :
+ basic_pointer_iserializer(eti)
+{
+ std::pair<BOOST_DEDUCED_TYPENAME iserializer_map<Archive>::iterator, bool> result;
+ result = serialization::singleton<
+ iserializer_map<Archive>
+ >::get_mutable_instance().insert(this);
+ assert(result.second);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_iserializer *)
+archive_pointer_iserializer<Archive>::find(
+ const boost::serialization::extended_type_info & eti
+){
+ const basic_serializer_arg bs(eti);
+ BOOST_DEDUCED_TYPENAME iserializer_map<Archive>::const_iterator it;
+ it = boost::serialization::singleton<
+ iserializer_map<Archive>
+ >::get_const_instance().find(& bs);
+ assert(
+ it
+ !=
+ boost::serialization::singleton<
+ iserializer_map<Archive>
+ >::get_const_instance().end()
+ );
+ return static_cast<const basic_pointer_iserializer *>(*it);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_pointer_iserializer<Archive>::~archive_pointer_iserializer(){
+ std::size_t count;
+ count = serialization::singleton<
+ iserializer_map<Archive>
+ >::get_mutable_instance().erase(this);
+ assert(count);
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/archive_pointer_oserializer.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/archive_pointer_oserializer.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,82 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// archive_pointer_oserializer.ipp:
+
+// (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.
+
+#include <utility>
+#include <cassert>
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+
+#include <boost/archive/detail/archive_pointer_oserializer.hpp>
+#include <boost/archive/detail/basic_serializer_map.hpp>
+#include <boost/serialization/singleton.hpp>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+namespace { // anon
+ template<class Archive>
+ class oserializer_map : public basic_serializer_map
+ {
+ };
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_pointer_oserializer<Archive>::archive_pointer_oserializer(
+ const boost::serialization::extended_type_info & eti
+) :
+ basic_pointer_oserializer(eti)
+{
+ std::pair<
+ BOOST_DEDUCED_TYPENAME oserializer_map<Archive>::iterator,
+ bool
+ > result;
+ result = serialization::singleton<
+ oserializer_map<Archive>
+ >::get_mutable_instance().insert(this);
+ assert(result.second);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(const basic_pointer_oserializer *)
+archive_pointer_oserializer<Archive>::find(
+ const boost::serialization::extended_type_info & eti
+){
+ const basic_serializer_arg bs(eti);
+ basic_serializer_map::const_iterator it;
+ it = boost::serialization::singleton<
+ oserializer_map<Archive>
+ >::get_const_instance().find(& bs);
+ assert(
+ it
+ !=
+ boost::serialization::singleton<
+ oserializer_map<Archive>
+ >::get_const_instance().end()
+ );
+ return static_cast<const basic_pointer_oserializer *>(*it);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+archive_pointer_oserializer<Archive>::~archive_pointer_oserializer(){
+ // note: we need to check that the map still exists as we can't depend
+ // on static variables being constructed in a specific sequence
+ unsigned int count;
+ count = serialization::singleton<
+ oserializer_map<Archive>
+ >::get_mutable_instance().erase(this);
+ assert(count);
+}
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_iarchive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_iarchive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,79 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iarchive.ipp:
+
+// (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.
+#include <string>
+#include <cassert>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+}
+#endif
+
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/basic_binary_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of binary_binary_archive
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_iarchive<Archive>::load_override(class_name_type & t, int){
+ std::string cn;
+ cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
+ load_override(cn, 0);
+ if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
+ boost::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ std::memcpy(t, cn.data(), cn.size());
+ // borland tweak
+ t.t[cn.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_iarchive<Archive>::init(){
+ // read signature in an archive version independent manner
+ std::string file_signature;
+ * this->This() >> file_signature;
+ if(file_signature != ARCHIVE_SIGNATURE())
+ boost::throw_exception(
+ archive_exception(archive_exception::invalid_signature)
+ );
+
+ // make sure the version of the reading archive library can
+ // support the format of the archive being read
+ version_type input_library_version;
+ * this->This() >> input_library_version;
+
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->set_library_version(input_library_version);
+ #else
+ #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+ detail::
+ #endif
+ basic_iarchive::set_library_version(input_library_version);
+ #endif
+
+ // extra little .t is to get around borland quirk
+ if(ARCHIVE_VERSION() < input_library_version.t)
+ boost::throw_exception(
+ archive_exception(archive_exception::unsupported_version)
+ );
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_iprimitive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_iprimitive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,196 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_iprimitive.ipp:
+
+// (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.
+
+#include <cassert>
+#include <cstddef> // size_t, NULL
+#include <cstring> // memcpy
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+ using ::memcpy;
+} // namespace std
+#endif
+
+#include <boost/detail/workaround.hpp> // fixup for RogueWave
+
+#include <boost/throw_exception.hpp>
+#include <boost/scoped_ptr.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/add_facet.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_binary_iprimitive
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_iprimitive<Archive, Elem, Tr>::init()
+{
+ // Detect attempts to pass native binary archives across
+ // incompatible platforms. This is not fool proof but its
+ // better than nothing.
+ unsigned char size;
+ this->This()->load(size);
+ if(sizeof(int) != size)
+ boost::throw_exception(
+ archive_exception(archive_exception::incompatible_native_format)
+ );
+ this->This()->load(size);
+ if(sizeof(long) != size)
+ boost::throw_exception(
+ archive_exception(archive_exception::incompatible_native_format)
+ );
+ this->This()->load(size);
+ if(sizeof(float) != size)
+ boost::throw_exception(
+ archive_exception(archive_exception::incompatible_native_format)
+ );
+ this->This()->load(size);
+ if(sizeof(double) != size)
+ boost::throw_exception(
+ archive_exception(archive_exception::incompatible_native_format)
+ );
+
+ // for checking endian
+ int i;
+ this->This()->load(i);
+ if(1 != i)
+ boost::throw_exception(
+ archive_exception(archive_exception::incompatible_native_format)
+ );
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_iprimitive<Archive, Elem, Tr>::load(wchar_t * ws)
+{
+ std::size_t l;
+ this->This()->load(l);
+ load_binary(ws, l * sizeof(wchar_t) / sizeof(char));
+ ws[l / sizeof(wchar_t)] = L'\0';
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_iprimitive<Archive, Elem, Tr>::load(std::string & s)
+{
+ std::size_t l;
+ this->This()->load(l);
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(l);
+ // note breaking a rule here - could be a problem on some platform
+ if(0 < l)
+ load_binary(&(*s.begin()), l);
+}
+
+#ifndef BOOST_NO_CWCHAR
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_iprimitive<Archive, Elem, Tr>::load(char * s)
+{
+ std::size_t l;
+ this->This()->load(l);
+ load_binary(s, l);
+ s[l] = '\0';
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_iprimitive<Archive, Elem, Tr>::load(std::wstring & ws)
+{
+ std::size_t l;
+ this->This()->load(l);
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(l);
+ // note breaking a rule here - is could be a problem on some platform
+ load_binary(const_cast<wchar_t *>(ws.data()), l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_binary_iprimitive<Archive, Elem, Tr>::basic_binary_iprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+) :
+#ifndef BOOST_NO_STD_LOCALE
+ m_sb(sb),
+ archive_locale(NULL),
+ locale_saver(m_sb)
+{
+ if(! no_codecvt){
+ archive_locale.reset(
+ boost::archive::add_facet(
+ std::locale::classic(),
+ new codecvt_null<Elem>
+ )
+ );
+ m_sb.pubimbue(* archive_locale);
+ }
+}
+#else
+ m_sb(sb)
+{}
+#endif
+
+// some libraries including stl and libcomo fail if the
+// buffer isn't flushed before the code_cvt facet is changed.
+// I think this is a bug. We explicity invoke sync to when
+// we're done with the streambuf to work around this problem.
+// Note that sync is a protected member of stream buff so we
+// have to invoke it through a contrived derived class.
+namespace detail {
+// note: use "using" to get past msvc bug
+using namespace std;
+template<class Elem, class Tr>
+class input_streambuf_access : public std::basic_streambuf<Elem, Tr> {
+ public:
+ virtual int sync(){
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+ return this->basic_streambuf::sync();
+#else
+ return this->basic_streambuf<Elem, Tr>::sync();
+#endif
+ }
+};
+} // detail
+
+// scoped_ptr requires that archive_locale be a complete type at time of
+// destruction so define destructor here rather than in the header
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_binary_iprimitive<Archive, Elem, Tr>::~basic_binary_iprimitive(){
+ // push back unread characters
+ int result = static_cast<detail::input_streambuf_access<Elem, Tr> &>(
+ m_sb
+ ).sync();
+ if(0 != result){
+ boost::throw_exception(
+ archive_exception(archive_exception::stream_error)
+ );
+ }
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_oarchive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_oarchive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,46 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oarchive.ipp:
+
+// (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.
+#include <string>
+#include <cassert>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+}
+#endif
+
+#include <boost/archive/basic_binary_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of binary_binary_oarchive
+
+template<class Archive>
+#if !defined(__BORLANDC__)
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+#else
+void
+#endif
+basic_binary_oarchive<Archive>::init(){
+ // write signature in an archive version independent manner
+ const std::string file_signature(ARCHIVE_SIGNATURE());
+ * this->This() << file_signature;
+ // write library version
+ const version_type v(ARCHIVE_VERSION());
+ * this->This() << v;
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_oprimitive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_binary_oprimitive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,166 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_binary_oprimitive.ipp:
+
+// (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.
+
+#include <ostream>
+#include <cstddef> // NULL
+#include <cstring>
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{
+ using ::strlen;
+} // namespace std
+#endif
+
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+#endif
+
+#include <boost/detail/workaround.hpp>
+
+#include <boost/throw_exception.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/archive/archive_exception.hpp>
+#include <boost/archive/add_facet.hpp>
+#include <boost/archive/codecvt_null.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_binary_oprimitive
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_oprimitive<Archive, Elem, Tr>::init()
+{
+ // record native sizes of fundamental types
+ // this is to permit detection of attempts to pass
+ // native binary archives accross incompatible machines.
+ // This is not foolproof but its better than nothing.
+ this->This()->save(static_cast<unsigned char>(sizeof(int)));
+ this->This()->save(static_cast<unsigned char>(sizeof(long)));
+ this->This()->save(static_cast<unsigned char>(sizeof(float)));
+ this->This()->save(static_cast<unsigned char>(sizeof(double)));
+ // for checking endianness
+ this->This()->save(int(1));
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const char * s)
+{
+ std::size_t l = std::strlen(s);
+ this->This()->save(l);
+ save_binary(s, l);
+}
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::string &s)
+{
+ std::size_t l = static_cast<unsigned int>(s.size());
+ this->This()->save(l);
+ save_binary(s.data(), l);
+}
+
+#ifndef BOOST_NO_CWCHAR
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const wchar_t * ws)
+{
+ std::size_t l = std::wcslen(ws);
+ this->This()->save(l);
+ save_binary(ws, l * sizeof(wchar_t) / sizeof(char));
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_binary_oprimitive<Archive, Elem, Tr>::save(const std::wstring &ws)
+{
+ std::size_t l = ws.size();
+ this->This()->save(l);
+ save_binary(ws.data(), l * sizeof(wchar_t) / sizeof(char));
+}
+#endif
+#endif
+
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_binary_oprimitive<Archive, Elem, Tr>::basic_binary_oprimitive(
+ std::basic_streambuf<Elem, Tr> & sb,
+ bool no_codecvt
+) :
+#ifndef BOOST_NO_STD_LOCALE
+ m_sb(sb),
+ archive_locale(NULL),
+ locale_saver(m_sb)
+{
+ if(! no_codecvt){
+ archive_locale.reset(
+ add_facet(
+ std::locale::classic(),
+ new codecvt_null<Elem>
+ )
+ );
+ m_sb.pubimbue(* archive_locale);
+ }
+}
+#else
+ m_sb(sb)
+{}
+#endif
+
+// some libraries including stl and libcomo fail if the
+// buffer isn't flushed before the code_cvt facet is changed.
+// I think this is a bug. We explicity invoke sync to when
+// we're done with the streambuf to work around this problem.
+// Note that sync is a protected member of stream buff so we
+// have to invoke it through a contrived derived class.
+namespace detail {
+// note: use "using" to get past msvc bug
+using namespace std;
+template<class Elem, class Tr>
+class output_streambuf_access : public std::basic_streambuf<Elem, Tr> {
+ public:
+ virtual int sync(){
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+ return this->basic_streambuf::sync();
+#else
+ return this->basic_streambuf<Elem, Tr>::sync();
+#endif
+ }
+};
+} // detail
+
+// scoped_ptr requires that g be a complete type at time of
+// destruction so define destructor here rather than in the header
+template<class Archive, class Elem, class Tr>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_binary_oprimitive<Archive, Elem, Tr>::~basic_binary_oprimitive(){
+ // flush buffer
+ int result = static_cast<detail::output_streambuf_access<Elem, Tr> &>(
+ m_sb
+ ).sync();
+ if(0 != result){
+ boost::throw_exception(
+ archive_exception(archive_exception::stream_error)
+ );
+ }
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_iarchive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_iarchive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,79 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iarchive.ipp:
+
+// (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.
+#include <string>
+#include <cassert>
+#include <algorithm>
+#include <cstring>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+}
+#endif
+
+#include <boost/detail/workaround.hpp>
+
+#include <boost/archive/basic_text_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of text_text_archive
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_text_iarchive<Archive>::load_override(class_name_type & t, int){
+ std::string cn;
+ cn.reserve(BOOST_SERIALIZATION_MAX_KEY_SIZE);
+ load_override(cn, 0);
+ if(cn.size() > (BOOST_SERIALIZATION_MAX_KEY_SIZE - 1))
+ boost::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ std::memcpy(t, cn.data(), cn.size());
+ // borland tweak
+ t.t[cn.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_text_iarchive<Archive>::init(void){
+ // read signature in an archive version independent manner
+ std::string file_signature;
+ * this->This() >> file_signature;
+ if(file_signature != ARCHIVE_SIGNATURE())
+ boost::throw_exception(
+ archive_exception(archive_exception::invalid_signature)
+ );
+
+ // make sure the version of the reading archive library can
+ // support the format of the archive being read
+ version_type input_library_version;
+ * this->This() >> input_library_version;
+
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->set_library_version(input_library_version);
+ #else
+ #if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+ detail::
+ #endif
+ basic_iarchive::set_library_version(input_library_version.t);
+ #endif
+
+ // extra little .t is to get around borland quirk
+ if(ARCHIVE_VERSION() < input_library_version.t)
+ boost::throw_exception(
+ archive_exception(archive_exception::unsupported_version)
+ );
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_iprimitive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_iprimitive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,131 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_iprimitive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+#include <cstddef> // size_t
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/throw_exception.hpp>
+#include <boost/pfto.hpp>
+
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/add_facet.hpp>
+
+#include <boost/archive/iterators/remove_whitespace.hpp>
+#include <boost/archive/iterators/istream_iterator.hpp>
+#include <boost/archive/iterators/binary_from_base64.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+
+namespace boost {
+namespace archive {
+
+// translate base64 text into binary and copy into buffer
+// until buffer is full.
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_text_iprimitive<IStream>::load_binary(
+ void *address,
+ std::size_t count
+){
+ typedef BOOST_DEDUCED_TYPENAME IStream::char_type CharType;
+
+ if(0 == count)
+ return;
+
+ assert(
+ static_cast<std::size_t>((std::numeric_limits<std::streamsize>::max)())
+ > (count + sizeof(CharType) - 1)/sizeof(CharType)
+ );
+
+ if(is.fail())
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+ // convert from base64 to binary
+ typedef BOOST_DEDUCED_TYPENAME
+ iterators::transform_width<
+ iterators::binary_from_base64<
+ iterators::remove_whitespace<
+ iterators::istream_iterator<CharType>
+ >
+ ,CharType
+ >
+ ,8
+ ,6
+ ,CharType
+ >
+ binary;
+
+ binary ti_begin = binary(
+ BOOST_MAKE_PFTO_WRAPPER(
+ iterators::istream_iterator<CharType>(is)
+ )
+ );
+
+ char * caddr = static_cast<char *>(address);
+ std::size_t padding = 2 - count % 3;
+
+ // take care that we don't increment anymore than necessary
+ while(--count > 0){
+ *caddr++ = static_cast<char>(*ti_begin);
+ ++ti_begin;
+ }
+ *caddr++ = static_cast<char>(*ti_begin);
+
+ if(padding > 1)
+ ++ti_begin;
+ if(padding > 2)
+ ++ti_begin;
+}
+
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_text_iprimitive<IStream>::basic_text_iprimitive(
+ IStream &is_,
+ bool no_codecvt
+) :
+#ifndef BOOST_NO_STD_LOCALE
+ is(is_),
+ flags_saver(is_),
+ precision_saver(is_),
+ archive_locale(NULL),
+ locale_saver(is_)
+{
+ if(! no_codecvt){
+ archive_locale.reset(
+ add_facet(
+ std::locale::classic(),
+ new codecvt_null<BOOST_DEDUCED_TYPENAME IStream::char_type>
+ )
+ );
+ is.imbue(* archive_locale);
+ }
+ is >> std::noboolalpha;
+}
+#else
+ is(is_),
+ flags_saver(is_),
+ precision_saver(is_)
+{}
+#endif
+
+template<class IStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_text_iprimitive<IStream>::~basic_text_iprimitive(){
+ is.sync();
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_oarchive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_oarchive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,62 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oarchive.ipp:
+
+// (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.
+#include <string>
+#include <cassert>
+#include <cstring>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+}
+#endif
+
+#include <boost/archive/basic_text_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of basic_text_oarchive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_text_oarchive<Archive>::newtoken()
+{
+ switch(delimiter){
+ default:
+ assert(false);
+ break;
+ case eol:
+ this->This()->put('\n');
+ delimiter = space;
+ break;
+ case space:
+ this->This()->put(' ');
+ break;
+ case none:
+ delimiter = space;
+ break;
+ }
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_text_oarchive<Archive>::init(){
+ // write signature in an archive version independent manner
+ const std::string file_signature(ARCHIVE_SIGNATURE());
+ * this->This() << file_signature;
+ // write library version
+ const version_type v(ARCHIVE_VERSION());
+ * this->This() << v;
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_oprimitive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_text_oprimitive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,111 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_text_oprimitive.ipp:
+
+// (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.
+
+#include <cstddef> // NULL
+#include <boost/pfto.hpp>
+
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/codecvt_null.hpp>
+#include <boost/archive/add_facet.hpp>
+
+#include <boost/archive/iterators/base64_from_binary.hpp>
+#include <boost/archive/iterators/insert_linebreaks.hpp>
+#include <boost/archive/iterators/transform_width.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+
+namespace boost {
+namespace archive {
+
+// translate to base64 and copy in to buffer.
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_text_oprimitive<OStream>::save_binary(
+ const void *address,
+ std::size_t count
+){
+ typedef BOOST_DEDUCED_TYPENAME OStream::char_type CharType;
+
+ if(0 == count)
+ return;
+
+ if(os.fail())
+ boost::throw_exception(archive_exception(archive_exception::stream_error));
+
+ os.put('\n');
+
+ typedef
+ boost::archive::iterators::insert_linebreaks<
+ boost::archive::iterators::base64_from_binary<
+ boost::archive::iterators::transform_width<
+ const char *,
+ 6,
+ 8
+ >
+ >
+ ,72
+ ,const char // cwpro8 needs this
+ >
+ base64_text;
+
+ boost::archive::iterators::ostream_iterator<CharType> oi(os);
+ std::copy(
+ base64_text(BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address))),
+ base64_text(
+ BOOST_MAKE_PFTO_WRAPPER(static_cast<const char *>(address) + count)
+ ),
+ oi
+ );
+ std::size_t padding = 2 - count % 3;
+ if(padding > 1)
+ *oi = '=';
+ if(padding > 2)
+ *oi = '=';
+
+}
+
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_text_oprimitive<OStream>::basic_text_oprimitive(
+ OStream & os_,
+ bool no_codecvt
+) :
+#ifndef BOOST_NO_STD_LOCALE
+ os(os_),
+ flags_saver(os_),
+ precision_saver(os_),
+ archive_locale(NULL),
+ locale_saver(os_)
+{
+ if(! no_codecvt){
+ archive_locale.reset(
+ add_facet(
+ std::locale::classic(),
+ new codecvt_null<BOOST_DEDUCED_TYPENAME OStream::char_type>
+ )
+ );
+ os.imbue(* archive_locale);
+ }
+ os << std::noboolalpha;
+}
+#else
+ os(os_),
+ flags_saver(os_),
+ precision_saver(os_)
+{}
+#endif
+
+template<class OStream>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_text_oprimitive<OStream>::~basic_text_oprimitive(){
+ os << std::endl;
+}
+
+} //namespace boost
+} //namespace archive
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_grammar.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_grammar.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,191 @@
+#ifndef BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
+#define BOOST_ARCHIVE_BASIC_XML_GRAMMAR_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_xml_grammar.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 module is derived from simplexml.cpp - an example shipped as part of
+// the spirit parser. This example contains the following notice:
+/*=============================================================================
+ simplexml.cpp
+
+ Spirit V1.3
+ URL: http://spirit.sourceforge.net/
+
+ Copyright (c) 2001, Daniel C. Nuffer
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the copyright holder be held liable for
+ any damages arising from the use of this software.
+
+ Permission is granted to anyone to use this software for any purpose,
+ including commercial applications, and to alter it and redistribute
+ it freely, subject to the following restrictions:
+
+ 1. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product documentation
+ would be appreciated but is not required.
+
+ 2. Altered source versions must be plainly marked as such, and must
+ not be misrepresented as being the original software.
+
+ 3. This notice may not be removed or altered from any source
+ distribution.
+=============================================================================*/
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+// supress noise
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+//#define BOOST_SPIRIT_DEBUG
+//#include <boost/spirit/core.hpp>
+#include <boost/spirit/core/non_terminal/rule.hpp>
+#include <boost/spirit/core/non_terminal/grammar.hpp>
+
+// the following hack is to evade a bogus error generated by using the
+// word "arg" when bind.hpp has been included
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+#define arg xarg
+#endif
+
+#include <boost/spirit/utility/chset.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+#undef arg
+#endif
+
+#include <boost/archive/basic_archive.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/version.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// XML grammar parsing
+
+template<class CharType>
+class basic_xml_grammar : public boost::spirit::grammar<basic_xml_grammar<CharType> >
+{
+public:
+ // The following is not necessary according to DR45, but at least
+ // one compiler (Compaq C++ 6.5 in strict_ansi mode) chokes otherwise.
+ struct return_values;
+ friend struct return_values;
+
+private:
+ typedef BOOST_DEDUCED_TYPENAME std::basic_istream<CharType> IStream;
+ typedef BOOST_DEDUCED_TYPENAME std::basic_string<CharType> StringType;
+ typedef BOOST_DEDUCED_TYPENAME boost::spirit::chset<CharType> chset_t;
+ typedef BOOST_DEDUCED_TYPENAME boost::spirit::chlit<CharType> chlit_t;
+ typedef BOOST_DEDUCED_TYPENAME boost::spirit::scanner<
+ BOOST_DEDUCED_TYPENAME std::basic_string<CharType>::iterator
+ > scanner_t;
+ typedef BOOST_DEDUCED_TYPENAME boost::spirit::rule<scanner_t> rule_t;
+ // Start grammar definition
+ rule_t
+ Reference,
+ Eq,
+ STag,
+ ETag,
+ LetterOrUnderscoreOrColon,
+ AttValue,
+ CharRef1,
+ CharRef2,
+ CharRef,
+ AmpRef,
+ LTRef,
+ GTRef,
+ AposRef,
+ QuoteRef,
+ CharData,
+ CharDataChars,
+ content,
+ AmpName,
+ LTName,
+ GTName,
+ ClassNameChar,
+ ClassName,
+ Name,
+ XMLDecl,
+ XMLDeclChars,
+ DocTypeDecl,
+ DocTypeDeclChars,
+ ClassIDAttribute,
+ ObjectIDAttribute,
+ ClassNameAttribute,
+ TrackingAttribute,
+ VersionAttribute,
+ UnusedAttribute,
+ Attribute,
+ SignatureAttribute,
+ SerializationWrapper,
+ NameHead,
+ NameTail,
+ AttributeList,
+ S;
+
+ // XML Character classes
+ chset_t
+ BaseChar,
+ Ideographic,
+ Char,
+ Letter,
+ Digit,
+ CombiningChar,
+ Extender,
+ Sch,
+ NameChar;
+
+ void init_chset();
+
+ bool my_parse(
+ IStream & is,
+ const rule_t &rule_,
+ const CharType delimiter = L'>'
+ );
+public:
+ struct return_values {
+ StringType object_name;
+ StringType contents;
+ class_id_type class_id;
+ object_id_type object_id;
+ version_type version;
+ tracking_type tracking_level;
+ StringType class_name;
+ return_values() :
+ version(0),
+ tracking_level(false)
+ {}
+ } rv;
+ bool parse_start_tag(IStream & is) ;
+ bool parse_end_tag(IStream & is);
+ bool parse_string(IStream & is, StringType & s);
+ void init(IStream & is);
+ void windup(IStream & is);
+ basic_xml_grammar();
+};
+
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_BASIC_XML_GRAMMAR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_iarchive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_iarchive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,111 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_iarchive.ipp:
+
+// (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.
+
+#include <cassert>
+#include <cstddef> // NULL
+#include <algorithm>
+
+#include <boost/throw_exception.hpp>
+
+#include <boost/archive/basic_xml_iarchive.hpp>
+#include <boost/serialization/tracking.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation of xml_text_archive
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_iarchive<Archive>::load_start(const char *name){
+ // if there's no name
+ if(NULL == name)
+ return;
+ bool result = this->This()->gimpl->parse_start_tag(this->This()->get_is());
+ if(true != result){
+ boost::throw_exception(
+ archive_exception(archive_exception::stream_error)
+ );
+ }
+ // don't check start tag at highest level
+ ++depth;
+ return;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_iarchive<Archive>::load_end(const char *name){
+ // if there's no name
+ if(NULL == name)
+ return;
+ bool result = this->This()->gimpl->parse_end_tag(this->This()->get_is());
+ if(true != result){
+ boost::throw_exception(
+ archive_exception(archive_exception::stream_error)
+ );
+ }
+
+ // don't check start tag at highest level
+ if(0 == --depth)
+ return;
+
+ if(0 == (this->get_flags() & no_xml_tag_checking)){
+ // double check that the tag matches what is expected - useful for debug
+ if(0 != name[this->This()->gimpl->rv.object_name.size()]
+ || ! std::equal(
+ this->This()->gimpl->rv.object_name.begin(),
+ this->This()->gimpl->rv.object_name.end(),
+ name
+ )
+ ){
+ boost::throw_exception(
+ archive_exception(archive_exception::stream_error)
+ );
+ }
+ }
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_iarchive<Archive>::load_override(object_id_type & t, int){
+ t = this->This()->gimpl->rv.object_id;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_iarchive<Archive>::load_override(version_type & t, int){
+ t = this->This()->gimpl->rv.version;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_iarchive<Archive>::load_override(class_id_type & t, int){
+ t = this->This()->gimpl->rv.class_id;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_iarchive<Archive>::load_override(tracking_type & t, int){
+ t = this->This()->gimpl->rv.tracking_level;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_xml_iarchive<Archive>::basic_xml_iarchive(unsigned int flags) :
+ detail::common_iarchive<Archive>(flags),
+ depth(0)
+{}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_xml_iarchive<Archive>::~basic_xml_iarchive(){}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_oarchive.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/basic_xml_oarchive.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,275 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// basic_xml_oarchive.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+#include <algorithm>
+#include <cstddef> // NULL
+#include <cstring>
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{
+ using ::strlen;
+} // namespace std
+#endif
+
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+
+namespace boost {
+namespace archive {
+
+namespace detail {
+template<class CharType>
+struct XML_name {
+ void operator()(CharType t) const{
+ const unsigned char lookup_table[] = {
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0, // -.
+ 1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, // 0-9
+ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // A-
+ 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1, // -Z _
+ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // a-
+ 1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, // -z
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
+ };
+ if((unsigned)t > 127)
+ return;
+ if(0 == lookup_table[(unsigned)t])
+ boost::throw_exception(
+ xml_archive_exception(
+ xml_archive_exception::xml_archive_tag_name_error
+ )
+ );
+ }
+};
+
+} // namespace detail
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions common to both types of xml output
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::write_attribute(
+ const char *attribute_name,
+ int t,
+ const char *conjunction
+){
+ this->This()->put(' ');
+ this->This()->put(attribute_name);
+ this->This()->put(conjunction);
+ this->This()->save(t);
+ this->This()->put('"');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::write_attribute(
+ const char *attribute_name,
+ const char *key
+){
+ this->This()->put(' ');
+ this->This()->put(attribute_name);
+ this->This()->put("=\"");
+ this->This()->save(key);
+ this->This()->put('"');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::indent(){
+ int i;
+ for(i = depth; i-- > 0;)
+ this->This()->put('\t');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_start(const char *name)
+{
+ if(NULL == name)
+ return;
+
+ // be sure name has no invalid characters
+ std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
+
+ end_preamble();
+ if(depth > 0){
+ this->This()->put('\n');
+ indent();
+ }
+ ++depth;
+ this->This()->put('<');
+ this->This()->save(name);
+ pending_preamble = true;
+ indent_next = false;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_end(const char *name)
+{
+ if(NULL == name)
+ return;
+
+ // be sure name has no invalid characters
+ std::for_each(name, name + std::strlen(name), detail::XML_name<const char>());
+
+ end_preamble();
+ --depth;
+ if(indent_next){
+ this->This()->put('\n');
+ indent();
+ }
+ indent_next = true;
+ this->This()->put("</");
+ this->This()->save(name);
+ this->This()->put('>');
+ if(0 == depth)
+ this->This()->put('\n');
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::end_preamble(){
+ if(pending_preamble){
+ this->This()->put('>');
+ pending_preamble = false;
+ }
+}
+#if 0
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t, int)
+{
+ int i = t.t; // extra .t is for borland
+ write_attribute(OBJECT_ID(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(
+ const object_reference_type & t,
+ int
+){
+ int i = t.t; // extra .t is for borland
+ write_attribute(OBJECT_REFERENCE(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(const version_type & t, int)
+{
+ int i = t.t; // extra .t is for borland
+ write_attribute(VERSION(), i);
+}
+#endif
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(const object_id_type & t, int)
+{
+ // borland doesn't do conversion of STRONG_TYPEDEFs very well
+ const unsigned int i = t;
+ write_attribute(OBJECT_ID(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(
+ const object_reference_type & t,
+ int
+){
+ const unsigned int i = t;
+ write_attribute(OBJECT_REFERENCE(), i, "=\"_");
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(const version_type & t, int)
+{
+ const unsigned int i = t;
+ write_attribute(VERSION(), i);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(const class_id_type & t, int)
+{
+ write_attribute(CLASS_ID(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(
+ const class_id_reference_type & t,
+ int
+){
+ write_attribute(CLASS_ID_REFERENCE(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(
+ const class_id_optional_type & t,
+ int
+){
+ write_attribute(CLASS_ID(), t);
+}
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(const class_name_type & t, int)
+{
+ const char * key = t;
+ if(NULL == key)
+ return;
+ write_attribute(CLASS_NAME(), key);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::save_override(const tracking_type & t, int)
+{
+ write_attribute(TRACKING(), t.t);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(void)
+basic_xml_oarchive<Archive>::init(){
+ // xml header
+ this->This()->put("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\" ?>\n");
+ this->This()->put("<!DOCTYPE boost_serialization>\n");
+ // xml document wrapper - outer root
+ this->This()->put("<boost_serialization");
+ write_attribute("signature", ARCHIVE_SIGNATURE());
+ write_attribute("version", ARCHIVE_VERSION());
+ this->This()->put(">\n");
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_xml_oarchive<Archive>::basic_xml_oarchive(unsigned int flags) :
+ detail::common_oarchive<Archive>(flags),
+ depth(0),
+ indent_next(false),
+ pending_preamble(false)
+{
+}
+
+template<class Archive>
+BOOST_ARCHIVE_OR_WARCHIVE_DECL(BOOST_PP_EMPTY())
+basic_xml_oarchive<Archive>::~basic_xml_oarchive(){
+ if(0 == (this->get_flags() & no_header)){
+ BOOST_TRY{
+ this->This()->put("</boost_serialization>\n");
+ }
+ BOOST_CATCH(...){}
+ BOOST_CATCH_END
+ }
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/text_iarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/text_iarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,128 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_iarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_iprimitive overrides for the combination
+// of template parameters used to implement a text_iprimitive
+
+#include <cstddef> // size_t, NULL
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/detail/workaround.hpp> // RogueWave
+
+#include <boost/archive/text_iarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_iarchive_impl<Archive>::load(char *s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // Works on all tested platforms
+ is.read(s, size);
+ s[size] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_iarchive_impl<Archive>::load(std::string &s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(size);
+ if(0 < size)
+ is.read(&(*s.begin()), size);
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_iarchive_impl<Archive>::load(wchar_t *ws)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ is.read((char *)ws, size * sizeof(wchar_t)/sizeof(char));
+ ws[size] = L'\0';
+}
+#endif // BOOST_NO_INTRINSIC_WCHAR_T
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_iarchive_impl<Archive>::load(std::wstring &ws)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(size);
+ // skip separating space
+ is.get();
+ is.read((char *)ws.data(), size * sizeof(wchar_t)/sizeof(char));
+}
+
+#endif // BOOST_NO_STD_WSTRING
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_iarchive_impl<Archive>::load_override(class_name_type & t, int){
+ basic_text_iarchive<Archive>::load_override(t, 0);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_iarchive_impl<Archive>::init(){
+ basic_text_iarchive<Archive>::init();
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+text_iarchive_impl<Archive>::text_iarchive_impl(
+ std::istream & is,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::istream>(
+ is,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_iarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->init();
+ #else
+ this->basic_text_iarchive<Archive>::init();
+ #endif
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/text_oarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/text_oarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,124 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_oarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+#include <string>
+#include <boost/config.hpp>
+#include <locale>
+#include <cstddef> // size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cwchar>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+#endif
+
+#include <boost/archive/add_facet.hpp>
+#include <boost/archive/text_oarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of basic_text_oprimitive overrides for the combination
+// of template parameters used to create a text_oprimitive
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_oarchive_impl<Archive>::save(const char * s)
+{
+ const std::size_t len = std::ostream::traits_type::length(s);
+ *this->This() << len;
+ this->This()->newtoken();
+ os << s;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_oarchive_impl<Archive>::save(const std::string &s)
+{
+ const std::size_t size = s.size();
+ *this->This() << size;
+ this->This()->newtoken();
+ os << s;
+}
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_oarchive_impl<Archive>::save(const wchar_t * ws)
+{
+ const std::size_t l = std::wcslen(ws);
+ * this->This() << l;
+ this->This()->newtoken();
+ os.write((const char *)ws, l * sizeof(wchar_t)/sizeof(char));
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_oarchive_impl<Archive>::save(const std::wstring &ws)
+{
+ const std::size_t l = ws.size();
+ * this->This() << l;
+ this->This()->newtoken();
+ os.write((const char *)(ws.data()), l * sizeof(wchar_t)/sizeof(char));
+}
+#endif
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+text_oarchive_impl<Archive>::text_oarchive_impl(
+ std::ostream & os,
+ unsigned int flags
+) :
+ basic_text_oprimitive<std::ostream>(
+ os,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_oarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+ this->init();
+ #else
+ this->basic_text_oarchive<Archive>::init();
+ #endif
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+text_oarchive_impl<Archive>::save_binary(const void *address, std::size_t count){
+ put('\n');
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::ostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ this->delimiter = this->eol;
+}
+
+} // namespace archive
+} // namespace boost
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/text_wiarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/text_wiarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,118 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_text_wiarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+#include <cstddef> // size_t, NULL
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/detail/workaround.hpp> // fixup for RogueWave
+
+#ifndef BOOST_NO_STD_WSTREAMBUF
+#include <boost/archive/basic_text_iprimitive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of wiprimtives functions
+//
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_wiarchive_impl<Archive>::load(char *s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ while(size-- > 0){
+ *s++ = is.narrow(is.get(), '\0');
+ }
+ *s = '\0';
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_wiarchive_impl<Archive>::load(std::string &s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(0);
+ s.reserve(size);
+ while(size-- > 0){
+ int x = is.narrow(is.get(), '\0');
+ s += x;
+ }
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_wiarchive_impl<Archive>::load(wchar_t *s)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // Works on all tested platforms
+ is.read(s, size);
+ s[size] = L'\0';
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_wiarchive_impl<Archive>::load(std::wstring &ws)
+{
+ std::size_t size;
+ * this->This() >> size;
+ // skip separating space
+ is.get();
+ // borland complains about resize
+ // borland de-allocator fixup
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(size);
+ // note breaking a rule here - is this a problem on some platform
+ is.read(const_cast<wchar_t *>(ws.data()), size);
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+text_wiarchive_impl<Archive>::text_wiarchive_impl(
+ std::wistream & is,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::wistream>(
+ is,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_iarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ basic_text_iarchive<Archive>::init();
+}
+
+} // archive
+} // boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/text_woarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/text_woarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,85 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// text_woarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <cstring>
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE) && ! defined(__LIBCOMO__)
+namespace std{
+ using ::strlen;
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <ostream>
+
+#include <boost/archive/text_woarchive.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of woarchive functions
+//
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_woarchive_impl<Archive>::save(const char *s)
+{
+ // note: superfluous local variable fixes borland warning
+ const std::size_t size = std::strlen(s);
+ * this->This() << size;
+ this->This()->newtoken();
+ while(*s != '\0')
+ os.put(os.widen(*s++));
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_woarchive_impl<Archive>::save(const std::string &s)
+{
+ const std::size_t size = s.size();
+ * this->This() << size;
+ this->This()->newtoken();
+ const char * cptr = s.data();
+ for(std::size_t i = size; i-- > 0;)
+ os.put(os.widen(*cptr++));
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_woarchive_impl<Archive>::save(const wchar_t *ws)
+{
+ const std::size_t size = std::wostream::traits_type::length(ws);
+ * this->This() << size;
+ this->This()->newtoken();
+ os.write(ws, size);
+}
+#endif
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+text_woarchive_impl<Archive>::save(const std::wstring &ws)
+{
+ const std::size_t size = ws.length();
+ * this->This() << size;
+ this->This()->newtoken();
+ os.write(ws.data(), size);
+}
+#endif
+
+} // namespace archive
+} // namespace boost
+
+#endif
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_iarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_iarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,202 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_iarchive_impl.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+#include <boost/config.hpp>
+#include <cstring> // memcpy
+#include <cstddef> // NULL
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+#include <cstdlib> // mbtowc
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::mbtowc;
+ } // namespace std
+#endif
+#endif // BOOST_NO_CWCHAR
+
+#include <boost/detail/workaround.hpp> // RogueWave and Dinkumware
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/detail/no_exceptions_support.hpp>
+
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+
+#include "basic_xml_grammar.hpp"
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to char archives
+
+// wide char stuff used by char archives
+
+#ifndef BOOST_NO_CWCHAR
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_iarchive_impl<Archive>::load(std::wstring &ws){
+ std::string s;
+ bool result = gimpl->parse_string(is, s);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != ws.data())
+ #endif
+ ws.resize(0);
+ const char * start = s.data();
+ const char * end = start + s.size();
+ while(start < end){
+ wchar_t wc;
+ int resultx = std::mbtowc(&wc, start, end - start);
+ if(0 < resultx){
+ start += resultx;
+ ws += wc;
+ continue;
+ }
+ boost::throw_exception(
+ iterators::dataflow_exception(
+ iterators::dataflow_exception::invalid_conversion
+ )
+ );
+ }
+}
+#endif // BOOST_NO_STD_WSTRING
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_iarchive_impl<Archive>::load(wchar_t * ws){
+ std::string s;
+ bool result = gimpl->parse_string(is, s);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+
+ const char * start = s.data();
+ const char * end = start + s.size();
+ while(start < end){
+ wchar_t wc;
+ int result = std::mbtowc(&wc, start, end - start);
+ if(0 < result){
+ start += result;
+ *ws++ = wc;
+ continue;
+ }
+ boost::throw_exception(
+ iterators::dataflow_exception(
+ iterators::dataflow_exception::invalid_conversion
+ )
+ );
+ }
+ *ws = L'\0';
+}
+#endif
+
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_iarchive_impl<Archive>::load(std::string &s){
+ bool result = gimpl->parse_string(is, s);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_iarchive_impl<Archive>::load(char * s){
+ std::string tstring;
+ bool result = gimpl->parse_string(is, tstring);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ std::memcpy(s, tstring.data(), tstring.size());
+ s[tstring.size()] = 0;
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_iarchive_impl<Archive>::load_override(class_name_type & t, int){
+ const std::string & s = gimpl->rv.class_name;
+ if(s.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
+ boost::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ char * tptr = t;
+ std::memcpy(tptr, s.data(), s.size());
+ tptr[s.size()] = '\0';
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_iarchive_impl<Archive>::init(){
+ gimpl->init(is);
+ this->set_library_version(gimpl->rv.version);
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+xml_iarchive_impl<Archive>::xml_iarchive_impl(
+ std::istream &is_,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::istream>(
+ is_,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_xml_iarchive<Archive>(flags),
+ gimpl(new xml_grammar())
+{
+ if(0 == (flags & no_header)){
+ BOOST_TRY{
+ init();
+ }
+ BOOST_CATCH(...){
+ delete gimpl;
+ #ifndef BOOST_NO_EXCEPTIONS
+ throw; // re-throw
+ #endif
+ }
+ BOOST_CATCH_END
+ }
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+xml_iarchive_impl<Archive>::~xml_iarchive_impl(){
+ if(0 == (this->get_flags() & no_header)){
+ BOOST_TRY{
+ gimpl->windup(is);
+ }
+ BOOST_CATCH(...){}
+ BOOST_CATCH_END
+ }
+ delete gimpl;
+}
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_oarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_oarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,117 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_oarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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)
+
+#include <ostream>
+#include <iomanip>
+#include <algorithm>
+#include <string>
+
+#include <cstring> // strlen
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::strlen;
+} // namespace std
+#endif
+
+#include <boost/archive/iterators/xml_escape.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+
+#ifndef BOOST_NO_CWCHAR
+#include <boost/archive/wcslen.hpp>
+#include <boost/archive/iterators/mb_from_wchar.hpp>
+#endif
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to char archives
+
+// wide char stuff used by char archives
+#ifndef BOOST_NO_CWCHAR
+// copy chars to output escaping to xml and translating wide chars to mb chars
+template<class InputIterator>
+void save_iterator(std::ostream &os, InputIterator begin, InputIterator end){
+ typedef boost::archive::iterators::mb_from_wchar<
+ boost::archive::iterators::xml_escape<InputIterator>
+ > translator;
+ std::copy(
+ translator(BOOST_MAKE_PFTO_WRAPPER(begin)),
+ translator(BOOST_MAKE_PFTO_WRAPPER(end)),
+ boost::archive::iterators::ostream_iterator<char>(os)
+ );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_oarchive_impl<Archive>::save(const std::wstring & ws){
+// at least one library doesn't typedef value_type for strings
+// so rather than using string directly make a pointer iterator out of it
+// save_iterator(os, ws.data(), ws.data() + std::wcslen(ws.data()));
+ save_iterator(os, ws.data(), ws.data() + ws.size());
+}
+#endif
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_oarchive_impl<Archive>::save(const wchar_t * ws){
+ save_iterator(os, ws, ws + std::wcslen(ws));
+}
+#endif
+
+#endif // BOOST_NO_CWCHAR
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_oarchive_impl<Archive>::save(const std::string & s){
+// at least one library doesn't typedef value_type for strings
+// so rather than using string directly make a pointer iterator out of it
+ typedef boost::archive::iterators::xml_escape<
+ const char *
+ > xml_escape_translator;
+ std::copy(
+ xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s.data())),
+ xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s.data()+ s.size())),
+ boost::archive::iterators::ostream_iterator<char>(os)
+ );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(void)
+xml_oarchive_impl<Archive>::save(const char * s){
+ typedef boost::archive::iterators::xml_escape<
+ const char *
+ > xml_escape_translator;
+ std::copy(
+ xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s)),
+ xml_escape_translator(BOOST_MAKE_PFTO_WRAPPER(s + std::strlen(s))),
+ boost::archive::iterators::ostream_iterator<char>(os)
+ );
+}
+
+template<class Archive>
+BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+xml_oarchive_impl<Archive>::xml_oarchive_impl(
+ std::ostream & os_,
+ unsigned int flags
+) :
+ basic_text_oprimitive<std::ostream>(
+ os_,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_xml_oarchive<Archive>(flags)
+{
+ if(0 == (flags & no_header))
+ this->init();
+}
+
+} // namespace archive
+} // namespace boost
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_wiarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_wiarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,204 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_wiprimitive.cpp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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.
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+
+#include <cstring>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::memcpy;
+} //std
+#endif
+
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <cassert>
+#include <algorithm>
+
+#include <boost/detail/workaround.hpp> // Dinkumware and RogueWave
+#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
+#include <boost/archive/dinkumware.hpp>
+#endif
+
+#include <boost/io/ios_state.hpp>
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/pfto.hpp>
+
+#include <boost/serialization/string.hpp>
+#include <boost/archive/add_facet.hpp>
+#include <boost/archive/xml_archive_exception.hpp>
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+#include <boost/archive/iterators/mb_from_wchar.hpp>
+
+#include <boost/archive/basic_xml_archive.hpp>
+#include <boost/archive/xml_wiarchive.hpp>
+
+#include "basic_xml_grammar.hpp"
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to wide char archives
+
+namespace { // anonymous
+
+void copy_to_ptr(char * s, const std::wstring & ws){
+ std::copy(
+ iterators::mb_from_wchar<std::wstring::const_iterator>(
+ BOOST_MAKE_PFTO_WRAPPER(ws.begin())
+ ),
+ iterators::mb_from_wchar<std::wstring::const_iterator>(
+ BOOST_MAKE_PFTO_WRAPPER(ws.end())
+ ),
+ s
+ );
+ s[ws.size()] = 0;
+}
+
+} // anonymous
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_wiarchive_impl<Archive>::load(std::string & s){
+ std::wstring ws;
+ bool result = gimpl->parse_string(is, ws);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ #if BOOST_WORKAROUND(_RWSTD_VER, BOOST_TESTED_AT(20101))
+ if(NULL != s.data())
+ #endif
+ s.resize(0);
+ s.reserve(ws.size());
+ std::copy(
+ iterators::mb_from_wchar<std::wstring::iterator>(
+ BOOST_MAKE_PFTO_WRAPPER(ws.begin())
+ ),
+ iterators::mb_from_wchar<std::wstring::iterator>(
+ BOOST_MAKE_PFTO_WRAPPER(ws.end())
+ ),
+ std::back_inserter(s)
+ );
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_wiarchive_impl<Archive>::load(std::wstring & ws){
+ bool result = gimpl->parse_string(is, ws);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_wiarchive_impl<Archive>::load(char * s){
+ std::wstring ws;
+ bool result = gimpl->parse_string(is, ws);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ copy_to_ptr(s, ws);
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_wiarchive_impl<Archive>::load(wchar_t * ws){
+ std::wstring twstring;
+ bool result = gimpl->parse_string(is, twstring);
+ if(! result)
+ boost::throw_exception(
+ xml_archive_exception(xml_archive_exception::xml_archive_parsing_error)
+ );
+ std::memcpy(ws, twstring.c_str(), twstring.size());
+ ws[twstring.size()] = L'\0';
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_wiarchive_impl<Archive>::load_override(class_name_type & t, int){
+ const std::wstring & ws = gimpl->rv.class_name;
+ if(ws.size() > BOOST_SERIALIZATION_MAX_KEY_SIZE - 1)
+ boost::throw_exception(
+ archive_exception(archive_exception::invalid_class_name)
+ );
+ copy_to_ptr(t, ws);
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_wiarchive_impl<Archive>::init(){
+ gimpl->init(is);
+ this->set_library_version(gimpl->rv.version);
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+xml_wiarchive_impl<Archive>::xml_wiarchive_impl(
+ std::wistream &is_,
+ unsigned int flags
+) :
+ basic_text_iprimitive<std::wistream>(
+ is_,
+ true // don't change the codecvt - use the one below
+ ),
+ basic_xml_iarchive<Archive>(flags),
+ gimpl(new xml_wgrammar())
+{
+ if(0 == (flags & no_codecvt)){
+ archive_locale.reset(
+ add_facet(
+ std::locale::classic(),
+ new detail::utf8_codecvt_facet
+ )
+ );
+ is.imbue(* archive_locale);
+ }
+ if(0 == (flags & no_header)){
+ BOOST_TRY{
+ this->init();
+ }
+ BOOST_CATCH(...){
+ delete gimpl;
+ #ifndef BOOST_NO_EXCEPTIONS
+ throw; // re-throw
+ #endif
+ }
+ BOOST_CATCH_END
+ }
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+xml_wiarchive_impl<Archive>::~xml_wiarchive_impl(){
+ if(0 == (this->get_flags() & no_header)){
+ BOOST_TRY{
+ gimpl->windup(is);
+ }
+ BOOST_CATCH(...){}
+ BOOST_CATCH_END
+ }
+ delete gimpl;
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_NO_STD_WSTREAMBUF
Added: branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_woarchive_impl.ipp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/impl/xml_woarchive_impl.ipp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,159 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// xml_woarchive_impl.ipp:
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// Distributed under 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)
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_STD_WSTREAMBUF
+
+#include <ostream>
+#include <string>
+#include <algorithm>
+#include <locale>
+
+#include <boost/config.hpp> // msvc 6.0 needs this to suppress warnings
+ // for BOOST_DEDUCED_TYPENAME
+#include <cstring> // strlen
+#include <cstdlib> // mbtowc
+#include <cwchar> // wcslen
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::strlen;
+ #if ! defined(BOOST_NO_INTRINSIC_WCHAR_T)
+ using ::mbtowc;
+ using ::wcslen;
+ #endif
+} // namespace std
+#endif
+
+#include <boost/throw_exception.hpp>
+#include <boost/pfto.hpp>
+
+#include <boost/archive/iterators/xml_escape.hpp>
+#include <boost/archive/iterators/wchar_from_mb.hpp>
+#include <boost/archive/iterators/ostream_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+#include <boost/archive/add_facet.hpp>
+#include <boost/archive/detail/utf8_codecvt_facet.hpp>
+
+namespace boost {
+namespace archive {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implemenations of functions specific to wide char archives
+
+// copy chars to output escaping to xml and widening characters as we go
+template<class InputIterator>
+void save_iterator(std::wostream &os, InputIterator begin, InputIterator end){
+ typedef iterators::wchar_from_mb<
+ iterators::xml_escape<InputIterator>
+ > xmbtows;
+ std::copy(
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(begin)),
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(end)),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+}
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_woarchive_impl<Archive>::save(const std::string & s){
+ // note: we don't use s.begin() and s.end() because dinkumware
+ // doesn't have string::value_type defined. So use a wrapper
+ // around these values to implement the definitions.
+ const char * begin = s.data();
+ const char * end = begin + s.size();
+ save_iterator(os, begin, end);
+}
+
+#ifndef BOOST_NO_STD_WSTRING
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_woarchive_impl<Archive>::save(const std::wstring & ws){
+#if 0
+ typedef iterators::xml_escape<std::wstring::const_iterator> xmbtows;
+ std::copy(
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.begin())),
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.end())),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+#endif
+ typedef iterators::xml_escape<const wchar_t *> xmbtows;
+ std::copy(
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.data())),
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws.data() + ws.size())),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+}
+#endif //BOOST_NO_STD_WSTRING
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_woarchive_impl<Archive>::save(const char * s){
+ save_iterator(os, s, s + std::strlen(s));
+}
+
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+template<class Archive>
+BOOST_WARCHIVE_DECL(void)
+xml_woarchive_impl<Archive>::save(const wchar_t * ws){
+ os << ws;
+ typedef iterators::xml_escape<const wchar_t *> xmbtows;
+ std::copy(
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws)),
+ xmbtows(BOOST_MAKE_PFTO_WRAPPER(ws + std::wcslen(ws))),
+ boost::archive::iterators::ostream_iterator<wchar_t>(os)
+ );
+}
+#endif
+
+template<class Archive>
+BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+xml_woarchive_impl<Archive>::xml_woarchive_impl(
+ std::wostream & os_,
+ unsigned int flags
+) :
+ basic_text_oprimitive<std::wostream>(
+ os_,
+ true // don't change the codecvt - use the one below
+ ),
+ basic_xml_oarchive<Archive>(flags)
+{
+ // Standard behavior is that imbue can be called
+ // a) before output is invoked or
+ // b) after flush has been called. This prevents one-to-many
+ // transforms (such as one to many transforms from getting
+ // mixed up. Unfortunately, STLPort doesn't respect b) above
+ // so the restoration of the original archive locale done by
+ // the locale_saver doesn't get processed,
+ // before the current one is destroyed.
+ // so the codecvt doesn't get replaced with the orginal
+ // so closing the stream invokes codecvt::do_unshift
+ // so it crashes because the corresponding locale that contained
+ // the codecvt isn't around any more.
+ // we can hack around this by using a static codecvt that never
+ // gets destroyed.
+ if(0 == (flags & no_codecvt)){
+ detail::utf8_codecvt_facet *pfacet;
+ #if defined(__SGI_STL_PORT)
+ static detail::utf8_codecvt_facet facet(static_cast<size_t>(1));
+ pfacet = & facet;
+ #else
+ pfacet = new detail::utf8_codecvt_facet;
+ #endif
+ archive_locale.reset(add_facet(std::locale::classic(), pfacet));
+ os.imbue(* archive_locale);
+ }
+ if(0 == (flags & no_header))
+ this->init();
+}
+
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_STD_WSTREAMBUF
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/base64_exception.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/base64_exception.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,68 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_EXCEPTION_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
+// base64_exception.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.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <cassert>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by base64s
+//
+class base64_exception : public std::exception
+{
+public:
+ typedef enum {
+ invalid_code, // attempt to encode a value > 6 bits
+ invalid_character, // decode a value not in base64 char set
+ other_exception
+ } exception_code;
+ exception_code code;
+
+ base64_exception(exception_code c = other_exception) : code(c)
+ {}
+
+ virtual const char *what( ) const throw( )
+ {
+ const char *msg = "unknown exception code";
+ switch(code){
+ case invalid_code:
+ msg = "attempt to encode a value > 6 bits";
+ break;
+ case invalid_character:
+ msg = "attempt to decode a value not in base64 char set";
+ break;
+ default:
+ assert(false);
+ break;
+ }
+ return msg;
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_ARCHIVE_EXCEPTION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/base64_from_binary.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/base64_from_binary.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,105 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
+#define BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_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
+// base64_from_binary.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/pfto.hpp>
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert binary integers to base64 characters
+
+namespace detail {
+
+template<class CharType>
+struct from_6_bit {
+ typedef CharType result_type;
+ CharType operator()(CharType t) const{
+ const char * lookup_table =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz"
+ "0123456789"
+ "+/";
+ assert(t < 64);
+ return lookup_table[t];
+ }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
+// typedef transform_iterator<
+// from_6_bit<CharType>,
+// transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+// > base64_from_binary;
+// but C++ won't accept this. Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor. This makes it incompatible with the dataflow
+// ideal. This is also addressed here.
+
+//template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
+template<
+ class Base,
+ class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+>
+class base64_from_binary :
+ public transform_iterator<
+ detail::from_6_bit<CharType>,
+ Base
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef transform_iterator<
+ BOOST_DEDUCED_TYPENAME detail::from_6_bit<CharType>,
+ Base
+ > super_t;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ base64_from_binary(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(
+ Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))),
+ detail::from_6_bit<CharType>()
+ )
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ base64_from_binary(const base64_from_binary & rhs) :
+ super_t(
+ Base(rhs.base_reference()),
+ detail::from_6_bit<CharType>()
+ )
+ {}
+// base64_from_binary(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BASE64_FROM_BINARY_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/binary_from_base64.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/binary_from_base64.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,120 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
+#define BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_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
+// binary_from_base64.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/throw_exception.hpp>
+#include <boost/pfto.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 characters to binary data
+
+namespace detail {
+
+template<class CharType>
+struct to_6_bit {
+ typedef CharType result_type;
+ CharType operator()(CharType t) const{
+ const char lookup_table[] = {
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
+ -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,62,-1,-1,-1,63,
+ 52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,
+ -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,
+ 15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,
+ -1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,
+ 41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1
+ };
+ // metrowerks trips this assertion - how come?
+ #if ! defined(__MWERKS__)
+ BOOST_STATIC_ASSERT(128 == sizeof(lookup_table));
+ #endif
+ signed char value = -1;
+ if((unsigned)t <= 127)
+ value = lookup_table[(unsigned)t];
+ if(-1 == value)
+ boost::throw_exception(
+ dataflow_exception(dataflow_exception::invalid_base64_character)
+ );
+ return value;
+ }
+};
+
+} // namespace detail
+
+// note: what we would like to do is
+// template<class Base, class CharType = BOOST_DEDUCED_TYPENAME Base::value_type>
+// typedef transform_iterator<
+// from_6_bit<CharType>,
+// transform_width<Base, 6, sizeof(Base::value_type) * 8, CharType>
+// > base64_from_binary;
+// but C++ won't accept this. Rather than using a "type generator" and
+// using a different syntax, make a derivation which should be equivalent.
+//
+// Another issue addressed here is that the transform_iterator doesn't have
+// a templated constructor. This makes it incompatible with the dataflow
+// ideal. This is also addressed here.
+
+template<
+ class Base,
+ class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+>
+class binary_from_base64 : public
+ transform_iterator<
+ detail::to_6_bit<CharType>,
+ Base
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef transform_iterator<
+ detail::to_6_bit<CharType>,
+ Base
+ > super_t;
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ binary_from_base64(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(
+ Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))),
+ detail::to_6_bit<CharType>()
+ )
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ binary_from_base64(const binary_from_base64 & rhs) :
+ super_t(
+ Base(rhs.base_reference()),
+ detail::to_6_bit<CharType>()
+ )
+ {}
+// binary_from_base64(){};
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_BINARY_FROM_BASE64_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/dataflow.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/dataflow.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,104 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_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
+// dataflow.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+#include <boost/static_assert.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// poor man's tri-state
+struct tri_state {
+ enum state_enum {
+ is_false = false,
+ is_true = true,
+ is_indeterminant,
+ } m_state;
+ // convert to bool
+ operator bool (){
+ assert(is_indeterminant != m_state);
+ return is_true == m_state ? true : false;
+ }
+ // assign from bool
+ tri_state & operator=(bool rhs) {
+ m_state = rhs ? is_true : is_false;
+ }
+ tri_state(bool rhs) :
+ m_state(rhs ? is_true : is_false)
+ {}
+ tri_state(state_enum state) :
+ m_state(state)
+ {}
+ bool operator==(const tri_state & rhs) const {
+ return m_state == rhs.m_state;
+ }
+ bool operator!=(const tri_state & rhs) const {
+ return m_state != rhs.m_state;
+ }
+};
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implement functions common to dataflow iterators
+template<class Derived>
+class dataflow {
+ bool m_eoi;
+protected:
+ // test for iterator equality
+ tri_state equal(const Derived & rhs) const {
+ if(m_eoi && rhs.m_eoi)
+ return true;
+ if(m_eoi || rhs.m_eoi)
+ return false;
+ return tri_state(tri_state::is_indeterminant);
+ }
+ void eoi(bool tf){
+ m_eoi = tf;
+ }
+ bool eoi() const {
+ return m_eoi;
+ }
+public:
+ dataflow(bool tf) :
+ m_eoi(tf)
+ {}
+ dataflow() : // used for iterator end
+ m_eoi(true)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_DATAFLOW_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/dataflow_exception.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/dataflow_exception.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,80 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_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
+// dataflow_exception.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.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <cassert>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by dataflows
+//
+class dataflow_exception : public std::exception
+{
+public:
+ typedef enum {
+ invalid_6_bitcode,
+ invalid_base64_character,
+ invalid_xml_escape_sequence,
+ comparison_not_permitted,
+ invalid_conversion,
+ other_exception
+ } exception_code;
+ exception_code code;
+
+ dataflow_exception(exception_code c = other_exception) : code(c)
+ {}
+
+ virtual const char *what( ) const throw( )
+ {
+ const char *msg = "unknown exception code";
+ switch(code){
+ case invalid_6_bitcode:
+ msg = "attempt to encode a value > 6 bits";
+ break;
+ case invalid_base64_character:
+ msg = "attempt to decode a value not in base64 char set";
+ break;
+ case invalid_xml_escape_sequence:
+ msg = "invalid xml escape_sequence";
+ break;
+ case comparison_not_permitted:
+ msg = "cannot invoke iterator comparison now";
+ break;
+ case invalid_conversion:
+ msg = "invalid multbyte/wide char conversion";
+ break;
+ default:
+ assert(false);
+ break;
+ }
+ return msg;
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_DATAFLOW_EXCEPTION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/escape.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/escape.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,115 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_ESCAPE_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
+// escape.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.
+
+#include <cassert>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into text
+
+template<class Derived, class Base>
+class escape :
+ public boost::iterator_adaptor<
+ Derived,
+ Base,
+ BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type,
+ single_pass_traversal_tag,
+ BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+ >
+{
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type base_value_type;
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<Base>::type reference_type;
+ friend class boost::iterator_core_access;
+
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+ Derived,
+ Base,
+ base_value_type,
+ single_pass_traversal_tag,
+ base_value_type
+ > super_t;
+
+ typedef escape<Derived, Base> this_t;
+
+ void dereference_impl() {
+ m_current_value = static_cast<Derived *>(this)->fill(m_bnext, m_bend);
+ m_full = true;
+ }
+
+ //Access the value referred to
+ reference_type dereference() const {
+ if(!m_full)
+ const_cast<this_t *>(this)->dereference_impl();
+ return m_current_value;
+ }
+
+ bool equal(const this_t & rhs) const {
+ if(m_full){
+ if(! rhs.m_full)
+ const_cast<this_t *>(& rhs)->dereference_impl();
+ }
+ else{
+ if(rhs.m_full)
+ const_cast<this_t *>(this)->dereference_impl();
+ }
+ if(m_bnext != rhs.m_bnext)
+ return false;
+ if(this->base_reference() != rhs.base_reference())
+ return false;
+ return true;
+ }
+
+ void increment(){
+ if(++m_bnext < m_bend){
+ m_current_value = *m_bnext;
+ return;
+ }
+ ++(this->base_reference());
+ m_bnext = NULL;
+ m_bend = NULL;
+ m_full = false;
+ }
+
+ // buffer to handle pending characters
+ const base_value_type *m_bnext;
+ const base_value_type *m_bend;
+ bool m_full;
+ BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type m_current_value;
+public:
+ escape(Base base) :
+ super_t(base),
+ m_bnext(NULL),
+ m_bend(NULL),
+ m_full(false)
+ {
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ESCAPE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/head_iterator.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/head_iterator.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,81 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_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
+// head_iterator.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.
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+template<class Predicate, class Base>
+class head_iterator
+ : public boost::iterator_adaptor<
+ head_iterator<Predicate, Base>,
+ Base,
+ use_default,
+ single_pass_traversal_tag
+ >
+{
+private:
+ friend class iterator_core_access;
+ typedef boost::iterator_adaptor<
+ head_iterator<Predicate, Base>,
+ Base,
+ use_default,
+ single_pass_traversal_tag
+ > super_t;
+
+ typedef head_iterator<Predicate, Base> this_t;
+ typedef BOOST_DEDUCED_TYPENAME super_t::value_type value_type;
+ typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
+
+ reference_type dereference_impl(){
+ if(! m_end){
+ while(! m_predicate(* base_reference()))
+ ++ base_reference();
+ m_end = true;
+ }
+ return * base_reference();
+ }
+
+ reference_type dereference() const {
+ return const_cast<this_t *>(this)->dereference_impl();
+ }
+
+ void increment(){
+ ++base_reference();
+ }
+ Predicate m_predicate;
+ bool m_end;
+public:
+ template<class T>
+ head_iterator(Predicate f, T start) :
+ super_t(Base(start)),
+ m_predicate(f),
+ m_end(false)
+ {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_HEAD_ITERATOR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/insert_linebreaks.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/insert_linebreaks.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,101 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
+#define BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_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
+// insert_linebreaks.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::memcpy; }
+#endif
+
+#include <boost/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert line break every N characters
+template<
+ class Base,
+ int N,
+ class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type
+>
+class insert_linebreaks :
+ public iterator_adaptor<
+ insert_linebreaks<Base, N, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ >
+{
+private:
+ friend class boost::iterator_core_access;
+ typedef iterator_adaptor<
+ insert_linebreaks<Base, N, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ > super_t;
+
+ bool equal(const insert_linebreaks<Base, N, CharType> & rhs) const {
+ return
+// m_count == rhs.m_count
+// && base_reference() == rhs.base_reference()
+ this->base_reference() == rhs.base_reference()
+ ;
+ }
+
+ void increment() {
+ if(m_count == N){
+ m_count = 0;
+ return;
+ }
+ ++m_count;
+ ++(this->base_reference());
+ }
+ CharType dereference() const {
+ if(m_count == N)
+ return '\n';
+ return * (this->base_reference());
+ }
+ unsigned int m_count;
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ insert_linebreaks(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+ m_count(0)
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ insert_linebreaks(const insert_linebreaks & rhs) :
+ super_t(rhs.base_reference()),
+ m_count(rhs.m_count)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_INSERT_LINEBREAKS_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/istream_iterator.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/istream_iterator.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,95 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_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
+// istream_iterator.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.
+
+// note: this is a custom version of the standard istream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <cstddef> // NULL
+#include <istream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem = char>
+class istream_iterator :
+ public boost::iterator_facade<
+ istream_iterator<Elem>,
+ Elem,
+ std::input_iterator_tag,
+ Elem
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef istream_iterator this_t ;
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_facade<
+ istream_iterator<Elem>,
+ Elem,
+ std::input_iterator_tag,
+ Elem
+ > super_t;
+ typedef BOOST_DEDUCED_TYPENAME std::basic_istream<Elem> istream_type;
+
+ //Access the value referred to
+ Elem dereference() const {
+ return m_current_value;
+ }
+
+ bool equal(const this_t & rhs) const {
+ // note: only works for comparison against end of stream
+ return m_istream == rhs.m_istream;
+ }
+
+ void increment(){
+ if(NULL != m_istream){
+ m_current_value = m_istream->get();
+ if(! m_istream->good()){
+ const_cast<this_t *>(this)->m_istream = NULL;
+ }
+ }
+ }
+
+ istream_type *m_istream;
+ Elem m_current_value;
+public:
+ istream_iterator(istream_type & is) :
+ m_istream(& is)
+ {
+ increment();
+ }
+
+ istream_iterator() :
+ m_istream(NULL)
+ {}
+
+ istream_iterator(const istream_iterator<Elem> & rhs) :
+ m_istream(rhs.m_istream),
+ m_current_value(rhs.m_current_value)
+ {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_ISTREAM_ITERATOR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/mb_from_wchar.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/mb_from_wchar.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,136 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
+#define BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_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
+// mb_from_wchar.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.
+
+#include <cassert>
+#include <cstddef> // size_t
+#include <cstdlib> // for wctomb()
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+ using ::wctomb;
+} // namespace std
+#endif
+
+#include <boost/pfto.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate wide strings and to char
+// strings of the currently selected locale
+template<class Base> // the input iterator
+class mb_from_wchar
+ : public boost::iterator_adaptor<
+ mb_from_wchar<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ char
+ >
+{
+ friend class boost::iterator_core_access;
+
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+ mb_from_wchar<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ char
+ > super_t;
+
+ typedef mb_from_wchar<Base> this_t;
+
+ char dereference_impl() {
+ if(! m_full){
+ fill();
+ m_full = true;
+ }
+ return m_buffer[m_bnext];
+ }
+ char dereference() const {
+ return (const_cast<this_t *>(this))->dereference_impl();
+ }
+
+ // test for iterator equality
+ bool equal(const mb_from_wchar<Base> & rhs) const {
+ // once the value is filled, the base_reference has been incremented
+ // so don't permit comparison anymore.
+ return
+ 0 == m_bend
+ && 0 == m_bnext
+ && this->base_reference() == rhs.base_reference()
+ ;
+ }
+
+ void fill(){
+ wchar_t value = * this->base_reference();
+ #if (defined(__MINGW32__) && ((__MINGW32_MAJOR_VERSION > 3) \
+ || ((__MINGW32_MAJOR_VERSION == 3) && (__MINGW32_MINOR_VERSION >= 8))))
+ m_bend = std::wcrtomb(m_buffer, value, 0);
+ #else
+ m_bend = std::wctomb(m_buffer, value);
+ #endif
+ assert(-1 != m_bend);
+ assert((std::size_t)m_bend <= sizeof(m_buffer));
+ assert(m_bend > 0);
+ m_bnext = 0;
+ }
+
+ void increment(){
+ if(++m_bnext < m_bend)
+ return;
+ m_bend =
+ m_bnext = 0;
+ ++(this->base_reference());
+ m_full = false;
+ }
+
+ // buffer to handle pending characters
+ int m_bend;
+ int m_bnext;
+ char m_buffer[9];
+ bool m_full;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ mb_from_wchar(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+ m_bend(0),
+ m_bnext(0),
+ m_full(false)
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ mb_from_wchar(const mb_from_wchar & rhs) :
+ super_t(rhs.base_reference()),
+ m_bend(rhs.m_bend),
+ m_bnext(rhs.m_bnext),
+ m_full(rhs.m_full)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_MB_FROM_WCHAR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/ostream_iterator.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/ostream_iterator.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,83 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
+#define BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_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
+// ostream_iterator.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.
+
+// note: this is a custom version of the standard ostream_iterator.
+// This is necessary as the standard version doesn't work as expected
+// for wchar_t based streams on systems for which wchar_t not a true
+// type but rather a synonym for some integer type.
+
+#include <ostream>
+#include <boost/iterator/iterator_facade.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// given a type, make an input iterator based on a pointer to that type
+template<class Elem>
+class ostream_iterator :
+ public boost::iterator_facade<
+ ostream_iterator<Elem>,
+ Elem,
+ std::output_iterator_tag,
+ ostream_iterator<Elem> &
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef ostream_iterator this_t ;
+ typedef Elem char_type;
+ typedef std::basic_ostream<char_type> ostream_type;
+
+ //emulate the behavior of std::ostream
+ ostream_iterator & dereference() const {
+ return const_cast<ostream_iterator &>(*this);
+ }
+ bool equal(const this_t & rhs) const {
+ return m_ostream == rhs.m_ostream;
+ }
+ void increment(){}
+protected:
+ ostream_type *m_ostream;
+ void put_val(char_type e){
+ if(NULL != m_ostream){
+ m_ostream->put(e);
+ if(! m_ostream->good())
+ m_ostream = NULL;
+ }
+ }
+public:
+ this_t & operator=(char_type c){
+ put_val(c);
+ return *this;
+ }
+ ostream_iterator(ostream_type & os) :
+ m_ostream (& os)
+ {}
+ ostream_iterator() :
+ m_ostream (NULL)
+ {}
+ ostream_iterator(const ostream_iterator & rhs) :
+ m_ostream (rhs.m_ostream)
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_OSTREAM_ITERATOR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/remove_whitespace.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/remove_whitespace.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,169 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
+#define BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_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
+// remove_whitespace.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+
+#include <boost/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+
+//#include <boost/detail/workaround.hpp>
+//#if ! BOOST_WORKAROUND(BOOST_MSVC, <=1300)
+
+// here is the default standard implementation of the functor used
+// by the filter iterator to remove spaces. Unfortunately usage
+// of this implementation in combination with spirit trips a bug
+// VC 6.5. The only way I can find to work around it is to
+// implement a special non-standard version for this platform
+
+#ifndef BOOST_NO_CWCTYPE
+#include <cwctype> // iswspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::iswspace; }
+#endif
+#endif
+
+#include <cctype> // isspace
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{ using ::isspace; }
+#endif
+
+#if defined(__STD_RWCOMPILER_H__) || defined(_RWSTD_VER)
+// this is required for the RW STL on Linux and Tru64.
+#undef isspace
+#undef iswspace
+#endif
+
+//#endif // BOOST_WORKAROUND
+
+namespace { // anonymous
+
+template<class CharType>
+struct remove_whitespace_predicate;
+
+template<>
+struct remove_whitespace_predicate<char>
+{
+ bool operator()(unsigned char t){
+ return ! std::isspace(t);
+ }
+};
+
+#ifndef BOOST_NO_CWCHAR
+template<>
+struct remove_whitespace_predicate<wchar_t>
+{
+ bool operator()(wchar_t t){
+ return ! std::iswspace(t);
+ }
+};
+#endif
+
+} // namespace anonymous
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// convert base64 file data (including whitespace and padding) to binary
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+// custom version of filter iterator which doesn't look ahead further than
+// necessary
+
+template<class Predicate, class Base>
+class filter_iterator
+ : public boost::iterator_adaptor<
+ filter_iterator<Predicate, Base>,
+ Base,
+ use_default,
+ single_pass_traversal_tag
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+ filter_iterator<Predicate, Base>,
+ Base,
+ use_default,
+ single_pass_traversal_tag
+ > super_t;
+ typedef filter_iterator<Predicate, Base> this_t;
+ typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
+
+ reference_type dereference_impl(){
+ if(! m_full){
+ while(! m_predicate(* this->base_reference()))
+ ++(this->base_reference());
+ m_full = true;
+ }
+ return * this->base_reference();
+ }
+
+ reference_type dereference() const {
+ return const_cast<this_t *>(this)->dereference_impl();
+ }
+
+ Predicate m_predicate;
+ bool m_full;
+public:
+ // note: this function is public only because comeau compiler complained
+ // I don't know if this is because the compiler is wrong or what
+ void increment(){
+ m_full = false;
+ ++(this->base_reference());
+ }
+ filter_iterator(Base start) :
+ super_t(start),
+ m_full(false)
+ {}
+ filter_iterator(){}
+};
+
+template<class Base>
+class remove_whitespace :
+ public filter_iterator<
+ remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
+ Base
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef filter_iterator<
+ remove_whitespace_predicate<BOOST_DEDUCED_TYPENAME Base::value_type>,
+ Base
+ > super_t;
+public:
+// remove_whitespace(){} // why is this needed?
+ // make composible buy using templated constructor
+ template<class T>
+ remove_whitespace(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ remove_whitespace(const remove_whitespace & rhs) :
+ super_t(rhs.base_reference())
+ {}
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_REMOVE_WHITESPACE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/transform_width.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/transform_width.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,168 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
+#define BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_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
+// transform_width.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.
+
+// iterator which takes elements of x bits and returns elements of y bits.
+// used to change streams of 8 bit characters into streams of 6 bit characters.
+// and vice-versa for implementing base64 encodeing/decoding. Be very careful
+// when using and end iterator. end is only reliable detected when the input
+// stream length is some common multiple of x and y. E.G. Base64 6 bit
+// character and 8 bit bytes. Lowest common multiple is 24 => 4 6 bit characters
+// or 3 8 bit characters
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME & PTFO
+#include <boost/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<
+ class Base,
+ int BitsOut,
+ int BitsIn,
+ class CharType = BOOST_DEDUCED_TYPENAME boost::iterator_value<Base>::type // output character
+>
+class transform_width :
+ public boost::iterator_adaptor<
+ transform_width<Base, BitsOut, BitsIn, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+ transform_width<Base, BitsOut, BitsIn, CharType>,
+ Base,
+ CharType,
+ single_pass_traversal_tag,
+ CharType
+ > super_t;
+
+ typedef transform_width<Base, BitsOut, BitsIn, CharType> this_t;
+ typedef BOOST_DEDUCED_TYPENAME iterator_value<Base>::type base_value_type;
+
+ CharType fill();
+
+ CharType dereference_impl(){
+ if(! m_full){
+ m_current_value = fill();
+ m_full = true;
+ }
+ return m_current_value;
+ }
+
+ CharType dereference() const {
+ return const_cast<this_t *>(this)->dereference_impl();
+ }
+
+ // test for iterator equality
+ bool equal(const this_t & rhs) const {
+ return
+ this->base_reference() == rhs.base_reference();
+ ;
+ }
+
+ void increment(){
+ m_displacement += BitsOut;
+
+ while(m_displacement >= BitsIn){
+ m_displacement -= BitsIn;
+ if(0 == m_displacement)
+ m_bufferfull = false;
+ if(! m_bufferfull){
+ // note: suspect that this is not invoked for borland
+ ++(this->base_reference());
+ }
+ }
+ m_full = false;
+ }
+
+ CharType m_current_value;
+ // number of bits left in current input character buffer
+ unsigned int m_displacement;
+ base_value_type m_buffer;
+ // flag to current output character is ready - just used to save time
+ bool m_full;
+ // flag to indicate that m_buffer has data
+ bool m_bufferfull;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ transform_width(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+ m_displacement(0),
+ m_full(false),
+ m_bufferfull(false)
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ transform_width(const transform_width & rhs) :
+ super_t(rhs.base_reference()),
+ m_current_value(rhs.m_current_value),
+ m_displacement(rhs.m_displacement),
+ m_buffer(rhs.m_buffer),
+ m_full(rhs.m_full),
+ m_bufferfull(rhs.m_bufferfull)
+ {}
+};
+
+template<class Base, int BitsOut, int BitsIn, class CharType>
+CharType transform_width<Base, BitsOut, BitsIn, CharType>::fill(){
+ CharType retval = 0;
+ unsigned int missing_bits = BitsOut;
+ for(;;){
+ unsigned int bcount;
+ if(! m_bufferfull){
+ m_buffer = * this->base_reference();
+ m_bufferfull = true;
+ bcount = BitsIn;
+ }
+ else
+ bcount = BitsIn - m_displacement;
+ unsigned int i = (std::min)(bcount, missing_bits);
+ // shift interesting bits to least significant position
+ unsigned int j = m_buffer >> (bcount - i);
+ // strip off uninteresting bits
+ // (note presumption of two's complement arithmetic)
+ j &= ~(-(1 << i));
+ // append then interesting bits to the output value
+ retval <<= i;
+ retval |= j;
+ missing_bits -= i;
+ if(0 == missing_bits)
+ break;
+ // note: suspect that this is not invoked for borland 5.51
+ ++(this->base_reference());
+ m_bufferfull = false;
+ }
+ return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_TRANSFORM_WIDTH_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/unescape.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/unescape.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,94 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_UNESCAPE_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
+// unescape.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/iterator/iterator_adaptor.hpp>
+//#include <boost/iterator/iterator_traits.hpp>
+#include <boost/pointee.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Derived, class Base>
+class unescape
+ : public boost::iterator_adaptor<
+ unescape<Derived, Base>,
+ Base,
+ BOOST_DEDUCED_TYPENAME pointee<Base>::type,
+ single_pass_traversal_tag,
+ BOOST_DEDUCED_TYPENAME pointee<Base>::type
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+ unescape<Derived, Base>,
+ Base,
+ BOOST_DEDUCED_TYPENAME pointee<Base>::type,
+ single_pass_traversal_tag,
+ BOOST_DEDUCED_TYPENAME pointee<Base>::type
+ > super_t;
+
+ typedef unescape<Derived, Base> this_t;
+ typedef BOOST_DEDUCED_TYPENAME super_t::reference reference_type;
+public:
+ // gcc 3.4.1 - linux required that this be public
+ typedef BOOST_DEDUCED_TYPENAME super_t::value_type value_type;
+private:
+
+ reference_type dereference_impl() {
+ if(! m_full){
+ m_current_value = static_cast<Derived *>(this)->drain();
+ m_full = true;
+ }
+ return m_current_value;
+ }
+
+ reference_type dereference() const {
+ return const_cast<this_t *>(this)->dereference_impl();
+ }
+
+ // value_type is const char - can't be const fix later
+ value_type m_current_value;
+ bool m_full;
+
+ void increment(){
+ ++(this->base_reference());
+ dereference_impl();
+ m_full = false;
+ };
+
+public:
+
+ unescape(Base base) :
+ super_t(base),
+ m_full(false)
+ {}
+
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_UNESCAPE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/wchar_from_mb.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/wchar_from_mb.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,129 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
+#define BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_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
+// wchar_from_mb.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.
+
+#include <cassert>
+#include <cctype>
+#include <cstddef> // size_t
+#include <cstdlib> // mblen
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::mblen;
+ using ::mbtowc;
+} // namespace std
+#endif
+
+#include <boost/throw_exception.hpp>
+#include <boost/pfto.hpp>
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// class used by text archives to translate char strings to wchar_t
+// strings of the currently selected locale
+template<class Base>
+class wchar_from_mb
+ : public boost::iterator_adaptor<
+ wchar_from_mb<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ wchar_t
+ >
+{
+ friend class boost::iterator_core_access;
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_adaptor<
+ wchar_from_mb<Base>,
+ Base,
+ wchar_t,
+ single_pass_traversal_tag,
+ wchar_t
+ > super_t;
+
+ typedef wchar_from_mb<Base> this_t;
+
+ wchar_t drain();
+
+ wchar_t dereference_impl() {
+ if(! m_full){
+ m_current_value = drain();
+ m_full = true;
+ }
+ return m_current_value;
+ }
+
+ wchar_t dereference() const {
+ return const_cast<this_t *>(this)->dereference_impl();
+ }
+
+ void increment(){
+ dereference_impl();
+ m_full = false;
+ ++(this->base_reference());
+ };
+
+ wchar_t m_current_value;
+ bool m_full;
+
+public:
+ // make composible buy using templated constructor
+ template<class T>
+ wchar_from_mb(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start)))),
+ m_full(false)
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ wchar_from_mb(const wchar_from_mb & rhs) :
+ super_t(rhs.base_reference()),
+ m_full(rhs.m_full)
+ {}
+};
+
+template<class Base>
+wchar_t wchar_from_mb<Base>::drain(){
+ char buffer[9];
+ char * bptr = buffer;
+ char val;
+ for(std::size_t i = 0; i++ < (unsigned)MB_CUR_MAX;){
+ val = * this->base_reference();
+ *bptr++ = val;
+ int result = std::mblen(buffer, i);
+ if(-1 != result)
+ break;
+ ++(this->base_reference());
+ }
+ wchar_t retval;
+ int result = std::mbtowc(& retval, buffer, MB_CUR_MAX);
+ if(0 >= result)
+ boost::throw_exception(iterators::dataflow_exception(
+ iterators::dataflow_exception::invalid_conversion
+ ));
+ return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_WCHAR_FROM_MB_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_escape.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_escape.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,125 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_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
+// xml_escape.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/pfto.hpp>
+
+#include <boost/archive/iterators/escape.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// insert escapes into xml text
+
+template<class Base>
+class xml_escape
+ : public escape<xml_escape<Base>, Base>
+{
+ friend class boost::iterator_core_access;
+
+ typedef escape<xml_escape<Base>, Base> super_t;
+
+public:
+ char fill(const char * & bstart, const char * & bend);
+ wchar_t fill(const wchar_t * & bstart, const wchar_t * & bend);
+
+ template<class T>
+ xml_escape(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ xml_escape(const xml_escape & rhs) :
+ super_t(rhs.base_reference())
+ {}
+};
+
+template<class Base>
+char xml_escape<Base>::fill(
+ const char * & bstart,
+ const char * & bend
+){
+ char current_value = * this->base_reference();
+ switch(current_value){
+ case '<':
+ bstart = "<";
+ bend = bstart + 4;
+ break;
+ case '>':
+ bstart = ">";
+ bend = bstart + 4;
+ break;
+ case '&':
+ bstart = "&";
+ bend = bstart + 5;
+ break;
+ case '"':
+ bstart = """;
+ bend = bstart + 6;
+ break;
+ case '\'':
+ bstart = "'";
+ bend = bstart + 6;
+ break;
+ default:
+ return current_value;
+ }
+ return *bstart;
+}
+
+template<class Base>
+wchar_t xml_escape<Base>::fill(
+ const wchar_t * & bstart,
+ const wchar_t * & bend
+){
+ wchar_t current_value = * this->base_reference();
+ switch(current_value){
+ case '<':
+ bstart = L"<";
+ bend = bstart + 4;
+ break;
+ case '>':
+ bstart = L">";
+ bend = bstart + 4;
+ break;
+ case '&':
+ bstart = L"&";
+ bend = bstart + 5;
+ break;
+ case '"':
+ bstart = L""";
+ bend = bstart + 6;
+ break;
+ case '\'':
+ bstart = L"'";
+ bend = bstart + 6;
+ break;
+ default:
+ return current_value;
+ }
+ return *bstart;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_ESCAPE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_unescape.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_unescape.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,118 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_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
+// xml_unescape.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.
+
+#include <cassert>
+
+#include <boost/config.hpp> // for BOOST_DEDUCED_TYPENAME
+#include <boost/throw_exception.hpp>
+#include <boost/pfto.hpp>
+
+#include <boost/archive/iterators/unescape.hpp>
+#include <boost/archive/iterators/dataflow_exception.hpp>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// replace &??? xml escape sequences with the corresponding characters
+template<class Base>
+class xml_unescape
+ : public unescape<xml_unescape<Base>, Base>
+{
+ friend class boost::iterator_core_access;
+ typedef xml_unescape<Base> this_t;
+ typedef unescape<this_t, Base> super_t;
+ typedef BOOST_DEDUCED_TYPENAME boost::iterator_reference<this_t> reference_type;
+
+ reference_type dereference() const {
+ return unescape<xml_unescape<Base>, Base>::dereference();
+ }
+public:
+ void drain_residue(const char *literal);
+ int drain();
+
+ template<class T>
+ xml_unescape(BOOST_PFTO_WRAPPER(T) start) :
+ super_t(Base(BOOST_MAKE_PFTO_WRAPPER(static_cast<T>(start))))
+ {}
+ // intel 7.1 doesn't like default copy constructor
+ xml_unescape(const xml_unescape & rhs) :
+ super_t(rhs.base_reference())
+ {}
+};
+
+template<class Base>
+void xml_unescape<Base>::drain_residue(const char * literal){
+ do{
+ if(* literal != * ++(this->base_reference()))
+ boost::throw_exception(
+ dataflow_exception(
+ dataflow_exception::invalid_xml_escape_sequence
+ )
+ );
+ }
+ while('\0' != * ++literal);
+}
+
+// note key constraint on this function is that can't "look ahead" any
+// more than necessary into base iterator. Doing so would alter the base
+// iterator refenence which would make subsequent iterator comparisons
+// incorrect and thereby break the composiblity of iterators.
+template<class Base>
+int xml_unescape<Base>::drain(){
+ int retval = * this->base_reference();
+ if('&' != retval){
+ return retval;
+ }
+ retval = * ++(this->base_reference());
+ switch(retval){
+ case 'l': // <
+ drain_residue("t;");
+ retval = '<';
+ break;
+ case 'g': // >
+ drain_residue("t;");
+ retval = '>';
+ break;
+ case 'a':
+ retval = * ++(this->base_reference());
+ switch(retval){
+ case 'p': // '
+ drain_residue("os;");
+ retval = '\'';
+ break;
+ case 'm': // &
+ drain_residue("p;");
+ retval = '&';
+ break;
+ }
+ break;
+ case 'q':
+ drain_residue("uot;");
+ retval = '"';
+ break;
+ }
+ return retval;
+}
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_unescape_exception.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/iterators/xml_unescape_exception.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,49 @@
+#ifndef BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_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
+// xml_unescape_exception.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.
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_EXCEPTIONS
+#include <exception>
+
+#include <cassert>
+
+namespace boost {
+namespace archive {
+namespace iterators {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by xml_unescapes
+//
+class xml_unescape_exception : public std::exception
+{
+public:
+ xml_unescape_exception()
+ {}
+
+ virtual const char *what( ) const throw( )
+ {
+ return "xml contained un-recognized escape code";
+ }
+};
+
+} // namespace iterators
+} // namespace archive
+} // namespace boost
+
+#endif //BOOST_NO_EXCEPTIONS
+#endif //BOOST_ARCHIVE_ITERATORS_XML_UNESCAPE_EXCEPTION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_binary_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_binary_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,45 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_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
+// polymorphic_binary_iarchive.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/binary_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+class polymorphic_binary_iarchive :
+ public detail::polymorphic_iarchive_route<naked_binary_iarchive>
+{
+public:
+ polymorphic_binary_iarchive(std::istream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<naked_binary_iarchive>(is, flags)
+ {}
+ ~polymorphic_binary_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_binary_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_IARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_binary_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_binary_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,43 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_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
+// polymorphic_binary_oarchive.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/binary_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ binary_oarchive_impl<
+ naked_binary_oarchive,
+ std::ostream::char_type,
+ std::ostream::traits_type
+ >
+ > polymorphic_binary_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_binary_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_BINARY_OARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,188 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_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
+// polymorphic_iarchive.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.
+
+#include <cstddef> // std::size_t
+#include <climits> // ULONG_MAX
+#include <boost/config.hpp>
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <string>
+#include <boost/cstdint.hpp>
+
+#include <boost/pfto.hpp>
+#include <boost/archive/detail/iserializer.hpp>
+#include <boost/archive/detail/interface_iarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+// determine if its necessary to handle (u)int64_t specifically
+// i.e. that its not a synonym for (unsigned) long
+// if there is no 64 bit int or if its the same as a long
+// we shouldn't define separate functions for int64 data types.
+#if defined(BOOST_NO_INT64_T)
+ #define BOOST_NO_INTRINSIC_INT64_T
+#else
+ #if defined(ULONG_MAX)
+ #if(ULONG_MAX != 0xffffffff && ULONG_MAX == 18446744073709551615u) // 2**64 - 1
+ #define BOOST_NO_INTRINSIC_INT64_T
+ #endif
+ #else
+ #define BOOST_NO_INTRINSIC_INT64_T
+ #endif
+#endif
+
+namespace boost {
+template<class T>
+class shared_ptr;
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail {
+ class basic_iarchive;
+ class basic_iserializer;
+}
+
+class polymorphic_iarchive;
+
+class polymorphic_iarchive_impl :
+ public detail::interface_iarchive<polymorphic_iarchive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_iarchive<polymorphic_iarchive>;
+ friend class load_access;
+#endif
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void load(bool & t) = 0;
+
+ virtual void load(char & t) = 0;
+ virtual void load(signed char & t) = 0;
+ virtual void load(unsigned char & t) = 0;
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void load(wchar_t & t) = 0;
+ #endif
+ #endif
+ virtual void load(short & t) = 0;
+ virtual void load(unsigned short & t) = 0;
+ virtual void load(int & t) = 0;
+ virtual void load(unsigned int & t) = 0;
+ virtual void load(long & t) = 0;
+ virtual void load(unsigned long & t) = 0;
+
+ #if !defined(BOOST_NO_INTRINSIC_INT64_T)
+ virtual void load(boost::int64_t & t) = 0;
+ virtual void load(boost::uint64_t & t) = 0;
+ #endif
+ virtual void load(float & t) = 0;
+ virtual void load(double & t) = 0;
+
+ // string types are treated as primitives
+ virtual void load(std::string & t) = 0;
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void load(std::wstring & t) = 0;
+ #endif
+
+ // used for xml and other tagged formats
+ virtual void load_start(const char * name) = 0;
+ virtual void load_end(const char * name) = 0;
+ virtual void register_basic_serializer(const detail::basic_iserializer & bis) = 0;
+
+ // msvc and borland won't automatically pass these to the base class so
+ // make it explicit here
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int)
+ {
+ archive::load(* this->This(), t);
+ }
+ // special treatment for name-value pairs.
+ template<class T>
+ void load_override(
+ #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ const
+ #endif
+ boost::serialization::nvp<T> & t,
+ int
+ ){
+ load_start(t.name());
+ archive::load(* this->This(), t.value());
+ load_end(t.name());
+ }
+protected:
+ virtual ~polymorphic_iarchive_impl(){};
+public:
+ // utility function implemented by all legal archives
+ virtual void set_library_version(unsigned int archive_library_version) = 0;
+ virtual unsigned int get_library_version() const = 0;
+ virtual unsigned int get_flags() const = 0;
+ virtual void delete_created_pointers() = 0;
+ virtual void reset_object_address(
+ const void * new_address,
+ const void * old_address
+ ) = 0;
+
+ virtual void load_binary(void * t, std::size_t size) = 0;
+
+ // these are used by the serialization library implementation.
+ virtual void load_object(
+ void *t,
+ const detail::basic_iserializer & bis
+ ) = 0;
+ virtual const detail::basic_pointer_iserializer * load_pointer(
+ void * & t,
+ const detail::basic_pointer_iserializer * bpis_ptr,
+ const detail::basic_pointer_iserializer * (*finder)(
+ const boost::serialization::extended_type_info & type
+ )
+ ) = 0;
+};
+
+} // namespace archive
+} // namespace boost
+
+// note special treatment of shared_ptr. This type needs a special
+// structure associated with every archive. We created a "mix-in"
+// class to provide this functionality. Since shared_ptr holds a
+// special esteem in the boost library - we included it here by default.
+#include <boost/archive/shared_ptr_helper.hpp>
+
+namespace boost {
+namespace archive {
+
+class polymorphic_iarchive :
+ public polymorphic_iarchive_impl,
+ public detail::shared_ptr_helper
+{
+public:
+ virtual ~polymorphic_iarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_iarchive)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,165 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_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
+// polymorphic_oarchive.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.
+
+#include <cstddef> // size_t
+#include <climits> // ULONG_MAX
+#include <string>
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/cstdint.hpp>
+#include <boost/pfto.hpp>
+#include <boost/archive/detail/oserializer.hpp>
+#include <boost/archive/detail/interface_oarchive.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/archive/detail/register_archive.hpp>
+
+// determine if its necessary to handle (u)int64_t specifically
+// i.e. that its not a synonym for (unsigned) long
+// if there is no 64 bit int or if its the same as a long
+// we shouldn't define separate functions for int64 data types.
+#if defined(BOOST_NO_INT64_T)
+ #define BOOST_NO_INTRINSIC_INT64_T
+#else
+ #if defined(ULONG_MAX)
+ #if(ULONG_MAX != 0xffffffff && ULONG_MAX == 18446744073709551615u) // 2**64 - 1
+ #define BOOST_NO_INTRINSIC_INT64_T
+ #endif
+ #else
+ #define BOOST_NO_INTRINSIC_INT64_T
+ #endif
+#endif
+
+namespace boost {
+template<class T>
+class shared_ptr;
+namespace serialization {
+ class extended_type_info;
+} // namespace serialization
+namespace archive {
+namespace detail {
+ class basic_oarchive;
+ class basic_oserializer;
+}
+
+class polymorphic_oarchive;
+
+class polymorphic_oarchive_impl :
+ public detail::interface_oarchive<polymorphic_oarchive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_oarchive<polymorphic_oarchive>;
+ friend class save_access;
+#endif
+ // primitive types the only ones permitted by polymorphic archives
+ virtual void save(const bool t) = 0;
+
+ virtual void save(const char t) = 0;
+ virtual void save(const signed char t) = 0;
+ virtual void save(const unsigned char t) = 0;
+ #ifndef BOOST_NO_CWCHAR
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ virtual void save(const wchar_t t) = 0;
+ #endif
+ #endif
+ virtual void save(const short t) = 0;
+ virtual void save(const unsigned short t) = 0;
+ virtual void save(const int t) = 0;
+ virtual void save(const unsigned int t) = 0;
+ virtual void save(const long t) = 0;
+ virtual void save(const unsigned long t) = 0;
+ #if !defined(BOOST_NO_INTRINSIC_INT64_T)
+ virtual void save(const boost::int64_t t) = 0;
+ virtual void save(const boost::uint64_t t) = 0;
+ #endif
+ virtual void save(const float t) = 0;
+ virtual void save(const double t) = 0;
+
+ // string types are treated as primitives
+ virtual void save(const std::string & t) = 0;
+ #ifndef BOOST_NO_STD_WSTRING
+ virtual void save(const std::wstring & t) = 0;
+ #endif
+
+ virtual void save_null_pointer() = 0;
+ // used for xml and other tagged formats
+ virtual void save_start(const char * name) = 0;
+ virtual void save_end(const char * name) = 0;
+ virtual void register_basic_serializer(const detail::basic_oserializer & bos) = 0;
+
+ virtual void end_preamble() = 0;
+
+ // msvc and borland won't automatically pass these to the base class so
+ // make it explicit here
+ template<class T>
+ void save_override(T & t, BOOST_PFTO int)
+ {
+ archive::save(* this->This(), t);
+ }
+ // special treatment for name-value pairs.
+ template<class T>
+ void save_override(
+ #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+ const
+ #endif
+ ::boost::serialization::nvp<T> & t, int
+ ){
+ save_start(t.name());
+ archive::save(* this->This(), t.const_value());
+ save_end(t.name());
+ }
+protected:
+ virtual ~polymorphic_oarchive_impl(){};
+public:
+ // utility functions implemented by all legal archives
+ virtual unsigned int get_flags() const = 0;
+ virtual unsigned int get_library_version() const = 0;
+ virtual void save_binary(const void * t, std::size_t size) = 0;
+
+ virtual void save_object(
+ const void *x,
+ const detail::basic_oserializer & bos
+ ) = 0;
+ virtual void save_pointer(
+ const void * t,
+ const detail::basic_pointer_oserializer * bpos_ptr
+ ) = 0;
+};
+
+// note: preserve naming symmetry
+class polymorphic_oarchive :
+ public polymorphic_oarchive_impl
+{
+public:
+ virtual ~polymorphic_oarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::polymorphic_oarchive)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,45 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_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
+// polymorphic_text_iarchive.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/text_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+class polymorphic_text_iarchive :
+ public detail::polymorphic_iarchive_route<naked_text_iarchive>
+{
+public:
+ polymorphic_text_iarchive(std::istream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<naked_text_iarchive>(is, flags)
+ {}
+ ~polymorphic_text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_IARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,39 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_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
+// polymorphic_text_oarchive.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/text_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ text_oarchive_impl<naked_text_oarchive>
+> polymorphic_text_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_OARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_wiarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_wiarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_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
+// polymorphic_text_wiarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/text_wiarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_iarchive_route<
+ text_wiarchive_impl<naked_text_wiarchive>
+> polymorphic_text_wiarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_wiarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WIARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_woarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_text_woarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_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
+// polymorphic_text_oarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/text_woarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ text_woarchive_impl<naked_text_woarchive>
+> polymorphic_text_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_text_woarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_TEXT_WOARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,45 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_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
+// polymorphic_xml_iarchive.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/xml_iarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+class polymorphic_xml_iarchive :
+ public detail::polymorphic_iarchive_route<naked_xml_iarchive>
+{
+public:
+ polymorphic_xml_iarchive(std::istream & is, unsigned int flags = 0) :
+ detail::polymorphic_iarchive_route<naked_xml_iarchive>(is, flags)
+ {}
+ ~polymorphic_xml_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_iarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_IARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,39 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_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
+// polymorphic_xml_oarchive.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.
+
+#include <boost/config.hpp>
+#include <boost/archive/xml_oarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ xml_oarchive_impl<naked_xml_oarchive>
+> polymorphic_xml_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_oarchive
+)
+
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_OARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_wiarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_wiarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_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
+// polymorphic_xml_wiarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/xml_wiarchive.hpp>
+#include <boost/archive/detail/polymorphic_iarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_iarchive_route<
+ xml_wiarchive_impl<naked_xml_wiarchive>
+> polymorphic_xml_wiarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_wiarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WIARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_woarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/polymorphic_xml_woarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,44 @@
+#ifndef BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_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
+// polymorphic_xml_oarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <boost/archive/xml_woarchive.hpp>
+#include <boost/archive/detail/polymorphic_oarchive_route.hpp>
+
+namespace boost {
+namespace archive {
+
+typedef detail::polymorphic_oarchive_route<
+ xml_woarchive_impl<naked_xml_woarchive>
+> polymorphic_xml_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(
+ boost::archive::polymorphic_xml_woarchive
+)
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_POLYMORPHIC_XML_WOARCHIVE_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/archive/shared_ptr_helper.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/shared_ptr_helper.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,153 @@
+#ifndef BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP
+#define BOOST_ARCHIVE_SHARED_PTR_HELPER_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
+// shared_ptr_helper.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2004 Robert Ramey and Martin Ecker
+// 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.
+
+#include <map>
+#include <list>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/shared_ptr_132.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+
+namespace boost_132 {
+ template<class T> class shared_ptr;
+}
+namespace boost {
+ template<class T> class shared_ptr;
+ namespace serialization {
+ class extended_type_info;
+ template<class Archive, class T>
+ inline void load(
+ Archive & ar,
+ boost::shared_ptr<T> &t,
+ const unsigned int file_version
+ );
+ }
+
+namespace archive{
+namespace detail {
+
+struct null_deleter {
+ void operator()(void const *) const {}
+};
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// a common class for holding various types of shared pointers
+
+class shared_ptr_helper {
+ typedef std::map<void*, shared_ptr<void> > collection_type;
+ typedef collection_type::const_iterator iterator_type;
+ // list of shared_pointers create accessable by raw pointer. This
+ // is used to "match up" shared pointers loaded at different
+ // points in the archive. Note, we delay construction until
+ // it is actually used since this is by default included as
+ // a "mix-in" even if shared_ptr isn't used.
+ collection_type * m_pointers;
+
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ template<class Archive, class T>
+ friend inline void boost::serialization::load(
+ Archive & ar,
+ boost::shared_ptr<T> &t,
+ const unsigned int file_version
+ );
+#endif
+
+ // list of loaded pointers. This is used to be sure that the pointers
+ // stay around long enough to be "matched" with other pointers loaded
+ // by the same archive. These are created with a "null_deleter" so that
+ // when this list is destroyed - the underlaying raw pointers are not
+ // destroyed. This has to be done because the pointers are also held by
+ // new system which is disjoint from this set. This is implemented
+ // by a change in load_construct_data below. It makes this file suitable
+ // only for loading pointers into a 1.33 or later boost system.
+ std::list<boost_132::shared_ptr<void> > * m_pointers_132;
+
+ // return a void pointer to the most derived type
+ template<class T>
+ void * object_identifier(T * t) const {
+ const boost::serialization::extended_type_info * true_type
+ = boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance().get_derived_extended_type_info(*t);
+ // note:if this exception is thrown, be sure that derived pointer
+ // is either registered or exported.
+ if(NULL == true_type)
+ boost::throw_exception(
+ boost::archive::archive_exception(
+ boost::archive::archive_exception::unregistered_class
+ )
+ );
+ const boost::serialization::extended_type_info * this_type
+ = & boost::serialization::type_info_implementation<T>::type
+ ::get_const_instance();
+ void * vp = void_downcast(*true_type, *this_type, t);
+ return vp;
+ }
+public:
+ template<class T>
+ void reset(shared_ptr<T> & s, T * r){
+ if(NULL == r){
+ s.reset();
+ return;
+ }
+ // get pointer to the most derived object. This is effectively
+ // the object identifer
+ void * od = object_identifier(r);
+
+ if(NULL == m_pointers)
+ m_pointers = new collection_type;
+
+ iterator_type it = m_pointers->find(od);
+
+ if(it == m_pointers->end()){
+ s.reset(r);
+ m_pointers->insert(collection_type::value_type(od,s));
+ }
+ else{
+ s = static_pointer_cast<T>((*it).second);
+ }
+ }
+ void append(const boost_132::shared_ptr<void> & t){
+ if(NULL == m_pointers_132)
+ m_pointers_132 = new std::list<boost_132::shared_ptr<void> >;
+ m_pointers_132->push_back(t);
+ }
+public:
+ shared_ptr_helper() :
+ m_pointers(NULL),
+ m_pointers_132(NULL)
+ {}
+ ~shared_ptr_helper(){
+ if(NULL != m_pointers)
+ delete m_pointers;
+ if(NULL != m_pointers_132)
+ delete m_pointers_132;
+ }
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_ARCHIVE_SHARED_PTR_HELPER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/text_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/text_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,123 @@
+#ifndef BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_IARCHIVE_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
+// text_iarchive.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.
+
+#include <istream>
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+#include <boost/config.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+class text_iarchive_impl :
+ public basic_text_iprimitive<std::istream>,
+ public basic_text_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_text_iarchive<Archive>;
+ friend class load_access;
+protected:
+#endif
+ template<class T>
+ void load(T & t){
+ basic_text_iprimitive<std::istream>::load(t);
+ }
+ BOOST_ARCHIVE_DECL(void)
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL(void)
+ load(wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL(void)
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL(void)
+ load(std::wstring &ws);
+ #endif
+ // note: the following should not needed - but one compiler (vc 7.1)
+ // fails to compile one test (test_shared_ptr) without it !!!
+ // make this protected so it can be called from a derived archive
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int){
+ basic_text_iarchive<Archive>::load_override(t, 0);
+ }
+ BOOST_ARCHIVE_DECL(void)
+ load_override(class_name_type & t, int);
+ BOOST_ARCHIVE_DECL(void)
+ init();
+ BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+ text_iarchive_impl(std::istream & is, unsigned int flags);
+ BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~text_iarchive_impl(){};
+};
+
+// do not derive from the classes below. If you want to extend this functionality
+// via inhertance, derived from text_iarchive_impl instead. This will
+// preserve correct static polymorphism.
+
+// same as text_iarchive below - without the shared_ptr_helper
+class naked_text_iarchive :
+ public text_iarchive_impl<naked_text_iarchive>
+{
+public:
+ naked_text_iarchive(std::istream & is, unsigned int flags = 0) :
+ text_iarchive_impl<naked_text_iarchive>(is, flags)
+ {}
+ ~naked_text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// note special treatment of shared_ptr. This type needs a special
+// structure associated with every archive. We created a "mix-in"
+// class to provide this functionality. Since shared_ptr holds a
+// special esteem in the boost library - we included it here by default.
+#include <boost/archive/shared_ptr_helper.hpp>
+
+namespace boost {
+namespace archive {
+
+class text_iarchive :
+ public text_iarchive_impl<text_iarchive>,
+ public detail::shared_ptr_helper
+{
+public:
+ text_iarchive(std::istream & is, unsigned int flags = 0) :
+ text_iarchive_impl<text_iarchive>(is, flags)
+ {}
+ ~text_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_iarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_TEXT_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/text_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/text_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,101 @@
+#ifndef BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_OARCHIVE_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
+// text_oarchive.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.
+
+#include <ostream>
+#include <cstddef> // std::size_t
+
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_text_oarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+class text_oarchive_impl :
+ /* protected ? */ public basic_text_oprimitive<std::ostream>,
+ public basic_text_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_text_oarchive<Archive>;
+ friend class save_access;
+protected:
+#endif
+ template<class T>
+ void save(const T & t){
+ this->newtoken();
+ basic_text_oprimitive<std::ostream>::save(t);
+ }
+ BOOST_ARCHIVE_DECL(void)
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL(void)
+ save(const wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL(void)
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL(void)
+ save(const std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+ text_oarchive_impl(std::ostream & os, unsigned int flags);
+ BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~text_oarchive_impl(){};
+public:
+ BOOST_ARCHIVE_DECL(void)
+ save_binary(const void *address, std::size_t count);
+};
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from text_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class text_oarchive :
+ public text_oarchive_impl<text_oarchive>
+{
+public:
+
+ text_oarchive(std::ostream & os, unsigned int flags = 0) :
+ text_oarchive_impl<text_oarchive>(os, flags)
+ {}
+ ~text_oarchive(){}
+};
+
+typedef text_oarchive naked_text_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_oarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_TEXT_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/text_wiarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/text_wiarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,122 @@
+#ifndef BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_WIARCHIVE_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
+// text_wiarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream>
+
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_text_iarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+class text_wiarchive_impl :
+ public basic_text_iprimitive<std::wistream>,
+ public basic_text_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_text_iarchive<Archive>;
+ friend class load_access;
+protected:
+#endif
+ template<class T>
+ void load(T & t){
+ basic_text_iprimitive<std::wistream>::load(t);
+ }
+ BOOST_WARCHIVE_DECL(void)
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL(void)
+ load(wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL(void)
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL(void)
+ load(std::wstring &ws);
+ #endif
+ // note: the following should not needed - but one compiler (vc 7.1)
+ // fails to compile one test (test_shared_ptr) without it !!!
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int){
+ basic_text_iarchive<Archive>::load_override(t, 0);
+ }
+ BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ text_wiarchive_impl(std::wistream & is, unsigned int flags);
+ ~text_wiarchive_impl(){};
+};
+
+// do not derive from the classes below. If you want to extend this functionality
+// via inhertance, derived from text_iarchive_impl instead. This will
+// preserve correct static polymorphism.
+
+// same as text_wiarchive below - without the shared_ptr_helper
+class naked_text_wiarchive :
+ public text_wiarchive_impl<naked_text_wiarchive>
+{
+public:
+ naked_text_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ text_wiarchive_impl<naked_text_wiarchive>(is, flags)
+ {}
+ ~naked_text_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// note special treatment of shared_ptr. This type needs a special
+// structure associated with every archive. We created a "mix-in"
+// class to provide this functionality. Since shared_ptr holds a
+// special esteem in the boost library - we included it here by default.
+#include <boost/archive/shared_ptr_helper.hpp>
+
+namespace boost {
+namespace archive {
+
+class text_wiarchive :
+ public text_wiarchive_impl<text_wiarchive>,
+ public detail::shared_ptr_helper
+{
+public:
+ text_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ text_wiarchive_impl<text_wiarchive>(is, flags)
+ {}
+ ~text_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_wiarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_TEXT_WIARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/text_woarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/text_woarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,128 @@
+#ifndef BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_TEXT_WOARCHIVE_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
+// text_woarchive.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.
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <ostream>
+#include <cstddef> // size_t
+
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_text_oarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+class text_woarchive_impl :
+ public basic_text_oprimitive<std::wostream>,
+ public basic_text_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_text_oarchive<Archive>;
+ friend class save_access;
+protected:
+#endif
+ template<class T>
+ void save(const T & t){
+ this->newtoken();
+ basic_text_oprimitive<std::wostream>::save(t);
+ }
+ BOOST_WARCHIVE_DECL(void)
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL(void)
+ save(const wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL(void)
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL(void)
+ save(const std::wstring &ws);
+ #endif
+ text_woarchive_impl(std::wostream & os, unsigned int flags) :
+ basic_text_oprimitive<std::wostream>(
+ os,
+ 0 != (flags & no_codecvt)
+ ),
+ basic_text_oarchive<Archive>(flags)
+ {
+ if(0 == (flags & no_header))
+ basic_text_oarchive<Archive>::init();
+ }
+public:
+ void save_binary(const void *address, std::size_t count){
+ put(L'\n');
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::wostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ put(L'\n');
+ this->delimiter = this->none;
+ }
+
+};
+
+// we use the following because we can't use
+// typedef text_oarchive_impl<text_oarchive_impl<...> > text_oarchive;
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from text_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class text_woarchive :
+ public text_woarchive_impl<text_woarchive>
+{
+public:
+ text_woarchive(std::wostream & os, unsigned int flags = 0) :
+ text_woarchive_impl<text_woarchive>(os, flags)
+ {}
+ ~text_woarchive(){}
+};
+
+typedef text_woarchive naked_text_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::text_woarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_TEXT_WOARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/tmpdir.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/tmpdir.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,50 @@
+#ifndef BOOST_ARCHIVE_TMPDIR_HPP
+#define BOOST_ARCHIVE_TMPDIR_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
+// tmpdir.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.
+
+#include <cstdlib> // getenv
+#include <cstddef> // NULL
+#include <cassert>
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std {
+ using ::getenv;
+}
+#endif
+
+namespace boost {
+namespace archive {
+
+inline char * tmpdir(){
+ char *dirname;
+ dirname = std::getenv("TMP");
+ if(NULL == dirname)
+ dirname = std::getenv("TMPDIR");
+ if(NULL == dirname)
+ dirname = std::getenv("TEMP");
+ if(NULL == dirname){
+ //assert(false); // no temp directory found
+ dirname = ".";
+ }
+ return dirname;
+}
+
+} // archive
+} // boost
+
+#endif // BOOST_ARCHIVE_TMPDIR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/wcslen.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/wcslen.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,56 @@
+#ifndef BOOST_ARCHIVE_WCSLEN_HPP
+#define BOOST_ARCHIVE_WCSLEN_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
+// wcslen.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.
+
+#include <cstddef> // size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#ifndef BOOST_NO_CWCHAR
+
+// a couple of libraries which include wchar_t don't include
+// wcslen
+
+#if defined(BOOST_DINKUMWARE_STDLIB) && BOOST_DINKUMWARE_STDLIB < 306 \
+|| defined(__LIBCOMO__)
+
+namespace std {
+inline std::size_t wcslen(const wchar_t * ws)
+{
+ const wchar_t * eows = ws;
+ while(* eows != 0)
+ ++eows;
+ return eows - ws;
+}
+} // namespace std
+
+#else
+
+#include <cwchar>
+#ifdef BOOST_NO_STDC_NAMESPACE
+namespace std{ using ::wcslen; }
+#endif
+
+#endif // wcslen
+
+#endif //BOOST_NO_CWCHAR
+
+#endif //BOOST_ARCHIVE_WCSLEN_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/xml_archive_exception.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/xml_archive_exception.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,66 @@
+#ifndef BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_HPP
+#define BOOST_ARCHIVE_XML_ARCHIVE_EXCEPTION_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
+// xml_archive_exception.hpp:
+
+// (C) Copyright 2007 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.
+
+#include <exception>
+#include <cassert>
+
+#include <boost/archive/archive_exception.hpp>
+
+namespace boost {
+namespace archive {
+
+//////////////////////////////////////////////////////////////////////
+// exceptions thrown by xml archives
+//
+class xml_archive_exception :
+ public virtual archive_exception
+{
+public:
+ typedef enum {
+ xml_archive_parsing_error, // see save_register
+ xml_archive_tag_mismatch,
+ xml_archive_tag_name_error
+ } exception_code;
+ exception_code code;
+ xml_archive_exception(exception_code c)
+ {}
+ virtual const char *what( ) const throw( )
+ {
+ const char *msg;
+ switch(code){
+ case xml_archive_parsing_error:
+ msg = "unrecognized XML syntax";
+ break;
+ case xml_archive_tag_mismatch:
+ msg = "XML start/end tag mismatch";
+ break;
+ case xml_archive_tag_name_error:
+ msg = "Invalid XML tag name";
+ break;
+ default:
+ msg = archive_exception::what();
+ break;
+ }
+ return msg;
+ }
+};
+
+}// namespace archive
+}// namespace boost
+
+#endif //BOOST_XML_ARCHIVE_ARCHIVE_EXCEPTION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/xml_iarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/xml_iarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,132 @@
+#ifndef BOOST_ARCHIVE_XML_IARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_IARCHIVE_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
+// xml_iarchive.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.
+
+#include <istream>
+
+//#include <boost/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+template<class CharType>
+class basic_xml_grammar;
+typedef basic_xml_grammar<char> xml_grammar;
+
+template<class Archive>
+class xml_iarchive_impl :
+ public basic_text_iprimitive<std::istream>,
+ public basic_xml_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_xml_iarchive<Archive>;
+ friend class load_access;
+protected:
+#endif
+ // instances of micro xml parser to parse start preambles
+ // scoped_ptr doesn't play nice with borland - so use a naked pointer
+ // scoped_ptr<xml_grammar> gimpl;
+ xml_grammar *gimpl;
+
+ std::istream & get_is(){
+ return is;
+ }
+ template<class T>
+ void load(T & t){
+ basic_text_iprimitive<std::istream>::load(t);
+ }
+ BOOST_ARCHIVE_DECL(void)
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL(void)
+ load(wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL(void)
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL(void)
+ load(std::wstring &ws);
+ #endif
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int){
+ basic_xml_iarchive<Archive>::load_override(t, 0);
+ }
+ BOOST_ARCHIVE_DECL(void)
+ load_override(class_name_type & t, int);
+ BOOST_ARCHIVE_DECL(void)
+ init();
+ BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+ xml_iarchive_impl(std::istream & is, unsigned int flags);
+ BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~xml_iarchive_impl();
+};
+
+// do not derive from the classes below. If you want to extend this functionality
+// via inhertance, derived from text_iarchive_impl instead. This will
+// preserve correct static polymorphism.
+
+// same as xml_iarchive below - without the shared_ptr_helper
+class naked_xml_iarchive :
+ public xml_iarchive_impl<naked_xml_iarchive>
+{
+public:
+ naked_xml_iarchive(std::istream & is, unsigned int flags = 0) :
+ xml_iarchive_impl<naked_xml_iarchive>(is, flags)
+ {}
+ ~naked_xml_iarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// note special treatment of shared_ptr. This type needs a special
+// structure associated with every archive. We created a "mix-in"
+// class to provide this functionality. Since shared_ptr holds a
+// special esteem in the boost library - we included it here by default.
+#include <boost/archive/shared_ptr_helper.hpp>
+
+namespace boost {
+namespace archive {
+
+class xml_iarchive :
+ public xml_iarchive_impl<xml_iarchive>,
+ public detail::shared_ptr_helper
+{
+public:
+ xml_iarchive(std::istream & is, unsigned int flags = 0) :
+ xml_iarchive_impl<xml_iarchive>(is, flags)
+ {}
+ ~xml_iarchive(){};
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_iarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_XML_IARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/xml_oarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/xml_oarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,114 @@
+#ifndef BOOST_ARCHIVE_XML_OARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_OARCHIVE_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
+// xml_oarchive.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.
+
+#include <ostream>
+
+#include <cstddef> // size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/archive/detail/auto_link_archive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+template<class Archive>
+class xml_oarchive_impl :
+ public basic_text_oprimitive<std::ostream>,
+ public basic_xml_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_xml_oarchive<Archive>;
+ friend class save_access;
+protected:
+#endif
+ //void end_preamble(){
+ // basic_xml_oarchive<Archive>::end_preamble();
+ //}
+ template<class T>
+ void save(const T & t){
+ basic_text_oprimitive<std::ostream>::save(t);
+ }
+ BOOST_ARCHIVE_DECL(void)
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_ARCHIVE_DECL(void)
+ save(const wchar_t * t);
+ #endif
+ BOOST_ARCHIVE_DECL(void)
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_ARCHIVE_DECL(void)
+ save(const std::wstring &ws);
+ #endif
+ BOOST_ARCHIVE_DECL(BOOST_PP_EMPTY())
+ xml_oarchive_impl(std::ostream & os, unsigned int flags);
+ ~xml_oarchive_impl(){}
+public:
+ void save_binary(const void *address, std::size_t count){
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::ostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ this->indent_next = true;
+ }
+};
+
+// we use the following because we can't use
+// typedef xml_oarchive_impl<xml_oarchive_impl<...> > xml_oarchive;
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from xml_oarchive_impl instead. This will
+// preserve correct static polymorphism.
+class xml_oarchive :
+ public xml_oarchive_impl<xml_oarchive>
+{
+public:
+ xml_oarchive(std::ostream & os, unsigned int flags = 0) :
+ xml_oarchive_impl<xml_oarchive>(os, flags)
+ {}
+ ~xml_oarchive(){}
+};
+
+typedef xml_oarchive naked_xml_oarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_oarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/xml_wiarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/xml_wiarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,137 @@
+#ifndef BOOST_ARCHIVE_XML_WIARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_WIARCHIVE_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
+// xml_wiarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <istream>
+
+//#include <boost/scoped_ptr.hpp>
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_iprimitive.hpp>
+#include <boost/archive/basic_xml_iarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+template<class CharType>
+class basic_xml_grammar;
+typedef basic_xml_grammar<wchar_t> xml_wgrammar;
+
+template<class Archive>
+class xml_wiarchive_impl :
+ public basic_text_iprimitive<std::wistream>,
+ public basic_xml_iarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_iarchive<Archive>;
+ friend class basic_xml_iarchive<Archive>;
+ friend class load_access;
+protected:
+#endif
+ // instances of micro xml parser to parse start preambles
+ // scoped_ptr doesn't play nice with borland - so use a naked pointer
+ // scoped_ptr<xml_wgrammar> gimpl;
+ xml_wgrammar *gimpl;
+ std::wistream & get_is(){
+ return is;
+ }
+ template<class T>
+ void load(T & t){
+ basic_text_iprimitive<std::wistream>::load(t);
+ }
+ BOOST_WARCHIVE_DECL(void)
+ load(char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL(void)
+ load(wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL(void)
+ load(std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL(void)
+ load(std::wstring &ws);
+ #endif
+ template<class T>
+ void load_override(T & t, BOOST_PFTO int){
+ basic_xml_iarchive<Archive>::load_override(t, 0);
+ }
+ BOOST_WARCHIVE_DECL(void)
+ load_override(class_name_type & t, int);
+ BOOST_WARCHIVE_DECL(void)
+ init();
+ BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ xml_wiarchive_impl(std::wistream & is, unsigned int flags) ;
+ BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ ~xml_wiarchive_impl();
+};
+
+// do not derive from the classes below. If you want to extend this functionality
+// via inhertance, derived from xml_wiarchive_impl instead. This will
+// preserve correct static polymorphism.
+
+// same as xml_wiarchive below - without the shared_ptr_helper
+class naked_xml_wiarchive :
+ public xml_wiarchive_impl<naked_xml_wiarchive>
+{
+public:
+ naked_xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ xml_wiarchive_impl<naked_xml_wiarchive>(is, flags)
+ {}
+ ~naked_xml_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// note special treatment of shared_ptr. This type needs a special
+// structure associated with every archive. We created a "mix-in"
+// class to provide this functionality. Since shared_ptr holds a
+// special esteem in the boost library - we included it here by default.
+#include <boost/archive/shared_ptr_helper.hpp>
+
+namespace boost {
+namespace archive {
+
+class xml_wiarchive :
+ public xml_wiarchive_impl<xml_wiarchive>,
+ public detail::shared_ptr_helper
+{
+public:
+ xml_wiarchive(std::wistream & is, unsigned int flags = 0) :
+ xml_wiarchive_impl<xml_wiarchive>(is, flags)
+ {}
+ ~xml_wiarchive(){}
+};
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_wiarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_XML_WIARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/archive/xml_woarchive.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/archive/xml_woarchive.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,129 @@
+#ifndef BOOST_ARCHIVE_XML_WOARCHIVE_HPP
+#define BOOST_ARCHIVE_XML_WOARCHIVE_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
+// xml_woarchive.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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_NO_STD_WSTREAMBUF
+#error "wide char i/o not supported on this platform"
+#else
+
+#include <cstddef> // size_t
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <ostream>
+
+#include <boost/archive/detail/auto_link_warchive.hpp>
+#include <boost/archive/basic_text_oprimitive.hpp>
+#include <boost/archive/basic_xml_oarchive.hpp>
+
+#include <boost/archive/detail/abi_prefix.hpp> // must be the last header
+
+namespace boost {
+namespace archive {
+
+#if 0
+BOOST_WARCHIVE_DECL(std::wostream &)
+operator<<(std::wostream &os, const char *t);
+
+BOOST_WARCHIVE_DECL(std::wostream &)
+operator<<(std::wostream &os, const char t);
+#endif
+
+template<class Archive>
+class xml_woarchive_impl :
+ public basic_text_oprimitive<std::wostream>,
+ public basic_xml_oarchive<Archive>
+{
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ friend class detail::interface_oarchive<Archive>;
+ friend class basic_xml_oarchive<Archive>;
+ friend class save_access;
+protected:
+#endif
+ //void end_preamble(){
+ // basic_xml_oarchive<Archive>::end_preamble();
+ //}
+ template<class T>
+ void
+ save(const T & t){
+ basic_text_oprimitive<std::wostream>::save(t);
+ }
+ BOOST_WARCHIVE_DECL(void)
+ save(const char * t);
+ #ifndef BOOST_NO_INTRINSIC_WCHAR_T
+ BOOST_WARCHIVE_DECL(void)
+ save(const wchar_t * t);
+ #endif
+ BOOST_WARCHIVE_DECL(void)
+ save(const std::string &s);
+ #ifndef BOOST_NO_STD_WSTRING
+ BOOST_WARCHIVE_DECL(void)
+ save(const std::wstring &ws);
+ #endif
+ BOOST_WARCHIVE_DECL(BOOST_PP_EMPTY())
+ xml_woarchive_impl(std::wostream & os, unsigned int flags);
+ ~xml_woarchive_impl(){}
+public:
+ void
+ save_binary(const void *address, std::size_t count){
+ this->end_preamble();
+ #if ! defined(__MWERKS__)
+ this->basic_text_oprimitive<std::wostream>::save_binary(
+ #else
+ this->basic_text_oprimitive::save_binary(
+ #endif
+ address,
+ count
+ );
+ this->indent_next = true;
+ }
+};
+
+// we use the following because we can't use
+// typedef xml_woarchive_impl<xml_woarchive_impl<...> > xml_woarchive;
+
+// do not derive from this class. If you want to extend this functionality
+// via inhertance, derived from xml_woarchive_impl instead. This will
+// preserve correct static polymorphism.
+class xml_woarchive :
+ public xml_woarchive_impl<xml_woarchive>
+{
+public:
+ xml_woarchive(std::wostream & os, unsigned int flags = 0) :
+ xml_woarchive_impl<xml_woarchive>(os, flags)
+ {}
+ ~xml_woarchive(){}
+};
+
+typedef xml_woarchive naked_xml_woarchive;
+
+} // namespace archive
+} // namespace boost
+
+// required by export
+BOOST_SERIALIZATION_REGISTER_ARCHIVE(boost::archive::xml_woarchive)
+
+#include <boost/archive/detail/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_NO_STD_WSTREAMBUF
+#endif // BOOST_ARCHIVE_XML_OARCHIVE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/access.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/access.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,130 @@
+#ifndef BOOST_SERIALIZATION_ACCESS_HPP
+#define BOOST_SERIALIZATION_ACCESS_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
+// access.hpp: interface for serialization system.
+
+// (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.
+
+#include <boost/config.hpp>
+
+#include <boost/pfto.hpp>
+
+namespace boost {
+
+namespace archive {
+namespace detail {
+ template<class Archive, class T>
+ class iserializer;
+ template<class Archive, class T>
+ class oserializer;
+} // namespace detail
+} // namespace archive
+
+namespace serialization {
+
+// forward declarations
+template<class Archive, class T>
+inline void serialize_adl(Archive &, T &, const unsigned int);
+namespace detail {
+ template<class Archive, class T>
+ struct member_saver;
+ template<class Archive, class T>
+ struct member_loader;
+} // namespace detail
+
+// use an "accessor class so that we can use:
+// "friend class boost::serialization::access;"
+// in any serialized class to permit clean, safe access to private class members
+// by the serialization system
+
+class access {
+public:
+ // grant access to "real" serialization defaults
+#ifdef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+public:
+#else
+ template<class Archive, class T>
+ friend struct detail::member_saver;
+ template<class Archive, class T>
+ friend struct detail::member_loader;
+ template<class Archive, class T>
+ friend class archive::detail::iserializer;
+ template<class Archive, class T>
+ friend class archive::detail::oserializer;
+ template<class Archive, class T>
+ friend inline void serialize(
+ Archive & ar,
+ T & t,
+ const BOOST_PFTO unsigned int file_version
+ );
+ template<class Archive, class T>
+ friend inline void save_construct_data(
+ Archive & ar,
+ const T * t,
+ const BOOST_PFTO unsigned int file_version
+ );
+ template<class Archive, class T>
+ friend inline void load_construct_data(
+ Archive & ar,
+ T * t,
+ const BOOST_PFTO unsigned int file_version
+ );
+#endif
+
+ // pass calls to users's class implementation
+ template<class Archive, class T>
+ static void member_save(
+ Archive & ar,
+ //const T & t,
+ T & t,
+ const unsigned int file_version
+ ){
+ t.save(ar, file_version);
+ }
+ template<class Archive, class T>
+ static void member_load(
+ Archive & ar,
+ T & t,
+ const unsigned int file_version
+ ){
+ t.load(ar, file_version);
+ }
+ template<class Archive, class T>
+ static void serialize(
+ Archive & ar,
+ T & t,
+ const unsigned int file_version
+ ){
+ t.serialize(ar, file_version);
+ }
+ template<class T>
+ static void destroy( const T * t) // const appropriate here?
+ {
+ // the const business is an MSVC 6.0 hack that should be
+ // benign on everything else
+ delete const_cast<T *>(t);
+ }
+ template<class Archive, class T>
+ static void construct(Archive & /* ar */, T * t){
+ // default is inplace invocation of default constructor
+ // Note the :: before the placement new. Required if the
+ // class doesn't have a class-specific placement new defined.
+ ::new(t)T;
+ }
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_ACCESS_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/array.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/array.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,137 @@
+#ifndef BOOST_SERIALIZATION_ARRAY_HPP
+#define BOOST_SERIALIZATION_ARRAY_HPP
+
+// (C) Copyright 2005 Matthias Troyer and Dave Abrahams
+// 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)
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/wrapper.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/array.hpp>
+#include <iostream>
+
+#include <cstddef> // std::size_t
+#include <cstddef>
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+namespace boost { namespace serialization {
+
+// traits to specify whether to use an optimized array serialization
+
+template <class Archive>
+struct use_array_optimization : boost::mpl::always<boost::mpl::false_> {};
+
+template<class T>
+class array
+ : public wrapper_traits<array<T> >
+{
+public:
+ typedef T value_type;
+
+ array(value_type* t, std::size_t s) :
+ m_t(t),
+ m_element_count(s)
+ {}
+
+ // default implementation
+ template<class Archive>
+ void serialize_optimized(Archive &ar, const unsigned int, mpl::false_ ) const
+ {
+ // default implemention does the loop
+ std::size_t c = count();
+ value_type * t = address();
+ while(0 < c--)
+ ar & make_nvp("item", *t++);
+ }
+
+ // optimized implementation
+ template<class Archive>
+ void serialize_optimized(Archive &ar, const unsigned int version, mpl::true_ )
+ {
+ boost::serialization::split_member(ar, *this, version);
+ }
+
+ // default implementation
+ template<class Archive>
+ void save(Archive &ar, const unsigned int version) const
+ {
+ ar.save_array(*this,version);
+ }
+
+ // default implementation
+ template<class Archive>
+ void load(Archive &ar, const unsigned int version)
+ {
+ ar.load_array(*this,version);
+ }
+
+ // default implementation
+ template<class Archive>
+ void serialize(Archive &ar, const unsigned int version)
+ {
+ typedef BOOST_DEDUCED_TYPENAME serialization::use_array_optimization<Archive>
+ ::template apply<BOOST_DEDUCED_TYPENAME remove_const<T>::type
+ >::type use_optimized;
+ serialize_optimized(ar,version,use_optimized());
+ }
+
+ value_type* address() const
+ {
+ return m_t;
+ }
+
+ std::size_t count() const
+ {
+ return m_element_count;
+ }
+
+
+private:
+ value_type* m_t;
+ std::size_t const m_element_count;
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+array<T> make_array( T* t, std::size_t s){
+ return array<T>(t, s);
+}
+
+
+template <class Archive, class T, std::size_t N>
+
+void serialize(Archive& ar, boost::array<T,N>& a, const unsigned int version)
+{
+ ar & make_nvp("elems",a.elems);
+}
+
+
+
+} } // end namespace boost::serialization
+
+
+#define BOOST_SERIALIZATION_USE_ARRAY_OPTIMIZATION(Archive) \
+namespace boost { namespace serialization { \
+template <> struct use_array_optimization<Archive> { \
+ template <class ValueType> \
+ struct apply : boost::mpl::apply1<Archive::use_array_optimization \
+ , BOOST_DEDUCED_TYPENAME boost::remove_const<ValueType>::type \
+ >::type {}; \
+}; }}
+
+
+#endif //BOOST_SERIALIZATION_ARRAY_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/assume_abstract.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/assume_abstract.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,59 @@
+#ifndef BOOST_SERIALIZATION_IS_ABSTRACT_CLASS_HPP
+#define BOOST_SERIALIZATION_IS_ABSTRACT_CLASS_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
+// is_abstract_class.hpp:
+
+// (C) Copyright 2008 Robert Ramey
+// 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 is useful for compilers which don't support the boost::is_abstract
+
+#include <boost/type_traits/is_abstract.hpp>
+
+#ifndef BOOST_NO_IS_ABSTRACT
+
+// if there is an intrinsic is_abstract defined, we don't have to do anything
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T)
+
+// but forward to the "official" is_abstract
+namespace boost {
+namespace serialization {
+ template<class T>
+ struct is_abstract : boost::is_abstract<T> {} ;
+} // namespace serialization
+} // namespace boost
+
+#else
+// we have to "make" one
+
+namespace boost {
+namespace serialization {
+ template<class T>
+ struct is_abstract : boost::false_type {};
+} // namespace serialization
+} // namespace boost
+
+// define a macro to make explicit designation of this more transparent
+#define BOOST_SERIALIZATION_ASSUME_ABSTRACT(T) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct is_abstract< T > : boost::true_type {}; \
+template<> \
+struct is_abstract< const T > : boost::true_type {}; \
+}} \
+/**/
+
+#endif // BOOST_NO_IS_ABSTRACT
+
+#endif //BOOST_SERIALIZATION_IS_ABSTRACT_CLASS_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/base_object.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/base_object.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,110 @@
+#ifndef BOOST_SERIALIZATION_BASE_OBJECT_HPP
+#define BOOST_SERIALIZATION_BASE_OBJECT_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
+// base_object.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.
+
+// if no archive headers have been included this is a no op
+// this is to permit BOOST_EXPORT etc to be included in a
+// file declaration header
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/void_cast_fwd.hpp>
+
+namespace boost {
+namespace serialization {
+
+namespace detail
+{
+ // get the base type for a given derived type
+ // preserving the const-ness
+ template<class B, class D>
+ struct base_cast
+ {
+ typedef BOOST_DEDUCED_TYPENAME
+ mpl::if_<
+ is_const<D>,
+ const B,
+ B
+ >::type type;
+ BOOST_STATIC_ASSERT(is_const<type>::value == is_const<D>::value);
+ };
+
+ // only register void casts if the types are polymorphic
+ template<class Base, class Derived>
+ struct base_register
+ {
+ struct polymorphic {
+ static void const * invoke(){
+ return &void_cast_register((Derived const*)0, (Base const*)0);
+ }
+ };
+ struct non_polymorphic {
+ static void const * invoke(){
+ return 0;
+ }
+ };
+ static void const * invoke(){
+ typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_polymorphic<Base>,
+ mpl::identity<polymorphic>,
+ mpl::identity<non_polymorphic>
+ >::type type;
+ return type::invoke();
+ }
+ };
+
+} // namespace detail
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+template<class Base, class Derived>
+const Base &
+base_object(const Derived & d)
+{
+ BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+ detail::base_register<Base, Derived>::invoke();
+ return static_cast<const Base &>(d);
+}
+#else
+template<class Base, class Derived>
+BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type &
+base_object(Derived &d)
+{
+ BOOST_STATIC_ASSERT(( is_base_and_derived<Base,Derived>::value));
+ BOOST_STATIC_ASSERT(! is_pointer<Derived>::value);
+ typedef BOOST_DEDUCED_TYPENAME detail::base_cast<Base, Derived>::type type;
+ detail::base_register<type, Derived>::invoke();
+ return static_cast<type &>(d);
+}
+#endif
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_BASE_OBJECT_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/binary_object.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/binary_object.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,96 @@
+#ifndef BOOST_SERIALIZATION_BINARY_OBJECT_HPP
+#define BOOST_SERIALIZATION_BINARY_OBJECT_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
+// nvp.hpp: interface for serialization system.
+
+// (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.
+
+#include <cassert>
+
+#include <cstddef> // std::size_t
+#include <boost/config.hpp>
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct binary_object {
+ /* const */ void * const m_t;
+ const std::size_t m_size;
+ template<class Archive>
+ void save(Archive & ar, const unsigned int /* file_version */) const {
+ ar.save_binary(m_t, m_size);
+ }
+ template<class Archive>
+ void load(Archive & ar, const unsigned int /* file_version */) const {
+ ar.load_binary(const_cast<void *>(m_t), m_size);
+ }
+ BOOST_SERIALIZATION_SPLIT_MEMBER()
+ binary_object(/* const */ void * const t, std::size_t size) :
+ m_t(t),
+ m_size(size)
+ {}
+ binary_object(const binary_object & rhs) :
+ m_t(rhs.m_t),
+ m_size(rhs.m_size)
+ {}
+};
+
+// just a little helper to support the convention that all serialization
+// wrappers follow the naming convention make_xxxxx
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+binary_object
+make_binary_object(/* const */ void * t, std::size_t size){
+ return binary_object(t, size);
+}
+
+// this is a wrapper
+
+template <>
+struct is_wrapper<binary_object>
+ : public mpl::true_
+{};
+
+} // namespace serialization
+} // boost
+
+// don't need versioning info for this type
+BOOST_CLASS_IMPLEMENTATION(
+ binary_object,
+ boost::serialization::object_serializable
+)
+
+// don't track binary objects - usually they will be created on the stack
+// and tracking algorithm (which uses the object address) might get
+// confused. note that these address will likely be members of some
+// other structure which itself is tracked, so as a practical matter
+// suppressing tracking shouldn't cause any redundancy.
+
+BOOST_CLASS_TRACKING(binary_object, boost::serialization::track_never)
+
+#endif // BOOST_SERIALIZATION_BINARY_OBJECT_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/collection_size_type.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/collection_size_type.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,20 @@
+#ifndef BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+#define BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
+
+// (C) Copyright 2005 Matthias Troyer
+// 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)
+
+#include <boost/strong_typedef.hpp>
+#include <boost/serialization/level.hpp>
+
+namespace boost { namespace serialization {
+
+BOOST_STRONG_TYPEDEF(std::size_t, collection_size_type)
+
+} } // end namespace boost::serialization
+
+BOOST_CLASS_IMPLEMENTATION(boost::serialization::collection_size_type, primitive_type)
+
+#endif //BOOST_SERIALIZATION_COLLECTION_SIZE_TYPE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/collection_traits.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/collection_traits.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,94 @@
+#ifndef BOOST_SERIALIZATION_COLLECTION_TRAITS_HPP
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS_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
+// collection_traits.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 header assigns a level implemenation trait to a collection type
+// for all primitives. It is needed so that archives which are meant to be
+// portable don't write class information in the archive. Since, not all
+// compiles recognize the same set of primitive types, the possibility
+// exists for archives to be non-portable if class information for primitive
+// types is included. This is addressed by the following macros.
+#include <boost/config.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/cstdint.hpp>
+#include <climits> // ULONG_MAX
+#include <boost/serialization/level.hpp>
+
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(T, C) \
+template<> \
+struct implementation_level< C < T > > { \
+ typedef mpl::integral_c_tag tag; \
+ typedef mpl::int_<object_serializable> type; \
+ BOOST_STATIC_CONSTANT(int, value = object_serializable); \
+}; \
+/**/
+
+#if defined(BOOST_NO_CWCHAR) || defined(BOOST_NO_INTRINSIC_WCHAR_T)
+ #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C)
+#else
+ #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(wchar_t, C) \
+ /**/
+#endif
+
+// determine if its necessary to handle (u)int64_t specifically
+// i.e. that its not a synonym for (unsigned) long
+// if there is no 64 bit int or if its the same as a long
+// we shouldn't define separate functions for int64 data types.
+#if defined(BOOST_NO_INT64_T)
+ #define BOOST_NO_INTRINSIC_INT64_T
+#else
+ #if defined(ULONG_MAX)
+ #if(ULONG_MAX != 0xffffffff && ULONG_MAX == 18446744073709551615u) // 2**64 - 1
+ #define BOOST_NO_INTRINSIC_INT64_T
+ #endif
+ #else
+ #define BOOST_NO_INTRINSIC_INT64_T
+ #endif
+#endif
+
+#if !defined(BOOST_NO_INTRINSIC_INT64_T)
+ #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::int64_t, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(boost::uint64_t, C) \
+ /**/
+#else
+ #define BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C)
+#endif
+
+#define BOOST_SERIALIZATION_COLLECTION_TRAITS(C) \
+ namespace boost { namespace serialization { \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(bool, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(char, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed char, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned char, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed int, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned int, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed long, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned long, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(float, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(double, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(unsigned short, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER(signed short, C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_INT64(C) \
+ BOOST_SERIALIZATION_COLLECTION_TRAITS_HELPER_WCHAR(C) \
+ } } \
+ /**/
+
+#endif // BOOST_SERIALIZATION_COLLECTION_TRAITS
Added: branches/CMake/release/libs/serialization/include/boost/serialization/collections_load_imp.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/collections_load_imp.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,199 @@
+#ifndef BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
+#define BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1020)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collections_load_imp.hpp: serialization for loading stl collections
+
+// (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.
+
+// helper function templates for serialization of collections
+
+#include <cassert>
+#include <cstddef> // size_t
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+// sequential container input
+template<class Archive, class Container>
+struct archive_input_seq
+{
+ inline void operator()(
+ Archive &ar,
+ Container &s,
+ const unsigned int v
+ ){
+ typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+ detail::stack_construct<Archive, type> t(ar, v);
+ // borland fails silently w/o full namespace
+ ar >> boost::serialization::make_nvp("item", t.reference());
+ s.push_back(t.reference());
+ ar.reset_object_address(& s.back() , & t.reference());
+ }
+};
+
+// map input
+template<class Archive, class Container>
+struct archive_input_map
+{
+ inline void operator()(
+ Archive &ar,
+ Container &s,
+ const unsigned int v
+ ){
+ typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+ detail::stack_construct<Archive, type> t(ar, v);
+ // borland fails silently w/o full namespace
+ ar >> boost::serialization::make_nvp("item", t.reference());
+ std::pair<BOOST_DEDUCED_TYPENAME Container::const_iterator, bool> result =
+ s.insert(t.reference());
+ // note: the following presumes that the map::value_type was NOT tracked
+ // in the archive. This is the usual case, but here there is no way
+ // to determine that.
+ if(result.second){
+ ar.reset_object_address(
+ & (result.first->second),
+ & t.reference().second
+ );
+ }
+ }
+};
+
+// multimap input
+template<class Archive, class Container>
+struct archive_input_multimap
+{
+ inline void operator()(
+ Archive &ar,
+ Container &s,
+ const unsigned int v
+ ){
+ typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+ detail::stack_construct<Archive, type> t(ar, v);
+ // borland fails silently w/o full namespace
+ ar >> boost::serialization::make_nvp("item", t.reference());
+ BOOST_DEDUCED_TYPENAME Container::const_iterator result
+ = s.insert(t.reference());
+ // note: the following presumes that the map::value_type was NOT tracked
+ // in the archive. This is the usual case, but here there is no way
+ // to determine that.
+ ar.reset_object_address(
+ & result->second,
+ & t.reference()
+ );
+ }
+};
+
+// set input
+template<class Archive, class Container>
+struct archive_input_set
+{
+ inline void operator()(
+ Archive &ar,
+ Container &s,
+ const unsigned int v
+ ){
+ typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+ detail::stack_construct<Archive, type> t(ar, v);
+ // borland fails silently w/o full namespace
+ ar >> boost::serialization::make_nvp("item", t.reference());
+ std::pair<BOOST_DEDUCED_TYPENAME Container::const_iterator, bool> result =
+ s.insert(t.reference());
+ if(result.second)
+ ar.reset_object_address(& (* result.first), & t.reference());
+ }
+};
+
+// multiset input
+template<class Archive, class Container>
+struct archive_input_multiset
+{
+ inline void operator()(
+ Archive &ar,
+ Container &s,
+ const unsigned int v
+ ){
+ typedef BOOST_DEDUCED_TYPENAME Container::value_type type;
+ detail::stack_construct<Archive, type> t(ar, v);
+ // borland fails silently w/o full namespace
+ ar >> boost::serialization::make_nvp("item", t.reference());
+ BOOST_DEDUCED_TYPENAME Container::const_iterator result
+ = s.insert(t.reference());
+ ar.reset_object_address(& (* result), & t.reference());
+ }
+};
+
+template<class Container>
+class reserve_imp
+{
+public:
+ void operator()(Container &s, std::size_t count) const {
+ s.reserve(count);
+ }
+};
+
+template<class Container>
+class no_reserve_imp
+{
+public:
+ void operator()(Container & /* s */, std::size_t /* count */) const{}
+};
+
+template<class Archive, class Container, class InputFunction, class R>
+inline void load_collection(Archive & ar, Container &s)
+{
+ s.clear();
+ // retrieve number of elements
+ collection_size_type count;
+ unsigned int item_version;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ if(3 < ar.get_library_version())
+ ar >> BOOST_SERIALIZATION_NVP(item_version);
+ else
+ item_version = 0;
+ R rx;
+ rx(s, count);
+ std::size_t c = count;
+ InputFunction ifunc;
+ while(c-- > 0){
+ ifunc(ar, s, item_version);
+ }
+}
+
+} // namespace stl
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_COLLECTIONS_LOAD_IMP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/collections_save_imp.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/collections_save_imp.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,68 @@
+#ifndef BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
+#define BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_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
+// collections_save_imp.hpp: serialization for stl collections
+
+// (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.
+
+// helper function templates for serialization of collections
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<class Archive, class Container>
+inline void save_collection(Archive & ar, const Container &s)
+{
+ // record number of elements
+ collection_size_type const count(s.size());
+ ar << BOOST_SERIALIZATION_NVP(count);
+ // make sure the target type is registered so we can retrieve
+ // the version when we load
+ if(3 < ar.get_library_version()){
+ const unsigned int item_version = version<
+ BOOST_DEDUCED_TYPENAME Container::value_type
+ >::value;
+ ar << BOOST_SERIALIZATION_NVP(item_version);
+ }
+ BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin();
+ std::size_t c=count;
+ while(c-- > 0){
+ // note borland emits a no-op without the explicit namespace
+ boost::serialization::save_construct_data_adl(
+ ar,
+ &(*it),
+ boost::serialization::version<
+ BOOST_DEDUCED_TYPENAME Container::value_type
+ >::value
+ );
+ ar << boost::serialization::make_nvp("item", *it++);
+ }
+}
+
+} // namespace stl
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_COLLECTIONS_SAVE_IMP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/complex.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/complex.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,81 @@
+#ifndef BOOST_SERIALIZATION_COMPLEX_HPP
+#define BOOST_SERIALIZATION_COMPLEX_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
+// serialization/utility.hpp:
+// serialization for stl utility templates
+
+// (C) Copyright 2007 Matthias Troyer .
+// 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.
+
+#include <complex>
+#include <boost/config.hpp>
+
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class T>
+inline void serialize(
+ Archive & ar,
+ std::complex<T> & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+template<class Archive, class T>
+inline void save(
+ Archive & ar,
+ std::complex<T> const& t,
+ const unsigned int /* file_version */
+){
+ const T re = t.real();
+ const T im = t.imag();
+ ar << boost::serialization::make_nvp("real", re);
+ ar << boost::serialization::make_nvp("imag", im);
+}
+
+template<class Archive, class T>
+inline void load(
+ Archive & ar,
+ std::complex<T>& t,
+ const unsigned int /* file_version */
+){
+ T re;
+ T im;
+ ar >> boost::serialization::make_nvp("real", re);
+ ar >> boost::serialization::make_nvp("imag", im);
+ t = std::complex<T>(re,im);
+}
+
+// specialization of serialization traits for complex
+template <class T>
+struct is_bitwise_serializable<std::complex<T> >
+ : public is_bitwise_serializable<T> {};
+
+template <class T>
+struct implementation_level<std::complex<T> >
+ : mpl::int_<object_serializable> {} ;
+
+// treat complex just like builtin arithmetic types for tracking
+template <class T>
+struct tracking_level<std::complex<T> >
+ : mpl::int_<track_never> {} ;
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_COMPLEX_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/config.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/config.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,82 @@
+// note lack of include guards. This is intentional
+
+// config.hpp ---------------------------------------------//
+
+// (c) Copyright Robert Ramey 2004
+// 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 library home page at http://www.boost.org/libs/serialization
+
+//----------------------------------------------------------------------------//
+
+// This header implements separate compilation features as described in
+// http://www.boost.org/more/separate_compilation.html
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+
+// note: this version incorporates the related code into the the
+// the same library as BOOST_ARCHIVE. This could change some day in the
+// future
+
+// if BOOST_SERIALIZATION_DECL is defined undefine it now:
+#ifdef BOOST_SERIALIZATION_DECL
+ #undef BOOST_SERIALIZATION_DECL
+#endif
+
+#ifdef BOOST_HAS_DECLSPEC // defined in config system
+// we need to import/export our code only if the user has specifically
+// asked for it by defining either BOOST_ALL_DYN_LINK if they want all boost
+// libraries to be dynamically linked, or BOOST_SERIALIZATION_DYN_LINK
+// if they want just this one to be dynamically liked:
+#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+ #if !defined(BOOST_DYN_LINK)
+ #define BOOST_DYN_LINK
+ #endif
+ // export if this is our own source, otherwise import:
+ #if defined(BOOST_SERIALIZATION_SOURCE)
+ #if defined(__BORLANDC__)
+ #define BOOST_SERIALIZATION_DECL(T) T __export
+ #else
+ #define BOOST_SERIALIZATION_DECL(T) __declspec(dllexport) T
+ #endif
+ #else
+ #if defined(__BORLANDC__)
+ #define BOOST_SERIALIZATION_DECL(T) T __import
+ #else
+ #define BOOST_SERIALIZATION_DECL(T) __declspec(dllimport) T
+ #endif
+ #endif // defined(BOOST_SERIALIZATION_SOURCE)
+#endif // defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+#endif // BOOST_HAS_DECLSPEC
+
+// if BOOST_SERIALIZATION_DECL isn't defined yet define it now:
+#ifndef BOOST_SERIALIZATION_DECL
+ #define BOOST_SERIALIZATION_DECL(T) T
+#endif
+
+// enable automatic library variant selection ------------------------------//
+
+#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_SERIALIZATION_NO_LIB) \
+&& !defined(BOOST_ARCHIVE_SOURCE) && !defined(BOOST_WARCHIVE_SOURCE) \
+&& !defined(BOOST_SERIALIZATION_SOURCE)
+ //
+ // Set the name of our library, this will get undef'ed by auto_link.hpp
+ // once it's done with it:
+ //
+ #define BOOST_LIB_NAME boost_serialization
+ //
+ // If we're importing code from a dll, then tell auto_link.hpp about it:
+ //
+ #if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_SERIALIZATION_DYN_LINK)
+ # define BOOST_DYN_LINK
+ #endif
+ //
+ // And include the header that does the work:
+ //
+ #include <boost/config/auto_link.hpp>
+
+#endif
Added: branches/CMake/release/libs/serialization/include/boost/serialization/deque.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/deque.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,75 @@
+#ifndef BOOST_SERIALIZATION_DEQUE_HPP
+#define BOOST_SERIALIZATION_DEQUE_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
+// deque.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.
+
+#include <deque>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+ Archive & ar,
+ const std::deque<U, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::save_collection<
+ Archive, std::deque<U, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+ Archive & ar,
+ std::deque<U, Allocator> &t,
+ const unsigned int /*file_version*/
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::deque<U, Allocator>,
+ boost::serialization::stl::archive_input_seq<
+ Archive, std::deque<U, Allocator>
+ >,
+ boost::serialization::stl::no_reserve_imp<std::deque<U, Allocator> >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+ Archive & ar,
+ std::deque<U, Allocator> &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::deque)
+
+#endif // BOOST_SERIALIZATION_DEQUE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/detail/get_data.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/detail/get_data.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,55 @@
+// (C) Copyright 2005 Matthias Troyer
+// 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.
+
+#ifndef BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP
+#define BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+
+#include <vector>
+#include <valarray>
+
+namespace boost { namespace serialization { namespace detail {
+
+template <class T, class Allocator>
+T* get_data(STD::vector<T,Allocator>& v)
+{
+ return v.empty() ? 0 : &(v[0]);
+}
+
+template <class T, class Allocator>
+T* get_data(STD::vector<T,Allocator> const & v)
+{
+ return get_data(const_cast<STD::vector<T,Allocator>&>(v));
+}
+
+
+template <class T>
+T* get_data(STD::valarray<T>& v)
+{
+ return v.size()==0 ? 0 : &(v[0]);
+}
+
+template <class T>
+const T* get_data(STD::valarray<T> const& v)
+{
+ return get_data(const_cast<STD::valarray<T>&>(v));
+}
+
+} } } //namespace boost::serialization::detail
+
+#endif // BOOST_SERIALIZATION_DETAIL_GET_DATA_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_count_132.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_count_132.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,569 @@
+#ifndef BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_COUNT_132_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+// detail/shared_count.hpp
+//
+// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
+//
+// Distributed under 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)
+//
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR) && defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+# error BOOST_SP_USE_STD_ALLOCATOR and BOOST_SP_USE_QUICK_ALLOCATOR are incompatible.
+#endif
+
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/lightweight_mutex.hpp>
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+#include <boost/detail/quick_allocator.hpp>
+#endif
+
+#include <memory> // std::auto_ptr, std::allocator
+#include <functional> // std::less
+#include <exception> // std::exception
+#include <new> // std::bad_alloc
+#include <typeinfo> // std::type_info in get_deleter
+#include <cstddef> // std::size_t
+
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#ifdef __BORLANDC__
+# pragma warn -8026 // Functions with excep. spec. are not expanded inline
+# pragma warn -8027 // Functions containing try are not expanded inline
+#endif
+
+namespace boost_132 {
+
+// Debug hooks
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+void sp_scalar_constructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_constructor_hook(void * px);
+void sp_scalar_destructor_hook(void * px, std::size_t size, void * pn);
+void sp_array_destructor_hook(void * px);
+
+#endif
+
+
+// The standard library that comes with Borland C++ 5.5.1
+// defines std::exception and its members as having C calling
+// convention (-pc). When the definition of bad_weak_ptr
+// is compiled with -ps, the compiler issues an error.
+// Hence, the temporary #pragma option -pc below. The version
+// check is deliberately conservative.
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option push -pc
+#endif
+
+class bad_weak_ptr: public std::exception
+{
+public:
+
+ virtual char const * what() const throw()
+ {
+ return "boost::bad_weak_ptr";
+ }
+};
+
+#if defined(__BORLANDC__) && __BORLANDC__ == 0x551
+# pragma option pop
+#endif
+
+namespace detail{
+
+class sp_counted_base
+{
+//private:
+
+ typedef boost::detail::lightweight_mutex mutex_type;
+
+public:
+
+ sp_counted_base(): use_count_(1), weak_count_(1)
+ {
+ }
+
+ virtual ~sp_counted_base() // nothrow
+ {
+ }
+
+ // dispose() is called when use_count_ drops to zero, to release
+ // the resources managed by *this.
+
+ virtual void dispose() = 0; // nothrow
+
+ // destruct() is called when weak_count_ drops to zero.
+
+ virtual void destruct() // nothrow
+ {
+ delete this;
+ }
+
+ virtual void * get_deleter(std::type_info const & ti) = 0;
+
+ void add_ref_copy()
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ ++use_count_;
+ }
+
+ void add_ref_lock()
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ if(use_count_ == 0) boost::throw_exception(bad_weak_ptr());
+ ++use_count_;
+ }
+
+ void release() // nothrow
+ {
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ long new_use_count = --use_count_;
+
+ if(new_use_count != 0) return;
+ }
+
+ dispose();
+ weak_release();
+ }
+
+ void weak_add_ref() // nothrow
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ ++weak_count_;
+ }
+
+ void weak_release() // nothrow
+ {
+ long new_weak_count;
+
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ new_weak_count = --weak_count_;
+ }
+
+ if(new_weak_count == 0)
+ {
+ destruct();
+ }
+ }
+
+ long use_count() const // nothrow
+ {
+#if defined(BOOST_HAS_THREADS)
+ mutex_type::scoped_lock lock(mtx_);
+#endif
+ return use_count_;
+ }
+
+//private:
+public:
+ sp_counted_base(sp_counted_base const &);
+ sp_counted_base & operator= (sp_counted_base const &);
+
+ long use_count_; // #shared
+ long weak_count_; // #weak + (#shared != 0)
+
+#if defined(BOOST_HAS_THREADS) || defined(BOOST_LWM_WIN32)
+ mutable mutex_type mtx_;
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+ boost::sp_scalar_constructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_constructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+ boost::sp_array_constructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_constructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base * pn, T * px, checked_deleter<T> const &, int)
+{
+ boost::sp_scalar_destructor_hook(px, sizeof(T), pn);
+}
+
+template<class T> void cbi_call_destructor_hook(sp_counted_base *, T * px, checked_array_deleter<T> const &, int)
+{
+ boost::sp_array_destructor_hook(px);
+}
+
+template<class P, class D> void cbi_call_destructor_hook(sp_counted_base *, P const &, D const &, long)
+{
+}
+
+#endif
+
+//
+// Borland's Codeguard trips up over the -Vx- option here:
+//
+#ifdef __CODEGUARD__
+# pragma option push -Vx-
+#endif
+
+template<class P, class D> class sp_counted_base_impl: public sp_counted_base
+{
+//private:
+public:
+ P ptr; // copy constructor must not throw
+ D del; // copy constructor must not throw
+
+ sp_counted_base_impl(sp_counted_base_impl const &);
+ sp_counted_base_impl & operator= (sp_counted_base_impl const &);
+
+ typedef sp_counted_base_impl<P, D> this_type;
+
+public:
+
+ // pre: initial_use_count <= initial_weak_count, d(p) must not throw
+
+ sp_counted_base_impl(P p, D d): ptr(p), del(d)
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ detail::cbi_call_constructor_hook(this, p, d, 0);
+#endif
+ }
+
+ virtual void dispose() // nothrow
+ {
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ detail::cbi_call_destructor_hook(this, ptr, del, 0);
+#endif
+ del(ptr);
+ }
+
+ virtual void * get_deleter(std::type_info const & ti)
+ {
+ return ti == typeid(D)? &del: 0;
+ }
+
+#if defined(BOOST_SP_USE_STD_ALLOCATOR)
+
+ void * operator new(std::size_t)
+ {
+ return std::allocator<this_type>().allocate(1, static_cast<this_type *>(0));
+ }
+
+ void operator delete(void * p)
+ {
+ std::allocator<this_type>().deallocate(static_cast<this_type *>(p), 1);
+ }
+
+#endif
+
+#if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
+
+ void * operator new(std::size_t)
+ {
+ return quick_allocator<this_type>::alloc();
+ }
+
+ void operator delete(void * p)
+ {
+ quick_allocator<this_type>::dealloc(p);
+ }
+
+#endif
+};
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+
+int const shared_count_id = 0x2C35F101;
+int const weak_count_id = 0x298C38A4;
+
+#endif
+
+class weak_count;
+
+class shared_count
+{
+//private:
+public:
+ sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ int id_;
+#endif
+
+ friend class weak_count;
+
+public:
+
+ shared_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ }
+
+ template<class P, class D> shared_count(P p, D d): pi_(0)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+#ifndef BOOST_NO_EXCEPTIONS
+
+ try
+ {
+ pi_ = new sp_counted_base_impl<P, D>(p, d);
+ }
+ catch(...)
+ {
+ d(p); // delete p
+ throw;
+ }
+
+#else
+
+ pi_ = new sp_counted_base_impl<P, D>(p, d);
+
+ if(pi_ == 0)
+ {
+ d(p); // delete p
+ boost::throw_exception(std::bad_alloc());
+ }
+
+#endif
+ }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+ // auto_ptr<Y> is special cased to provide the strong guarantee
+
+ template<class Y>
+ explicit shared_count(std::auto_ptr<Y> & r): pi_(
+ new sp_counted_base_impl<
+ Y *,
+ boost::checked_deleter<Y>
+ >(r.get(), boost::checked_deleter<Y>()))
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ r.release();
+ }
+
+#endif
+
+ ~shared_count() // nothrow
+ {
+ if(pi_ != 0) pi_->release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ id_ = 0;
+#endif
+ }
+
+ shared_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ if(pi_ != 0) pi_->add_ref_copy();
+ }
+
+ explicit shared_count(weak_count const & r); // throws bad_weak_ptr when r.use_count() == 0
+
+ shared_count & operator= (shared_count const & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+
+ if(tmp != pi_)
+ {
+ if(tmp != 0) tmp->add_ref_copy();
+ if(pi_ != 0) pi_->release();
+ pi_ = tmp;
+ }
+
+ return *this;
+ }
+
+ void swap(shared_count & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ r.pi_ = pi_;
+ pi_ = tmp;
+ }
+
+ long use_count() const // nothrow
+ {
+ return pi_ != 0? pi_->use_count(): 0;
+ }
+
+ bool unique() const // nothrow
+ {
+ return use_count() == 1;
+ }
+
+ friend inline bool operator==(shared_count const & a, shared_count const & b)
+ {
+ return a.pi_ == b.pi_;
+ }
+
+ friend inline bool operator<(shared_count const & a, shared_count const & b)
+ {
+ return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+ }
+
+ void * get_deleter(std::type_info const & ti) const
+ {
+ return pi_? pi_->get_deleter(ti): 0;
+ }
+};
+
+#ifdef __CODEGUARD__
+# pragma option pop
+#endif
+
+
+class weak_count
+{
+private:
+
+ sp_counted_base * pi_;
+
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ int id_;
+#endif
+
+ friend class shared_count;
+
+public:
+
+ weak_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(weak_count_id)
+#endif
+ {
+ }
+
+ weak_count(shared_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ if(pi_ != 0) pi_->weak_add_ref();
+ }
+
+ weak_count(weak_count const & r): pi_(r.pi_) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+ {
+ if(pi_ != 0) pi_->weak_add_ref();
+ }
+
+ ~weak_count() // nothrow
+ {
+ if(pi_ != 0) pi_->weak_release();
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ id_ = 0;
+#endif
+ }
+
+ weak_count & operator= (shared_count const & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ if(tmp != 0) tmp->weak_add_ref();
+ if(pi_ != 0) pi_->weak_release();
+ pi_ = tmp;
+
+ return *this;
+ }
+
+ weak_count & operator= (weak_count const & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ if(tmp != 0) tmp->weak_add_ref();
+ if(pi_ != 0) pi_->weak_release();
+ pi_ = tmp;
+
+ return *this;
+ }
+
+ void swap(weak_count & r) // nothrow
+ {
+ sp_counted_base * tmp = r.pi_;
+ r.pi_ = pi_;
+ pi_ = tmp;
+ }
+
+ long use_count() const // nothrow
+ {
+ return pi_ != 0? pi_->use_count(): 0;
+ }
+
+ friend inline bool operator==(weak_count const & a, weak_count const & b)
+ {
+ return a.pi_ == b.pi_;
+ }
+
+ friend inline bool operator<(weak_count const & a, weak_count const & b)
+ {
+ return std::less<sp_counted_base *>()(a.pi_, b.pi_);
+ }
+};
+
+inline shared_count::shared_count(weak_count const & r): pi_(r.pi_)
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+ , id_(shared_count_id)
+#endif
+{
+ if(pi_ != 0)
+ {
+ pi_->add_ref_lock();
+ }
+ else
+ {
+ boost::throw_exception(bad_weak_ptr());
+ }
+}
+
+} // namespace detail
+
+} // namespace boost
+
+BOOST_SERIALIZATION_ASSUME_ABSTRACT(boost_132::detail::sp_counted_base)
+
+#ifdef __BORLANDC__
+# pragma warn .8027 // Functions containing try are not expanded inline
+# pragma warn .8026 // Functions with excep. spec. are not expanded inline
+#endif
+
+#endif // #ifndef BOOST_DETAIL_SHARED_COUNT_HPP_INCLUDED
Added: branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_ptr_132.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_ptr_132.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,482 @@
+#ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
+#define BOOST_SHARED_PTR_132_HPP_INCLUDED
+
+//
+// shared_ptr.hpp
+//
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// Copyright (c) 2001, 2002, 2003 Peter Dimov
+//
+// Distributed under 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/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include <boost/config.hpp> // for broken compiler workarounds
+
+#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+#include <boost/serializaition/detail/shared_ptr_nmt_132.hpp>
+#else
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/access.hpp>
+#include <boost/serialization/detail/shared_count_132.hpp>
+
+#include <memory> // for std::auto_ptr
+#include <algorithm> // for std::swap
+#include <functional> // for std::less
+#include <typeinfo> // for std::bad_cast
+#include <iosfwd> // for std::basic_ostream
+
+#ifdef BOOST_MSVC // moved here to work around VC++ compiler crash
+# pragma warning(push)
+# pragma warning(disable:4284) // odd return type for operator->
+#endif
+
+namespace boost_132 {
+
+#if !BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x560) )
+using namespace boost;
+#endif
+
+template<class T> class weak_ptr;
+template<class T> class enable_shared_from_this;
+
+namespace detail
+{
+
+struct static_cast_tag {};
+struct const_cast_tag {};
+struct dynamic_cast_tag {};
+struct polymorphic_cast_tag {};
+
+template<class T> struct shared_ptr_traits
+{
+ typedef T & reference;
+};
+
+template<> struct shared_ptr_traits<void>
+{
+ typedef void reference;
+};
+
+#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)
+
+template<> struct shared_ptr_traits<void const>
+{
+ typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void volatile>
+{
+ typedef void reference;
+};
+
+template<> struct shared_ptr_traits<void const volatile>
+{
+ typedef void reference;
+};
+
+#endif
+
+// enable_shared_from_this support
+
+template<class T, class Y> void sp_enable_shared_from_this( shared_count const & pn, enable_shared_from_this<T> const * pe, Y const * px )
+{
+ if(pe != 0) pe->_internal_weak_this._internal_assign(const_cast<Y*>(px), pn);
+}
+
+inline void sp_enable_shared_from_this( shared_count const & /*pn*/, ... )
+{
+}
+
+} // namespace detail
+
+
+//
+// shared_ptr
+//
+// An enhanced relative of scoped_ptr with reference counted copy semantics.
+// The object pointed to is deleted when the last shared_ptr pointing to it
+// is destroyed or reset.
+//
+
+template<class T> class shared_ptr
+{
+private:
+ // Borland 5.5.1 specific workaround
+ typedef shared_ptr<T> this_type;
+
+public:
+
+ typedef T element_type;
+ typedef T value_type;
+ typedef T * pointer;
+ typedef BOOST_DEDUCED_TYPENAME detail::shared_ptr_traits<T>::reference reference;
+
+ shared_ptr(): px(0), pn() // never throws in 1.30+
+ {
+ }
+
+#if BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x564) )
+ template<class Y>
+ explicit shared_ptr(Y * p): px(p), pn(p,boost::checked_deleter<Y>()) // Y must be complete
+#else
+ template<class Y>
+ explicit shared_ptr(Y * p): px(p), pn(p, checked_deleter<Y>()) // Y must be complete
+#endif
+ {
+ detail::sp_enable_shared_from_this( pn, p, p );
+ }
+
+ //
+ // Requirements: D's copy constructor must not throw
+ //
+ // shared_ptr will release p by calling d(p)
+ //
+
+ template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
+ {
+ detail::sp_enable_shared_from_this( pn, p, p );
+ }
+
+// generated copy constructor, assignment, destructor are fine...
+
+// except that Borland C++ has a bug, and g++ with -Wsynth warns
+#if defined(__BORLANDC__) || defined(__GNUC__)
+
+ shared_ptr & operator=(shared_ptr const & r) // never throws
+ {
+ px = r.px;
+ pn = r.pn; // shared_count::op= doesn't throw
+ return *this;
+ }
+
+#endif
+
+ template<class Y>
+ explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
+ {
+ // it is now safe to copy r.px, as pn(r.pn) did not throw
+ px = r.px;
+ }
+
+ template<class Y>
+ shared_ptr(shared_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+ {
+ }
+
+ template<class Y>
+ shared_ptr(shared_ptr<Y> const & r, detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
+ {
+ }
+
+ template<class Y>
+ shared_ptr(shared_ptr<Y> const & r, detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
+ {
+ }
+
+ template<class Y>
+ shared_ptr(shared_ptr<Y> const & r, detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+ {
+ if(px == 0) // need to allocate new counter -- the cast failed
+ {
+ pn = detail::shared_count();
+ }
+ }
+
+ template<class Y>
+ shared_ptr(shared_ptr<Y> const & r, detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
+ {
+ if(px == 0)
+ {
+ boost::throw_exception(std::bad_cast());
+ }
+ }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+ template<class Y>
+ explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
+ {
+ Y * tmp = r.get();
+ pn = detail::shared_count(r);
+ detail::sp_enable_shared_from_this( pn, tmp, tmp );
+ }
+
+#endif
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1200)
+
+ template<class Y>
+ shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
+ {
+ px = r.px;
+ pn = r.pn; // shared_count::op= doesn't throw
+ return *this;
+ }
+
+#endif
+
+#ifndef BOOST_NO_AUTO_PTR
+
+ template<class Y>
+ shared_ptr & operator=(std::auto_ptr<Y> & r)
+ {
+ this_type(r).swap(*this);
+ return *this;
+ }
+
+#endif
+
+ void reset() // never throws in 1.30+
+ {
+ this_type().swap(*this);
+ }
+
+ template<class Y> void reset(Y * p) // Y must be complete
+ {
+ BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
+ this_type(p).swap(*this);
+ }
+
+ template<class Y, class D> void reset(Y * p, D d)
+ {
+ this_type(p, d).swap(*this);
+ }
+
+ reference operator* () const // never throws
+ {
+ BOOST_ASSERT(px != 0);
+ return *px;
+ }
+
+ T * operator-> () const // never throws
+ {
+ BOOST_ASSERT(px != 0);
+ return px;
+ }
+
+ T * get() const // never throws
+ {
+ return px;
+ }
+
+ // implicit conversion to "bool"
+
+#if defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x530)
+
+ operator bool () const
+ {
+ return px != 0;
+ }
+
+#elif defined(__MWERKS__) && BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
+ typedef T * (this_type::*unspecified_bool_type)() const;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return px == 0? 0: &this_type::get;
+ }
+
+#else
+
+ typedef T * this_type::*unspecified_bool_type;
+
+ operator unspecified_bool_type() const // never throws
+ {
+ return px == 0? 0: &this_type::px;
+ }
+
+#endif
+
+ // operator! is redundant, but some compilers need it
+
+ bool operator! () const // never throws
+ {
+ return px == 0;
+ }
+
+ bool unique() const // never throws
+ {
+ return pn.unique();
+ }
+
+ long use_count() const // never throws
+ {
+ return pn.use_count();
+ }
+
+ void swap(shared_ptr<T> & other) // never throws
+ {
+ std::swap(px, other.px);
+ pn.swap(other.pn);
+ }
+
+ template<class Y> bool _internal_less(shared_ptr<Y> const & rhs) const
+ {
+ return pn < rhs.pn;
+ }
+
+ void * _internal_get_deleter(std::type_info const & ti) const
+ {
+ return pn.get_deleter(ti);
+ }
+
+// Tasteless as this may seem, making all members public allows member templates
+// to work in the absence of member template friends. (Matthew Langston)
+
+#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
+
+private:
+
+ template<class Y> friend class shared_ptr;
+ template<class Y> friend class weak_ptr;
+
+
+#endif
+public: // for serialization
+ T * px; // contained pointer
+ detail::shared_count pn; // reference counter
+
+}; // shared_ptr
+
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+ return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+ return a.get() != b.get();
+}
+
+#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96
+
+// Resolve the ambiguity between our op!= and the one in rel_ops
+
+template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
+{
+ return a.get() != b.get();
+}
+
+#endif
+
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+ return a._internal_less(b);
+}
+
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+ a.swap(b);
+}
+
+template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
+{
+ return shared_ptr<T>(r, detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
+{
+ return shared_ptr<T>(r, detail::const_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
+{
+ return shared_ptr<T>(r, detail::dynamic_cast_tag());
+}
+
+// shared_*_cast names are deprecated. Use *_pointer_cast instead.
+
+template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
+{
+ return shared_ptr<T>(r, detail::static_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
+{
+ return shared_ptr<T>(r, detail::dynamic_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
+{
+ return shared_ptr<T>(r, detail::polymorphic_cast_tag());
+}
+
+template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
+{
+ BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
+ return shared_static_cast<T>(r);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+{
+ return p.get();
+}
+
+// operator<<
+
+#if defined(__GNUC__) && (__GNUC__ < 3)
+
+template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
+{
+ os << p.get();
+ return os;
+}
+
+#else
+
+# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, <= 1200 && __SGI_STL_PORT)
+// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
+using std::basic_ostream;
+template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+# else
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
+# endif
+{
+ os << p.get();
+ return os;
+}
+
+#endif
+
+// get_deleter (experimental)
+
+#if (defined(__GNUC__) && (__GNUC__ < 3)) || (defined(__EDG_VERSION__) && (__EDG_VERSION__ <= 238))
+
+// g++ 2.9x doesn't allow static_cast<X const *>(void *)
+// apparently EDG 2.38 also doesn't accept it
+
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+ void const * q = p._internal_get_deleter(typeid(D));
+ return const_cast<D *>(static_cast<D const *>(q));
+}
+
+#else
+
+template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
+{
+ return static_cast<D *>(p._internal_get_deleter(typeid(D)));
+}
+
+#endif
+
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#endif // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
+
+#endif // #ifndef BOOST_SHARED_PTR_132_HPP_INCLUDED
Added: branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_ptr_nmt_132.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/detail/shared_ptr_nmt_132.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,182 @@
+#ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
+#define BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
+
+//
+// detail/shared_ptr_nmt.hpp - shared_ptr.hpp without member templates
+//
+// (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
+// Copyright (c) 2001, 2002 Peter Dimov
+//
+// Distributed under 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/libs/smart_ptr/shared_ptr.htm for documentation.
+//
+
+#include <boost/assert.hpp>
+#include <boost/checked_delete.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/detail/atomic_count.hpp>
+
+#ifndef BOOST_NO_AUTO_PTR
+# include <memory> // for std::auto_ptr
+#endif
+
+#include <algorithm> // for std::swap
+#include <functional> // for std::less
+#include <new> // for std::bad_alloc
+
+namespace boost
+{
+
+template<class T> class shared_ptr
+{
+private:
+
+ typedef detail::atomic_count count_type;
+
+public:
+
+ typedef T element_type;
+ typedef T value_type;
+
+ explicit shared_ptr(T * p = 0): px(p)
+ {
+#ifndef BOOST_NO_EXCEPTIONS
+
+ try // prevent leak if new throws
+ {
+ pn = new count_type(1);
+ }
+ catch(...)
+ {
+ boost::checked_delete(p);
+ throw;
+ }
+
+#else
+
+ pn = new count_type(1);
+
+ if(pn == 0)
+ {
+ boost::checked_delete(p);
+ boost::throw_exception(std::bad_alloc());
+ }
+
+#endif
+ }
+
+ ~shared_ptr()
+ {
+ if(--*pn == 0)
+ {
+ boost::checked_delete(px);
+ delete pn;
+ }
+ }
+
+ shared_ptr(shared_ptr const & r): px(r.px) // never throws
+ {
+ pn = r.pn;
+ ++*pn;
+ }
+
+ shared_ptr & operator=(shared_ptr const & r)
+ {
+ shared_ptr(r).swap(*this);
+ return *this;
+ }
+
+#ifndef BOOST_NO_AUTO_PTR
+
+ explicit shared_ptr(std::auto_ptr<T> & r)
+ {
+ pn = new count_type(1); // may throw
+ px = r.release(); // fix: moved here to stop leak if new throws
+ }
+
+ shared_ptr & operator=(std::auto_ptr<T> & r)
+ {
+ shared_ptr(r).swap(*this);
+ return *this;
+ }
+
+#endif
+
+ void reset(T * p = 0)
+ {
+ BOOST_ASSERT(p == 0 || p != px);
+ shared_ptr(p).swap(*this);
+ }
+
+ T & operator*() const // never throws
+ {
+ BOOST_ASSERT(px != 0);
+ return *px;
+ }
+
+ T * operator->() const // never throws
+ {
+ BOOST_ASSERT(px != 0);
+ return px;
+ }
+
+ T * get() const // never throws
+ {
+ return px;
+ }
+
+ long use_count() const // never throws
+ {
+ return *pn;
+ }
+
+ bool unique() const // never throws
+ {
+ return *pn == 1;
+ }
+
+ void swap(shared_ptr<T> & other) // never throws
+ {
+ std::swap(px, other.px);
+ std::swap(pn, other.pn);
+ }
+
+private:
+
+ T * px; // contained pointer
+ count_type * pn; // ptr to reference counter
+};
+
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+ return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
+{
+ return a.get() != b.get();
+}
+
+template<class T> inline bool operator<(shared_ptr<T> const & a, shared_ptr<T> const & b)
+{
+ return std::less<T*>()(a.get(), b.get());
+}
+
+template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b)
+{
+ a.swap(b);
+}
+
+// get_pointer() enables boost::mem_fn to recognize shared_ptr
+
+template<class T> inline T * get_pointer(shared_ptr<T> const & p)
+{
+ return p.get();
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_DETAIL_SHARED_PTR_NMT_132_HPP_INCLUDED
Added: branches/CMake/release/libs/serialization/include/boost/serialization/detail/stack_constructor.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/detail/stack_constructor.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,73 @@
+#ifndef BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
+#define BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1020)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// collections_load_imp.hpp: serialization for loading stl collections
+
+// (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.
+
+#include <boost/aligned_storage.hpp>
+
+namespace boost{
+namespace serialization {
+namespace detail {
+
+// reserve space on stack for an object of type T without actually
+// construction such an object
+template<typename T >
+struct stack_allocate
+{
+ T * address() {
+ return static_cast<T*>(storage_.address());
+ }
+ T & reference() {
+ return * address();
+ }
+private:
+ typedef BOOST_DEDUCED_TYPENAME boost::aligned_storage<
+ sizeof(T),
+ #if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x560))
+ 8
+ #else
+ boost::alignment_of<T>::value
+ #endif
+ > type;
+ type storage_;
+};
+
+// construct element on the stack
+template<class Archive, class T>
+struct stack_construct : public stack_allocate<T>
+{
+ stack_construct(Archive & ar, const unsigned int version){
+ // note borland emits a no-op without the explicit namespace
+ boost::serialization::load_construct_data_adl(
+ ar,
+ this->address(),
+ version
+ );
+ }
+ ~stack_construct(){
+ this->address()->~T(); // undo load_construct_data above
+ }
+};
+
+} // detail
+} // serializaition
+} // boost
+
+#endif // BOOST_SERIALIZATION_DETAIL_STACH_CONSTRUCTOR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/ephemeral.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/ephemeral.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,80 @@
+#ifndef BOOST_SERIALIZATION_EPHEMERAL_HPP
+#define BOOST_SERIALIZATION_EPHEMERAL_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
+// ephemeral_object.hpp: interface for serialization system.
+
+// (C) Copyright 2007 Matthias Troyer.
+// 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.
+
+#include <utility>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+// supress noise
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/traits.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct ephemeral_object :
+ public wrapper_traits<ephemeral_object<T> >
+{
+ explicit ephemeral_object(T& t) :
+ val(t)
+ {}
+
+ T & value() const {
+ return val;
+ }
+
+ const T & const_value() const {
+ return val;
+ }
+
+ template<class Archive>
+ void serialize(Archive &ar, const unsigned int) const
+ {
+ ar & val;
+ }
+
+private:
+ T & val;
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+ephemeral_object<T> ephemeral(const char * name, T & t){
+ return ephemeral_object<T>(name, t);
+}
+
+} // seralization
+} // boost
+
+#endif // BOOST_SERIALIZATION_EPHEMERAL_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/export.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/export.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,213 @@
+#ifndef BOOST_SERIALIZATION_EXPORT_HPP
+#define BOOST_SERIALIZATION_EXPORT_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
+// export.hpp: set traits of classes to be serialized
+
+// (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.
+
+// (C) Copyright 2006 David Abrahams - http://www.boost.org.
+// implementation of class export functionality. This is an alternative to
+// "forward declaration" method to provoke instantiation of derived classes
+// that are to be serialized through pointers.
+
+#include <utility>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/static_warning.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #include <boost/serialization/extended_type_info_typeid.hpp>
+#endif
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/singleton.hpp>
+
+#include <boost/archive/detail/register_archive.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/bool.hpp>
+
+#include <iostream>
+
+namespace boost {
+namespace archive {
+namespace detail {
+
+class basic_pointer_iserializer;
+class basic_pointer_oserializer;
+
+template<class Archive, class T>
+class pointer_iserializer;
+template<class Archive, class T>
+class pointer_oserializer;
+
+template <class Archive, class Serializable>
+struct export_impl
+{
+ static const basic_pointer_iserializer &
+ enable_load(mpl::true_){
+ return boost::serialization::singleton<
+ pointer_iserializer<Archive, Serializable>
+ >::get_const_instance();
+ }
+
+ static const basic_pointer_oserializer &
+ enable_save(mpl::true_){
+ return boost::serialization::singleton<
+ pointer_oserializer<Archive, Serializable>
+ >::get_const_instance();
+ }
+ inline static void enable_load(mpl::false_) {}
+ inline static void enable_save(mpl::false_) {}
+};
+
+// On many platforms, naming a specialization of this template is
+// enough to cause its argument to be instantiated.
+template <void(*)()>
+struct instantiate_function {};
+
+template <class Archive, class Serializable>
+struct ptr_serialization_support
+{
+# if defined(BOOST_MSVC)
+ virtual BOOST_DLLEXPORT void instantiate() BOOST_USED;
+# elif defined(__BORLANDC__)
+ static BOOST_DLLEXPORT void instantiate() BOOST_USED;
+ enum { x = sizeof(instantiate(),3) };
+# else
+ static BOOST_DLLEXPORT void instantiate() BOOST_USED;
+ typedef instantiate_function<
+ &ptr_serialization_support::instantiate
+ > x;
+# endif
+};
+
+template <class Archive, class Serializable>
+BOOST_DLLEXPORT void
+ptr_serialization_support<Archive,Serializable>::instantiate()
+{
+ export_impl<Archive,Serializable>::enable_save(
+ BOOST_DEDUCED_TYPENAME Archive::is_saving()
+ );
+
+ export_impl<Archive,Serializable>::enable_load(
+ BOOST_DEDUCED_TYPENAME Archive::is_loading()
+ );
+}
+
+template<class T>
+struct guid_initializer
+{
+ const guid_initializer & export_guid(char const* key, mpl::false_){
+ // generates the statically-initialized objects whose constructors
+ // register the information allowing serialization of T objects
+ // through pointers to their base classes.
+ instantiate_ptr_serialization((T*)0, 0, adl_tag());
+ return *this;
+ }
+ const guid_initializer & export_guid(char const* /*key*/, mpl::true_){
+ return *this;
+ }
+ const guid_initializer & export_guid(char const* key){
+ BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+ assert(NULL != key);
+ boost::serialization::singleton<
+ BOOST_DEDUCED_TYPENAME
+ boost::serialization::type_info_implementation<T>::type
+ >::get_mutable_instance().key_register(key);
+ // note: exporting an abstract base class will have no effect
+ // and cannot be used to instantitiate serialization code
+ // (one might be using this in a DLL to instantiate code)
+ //BOOST_STATIC_WARNING(! boost::serialization::is_abstract<T>::value);
+ return export_guid(key, boost::serialization::is_abstract<T>());
+ }
+};
+
+} // namespace detail
+} // namespace archive
+} // namespace boost
+
+#define BOOST_CLASS_EXPORT_GUID(T, K) \
+namespace \
+{ \
+ ::boost::archive::detail::guid_initializer< T > const & \
+ BOOST_PP_CAT(boost_serialization_guid_initializer_, __LINE__) \
+ = ::boost::serialization::singleton< \
+ ::boost::archive::detail::guid_initializer< T > \
+ >::get_mutable_instance().export_guid(K); \
+}
+
+// the following is solely to support de-serialization of pointers serialized
+// under 1.32
+#define BOOST_CLASS_EXPORT_GUID_1(T, K) \
+namespace \
+{ \
+ ::boost::archive::detail::guid_initializer< T > const & \
+ BOOST_PP_CAT( \
+ boost_serialization_guid_initializer_, \
+ BOOST_PP_CAT(__LINE__,_1) \
+ ) = ::boost::serialization::singleton< \
+ ::boost::archive::detail::guid_initializer< T > \
+ >::get_mutable_instance().export_guid(K); \
+}
+
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3205))
+
+// CodeWarrior fails to construct static members of class templates
+// when they are instantiated from within templates, so on that
+// compiler we ask users to specifically register base/derived class
+// relationships for exported classes. On all other compilers, use of
+// this macro is entirely optional.
+# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived) \
+namespace \
+{ \
+ int BOOST_PP_CAT(boost_serialization_mwerks_init_, __LINE__) = \
+ (::boost::archive::detail::instantiate_ptr_serialization((Derived*)0,0), 3); \
+ int BOOST_PP_CAT(boost_serialization_mwerks_init2_, __LINE__) = ( \
+ ::boost::serialization::void_cast_register((Derived*)0,(Base*)0) \
+ , 3); \
+}
+
+#else
+
+# define BOOST_SERIALIZATION_MWERKS_BASE_AND_DERIVED(Base,Derived)
+
+#endif
+
+// check for unnecessary export. T isn't polymorphic so there is no
+// need to export it.
+#define BOOST_CLASS_EXPORT_CHECK(T) \
+ BOOST_STATIC_WARNING( \
+ boost::is_polymorphic<U>::value \
+ ); \
+ /**/
+
+// the default exportable class identifier is the class name
+// the default list of archives types for which code id generated
+// are the originally included with this serialization system
+#define BOOST_CLASS_EXPORT(T) \
+ BOOST_CLASS_EXPORT_GUID( \
+ T, \
+ BOOST_PP_STRINGIZE(T) \
+ ) \
+ /**/
+
+#endif // BOOST_SERIALIZATION_EXPORT_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,98 @@
+#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
+#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_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
+// extended_type_info.hpp: interface for portable version of type_info
+
+// (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.
+
+// for now, extended type info is part of the serialization libraries
+// this could change in the future.
+#include <cstdarg>
+#include <cassert>
+#include <cstddef> // NULL
+#include <boost/config.hpp>
+#include <boost/serialization/config.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+#define BOOST_SERIALIZATION_MAX_KEY_SIZE 128
+
+namespace boost {
+namespace serialization {
+
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info
+{
+private:
+ // used to uniquely identify the type of class derived from this one
+ // so that different derivations of this class can be simultaneously
+ // included in implementation of sets and maps.
+ const unsigned int m_type_info_key;
+ virtual bool
+ is_less_than(const extended_type_info & /*rhs*/) const {
+ assert(false);
+ return false;
+ };
+ virtual bool
+ is_equal(const extended_type_info & /*rhs*/) const {
+ assert(false);
+ return false;
+ };
+ void key_unregister();
+protected:
+ const char * m_key;
+ // this class can't be used as is. It's just the
+ // common functionality for all type_info replacement
+ // systems. Hence, make these protected
+ extended_type_info(const unsigned int type_info_key = 0);
+ // account for bogus gcc warning
+ #if defined(__GNUC__)
+ virtual
+ #endif
+ ~extended_type_info();
+public:
+ const char * get_key() const {
+ return m_key;
+ }
+ void key_register(const char *key);
+ bool operator<(const extended_type_info &rhs) const;
+ bool operator==(const extended_type_info &rhs) const;
+ bool operator!=(const extended_type_info &rhs) const {
+ return !(operator==(rhs));
+ }
+ static const extended_type_info * find(const char *key);
+ // for plugins
+ virtual void * construct(unsigned int /*count*/ = 0, ...) const {
+ assert(false); // must be implemented if used
+ return NULL;
+ };
+ virtual void destroy(void const * const /*p*/) const {
+ assert(false); // must be implemented if used
+ }
+};
+
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info_no_rtti.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info_no_rtti.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,129 @@
+#ifndef BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
+#define BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// extended_type_info_no_rtti.hpp: implementation for version that depends
+// on runtime typing (rtti - typeid) but uses a user specified string
+// as the portable class identifier.
+
+// (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.
+#include <cassert>
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/factory.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost {
+namespace serialization {
+///////////////////////////////////////////////////////////////////////
+// define a special type_info that doesn't depend on rtti which is not
+// available in all situations.
+
+namespace detail {
+
+// common base class to share type_info_key. This is used to
+// identify the method used to keep track of the extended type
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_no_rtti_0 :
+ public extended_type_info
+{
+protected:
+ extended_type_info_no_rtti_0();
+ ~extended_type_info_no_rtti_0();
+public:
+ virtual bool
+ is_less_than(const boost::serialization::extended_type_info &rhs) const ;
+ virtual bool
+ is_equal(const boost::serialization::extended_type_info &rhs) const ;
+};
+
+} // detail
+
+template<class T>
+class extended_type_info_no_rtti :
+ public detail::extended_type_info_no_rtti_0,
+ public singleton<extended_type_info_no_rtti<T> >
+{
+public:
+ const extended_type_info *
+ get_derived_extended_type_info(const T & t) const {
+ // find the type that corresponds to the most derived type.
+ // this implementation doesn't depend on typeid() but assumes
+ // that the specified type has a function of the following signature.
+ // A common implemention of such a function is to define as a virtual
+ // function.
+ const char * derived_key = t.get_key();
+ assert(NULL != derived_key);
+ return boost::serialization::extended_type_info::find(derived_key);
+ }
+ void * construct(unsigned int count, ...) const{
+ // count up the arguments
+ std::va_list ap;
+ va_start(ap, count);
+ switch(count){
+ case 0:
+ return factory<T, 0>(ap);
+ case 1:
+ return factory<T, 1>(ap);
+ case 2:
+ return factory<T, 2>(ap);
+ case 3:
+ return factory<T, 3>(ap);
+ case 4:
+ return factory<T, 4>(ap);
+ default:
+ assert(false); // too many arguments
+ // throw exception here?
+ return NULL;
+ }
+ }
+ void destroy(void const * const p) const{
+ delete static_cast<T const *>(p) ;
+ }
+};
+
+} // namespace serialization
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// If no other implementation has been designated as default,
+// use this one. To use this implementation as the default, specify it
+// before any of the other headers.
+
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ namespace boost {
+ namespace serialization {
+ template<class T>
+ struct extended_type_info_impl {
+ typedef BOOST_DEDUCED_TYPENAME
+ boost::serialization::extended_type_info_no_rtti<T> type;
+ };
+ } // namespace serialization
+ } // namespace boost
+#endif
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_EXTENDED_TYPE_INFO_NO_RTTI_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info_typeid.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/extended_type_info_typeid.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,145 @@
+#ifndef BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
+#define BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// extended_type_info_typeid.hpp: implementation for version that depends
+// on runtime typing (rtti - typeid) but uses a user specified string
+// as the portable class identifier.
+
+// (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.
+
+#include <typeinfo>
+#include <cstdarg>
+
+#include <boost/config.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/static_warning.hpp>
+#include <boost/type_traits/is_polymorphic.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/extended_type_info.hpp>
+#include <boost/serialization/factory.hpp>
+
+#include <boost/config/abi_prefix.hpp> // must be the last header
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost {
+namespace serialization {
+namespace detail {
+
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) extended_type_info_typeid_0 :
+ public extended_type_info
+{
+protected:
+ const std::type_info * m_ti;
+ extended_type_info_typeid_0();
+ ~extended_type_info_typeid_0();
+ void type_register(const std::type_info & ti);
+ void type_unregister();
+ const extended_type_info *
+ get_extended_type_info(const std::type_info & ti) const;
+public:
+ virtual bool
+ is_less_than(const extended_type_info &rhs) const;
+ virtual bool
+ is_equal(const extended_type_info &rhs) const;
+ const std::type_info & get_typeid() const {
+ return *m_ti;
+ }
+};
+
+} // namespace detail
+
+template<class T>
+class extended_type_info_typeid :
+ public detail::extended_type_info_typeid_0,
+ public singleton<extended_type_info_typeid<T> >
+{
+public:
+ extended_type_info_typeid() :
+ detail::extended_type_info_typeid_0()
+ {
+ type_register(typeid(T));
+ }
+ ~extended_type_info_typeid(){
+ type_unregister();
+ }
+ // get the eti record for the true type of this record
+ // relying upon standard type info implemenation (rtti)
+ const extended_type_info *
+ get_derived_extended_type_info(const T & t) const {
+ // note: this implementation - based on usage of typeid (rtti)
+ // only does something if the class has at least one virtual function.
+ BOOST_STATIC_WARNING(boost::is_polymorphic<T>::value);
+ return
+ detail::extended_type_info_typeid_0::get_extended_type_info(
+ typeid(t)
+ );
+ }
+ void * construct(unsigned int count, ...) const{
+ // count up the arguments
+ std::va_list ap;
+ va_start(ap, count);
+ switch(count){
+ case 0:
+ return factory<boost::remove_const<T>, 0>(ap);
+ case 1:
+ return factory<boost::remove_const<T>, 1>(ap);
+ case 2:
+ return factory<boost::remove_const<T>, 2>(ap);
+ case 3:
+ return factory<boost::remove_const<T>, 3>(ap);
+ case 4:
+ return factory<boost::remove_const<T>, 4>(ap);
+ default:
+ assert(false); // too many arguments
+ // throw exception here?
+ return NULL;
+ }
+ }
+ void destroy(void const * const p) const{
+ delete static_cast<T const *>(p) ;
+ }
+};
+
+} // namespace serialization
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// If no other implementation has been designated as default,
+// use this one. To use this implementation as the default, specify it
+// before any of the other headers.
+#ifndef BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ #define BOOST_SERIALIZATION_DEFAULT_TYPE_INFO
+ namespace boost {
+ namespace serialization {
+ template<class T>
+ struct extended_type_info_impl {
+ typedef BOOST_DEDUCED_TYPENAME
+ boost::serialization::extended_type_info_typeid<T> type;
+ };
+ } // namespace serialization
+ } // namespace boost
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_EXTENDED_TYPE_INFO_TYPEID_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/factory.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/factory.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,93 @@
+#ifndef BOOST_SERIALIZATION_FACTORY_HPP
+#define BOOST_SERIALIZATION_FACTORY_HPP
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// factory.hpp: create an instance from an extended_type_info instance.
+
+// (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.
+
+#include <cstdarg>
+#include <cstddef> // NULL
+
+#include <boost/preprocessor/control/if.hpp>
+#include <boost/preprocessor/comparison/greater.hpp>
+#include <boost/preprocessor/facilities/empty.hpp>
+
+namespace std{
+ #if defined(__LIBCOMO__)
+ using ::va_list;
+ #endif
+} // namespace std
+
+namespace boost {
+namespace serialization {
+
+// default implementation does nothing.
+template<class T, int N>
+T * factory(std::va_list){
+ assert(false);
+ // throw exception here?
+ return NULL;
+}
+
+} // namespace serialization
+} // namespace boost
+
+#define BOOST_SERIALIZATION_FACTORY(N, T, A0, A1, A2, A3) \
+namespace boost { \
+namespace serialization { \
+ template<> \
+ T * factory<T, N>(std::va_list ap){ \
+ BOOST_PP_IF(BOOST_PP_GREATER(N,0) \
+ ,A0 a0 = va_arg(ap, A0); \
+ ,BOOST_PP_IF(BOOST_PP_GREATER(N,1) \
+ ,A1 a1 = va_arg(ap, A1); \
+ ,BOOST_PP_IF(BOOST_PP_GREATER(N,2) \
+ ,A2 a2 = va_arg(ap, A2); \
+ ,BOOST_PP_IF(BOOST_PP_GREATER(N,3) \
+ ,A3 a3 = va_arg(ap, A3); \
+ ,BOOST_PP_EMPTY() \
+ )))) \
+ return new T( \
+ BOOST_PP_IF(BOOST_PP_GREATER(N,0) \
+ ,a0 \
+ ,BOOST_PP_IF(BOOST_PP_GREATER(N,1) \
+ ,a1 \
+ ,BOOST_PP_IF(BOOST_PP_GREATER(N,2) \
+ ,a2 \
+ ,BOOST_PP_IF(BOOST_PP_GREATER(N,3) \
+ ,a3 \
+ ,BOOST_PP_EMPTY() \
+ )))) \
+ ); \
+ } \
+} \
+} \
+/**/
+
+#define BOOST_SERIALIZATION_FACTORY_4(T, A0, A1, A2, A3) \
+ BOOST_SERIALIZATION_FACTORY(4, T, A0, A1, A2, A3)
+
+#define BOOST_SERIALIZATION_FACTORY_3(T, A0, A1, A2) \
+ BOOST_SERIALIZATION_FACTORY(3, T, A0, A1, A2, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_2(T, A0, A1) \
+ BOOST_SERIALIZATION_FACTORY(2, T, A0, A1, 0, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_1(T, A0) \
+ BOOST_SERIALIZATION_FACTORY(1, T, A0, 0, 0, 0)
+
+#define BOOST_SERIALIZATION_FACTORY_0(T) \
+ BOOST_SERIALIZATION_FACTORY(0, T, 0, 0, 0, 0)
+
+#endif // BOOST_SERIALIZATION_FACTORY_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/force_include.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/force_include.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,57 @@
+#ifndef BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
+#define BOOST_SERIALIZATION_FORCE_INCLUDE_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
+// force_include.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.
+
+#include <boost/config.hpp>
+
+// the following help macro is to guarentee that certain coded
+// is not removed by over-eager linker optimiser. In certain cases
+// we create static objects must be created but are actually never
+// referenced - creation has a side-effect such as global registration
+// which is important to us. We make an effort to refer these objects
+// so that a smart linker won't remove them as being unreferenced.
+// In microsoft compilers, inlining the code that does the referring
+// means the code gets lost and the static object is not included
+// in the library and hence never registered. This manifests itself
+// in an ungraceful crash at runtime when (and only when) built in
+// release mode.
+
+#if defined(BOOST_HAS_DECLSPEC) && !defined(__COMO__)
+# if defined(__BORLANDC__)
+# define BOOST_DLLEXPORT __export
+# else
+# define BOOST_DLLEXPORT __declspec(dllexport)
+# endif
+#elif ! defined(_WIN32) && ! defined(_WIN64)
+# if defined(__MWERKS__)
+# define BOOST_DLLEXPORT __declspec(dllexport)
+# elif defined(__GNUC__) && (__GNUC__ >= 3)
+# define BOOST_USED __attribute__ ((used))
+# elif defined(__INTEL_COMPILER) && (BOOST_INTEL_CXX_VERSION >= 800)
+# define BOOST_USED __attribute__ ((used))
+# endif
+#endif
+
+#ifndef BOOST_USED
+# define BOOST_USED
+#endif
+
+#ifndef BOOST_DLLEXPORT
+# define BOOST_DLLEXPORT
+#endif
+
+#endif // BOOST_SERIALIZATION_FORCE_INCLUDE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/hash_collections_load_imp.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/hash_collections_load_imp.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,58 @@
+#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
+#define BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// hash_collections_load_imp.hpp: serialization for loading stl collections
+
+// (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.
+
+// helper function templates for serialization of hashed collections
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+template<class Archive, class Container, class InputFunction>
+inline void load_hash_collection(Archive & ar, Container &s)
+{
+ s.clear();
+ // retrieve number of elements
+ unsigned int count;
+ unsigned int item_version(0);
+ unsigned int bucket_count;;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ if(3 < ar.get_library_version()){
+ ar >> BOOST_SERIALIZATION_NVP(bucket_count);
+ ar >> BOOST_SERIALIZATION_NVP(item_version);
+ }
+ #if ! defined(__MWERKS__)
+ s.resize(bucket_count);
+ #endif
+ InputFunction ifunc;
+ while(count-- > 0){
+ ifunc(ar, s, item_version);
+ }
+}
+
+} // namespace stl
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_LOAD_IMP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/hash_collections_save_imp.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/hash_collections_save_imp.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,66 @@
+#ifndef BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
+#define BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_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
+// hash_collections_save_imp.hpp: serialization for stl collections
+
+// (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.
+
+// helper function templates for serialization of collections
+
+#include <boost/config.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/version.hpp>
+
+namespace boost{
+namespace serialization {
+namespace stl {
+
+//////////////////////////////////////////////////////////////////////
+// implementation of serialization for STL containers
+//
+
+template<class Archive, class Container>
+inline void save_hash_collection(Archive & ar, const Container &s)
+{
+ // record number of elements
+ unsigned int count = s.size();
+ ar << BOOST_SERIALIZATION_NVP(count);
+ // make sure the target type is registered so we can retrieve
+ // the version when we load
+ if(3 < ar.get_library_version()){
+ const unsigned int bucket_count = s.bucket_count();
+ ar << BOOST_SERIALIZATION_NVP(bucket_count);
+ const unsigned int item_version = version<BOOST_DEDUCED_TYPENAME Container::value_type>::value;
+ ar << BOOST_SERIALIZATION_NVP(item_version);
+ }
+ BOOST_DEDUCED_TYPENAME Container::const_iterator it = s.begin();
+ while(count-- > 0){
+ // note borland emits a no-op without the explicit namespace
+ boost::serialization::save_construct_data_adl(
+ ar,
+ &(*it),
+ boost::serialization::version<
+ BOOST_DEDUCED_TYPENAME Container::value_type
+ >::value
+ );
+ ar << boost::serialization::make_nvp("item", *it++);
+ }
+}
+
+} // namespace stl
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_HASH_COLLECTIONS_SAVE_IMP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/hash_map.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/hash_map.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,175 @@
+#ifndef BOOST_SERIALIZATION_HASH_MAP_HPP
+#define BOOST_SERIALIZATION_HASH_MAP_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
+// serialization/hash_map.hpp:
+// serialization for stl hash_map templates
+
+// (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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_HASH
+#include BOOST_HASH_MAP_HEADER
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/hash_collections_save_imp.hpp>
+#include <boost/serialization/hash_collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void save(
+ Archive & ar,
+ const BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::save_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >(ar, t);
+}
+
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void load(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::load_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+ Key, HashFcn, EqualKey, Allocator
+ >,
+ boost::serialization::stl::archive_input_map<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void serialize(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_map<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+// hash_multimap
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void save(
+ Archive & ar,
+ const BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::save_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >(ar, t);
+}
+
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void load(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::load_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+ Key, HashFcn, EqualKey, Allocator
+ >,
+ boost::serialization::stl::archive_input_multimap<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void serialize(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multimap<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_HAS_HASH
+#endif // BOOST_SERIALIZATION_HASH_MAP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/hash_set.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/hash_set.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,178 @@
+#ifndef BOOST_SERIALIZATION_HASH_SET_HPP
+#define BOOST_SERIALIZATION_HASH_SET_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
+// hash_set.hpp: serialization for stl hash_set templates
+
+// (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.
+
+#include <boost/config.hpp>
+#ifdef BOOST_HAS_HASH
+#include BOOST_HASH_SET_HEADER
+
+#include <boost/serialization/hash_collections_save_imp.hpp>
+#include <boost/serialization/hash_collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void save(
+ Archive & ar,
+ const BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::save_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >(ar, t);
+}
+
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void load(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::load_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+ Key, HashFcn, EqualKey, Allocator
+ >,
+ boost::serialization::stl::archive_input_set<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void serialize(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_set<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+// hash_multiset
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void save(
+ Archive & ar,
+ const BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::save_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >(ar, t);
+}
+
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void load(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+ Key, HashFcn, EqualKey, Allocator
+ > &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::load_hash_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+ Key, HashFcn, EqualKey, Allocator
+ >,
+ boost::serialization::stl::archive_input_multiset<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+ Key, HashFcn, EqualKey, Allocator
+ >
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<
+ class Archive,
+ class Key,
+ class HashFcn,
+ class EqualKey,
+ class Allocator
+>
+inline void serialize(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::hash_multiset<
+ Key, HashFcn, EqualKey, Allocator
+ > & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_set)
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::hash_multiset)
+
+#endif // BOOST_HAS_HASH
+#endif // BOOST_SERIALIZATION_HASH_SET_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/is_bitwise_serializable.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/is_bitwise_serializable.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,46 @@
+// (C) Copyright 2007 Matthias Troyer
+
+// 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)
+
+// Authors: Matthias Troyer
+
+/** @file is_bitwise_serializable.hpp
+ *
+ * This header provides a traits class for determining whether a class
+ * can be serialized (in a non-portable way) just by copying the bits.
+ */
+
+
+#ifndef BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+#define BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/mpl/bool.hpp>
+#include <boost/type_traits/is_arithmetic.hpp>
+
+namespace boost {
+namespace serialization {
+ template<class T>
+ struct is_bitwise_serializable
+ : public is_arithmetic<T>
+ {};
+} // namespace serialization
+} // namespace boost
+
+
+// define a macro to make explicit designation of this more transparent
+#define BOOST_IS_BITWISE_SERIALIZABLE(T) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct is_bitwise_serializable< T > : mpl::true_ {}; \
+}} \
+/**/
+
+#endif //BOOST_SERIALIZATION_IS_BITWISE_SERIALIZABLE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/level.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/level.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,120 @@
+#ifndef BOOST_SERIALIZATION_LEVEL_HPP
+#define BOOST_SERIALIZATION_LEVEL_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
+// level.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.
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_enum.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+#include <boost/mpl/aux_/nttp_decl.hpp>
+
+#include <boost/serialization/level_enum.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct basic_traits;
+
+// default serialization implementation level
+template<class T>
+struct implementation_level {
+ template<class U>
+ struct traits_class_level {
+ typedef BOOST_DEDUCED_TYPENAME U::level type;
+ };
+
+ typedef mpl::integral_c_tag tag;
+ // note: at least one compiler complained w/o the full qualification
+ // on basic traits below
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_base_and_derived<boost::serialization::basic_traits, T>,
+ traits_class_level<T>,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_fundamental<T>,
+ mpl::int_<primitive_type>,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_class<T>,
+ mpl::int_<object_class_info>,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_array<T>,
+ #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+ mpl::int_<not_serializable>,
+ #else
+ mpl::int_<object_serializable>,
+ #endif
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_enum<T>,
+ //#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+ // mpl::int_<not_serializable>,
+ //#else
+ mpl::int_<primitive_type>,
+ //#endif
+ //else
+ mpl::int_<not_serializable>
+ >
+ >
+ >
+ >
+ >::type type;
+ // vc 7.1 doesn't like enums here
+ BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);
+};
+
+
+template<class T, BOOST_MPL_AUX_NTTP_DECL(int, L) >
+inline bool operator>=(implementation_level<T> t, enum level_type l)
+{
+ return t.value >= (int)l;
+}
+
+} // namespace serialization
+} // namespace boost
+
+// specify the level of serialization implementation for the class
+// require that class info saved when versioning is used
+#define BOOST_CLASS_IMPLEMENTATION(T, E) \
+ namespace boost { \
+ namespace serialization { \
+ template <> \
+ struct implementation_level< T > \
+ { \
+ typedef mpl::integral_c_tag tag; \
+ typedef mpl::int_< E > type; \
+ BOOST_STATIC_CONSTANT( \
+ int, \
+ value = implementation_level::type::value \
+ ); \
+ }; \
+ } \
+ }
+ /**/
+
+#endif // BOOST_SERIALIZATION_LEVEL_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/level_enum.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/level_enum.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,55 @@
+#ifndef BOOST_SERIALIZATION_LEVEL_ENUM_HPP
+#define BOOST_SERIALIZATION_LEVEL_ENUM_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
+// level_enum.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.
+
+namespace boost {
+namespace serialization {
+
+// for each class used in the program, specify which level
+// of serialization should be implemented
+
+// names for each level
+enum level_type
+{
+ // Don't serialize this type. An attempt to do so should
+ // invoke a compile time assertion.
+ not_serializable = 0,
+ // write/read this type directly to the archive. In this case
+ // serialization code won't be called. This is the default
+ // case for fundamental types. It presumes a member function or
+ // template in the archive class that can handle this type.
+ // there is no runtime overhead associated reading/writing
+ // instances of this level
+ primitive_type = 1,
+ // Serialize the objects of this type using the objects "serialize"
+ // function or template. This permits values to be written/read
+ // to/from archives but includes no class or version information.
+ object_serializable = 2,
+ ///////////////////////////////////////////////////////////////////
+ // once an object is serialized at one of the above levels, the
+ // corresponding archives cannot be read if the implementation level
+ // for the archive object is changed.
+ ///////////////////////////////////////////////////////////////////
+ // Add class information to the archive. Class information includes
+ // implementation level, class version and class name if available
+ object_class_info = 3
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_LEVEL_ENUM_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/list.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/list.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,77 @@
+#ifndef BOOST_SERIALIZATION_LIST_HPP
+#define BOOST_SERIALIZATION_LIST_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
+// list.hpp: serialization for stl list templates
+
+// (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.
+
+#include <list>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+ Archive & ar,
+ const std::list<U, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::save_collection<
+ Archive,
+ std::list<U, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+ Archive & ar,
+ std::list<U, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::list<U, Allocator>,
+ boost::serialization::stl::archive_input_seq<
+ Archive,
+ std::list<U, Allocator>
+ >,
+ boost::serialization::stl::no_reserve_imp<std::list<U, Allocator> >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+ Archive & ar,
+ std::list<U, Allocator> & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::list)
+
+#endif // BOOST_SERIALIZATION_LIST_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/map.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/map.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,118 @@
+#ifndef BOOST_SERIALIZATION_MAP_HPP
+#define BOOST_SERIALIZATION_MAP_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
+// serialization/map.hpp:
+// serialization for stl map templates
+
+// (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.
+
+#include <map>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/utility.hpp>
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void save(
+ Archive & ar,
+ const std::map<Key, Type, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::save_collection<
+ Archive,
+ std::map<Key, Type, Compare, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void load(
+ Archive & ar,
+ std::map<Key, Type, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::map<Key, Type, Compare, Allocator>,
+ boost::serialization::stl::archive_input_map<
+ Archive, std::map<Key, Type, Compare, Allocator> >,
+ boost::serialization::stl::no_reserve_imp<std::map<
+ Key, Type, Compare, Allocator
+ >
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void serialize(
+ Archive & ar,
+ std::map<Key, Type, Compare, Allocator> &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+// multimap
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void save(
+ Archive & ar,
+ const std::multimap<Key, Type, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::save_collection<
+ Archive,
+ std::multimap<Key, Type, Compare, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void load(
+ Archive & ar,
+ std::multimap<Key, Type, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::multimap<Key, Type, Compare, Allocator>,
+ boost::serialization::stl::archive_input_multimap<
+ Archive, std::multimap<Key, Type, Compare, Allocator>
+ >,
+ boost::serialization::stl::no_reserve_imp<
+ std::multimap<Key, Type, Compare, Allocator>
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Type, class Key, class Compare, class Allocator >
+inline void serialize(
+ Archive & ar,
+ std::multimap<Key, Type, Compare, Allocator> &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_MAP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/nvp.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/nvp.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,143 @@
+#ifndef BOOST_SERIALIZATION_NVP_HPP
+#define BOOST_SERIALIZATION_NVP_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
+// nvp.hpp: interface for serialization system.
+
+// (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.
+
+#include <utility>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+// supress noise
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/base_object.hpp>
+#include <boost/serialization/traits.hpp>
+#include <boost/serialization/wrapper.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class T>
+struct nvp :
+ public std::pair<const char *, T *>,
+ public wrapper_traits<nvp<T> >
+{
+ explicit nvp(const char * name, T & t) :
+ // note: redundant cast works around borland issue
+ std::pair<const char *, T *>(name, (T*)(& t))
+ {}
+ nvp(const nvp & rhs) :
+ // note: redundant cast works around borland issue
+ std::pair<const char *, T *>(rhs.first, (T*)rhs.second)
+ {}
+
+ const char * name() const {
+ return this->first;
+ }
+ T & value() const {
+ return *(this->second);
+ }
+
+ const T & const_value() const {
+ return *(this->second);
+ }
+
+ // True64 compiler complains with a warning about the use of
+ // the name "Archive" hiding some higher level usage. I'm sure this
+ // is an error but I want to accomodated as it generates a long warning
+ // listing and might be related to a lot of test failures.
+ // default treatment for name-value pairs. The name is
+ // just discarded and only the value is serialized.
+ template<class Archivex>
+ void save(
+ Archivex & ar,
+ const unsigned int /* file_version */
+ ) const {
+ // CodeWarrior 8.x can't seem to resolve the << op for a rhs of "const T *"
+ ar.operator<<(const_value());
+ }
+ template<class Archivex>
+ void load(
+ Archivex & ar,
+ const unsigned int /* file_version */
+ ){
+ // CodeWarrior 8.x can't seem to resolve the >> op for a rhs of "const T *"
+ ar.operator>>(value());
+ }
+ BOOST_SERIALIZATION_SPLIT_MEMBER()
+};
+
+template<class T>
+inline
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+const
+#endif
+nvp<T> make_nvp(const char * name, T & t){
+ return nvp<T>(name, t);
+}
+
+// to maintain efficiency and portability, we want to assign
+// specific serialization traits to all instances of this wrappers.
+// we can't strait forward method below as it depends upon
+// Partial Template Specialization and doing so would mean that wrappers
+// wouldn't be treated the same on different platforms. This would
+// break archive portability. Leave this here as reminder not to use it !!!
+#if 0 // #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+template <class T>
+struct implementation_level<nvp<T> >
+{
+ typedef mpl::integral_c_tag tag;
+ typedef mpl::int_<object_serializable> type;
+ BOOST_STATIC_CONSTANT(int, value = implementation_level::type::value);
+};
+
+// nvp objects are generally created on the stack and are never tracked
+template<class T>
+struct tracking_level<nvp<T> >
+{
+ typedef mpl::integral_c_tag tag;
+ typedef mpl::int_<track_never> type;
+ BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);
+};
+
+#endif
+
+} // seralization
+} // boost
+
+#include <boost/preprocessor/stringize.hpp>
+
+#define BOOST_SERIALIZATION_NVP(name) \
+ boost::serialization::make_nvp(BOOST_PP_STRINGIZE(name), name)
+/**/
+
+#define BOOST_SERIALIZATION_BASE_OBJECT_NVP(name) \
+ boost::serialization::make_nvp( \
+ BOOST_PP_STRINGIZE(name), \
+ boost::serialization::base_object<name >(*this) \
+ )
+/**/
+
+#endif // BOOST_SERIALIZATION_NVP_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/optional.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/optional.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,113 @@
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+
+// (C) Copyright 2002-4 Pavel Vozenilek .
+// 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)
+
+// Provides non-intrusive serialization for boost::optional.
+
+#ifndef BOOST_SERIALIZATION_OPTIONAL_HPP_
+#define BOOST_SERIALIZATION_OPTIONAL_HPP_
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+
+#include <boost/optional.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/detail/stack_constructor.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+namespace boost {
+namespace serialization {
+
+template<class Archive, class T>
+void save(
+ Archive & ar,
+ const boost::optional<T> & t,
+ const unsigned int /*version*/
+){
+ const bool tflag = t.is_initialized();
+ ar << boost::serialization::make_nvp("initialized", tflag);
+ if (tflag){
+ if(3 < ar.get_library_version()){
+ const int v = version<T>::value;
+ ar << make_nvp("item_version", v);
+ }
+ ar << boost::serialization::make_nvp("value", *t);
+ }
+}
+
+template<class Archive, class T>
+void load(
+ Archive & ar,
+ boost::optional<T> & t,
+ const unsigned int /*version*/
+){
+ bool tflag;
+ ar >> boost::serialization::make_nvp("initialized", tflag);
+ if (tflag){
+ unsigned int v = 0;
+ if(3 < ar.get_library_version()){
+ ar >> make_nvp("item_version", v);
+ }
+ detail::stack_construct<Archive, T> aux(ar, v);
+ ar >> boost::serialization::make_nvp("value", aux.reference());
+ t.reset(aux.reference());
+ }
+ else {
+ t.reset();
+ }
+}
+
+template<class Archive, class T>
+void serialize(
+ Archive & ar,
+ boost::optional<T> & t,
+ const unsigned int version
+){
+ boost::serialization::split_free(ar, t, version);
+}
+
+// the following would be slightly more efficient. But it
+// would mean that archives created with programs that support
+// TPS wouldn't be readable by programs that don't support TPS.
+// Hence we decline to support this otherwise convenient optimization.
+//#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#if 0
+
+template <class T>
+struct implementation_level<optional<T> >
+{
+ typedef mpl::integral_c_tag tag;
+ typedef mpl::int_<boost::serialization::object_serializable> type;
+ BOOST_STATIC_CONSTANT(
+ int ,
+ value = boost::serialization::implementation_level::type::value
+ );
+};
+
+template<class T>
+struct tracking_level<optional<T> >
+{
+ typedef mpl::integral_c_tag tag;
+ typedef mpl::int_<boost::serialization::track_never> type;
+ BOOST_STATIC_CONSTANT(
+ int ,
+ value = boost::serialization::tracking_level::type::value
+ );
+};
+
+#endif
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_OPTIONAL_HPP_
Added: branches/CMake/release/libs/serialization/include/boost/serialization/scoped_ptr.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/scoped_ptr.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,58 @@
+#ifndef BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
+#define BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// Copyright (c) 2003 Vladimir Prus.
+// 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)
+
+// Provides non-intrusive serialization for boost::scoped_ptr
+// Does not allow to serialize scoped_ptr's to builtin types.
+
+#include <boost/config.hpp>
+
+#include <boost/scoped_ptr.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+ template<class Archive, class T>
+ void save(
+ Archive & ar,
+ const boost::scoped_ptr<T> & t,
+ const unsigned int /* version */
+ ){
+ T* r = t.get();
+ ar << boost::serialization::make_nvp("scoped_ptr", r);
+ }
+
+ template<class Archive, class T>
+ void load(
+ Archive & ar,
+ boost::scoped_ptr<T> & t,
+ const unsigned int /* version */
+ ){
+ T* r;
+ ar >> boost::serialization::make_nvp("scoped_ptr", r);
+ t.reset(r);
+ }
+
+ template<class Archive, class T>
+ void serialize(
+ Archive& ar,
+ boost::scoped_ptr<T>& t,
+ const unsigned int version
+ ){
+ boost::serialization::split_free(ar, t, version);
+ }
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SCOPED_PTR_HPP_VP_2003_10_30
Added: branches/CMake/release/libs/serialization/include/boost/serialization/serialization.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/serialization.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,172 @@
+#ifndef BOOST_SERIALIZATION_SERIALIZATION_HPP
+#define BOOST_SERIALIZATION_SERIALIZATION_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1310)
+# pragma warning (disable : 4675) // suppress ADL warning
+#endif
+
+#include <boost/config.hpp>
+#include <boost/strong_typedef.hpp>
+#include <boost/pfto.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/serialization/nvp.hpp>
+
+// incremented for each "release"
+#define BOOST_SERIALIZATION_LIBRARY_VERSION 19
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization.hpp: interface for serialization system.
+
+// (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.
+
+//////////////////////////////////////////////////////////////////////
+// public interface to serialization.
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 0 - intrusive verison
+// declared and implemented for each user defined class to be serialized
+//
+// template<Archive>
+// serialize(Archive &ar, const unsigned int file_version){
+// ar & base_object<base>(*this) & member1 & member2 ... ;
+// }
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 1 - layer that routes member access through the access class.
+// this is what permits us to grant access to private class member functions
+// by specifying friend class boost::serialization::access
+
+#include <boost/serialization/access.hpp>
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 2 - default implementation of non-intrusive serialization.
+//
+// note the usage of function overloading to compensate that C++ does not
+// currently support Partial Template Specialization for function templates
+// We have declared the version number as "const unsigned long".
+// Overriding templates for specific data types should declare the version
+// number as "const unsigned int". Template matching will first be applied
+// to functions with the same version types - that is the overloads.
+// If there is no declared function prototype that matches, the second argument
+// will be converted to "const unsigned long" and a match will be made with
+// one of the default template functions below.
+
+namespace boost {
+namespace serialization {
+
+BOOST_STRONG_TYPEDEF(unsigned int, version_type)
+
+// default implemenation - call the member function "serialize"
+template<class Archive, class T>
+inline void serialize(
+ Archive & ar, T & t, const BOOST_PFTO unsigned int file_version
+){
+ access::serialize(ar, t, static_cast<unsigned int>(file_version));
+}
+
+// save data required for construction
+template<class Archive, class T>
+inline void save_construct_data(
+ Archive & /*ar*/,
+ const T * /*t*/,
+ const BOOST_PFTO unsigned int /*file_version */
+){
+ // default is to save no data because default constructor
+ // requires no arguments.
+}
+
+// load data required for construction and invoke constructor in place
+template<class Archive, class T>
+inline void load_construct_data(
+ Archive & ar,
+ T * t,
+ const BOOST_PFTO unsigned int /*file_version*/
+){
+ // default just uses the default constructor. going
+ // through access permits usage of otherwise private default
+ // constructor
+ access::construct(ar, t);
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// layer 3 - move call into serialization namespace so that ADL will function
+// in the manner we desire.
+//
+// on compilers which don't implement ADL. only the current namespace
+// i.e. boost::serialization will be searched.
+//
+// on compilers which DO implement ADL
+// serialize overrides can be in any of the following
+//
+// 1) same namepace as Archive
+// 2) same namespace as T
+// 3) boost::serialization
+//
+// Due to Martin Ecker
+
+template<class Archive, class T>
+inline void serialize_adl(
+ Archive & ar,
+ T & t,
+ const unsigned int file_version
+){
+ // note usage of function overloading to delay final resolution
+ // until the point of instantiation. This works around the two-phase
+ // lookup "feature" which inhibits redefintion of a default function
+ // template implementation. Due to Robert Ramey
+ //
+ // Note that this trick generates problems for compiles which don't support
+ // PFTO, suppress it here. As far as we know, there are no compilers
+ // which fail to support PFTO while supporting two-phase lookup.
+ #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+ const version_type v(file_version);
+ serialize(ar, t, v);
+ #else
+ serialize(ar, t, file_version);
+ #endif
+}
+
+template<class Archive, class T>
+inline void save_construct_data_adl(
+ Archive & ar,
+ const T * t,
+ const unsigned int file_version
+){
+ // see above
+ #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+ const version_type v(file_version);
+ save_construct_data(ar, t, v);
+ #else
+ save_construct_data(ar, t, file_version);
+ #endif
+}
+
+template<class Archive, class T>
+inline void load_construct_data_adl(
+ Archive & ar,
+ T * t,
+ const unsigned int file_version
+){
+ // see above comment
+ #if ! defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
+ const version_type v(file_version);
+ load_construct_data(ar, t, v);
+ #else
+ load_construct_data(ar, t, file_version);
+ #endif
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_SERIALIZATION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/set.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/set.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,120 @@
+#ifndef BOOST_SERIALIZATION_SET_HPP
+#define BOOST_SERIALIZATION_SET_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
+// set.hpp: serialization for stl set templates
+
+// (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.
+
+#include <set>
+
+#include <boost/config.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void save(
+ Archive & ar,
+ const std::set<Key, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::save_collection<
+ Archive, std::set<Key, Compare, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void load(
+ Archive & ar,
+ std::set<Key, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::set<Key, Compare, Allocator>,
+ boost::serialization::stl::archive_input_set<
+ Archive, std::set<Key, Compare, Allocator>
+ >,
+ boost::serialization::stl::no_reserve_imp<std::set<
+ Key, Compare, Allocator>
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Key, class Compare, class Allocator >
+inline void serialize(
+ Archive & ar,
+ std::set<Key, Compare, Allocator> & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+// multiset
+template<class Archive, class Key, class Compare, class Allocator >
+inline void save(
+ Archive & ar,
+ const std::multiset<Key, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::save_collection<
+ Archive,
+ std::multiset<Key, Compare, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class Key, class Compare, class Allocator >
+inline void load(
+ Archive & ar,
+ std::multiset<Key, Compare, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::multiset<Key, Compare, Allocator>,
+ boost::serialization::stl::archive_input_multiset<
+ Archive, std::multiset<Key, Compare, Allocator>
+ >,
+ boost::serialization::stl::no_reserve_imp<
+ std::multiset<Key, Compare, Allocator>
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Key, class Compare, class Allocator >
+inline void serialize(
+ Archive & ar,
+ std::multiset<Key, Compare, Allocator> & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::set)
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::multiset)
+
+#endif // BOOST_SERIALIZATION_SET_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/shared_ptr.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/shared_ptr.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,159 @@
+#ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_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
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2004 Robert Ramey and Martin Ecker
+// 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.
+
+#include <map>
+#include <cstddef> // NULL
+
+#include <boost/config.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/detail/workaround.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/version.hpp>
+#include <boost/serialization/tracking.hpp>
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// shared_ptr serialization traits
+// version 1 to distinguish from boost 1.32 version. Note: we can only do this
+// for a template when the compiler supports partial template specialization
+
+#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+ namespace boost {
+ namespace serialization{
+ template<class T>
+ struct version< ::boost::shared_ptr<T> > {
+ typedef mpl::integral_c_tag tag;
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+ typedef BOOST_DEDUCED_TYPENAME mpl::int_<1> type;
+ #else
+ typedef mpl::int_<1> type;
+ #endif
+ #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
+ BOOST_STATIC_CONSTANT(unsigned int, value = 1);
+ #else
+ BOOST_STATIC_CONSTANT(unsigned int, value = type::value);
+ #endif
+ };
+ // don't track shared pointers
+ template<class T>
+ struct tracking_level< ::boost::shared_ptr<T> > {
+ typedef mpl::integral_c_tag tag;
+ #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
+ typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type;
+ #else
+ typedef mpl::int_< ::boost::serialization::track_never> type;
+ #endif
+ #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
+ BOOST_STATIC_CONSTANT(int, value = ::boost::serialization::track_never);
+ #else
+ BOOST_STATIC_CONSTANT(int, value = type::value);
+ #endif
+ };
+ }}
+ #define BOOST_SERIALIZATION_SHARED_PTR(T)
+#else
+ // define macro to let users of these compilers do this
+ #define BOOST_SERIALIZATION_SHARED_PTR(T) \
+ BOOST_CLASS_VERSION( \
+ ::boost::shared_ptr< T >, \
+ 1 \
+ ) \
+ BOOST_CLASS_TRACKING( \
+ ::boost::shared_ptr< T >, \
+ ::boost::serialization::track_never \
+ ) \
+ /**/
+#endif
+
+namespace boost {
+namespace serialization{
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// serialization for shared_ptr
+
+template<class Archive, class T>
+inline void save(
+ Archive & ar,
+ const boost::shared_ptr<T> &t,
+ const unsigned int /* file_version */
+){
+ // The most common cause of trapping here would be serializing
+ // something like shared_ptr<int>. This occurs because int
+ // is never tracked by default. Wrap int in a trackable type
+ BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+ const T * t_ptr = t.get();
+ ar << boost::serialization::make_nvp("px", t_ptr);
+}
+
+template<class Archive, class T>
+inline void load(
+ Archive & ar,
+ boost::shared_ptr<T> &t,
+ const unsigned int file_version
+){
+ // The most common cause of trapping here would be serializing
+ // something like shared_ptr<int>. This occurs because int
+ // is never tracked by default. Wrap int in a trackable type
+ BOOST_STATIC_ASSERT((tracking_level<T>::value != track_never));
+ T* r;
+ #ifdef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+ if(file_version < 1){
+ //ar.register_type(static_cast<
+ // boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+ //>(NULL));
+ ar.register_type(static_cast<
+ boost_132::detail::sp_counted_base_impl<T *, boost::archive::detail::null_deleter > *
+ >(NULL));
+ boost_132::shared_ptr<T> sp;
+ ar >> boost::serialization::make_nvp("px", sp.px);
+ ar >> boost::serialization::make_nvp("pn", sp.pn);
+ // got to keep the sps around so the sp.pns don't disappear
+ ar.append(sp);
+ r = sp.get();
+ }
+ else
+ #endif
+ {
+ ar >> boost::serialization::make_nvp("px", r);
+ }
+ ar.reset(t,r);
+}
+
+template<class Archive, class T>
+inline void serialize(
+ Archive & ar,
+ boost::shared_ptr<T> &t,
+ const unsigned int file_version
+){
+ // correct shared_ptr serialization depends upon object tracking
+ // being used.
+ BOOST_STATIC_ASSERT(
+ boost::serialization::tracking_level<T>::value
+ != boost::serialization::track_never
+ );
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/shared_ptr_132.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/shared_ptr_132.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,222 @@
+#ifndef BOOST_SERIALIZATION_SHARED_PTR_132_HPP
+#define BOOST_SERIALIZATION_SHARED_PTR_132_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
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (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.
+
+// note: totally unadvised hack to gain access to private variables
+// in shared_ptr and shared_count. Unfortunately its the only way to
+// do this without changing shared_ptr and shared_count
+// the best we can do is to detect a conflict here
+#include <boost/config.hpp>
+
+#include <list>
+#include <cstddef> // NULL
+
+#include <boost/serialization/assume_abstract.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/tracking.hpp>
+#include <boost/serialization/void_cast.hpp>
+
+// mark base class as an (uncreatable) base class
+#include <boost/serialization/detail/shared_ptr_132.hpp>
+
+/////////////////////////////////////////////////////////////
+// Maintain a couple of lists of loaded shared pointers of the old previous
+// version (1.32)
+
+namespace boost_132 {
+namespace serialization {
+namespace detail {
+
+struct null_deleter {
+ void operator()(void const *) const {}
+};
+
+} // namespace detail
+} // namespace serialization
+} // namespace boost_132
+
+/////////////////////////////////////////////////////////////
+// sp_counted_base_impl serialization
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class P, class D>
+inline void serialize(
+ Archive & /* ar */,
+ boost_132::detail::sp_counted_base_impl<P, D> & /* t */,
+ const unsigned int /*file_version*/
+){
+ // register the relationship between each derived class
+ // its polymorphic base
+ boost::serialization::void_cast_register<
+ boost_132::detail::sp_counted_base_impl<P, D>,
+ boost_132::detail::sp_counted_base
+ >(
+ static_cast<boost_132::detail::sp_counted_base_impl<P, D> *>(NULL),
+ static_cast<boost_132::detail::sp_counted_base *>(NULL)
+ );
+}
+
+template<class Archive, class P, class D>
+inline void save_construct_data(
+ Archive & ar,
+ const
+ boost_132::detail::sp_counted_base_impl<P, D> *t,
+ const BOOST_PFTO unsigned int /* file_version */
+){
+ // variables used for construction
+ ar << boost::serialization::make_nvp("ptr", t->ptr);
+}
+
+template<class Archive, class P, class D>
+inline void load_construct_data(
+ Archive & ar,
+ boost_132::detail::sp_counted_base_impl<P, D> * t,
+ const unsigned int /* file_version */
+){
+ P ptr_;
+ ar >> boost::serialization::make_nvp("ptr", ptr_);
+ // ::new(t)boost_132::detail::sp_counted_base_impl<P, D>(ptr_, D());
+ // placement
+ // note: the original ::new... above is replaced by the one here. This one
+ // creates all new objects with a null_deleter so that after the archive
+ // is finished loading and the shared_ptrs are destroyed - the underlying
+ // raw pointers are NOT deleted. This is necessary as they are used by the
+ // new system as well.
+ ::new(t)boost_132::detail::sp_counted_base_impl<
+ P,
+ boost_132::serialization::detail::null_deleter
+ >(
+ ptr_, boost_132::serialization::detail::null_deleter()
+ ); // placement new
+ // compensate for that fact that a new shared count always is
+ // initialized with one. the add_ref_copy below will increment it
+ // every time its serialized so without this adjustment
+ // the use and weak counts will be off by one.
+ t->use_count_ = 0;
+}
+
+} // serialization
+} // namespace boost
+
+/////////////////////////////////////////////////////////////
+// shared_count serialization
+
+namespace boost {
+namespace serialization {
+
+template<class Archive>
+inline void save(
+ Archive & ar,
+ const boost_132::detail::shared_count &t,
+ const unsigned int /* file_version */
+){
+ ar << boost::serialization::make_nvp("pi", t.pi_);
+}
+
+template<class Archive>
+inline void load(
+ Archive & ar,
+ boost_132::detail::shared_count &t,
+ const unsigned int /* file_version */
+){
+ ar >> boost::serialization::make_nvp("pi", t.pi_);
+ if(NULL != t.pi_)
+ t.pi_->add_ref_copy();
+}
+
+} // serialization
+} // namespace boost
+
+BOOST_SERIALIZATION_SPLIT_FREE(boost_132::detail::shared_count)
+
+/////////////////////////////////////////////////////////////
+// implement serialization for shared_ptr<T>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class T>
+inline void save(
+ Archive & ar,
+ const boost_132::shared_ptr<T> &t,
+ const unsigned int /* file_version */
+){
+ // only the raw pointer has to be saved
+ // the ref count is maintained automatically as shared pointers are loaded
+ ar.register_type(static_cast<
+ boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+ >(NULL));
+ ar << boost::serialization::make_nvp("px", t.px);
+ ar << boost::serialization::make_nvp("pn", t.pn);
+}
+
+template<class Archive, class T>
+inline void load(
+ Archive & ar,
+ boost_132::shared_ptr<T> &t,
+ const unsigned int /* file_version */
+){
+ // only the raw pointer has to be saved
+ // the ref count is maintained automatically as shared pointers are loaded
+ ar.register_type(static_cast<
+ boost_132::detail::sp_counted_base_impl<T *, boost::checked_deleter<T> > *
+ >(NULL));
+ ar >> boost::serialization::make_nvp("px", t.px);
+ ar >> boost::serialization::make_nvp("pn", t.pn);
+}
+
+template<class Archive, class T>
+inline void serialize(
+ Archive & ar,
+ boost_132::shared_ptr<T> &t,
+ const unsigned int file_version
+){
+ // correct shared_ptr serialization depends upon object tracking
+ // being used.
+ BOOST_STATIC_ASSERT(
+ boost::serialization::tracking_level<T>::value
+ != boost::serialization::track_never
+ );
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+// note: change below uses null_deleter
+// This macro is used to export GUIDS for shared pointers to allow
+// the serialization system to export them properly. David Tonge
+#define BOOST_SHARED_POINTER_EXPORT_GUID(T, K) \
+ typedef boost_132::detail::sp_counted_base_impl< \
+ T *, \
+ boost::checked_deleter< T > \
+ > __shared_ptr_ ## T; \
+ BOOST_CLASS_EXPORT_GUID(__shared_ptr_ ## T, "__shared_ptr_" K) \
+ BOOST_CLASS_EXPORT_GUID_1(T, K) \
+ /**/
+
+#define BOOST_SHARED_POINTER_EXPORT(T) \
+ BOOST_SHARED_POINTER_EXPORT_GUID( \
+ T, \
+ BOOST_PP_STRINGIZE(T) \
+ ) \
+ /**/
+
+#endif // BOOST_SERIALIZATION_SHARED_PTR_132_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/singleton.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/singleton.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,126 @@
+#ifndef BOOST_SERIALIZATION_SINGLETON_HPP
+#define BOOST_SERIALIZATION_SINGLETON_HPP
+
+/////////1/////////2///////// 3/////////4/////////5/////////6/////////7/////////8
+// singleton.hpp
+//
+// Copyright David Abrahams 2006. Original version
+//
+// Copyright Robert Ramey 2007. Changes made to permit
+// application throughout the serialization library.
+//
+// Distributed under 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)
+//
+// The intention here is to define a template which will convert
+// any class into a singleton with the following features:
+//
+// a) initialized before first use.
+// b) thread-safe for const access to the class
+// c) non-locking
+//
+// In order to do this,
+// a) Initialize dynamically when used.
+// b) Require that all singletons be initialized before main
+// is called or any entry point into the shared library is invoked.
+// This guarentees no race condition for initialization.
+// In debug mode, we assert that no non-const functions are called
+// after main is invoked.
+//
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <cassert>
+#include <boost/noncopyable.hpp>
+#include <boost/serialization/force_include.hpp>
+
+namespace boost {
+namespace serialization {
+
+//////////////////////////////////////////////////////////////////////
+// Provides a dynamically-initialized (singleton) instance of T in a
+// way that avoids LNK1179 on vc6. See http://tinyurl.com/ljdp8 or
+// http://lists.boost.org/Archives/boost/2006/05/105286.php for
+// details.
+//
+
+// singletons created by this code are guarenteed to be unique
+// within the executable or shared library which creates them.
+// This is sufficient and in fact ideal for the serialization library.
+// The singleton is created when the module is loaded and destroyed
+// when the module is unloaded.
+
+// This base class has two functions.
+
+// First it provides a module handle for each singleton indicating
+// the executable or shared library in which it was created. This
+// turns out to be necessary and sufficient to implement the tables
+// used by serialization library.
+
+// Second, it provides a mechanism to detect when a non-const function
+// is called after initialization.
+
+// make a singleton to lock/unlock all singletons for alteration.
+// The intent is that all singletons created/used by this code
+// are to be initialized before main is called. A test program
+// can lock all the singletons when main is entereed. This any
+// attempt to retieve a mutable instances while locked will
+// generate a assertion if compiled for debug.
+
+class singleton_module : public boost::noncopyable
+{
+private:
+ static bool & get_lock(){
+ static bool lock = false;
+ return lock;
+ }
+public:
+// static const void * get_module_handle(){
+// return static_cast<const void *>(get_module_handle);
+// }
+ static void lock(){
+ get_lock() = true;
+ }
+ static void unlock(){
+ get_lock() = false;
+ }
+ static bool is_locked() {
+ return get_lock();
+ }
+};
+
+template <class T>
+class singleton : public singleton_module
+{
+private:
+ BOOST_DLLEXPORT static T & instance;
+ // include this to provoke instantiation at pre-execution time
+ static void use(T const &) {}
+ BOOST_DLLEXPORT static T & get_instance() {
+ static T t;
+ // refer to instance, causing it to be instantiated (and
+ // initialized at startup on working compilers)
+ use(instance);
+ return t;
+ }
+public:
+ BOOST_DLLEXPORT static T & get_mutable_instance(){
+ assert(! is_locked());
+ return get_instance();
+ }
+ BOOST_DLLEXPORT static const T & get_const_instance(){
+ return get_instance();
+ }
+};
+
+template<class T>
+BOOST_DLLEXPORT T & singleton<T>::instance = singleton<T>::get_instance();
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_SINGLETON_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/slist.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/slist.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,101 @@
+#ifndef BOOST_SERIALIZATION_SLIST_HPP
+#define BOOST_SERIALIZATION_SLIST_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
+// slist.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.
+
+#include <cstddef> // size_t
+#include <boost/config.hpp> // msvc 6.0 needs this for warning suppression
+#if defined(BOOST_NO_STDC_NAMESPACE)
+namespace std{
+ using ::size_t;
+} // namespace std
+#endif
+
+#ifdef BOOST_HAS_SLIST
+#include BOOST_SLIST_HEADER
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/nvp.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive, class U, class Allocator>
+inline void save(
+ Archive & ar,
+ const BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::save_collection<
+ Archive,
+ BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+ const unsigned int file_version
+){
+ // retrieve number of elements
+ t.clear();
+ // retrieve number of elements
+ collection_size_type count;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ if(std::size_t(0) == count)
+ return;
+ unsigned int v;
+ if(3 < ar.get_library_version()){
+ ar >> make_nvp("item_version", v);
+ }
+ boost::serialization::detail::stack_construct<Archive, U> u(ar, v);
+ ar >> boost::serialization::make_nvp("item", u.reference());
+ t.push_front(u.reference());
+ BOOST_DEDUCED_TYPENAME BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator>::iterator last;
+ last = t.begin();
+ std::size_t c = count;
+ while(--c > 0){
+ boost::serialization::detail::stack_construct<Archive, U>
+ u(ar, file_version);
+ ar >> boost::serialization::make_nvp("item", u.reference());
+ last = t.insert_after(last, u.reference());
+ ar.reset_object_address(& (*last), & u.reference());
+ }
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+ Archive & ar,
+ BOOST_STD_EXTENSION_NAMESPACE::slist<U, Allocator> &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(BOOST_STD_EXTENSION_NAMESPACE::slist)
+
+#endif // BOOST_HAS_SLIST
+#endif // BOOST_SERIALIZATION_SLIST_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/split_free.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/split_free.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,93 @@
+#ifndef BOOST_SERIALIZATION_SPLIT_FREE_HPP
+#define BOOST_SERIALIZATION_SPLIT_FREE_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
+// split_free.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/serialization/serialization.hpp>
+
+namespace boost {
+namespace archive {
+ namespace detail {
+ template<class Archive> class interface_oarchive;
+ template<class Archive> class interface_iarchive;
+ } // namespace detail
+} // namespace archive
+
+namespace serialization {
+
+//namespace detail {
+template<class Archive, class T>
+struct free_saver {
+ static void invoke(
+ Archive & ar,
+ const T & t,
+ const unsigned int file_version
+ ){
+ // use function overload (version_type) to workaround
+ // two-phase lookup issue
+ const version_type v(file_version);
+ save(ar, t, v);
+ }
+};
+template<class Archive, class T>
+struct free_loader {
+ static void invoke(
+ Archive & ar,
+ T & t,
+ const unsigned int file_version
+ ){
+ // use function overload (version_type) to workaround
+ // two-phase lookup issue
+ const version_type v(file_version);
+ load(ar, t, v);
+ }
+};
+//} // namespace detail
+
+template<class Archive, class T>
+inline void split_free(
+ Archive & ar,
+ T & t,
+ const unsigned int file_version
+){
+ typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ BOOST_DEDUCED_TYPENAME Archive::is_saving,
+ mpl::identity</* detail:: */ free_saver<Archive, T> >,
+ mpl::identity</* detail:: */ free_loader<Archive, T> >
+ >::type typex;
+ typex::invoke(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#define BOOST_SERIALIZATION_SPLIT_FREE(T) \
+namespace boost { namespace serialization { \
+template<class Archive> \
+inline void serialize( \
+ Archive & ar, \
+ T & t, \
+ const unsigned int file_version \
+){ \
+ split_free(ar, t, file_version); \
+} \
+}}
+/**/
+
+#endif // BOOST_SERIALIZATION_SPLIT_FREE_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/split_member.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/split_member.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,86 @@
+#ifndef BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
+#define BOOST_SERIALIZATION_SPLIT_MEMBER_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
+// split_member.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+
+#include <boost/serialization/access.hpp>
+
+namespace boost {
+namespace archive {
+ namespace detail {
+ template<class Archive> class interface_oarchive;
+ template<class Archive> class interface_iarchive;
+ } // namespace detail
+} // namespace archive
+
+namespace serialization {
+namespace detail {
+
+ template<class Archive, class T>
+ struct member_saver {
+ static void invoke(
+ Archive & ar,
+ const T & t,
+ const unsigned int file_version
+ ){
+ access::member_save(ar, t, file_version);
+ }
+ };
+
+ template<class Archive, class T>
+ struct member_loader {
+ static void invoke(
+ Archive & ar,
+ T & t,
+ const unsigned int file_version
+ ){
+ access::member_load(ar, t, file_version);
+ }
+ };
+
+} // detail
+
+template<class Archive, class T>
+inline void split_member(
+ Archive & ar, T & t, const unsigned int file_version
+){
+ typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ BOOST_DEDUCED_TYPENAME Archive::is_saving,
+ mpl::identity<detail::member_saver<Archive, T> >,
+ mpl::identity<detail::member_loader<Archive, T> >
+ >::type typex;
+ typex::invoke(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+// split member function serialize funcition into save/load
+#define BOOST_SERIALIZATION_SPLIT_MEMBER() \
+template<class Archive> \
+void serialize( \
+ Archive &ar, \
+ const unsigned int file_version \
+){ \
+ boost::serialization::split_member(ar, *this, file_version); \
+} \
+/**/
+
+#endif // BOOST_SERIALIZATION_SPLIT_MEMBER_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/string.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/string.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,91 @@
+#ifndef BOOST_SERIALIZATION_STRING_HPP
+#define BOOST_SERIALIZATION_STRING_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
+// serialization/string.hpp:
+// serialization for stl string templates
+
+// (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.
+
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/serialization/level.hpp>
+
+BOOST_CLASS_IMPLEMENTATION(std::string, boost::serialization::primitive_type)
+#ifndef BOOST_NO_STD_WSTRING
+BOOST_CLASS_IMPLEMENTATION(std::wstring, boost::serialization::primitive_type)
+#endif
+
+// left over from a previous incarnation - strings are now always primitive types
+#if 0
+#include <string>
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+
+namespace boost {
+namespace serialization {
+
+// basic_string - general case
+template<class Archive, class U, class Allocator>
+inline void save(
+ Archive & ar,
+ const std::basic_string<U, Allocator> &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::save_collection<
+ Archive, std::basic_string<U, Allocator>
+ >(ar, t);
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+ Archive & ar,
+ std::basic_string<U, Allocator> &t,
+ const unsigned int file_version
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::basic_string<U, Allocator>,
+ boost::serialization::stl::archive_input_seq<
+ Archive,
+ std::basic_string<U, Allocator>
+ >,
+ boost::serialization::stl::reserve_imp<
+ std::basic_string<U, Allocator>
+ >
+ >(ar, t);
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+ Archive & ar,
+ std::basic_string<U, Allocator> & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
+
+#endif
+
+#endif // BOOST_SERIALIZATION_STRING_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/tracking.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/tracking.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,112 @@
+#ifndef BOOST_SERIALIZATION_TRACKING_HPP
+#define BOOST_SERIALIZATION_TRACKING_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
+// tracking.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.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/serialization/level.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct basic_traits;
+
+// default tracking level
+template<class T>
+struct tracking_level {
+ template<class U>
+ struct traits_class_tracking {
+ typedef BOOST_DEDUCED_TYPENAME U::tracking type;
+ };
+ typedef mpl::integral_c_tag tag;
+ // note: at least one compiler complained w/o the full qualification
+ // on basic traits below
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_base_and_derived<boost::serialization::basic_traits, T>,
+ traits_class_tracking<T>,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_pointer<T>,
+ // pointers are not tracked by default
+ mpl::int_<track_never>,
+ //else
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ // for primitives
+ BOOST_DEDUCED_TYPENAME mpl::equal_to<
+ implementation_level<T>,
+ mpl::int_<primitive_type>
+ >,
+ // is never
+ mpl::int_<track_never>,
+ // otherwise its selective
+ mpl::int_<track_selectively>
+ > > >::type type;
+ BOOST_STATIC_CONSTANT(int, value = tracking_level::type::value);
+};
+
+
+template<class T, enum tracking_type L>
+inline bool operator>=(tracking_level<T> t, enum tracking_type l)
+{
+ return t.value >= (int)l;
+}
+
+} // namespace serialization
+} // namespace boost
+
+
+// The STATIC_ASSERT is prevents one from setting tracking for a primitive type.
+// This almost HAS to be an error. Doing this will effect serialization of all
+// char's in your program which is almost certainly what you don't want to do.
+// If you want to track all instances of a given primitive type, You'll have to
+// wrap it in your own type so its not a primitive anymore. Then it will compile
+// without problem.
+#define BOOST_CLASS_TRACKING(T, E) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct tracking_level< T > \
+{ \
+ typedef mpl::integral_c_tag tag; \
+ typedef mpl::int_< E> type; \
+ BOOST_STATIC_CONSTANT( \
+ int, \
+ value = tracking_level::type::value \
+ ); \
+ /* tracking for a class */ \
+ BOOST_STATIC_ASSERT(( \
+ mpl::greater< \
+ /* that is a prmitive */ \
+ implementation_level< T >, \
+ mpl::int_<primitive_type> \
+ >::value \
+ )); \
+}; \
+}}
+
+#endif // BOOST_SERIALIZATION_TRACKING_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/tracking_enum.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/tracking_enum.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,41 @@
+#ifndef BOOST_SERIALIZATION_TRACKING_ENUM_HPP
+#define BOOST_SERIALIZATION_TRACKING_ENUM_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
+// tracking_enum.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.
+
+namespace boost {
+namespace serialization {
+
+// addresses of serialized objects may be tracked to avoid saving/loading
+// redundant copies. This header defines a class trait that can be used
+// to specify when objects should be tracked
+
+// names for each tracking level
+enum tracking_type
+{
+ // never track this type
+ track_never = 0,
+ // track objects of this type if the object is serialized through a
+ // pointer.
+ track_selectively = 1,
+ // always track this type
+ track_always = 2
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_TRACKING_ENUM_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/traits.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/traits.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,65 @@
+#ifndef BOOST_SERIALIZATION_TRAITS_HPP
+#define BOOST_SERIALIZATION_TRAITS_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
+// traits.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 header is used to apply serialization traits to templates. The
+// standard system can't be used for platforms which don't support
+// Partial Templlate Specialization.
+
+// The motivation for this is the Name-Value Pair (NVP) template.
+// it has to work the same on all platforms in order for archives
+// to be portable accross platforms.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/serialization/level_enum.hpp>
+#include <boost/serialization/tracking_enum.hpp>
+
+namespace boost {
+namespace serialization {
+
+// common base class used to detect appended traits class
+struct basic_traits {};
+
+template <class T>
+struct extended_type_info_impl;
+
+template<
+ class T,
+ int Level,
+ int Tracking,
+ unsigned int Version = 0,
+ class ETII = extended_type_info_impl< T >,
+ class Wrapper = mpl::false_
+>
+struct traits : public basic_traits {
+ BOOST_STATIC_ASSERT(Version == 0 || Level >= object_class_info);
+ BOOST_STATIC_ASSERT(Tracking == track_never || Level >= object_serializable);
+ typedef BOOST_DEDUCED_TYPENAME mpl::int_<Level> level;
+ typedef BOOST_DEDUCED_TYPENAME mpl::int_<Tracking> tracking;
+ typedef BOOST_DEDUCED_TYPENAME mpl::int_<Version> version;
+ typedef ETII type_info_implementation;
+ typedef Wrapper is_wrapper;
+};
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_TRAITS_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/type_info_implementation.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/type_info_implementation.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,86 @@
+#ifndef BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
+#define BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_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
+// type_info_implementation.hpp: interface for portable version of type_info
+
+// (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.
+
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/static_assert.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/serialization/traits.hpp>
+
+namespace boost {
+namespace serialization {
+
+// note that T and const T are folded into const T so that
+// there is only one table entry per type
+template<class T>
+struct type_info_implementation {
+ template<class U>
+ struct traits_class_typeinfo_implementation {
+ typedef BOOST_DEDUCED_TYPENAME U::type_info_implementation::type type;
+ };
+ // note: at least one compiler complained w/o the full qualification
+ // on basic traits below
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_base_and_derived<boost::serialization::basic_traits, T>,
+ traits_class_typeinfo_implementation<T>,
+ //else
+ mpl::identity<
+ BOOST_DEDUCED_TYPENAME extended_type_info_impl<T>::type
+ >
+ >::type type;
+};
+
+} // namespace serialization
+} // namespace boost
+
+// define a macro to assign a particular derivation of extended_type_info
+// to a specified a class.
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x560))
+#define BOOST_CLASS_TYPE_INFO(T, ETI) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct type_info_implementation< T > { \
+ typedef const ETI type; \
+}; \
+} \
+} \
+/**/
+#else
+#define BOOST_CLASS_TYPE_INFO(T, ETI) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct type_info_implementation< T > { \
+ typedef ETI type; \
+}; \
+template<> \
+struct type_info_implementation< const T > { \
+ typedef ETI type; \
+}; \
+} \
+} \
+/**/
+#endif
+
+#endif /// BOOST_SERIALIZATION_TYPE_INFO_IMPLEMENTATION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/utility.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/utility.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,56 @@
+#ifndef BOOST_SERIALIZATION_UTILITY_HPP
+#define BOOST_SERIALIZATION_UTILITY_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
+// serialization/utility.hpp:
+// serialization for stl utility templates
+
+// (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.
+
+#include <utility>
+#include <boost/config.hpp>
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/serialization/nvp.hpp>
+#include <boost/serialization/is_bitwise_serializable.hpp>
+#include <boost/mpl/and.hpp>
+
+namespace boost {
+namespace serialization {
+
+// pair
+template<class Archive, class F, class S>
+inline void serialize(
+ Archive & ar,
+ std::pair<F, S> & p,
+ const unsigned int /* file_version */
+){
+ // note: we remove any const-ness on the first argument. The reason is that
+ // for stl maps, the type saved is pair<const key, T). We remove
+ // the const-ness in order to be able to load it.
+ typedef BOOST_DEDUCED_TYPENAME boost::remove_const<F>::type typef;
+ ar & boost::serialization::make_nvp("first", const_cast<typef &>(p.first));
+ ar & boost::serialization::make_nvp("second", p.second);
+}
+
+/// specialization of is_bitwise_serializable for pairs
+template <class T, class U>
+struct is_bitwise_serializable<std::pair<T,U> >
+ : public mpl::and_<is_bitwise_serializable<T>,is_bitwise_serializable<U> >
+{
+};
+
+} // serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_UTILITY_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/valarray.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/valarray.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,74 @@
+#ifndef BOOST_SERIALIZATION_VALARAY_HPP
+#define BOOST_SERIALIZATION_VALARAY_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
+// valarray.hpp: serialization for stl vector templates
+
+// (C) Copyright 2005 Matthias Troyer .
+// 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.
+
+#include <valarray>
+#include <boost/config.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/collection_size_type.hpp>
+#include <boost/serialization/detail/get_data.hpp>
+
+// function specializations must be defined in the appropriate
+// namespace - boost::serialization
+#if defined(__SGI_STL_PORT) || defined(_STLPORT_VERSION)
+#define STD _STLP_STD
+#else
+#define STD std
+#endif
+
+namespace boost { namespace serialization {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// valarray<T>
+
+template<class Archive, class U>
+void save( Archive & ar, const STD::valarray<U> &t, const unsigned int /*file_version*/ )
+{
+ const collection_size_type count(t.size());
+ ar << BOOST_SERIALIZATION_NVP(count);
+ if (t.size())
+ ar << make_array(detail::get_data(t), t.size());
+}
+
+
+template<class Archive, class U>
+void load( Archive & ar, STD::valarray<U> &t, const unsigned int /*file_version*/ )
+{
+ collection_size_type count;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ t.resize(count);
+ if (t.size())
+ ar >> make_array(detail::get_data(t), t.size());
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U>
+inline void serialize( Archive & ar, STD::valarray<U> & t, const unsigned int file_version)
+{
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} } // end namespace boost::serialization
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(STD::valarray)
+#undef STD
+
+#endif // BOOST_SERIALIZATION_VALARAY_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/variant.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/variant.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,161 @@
+#ifndef BOOST_SERIALIZATION_VARIANT_HPP
+#define BOOST_SERIALIZATION_VARIANT_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#if defined(_MSC_VER) && (_MSC_VER <= 1020)
+# pragma warning (disable : 4786) // too long name, harmless warning
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// variant.hpp - non-intrusive serialization of variant types
+//
+// copyright (c) 2005
+// troy d. straszheim <troy_at_[hidden]>
+// http://www.resophonic.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.
+//
+// thanks to Robert Ramey, Peter Dimov, and Richard Crossley.
+//
+
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/empty.hpp>
+
+#include <boost/throw_exception.hpp>
+
+#include <boost/variant.hpp>
+
+#include <boost/archive/archive_exception.hpp>
+
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/serialization.hpp>
+
+namespace boost {
+namespace serialization {
+
+template<class Archive>
+struct variant_save_visitor : boost::static_visitor<> {
+ variant_save_visitor(Archive& ar) :
+ m_ar(ar)
+ {}
+ template<class T>
+ void operator()(T const & value) const
+ {
+ m_ar << BOOST_SERIALIZATION_NVP(value);
+ }
+private:
+ Archive & m_ar;
+};
+
+template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+void save(
+ Archive & ar,
+ boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const & v,
+ unsigned int /*version*/
+){
+ int which = v.which();
+ ar << BOOST_SERIALIZATION_NVP(which);
+ typedef BOOST_DEDUCED_TYPENAME boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
+ variant_save_visitor<Archive> visitor(ar);
+ v.apply_visitor(visitor);
+}
+
+template<class S>
+struct variant_impl {
+
+ struct load_null {
+ template<class Archive, class V>
+ static void invoke(
+ Archive & /*ar*/,
+ int /*which*/,
+ V & /*v*/,
+ unsigned int /*version*/
+ ){}
+ };
+
+ struct load_impl {
+ template<class Archive, class V>
+ static void invoke(
+ Archive & ar,
+ int which,
+ V & v,
+ unsigned int version
+ ){
+ if(which == 0){
+ // note: A non-intrusive implementation (such as this one)
+ // necessary has to copy the value. This wouldn't be necessary
+ // with an implementation that de-serialized to the address of the
+ // aligned storage included in the variant.
+ typedef BOOST_DEDUCED_TYPENAME mpl::front<S>::type head_type;
+ head_type value;
+ ar >> BOOST_SERIALIZATION_NVP(value);
+ v = value;
+ ar.reset_object_address(& boost::get<head_type>(v), & value);
+ return;
+ }
+ typedef BOOST_DEDUCED_TYPENAME mpl::pop_front<S>::type type;
+ variant_impl<type>::load(ar, which - 1, v, version);
+ }
+ };
+
+ template<class Archive, class V>
+ static void load(
+ Archive & ar,
+ int which,
+ V & v,
+ unsigned int version
+ ){
+ typedef BOOST_DEDUCED_TYPENAME mpl::eval_if<mpl::empty<S>,
+ mpl::identity<load_null>,
+ mpl::identity<load_impl>
+ >::type typex;
+ typex::invoke(ar, which, v, version);
+ }
+
+};
+
+template<class Archive, BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+void load(
+ Archive & ar,
+ boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& v,
+ unsigned int version
+){
+ int which;
+ typedef BOOST_DEDUCED_TYPENAME boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types types;
+ ar >> BOOST_SERIALIZATION_NVP(which);
+ if(which >= mpl::size<types>::value)
+ // this might happen if a type was removed from the list of variant types
+ boost::throw_exception(
+ boost::archive::archive_exception(
+ boost::archive::archive_exception::unsupported_version
+ )
+ );
+ variant_impl<types>::load(ar, which, v, version);
+}
+
+template<class Archive,BOOST_VARIANT_ENUM_PARAMS(/* typename */ class T)>
+inline void serialize(
+ Archive & ar,
+ boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> & v,
+ unsigned int file_version
+){
+ split_free(ar,v,file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif //BOOST_SERIALIZATION_VARIANT_HPP
+
Added: branches/CMake/release/libs/serialization/include/boost/serialization/vector.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/vector.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,193 @@
+#ifndef BOOST_SERIALIZATION_VECTOR_HPP
+#define BOOST_SERIALIZATION_VECTOR_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
+// vector.hpp: serialization for stl vector templates
+
+// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com .
+// fast array serialization (C) Copyright 2005 Matthias Troyer
+// 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.
+
+#include <vector>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/serialization/collections_save_imp.hpp>
+#include <boost/serialization/collections_load_imp.hpp>
+#include <boost/serialization/split_free.hpp>
+#include <boost/serialization/array.hpp>
+#include <boost/serialization/detail/get_data.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost {
+namespace serialization {
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector<T>
+
+// the default versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+ Archive & ar,
+ const std::vector<U, Allocator> &t,
+ const unsigned int /* file_version */,
+ mpl::false_
+){
+ boost::serialization::stl::save_collection<Archive, STD::vector<U, Allocator> >(
+ ar, t
+ );
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+ Archive & ar,
+ std::vector<U, Allocator> &t,
+ const unsigned int /* file_version */,
+ mpl::false_
+){
+ boost::serialization::stl::load_collection<
+ Archive,
+ std::vector<U, Allocator>,
+ boost::serialization::stl::archive_input_seq<
+ Archive, STD::vector<U, Allocator>
+ >,
+ boost::serialization::stl::reserve_imp<STD::vector<U, Allocator> >
+ >(ar, t);
+}
+
+// the optimized versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+ Archive & ar,
+ const std::vector<U, Allocator> &t,
+ const unsigned int /* file_version */,
+ mpl::true_
+){
+ const collection_size_type count(t.size());
+ ar << BOOST_SERIALIZATION_NVP(count);
+ if(3 < ar.get_library_version()) {
+ const unsigned int item_version = version<U>::value;
+ ar << BOOST_SERIALIZATION_NVP(item_version);
+ }
+ if (!t.empty())
+ ar << make_array(detail::get_data(t),t.size());
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+ Archive & ar,
+ std::vector<U, Allocator> &t,
+ const unsigned int /* file_version */,
+ mpl::true_
+){
+ collection_size_type count(t.size());
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ t.resize(count);
+ unsigned int item_version=0;
+ if(3 < ar.get_library_version())
+ ar >> BOOST_SERIALIZATION_NVP(item_version);
+ if (!t.empty())
+ ar >> make_array(detail::get_data(t),t.size());
+ }
+
+// dispatch to either default or optimized versions
+
+template<class Archive, class U, class Allocator>
+inline void save(
+ Archive & ar,
+ const std::vector<U, Allocator> &t,
+ const unsigned int file_version
+){
+ save(ar,t,file_version, typename use_array_optimization<Archive>::template apply<U>::type());
+}
+
+template<class Archive, class U, class Allocator>
+inline void load(
+ Archive & ar,
+ std::vector<U, Allocator> &t,
+ const unsigned int file_version
+){
+ load(ar,t,file_version, typename use_array_optimization<Archive>::template apply<U>::type());
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class U, class Allocator>
+inline void serialize(
+ Archive & ar,
+ std::vector<U, Allocator> & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+#if ! BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// vector<bool>
+template<class Archive, class Allocator>
+inline void save(
+ Archive & ar,
+ const std::vector<bool, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ // record number of elements
+ collection_size_type count (t.size());
+ ar << BOOST_SERIALIZATION_NVP(count);
+ std::vector<bool>::const_iterator it = t.begin();
+ while(count-- > 0){
+ bool tb = *it++;
+ ar << boost::serialization::make_nvp("item", tb);
+ }
+}
+
+template<class Archive, class Allocator>
+inline void load(
+ Archive & ar,
+ std::vector<bool, Allocator> &t,
+ const unsigned int /* file_version */
+){
+ // retrieve number of elements
+ collection_size_type count;
+ ar >> BOOST_SERIALIZATION_NVP(count);
+ t.clear();
+ while(count-- > 0){
+ bool i;
+ ar >> boost::serialization::make_nvp("item", i);
+ t.push_back(i);
+ }
+}
+
+// split non-intrusive serialization function member into separate
+// non intrusive save/load member functions
+template<class Archive, class Allocator>
+inline void serialize(
+ Archive & ar,
+ std::vector<bool, Allocator> & t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+#endif // BOOST_WORKAROUND
+
+} // serialization
+} // namespace boost
+
+#include <boost/serialization/collection_traits.hpp>
+
+BOOST_SERIALIZATION_COLLECTION_TRAITS(std::vector)
+
+#endif // BOOST_SERIALIZATION_VECTOR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/version.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/version.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,87 @@
+#ifndef BOOST_SERIALIZATION_VERSION_HPP
+#define BOOST_SERIALIZATION_VERSION_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
+// version.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.
+
+#include <boost/config.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/integral_c_tag.hpp>
+
+#include <boost/type_traits/is_base_and_derived.hpp>
+//#include <boost/serialization/traits.hpp>
+
+namespace boost {
+namespace serialization {
+
+struct basic_traits;
+
+// default version number is 0. Override with higher version
+// when class definition changes.
+template<class T>
+struct version
+{
+ template<class U>
+ struct traits_class_version {
+ typedef BOOST_DEDUCED_TYPENAME U::version type;
+ };
+
+ typedef mpl::integral_c_tag tag;
+ // note: at least one compiler complained w/o the full qualification
+ // on basic traits below
+ typedef
+ BOOST_DEDUCED_TYPENAME mpl::eval_if<
+ is_base_and_derived<boost::serialization::basic_traits,T>,
+ traits_class_version<T>,
+ mpl::int_<0>
+ >::type type;
+ BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);
+};
+
+} // namespace serialization
+} // namespace boost
+
+// specify the current version number for the class
+#define BOOST_CLASS_VERSION(T, N) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct version<T > \
+{ \
+ typedef mpl::int_<N> type; \
+ typedef mpl::integral_c_tag tag; \
+ BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value); \
+ /* require that class info saved when versioning is used */ \
+ /* \
+ BOOST_STATIC_ASSERT(( \
+ mpl::or_< \
+ mpl::equal_to< \
+ mpl::int_<0>, \
+ mpl::int_<N> \
+ >, \
+ mpl::equal_to< \
+ implementation_level<T>, \
+ mpl::int_<object_class_info> \
+ > \
+ >::value \
+ )); \
+ */ \
+}; \
+} \
+}
+
+#endif // BOOST_SERIALIZATION_VERSION_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/void_cast.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/void_cast.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,194 @@
+#ifndef BOOST_SERIALIZATION_VOID_CAST_HPP
+#define BOOST_SERIALIZATION_VOID_CAST_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
+// void_cast.hpp: interface for run-time casting of void pointers.
+
+// (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)
+// gennadiy.rozental_at_[hidden]
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <boost/smart_cast.hpp>
+#include <boost/serialization/singleton.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/serialization/type_info_implementation.hpp>
+#include <boost/serialization/config.hpp>
+#include <boost/serialization/force_include.hpp>
+#include <boost/config/abi_prefix.hpp> // must be the last header
+
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable : 4251 4231 4660 4275)
+#endif
+
+namespace boost {
+namespace serialization {
+
+BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) class extended_type_info;
+
+// Given a void *, assume that it really points to an instance of one type
+// and alter it so that it would point to an instance of a related type.
+// Return the altered pointer. If there exists no sequence of casts that
+// can transform from_type to to_type, return a NULL.
+
+BOOST_SERIALIZATION_DECL(void const *)
+void_upcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void const * const t
+);
+
+inline void *
+void_upcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void * const t
+){
+ return const_cast<void*>(void_upcast(
+ derived,
+ base,
+ const_cast<void const *>(t)
+ ));
+}
+
+BOOST_SERIALIZATION_DECL(void const *)
+void_downcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void const * const t
+);
+
+inline void *
+void_downcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void * const t
+){
+ return const_cast<void*>(void_downcast(
+ derived,
+ base,
+ const_cast<void const *>(t)
+ ));
+}
+
+namespace void_cast_detail {
+
+class BOOST_SERIALIZATION_DECL(BOOST_PP_EMPTY()) void_caster
+{
+ friend struct void_caster_compare ;
+ friend
+ BOOST_SERIALIZATION_DECL(void const *)
+ boost::serialization::void_upcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void const * const
+ );
+ friend
+ BOOST_SERIALIZATION_DECL(void const *)
+ boost::serialization::void_downcast(
+ extended_type_info const & derived,
+ extended_type_info const & base,
+ void const * const
+ );
+ // Data members
+ const extended_type_info & m_derived;
+ const extended_type_info & m_base;
+ // each derived class must re-implement these;
+ virtual void const * upcast(void const * const t) const = 0;
+ virtual void const * downcast(void const * const t) const = 0;
+ // cw 8.3 requires this!!
+ void_caster& operator=(void_caster const &);
+protected:
+ void
+ static_register() const;
+ void
+ static_unregister() const;
+public:
+ // Constructor
+ void_caster(
+ extended_type_info const & derived,
+ extended_type_info const & base
+ );
+ virtual ~void_caster(){};
+ bool operator==(const void_caster & rhs) const;
+};
+
+template <class Derived, class Base>
+class void_caster_primitive :
+ public void_caster
+{
+ virtual void const * downcast(void const * const t) const {
+ const Derived * d = boost::smart_cast<const Derived *, const Base *>(
+ static_cast<const Base *>(t)
+ );
+ return d;
+ }
+ virtual void const * upcast(void const * const t) const {
+ const Base * b = boost::smart_cast<const Base *, const Derived *>(
+ static_cast<const Derived *>(t)
+ );
+ return b;
+ }
+public:
+ BOOST_DLLEXPORT void_caster_primitive() BOOST_USED;
+ ~void_caster_primitive();
+};
+
+template <class Derived, class Base>
+BOOST_DLLEXPORT void_caster_primitive<Derived, Base>::void_caster_primitive() :
+ void_caster(
+ type_info_implementation<Derived>::type::get_const_instance(),
+ type_info_implementation<Base>::type::get_const_instance()
+ )
+{
+ static_register();
+}
+
+template <class Derived, class Base>
+void_caster_primitive<Derived, Base>::~void_caster_primitive(){
+ static_unregister();
+}
+
+} // void_cast_detail
+
+// Register a base/derived pair. This indicates that it is possible
+// to upcast a void pointer from Derived to Base and downcast a
+// void pointer from Base to Derived. Note bogus arguments to workaround
+// bug in msvc 6.0
+template<class Derived, class Base>
+BOOST_DLLEXPORT
+inline const void_cast_detail::void_caster & void_cast_register(
+ const Derived * dnull,
+ const Base * bnull
+) BOOST_USED;
+
+template<class Derived, class Base>
+BOOST_DLLEXPORT
+inline const void_cast_detail::void_caster & void_cast_register(
+ Derived const * /* dnull = NULL */,
+ Base const * /* bnull = NULL */
+){
+ return singleton<void_cast_detail::void_caster_primitive<
+ Derived, Base
+ > >::get_const_instance();
+}
+
+} // namespace serialization
+} // namespace boost
+
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
+#include <boost/config/abi_suffix.hpp> // pops abi_suffix.hpp pragmas
+
+#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/void_cast_fwd.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/void_cast_fwd.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,37 @@
+#ifndef BOOST_SERIALIZATION_VOID_CAST_FWD_HPP
+#define BOOST_SERIALIZATION_VOID_CAST_FWD_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
+// void_cast_fwd.hpp: interface for run-time casting of void pointers.
+
+// (C) Copyright 2005 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)
+// gennadiy.rozental_at_[hidden]
+
+// See http://www.boost.org for updates, documentation, and revision history.
+
+#include <cstddef> // NULL
+#include <boost/serialization/force_include.hpp>
+
+namespace boost {
+namespace serialization {
+namespace void_cast_detail{
+class void_caster;
+} // namespace void_cast_detail
+template<class Derived, class Base>
+BOOST_DLLEXPORT
+inline const void_cast_detail::void_caster & void_cast_register(
+ const Derived * dnull = NULL,
+ const Base * bnull = NULL
+) BOOST_USED;
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_VOID_CAST_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/weak_ptr.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/weak_ptr.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,58 @@
+#ifndef BOOST_SERIALIZATION_WEAK_PTR_HPP
+#define BOOST_SERIALIZATION_WEAK_PTR_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
+// shared_ptr.hpp: serialization for boost shared pointer
+
+// (C) Copyright 2004 Robert Ramey and Martin Ecker
+// 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.
+
+#include <boost/weak_ptr.hpp>
+#include <boost/serialization/shared_ptr.hpp>
+
+namespace boost {
+namespace serialization{
+
+template<class Archive, class T>
+inline void save(
+ Archive & ar,
+ const boost::weak_ptr<T> &t,
+ const unsigned int /* file_version */
+){
+ const boost::shared_ptr<T> sp = t.lock();
+ ar << boost::serialization::make_nvp("shared_ptr", sp);
+}
+
+template<class Archive, class T>
+inline void load(
+ Archive & ar,
+ boost::weak_ptr<T> &t,
+ const unsigned int /* file_version */
+){
+ boost::shared_ptr<T> sp;
+ ar >> boost::serialization::make_nvp("shared_ptr", sp);
+ t = sp;
+}
+
+template<class Archive, class T>
+inline void serialize(
+ Archive & ar,
+ boost::weak_ptr<T> &t,
+ const unsigned int file_version
+){
+ boost::serialization::split_free(ar, t, file_version);
+}
+
+} // namespace serialization
+} // namespace boost
+
+#endif // BOOST_SERIALIZATION_WEAK_PTR_HPP
Added: branches/CMake/release/libs/serialization/include/boost/serialization/wrapper.hpp
==============================================================================
--- (empty file)
+++ branches/CMake/release/libs/serialization/include/boost/serialization/wrapper.hpp 2008-07-01 12:53:23 EDT (Tue, 01 Jul 2008)
@@ -0,0 +1,63 @@
+#ifndef BOOST_SERIALIZATION_WRAPPER_HPP
+#define BOOST_SERIALIZATION_WRAPPER_HPP
+
+// (C) Copyright 2005-2006 Matthias Troyer
+// 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)
+
+#include <boost/serialization/traits.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+namespace boost { namespace serialization {
+
+/// the base class for serialization wrappers
+///
+/// wrappers need to be treated differently at various places in the serialization library,
+/// e.g. saving of non-const wrappers has to be possible. Since partial specialization
+// is not supported by all compilers, we derive all wrappers from wrapper_traits.
+
+template<
+ class T,
+ int Level = object_serializable,
+ int Tracking = track_never,
+ unsigned int Version = 0,
+ class ETII = extended_type_info_impl< T >
+>
+struct wrapper_traits : public traits<T,Level,Tracking,Version,ETII,mpl::true_>
+{};
+
+/// the is_wrapper type traits class.
+
+namespace detail {
+template <class T>
+struct is_wrapper_member
+{
+ typedef BOOST_DEDUCED_TYPENAME T::is_wrapper type;
+};
+
+}
+
+
+template<class T>
+struct is_wrapper
+ : mpl::eval_if<
+ is_base_and_derived<basic_traits,T>,
+ detail::is_wrapper_member<T>,
+ mpl::false_
+ >::type
+{};
+
+} } // end namespace boost::serialization
+
+// A macro to define that a class is a wrapper
+#define BOOST_CLASS_IS_WRAPPER(T) \
+namespace boost { \
+namespace serialization { \
+template<> \
+struct is_wrapper< T > : mpl::true_ {}; \
+}}
+
+
+#endif //BOOST_SERIALIZATION_WRAPPER_HPP
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk