This is just a thin wrapper which permits one to explicitly specify that a
particular type is an abstract base class. It is necessary to use this
for compilers which don't support the boost type traits implementation of
is_abstact.

This group will be required less frequently. The are used to override aspects of
the default implementation of the serialization process for specified types.

By default, the library uses RTTI, to identify types at runtime. In some cases, E.G.
such as a platform which doesn't implement RTTI, this header can be included to permit
the override of the default runtime type identification system.

This file includes declarations for certain types that have to be accounted
for in all archive implementations. The serialization system relies on
certain special types such as class_id_type and others to
record information in archives that is required to reconstruct the original
data structure. These are handled exactly as any other serializable type.
That is, the can be handled as simple primitives such as they are in simple
text files, or with special code as they are in xml archives.

Implementation of serialization of primitive types in terms of an character
or wide character text streams. This is used in the implementation of text and
xml archives. Presumably this would be useful for implementations of other variations
of text archives such as user friendly text or windows ini files.

Implementation of serialization of all types in terms of an character
or wide character binary streams. This is factored out separately from the
implementation of binary primitives above. This may facilitate the creation of
other types of binary archives in the future. It also preserves analogy and symetry with
the rest of the library which aids in understanding.

Implementation of serialization of all types in terms of an character
or wide character text streams. These classes specify archive type specific
behavior on a type by type basis. For example, basic_xml_oarchive.hpp
includes code to guarentee that any object not attached to a name will
trap during compile time. On the other hand, basic_text_oarchive.hpp
contains code to strip out and ingore any names attached to objects.

The interface (see Archive Concepts)
and implementation are factored out into separate classes to minimize code duplication.
These files are found in the directory
boost/archive/detail.
These are included as necessary by the archive class implemenations listed above.
This has the unfortunate side effect of making the implementation less transparent.
of the library in order to implement either a class serialization or a new
archive type. Users should never find it necessary to change these files.

Here are the declarations and definitions which for the
archive_concept. This class redirects calls to the
archive interface to a function named save_override in the most derived
archive class.

save_override is declared and implemented in each class in
the archive hierarchy.

template
void save_override(T & t, BOOST_PFTO int){
// All for otherwise unhandled types are forwarded to the base class.
// This emulates behavior for function overloading.
this->base::save_override(t, 0);
}
void save_override(const some_type & t, int){
// any special handling for some type
// this will usually entail forwarding some other operation
// in the most derived class.
this->This()->...
// or in one of its parents basic_text_oprimitive
this->This()->save(static_cast<int>(t));
}
... // other special type handling

The trade offs related to library implementation via pre-compiled code and templated
headers are well known. This library uses both. It uses templated headers
to generate code to serialize user and primitive types and it uses pre-compiled
library code for that part of the code which only depends upon the archive type.
Building of the library generates and compiles code for all archives implemented.

Serialization of user and primitive types runs a top speed. This is a noticiable
difference with a previous version of the library which did not use templates for archives.

Library implementation code that never changes need only be compiled once
rather than each time a user's program is recompiled. This can save much
development time.

Headers which solely related to implementation need only be included
in the library code modules. This prevents a user program from accidently
depending on an implementation feature of the serialization library.

In building the library I came to the conclusions that there can arise
situations regarding static code/data instantiation that could not be
satisfactorily addressed without a code module. Unfortunately, I've forgotten
the circumstances which led me to this conclusion.

An example of this is the usage of the spirit library in the library.
It takes a long time to compile and includes lots of other files. Having this
only in the library is much more convenient that having to include in every
program which uses xml serialization.

The code for these iterators is really independent of this library. But since it
hasn't been and probably won't be reviewed outside of this context. I've left in a directory
local to the serialization library:
boost/archive/iterators.
These iterators are described in
Dataflow Iterators.