
This is the informal ChangeLog for libs11n (there is no formal
one). Newest items are at the top.

libs11n home page: http://s11n.net/

0.8.7: 25 June 2004

- Back-ported from 0.9.3: worked around a problem which caused part of
  the REALLY LONG client-side compile times. Build times "should" be
  cut significantly, especially for projects in which multiple files
  include the s11n headers. Build time of the lib itself was cut by
  19 seconds on my 2GHz box by this workaround.


0.8.6: 13 June 2004

- Added -fPIC compile option to all sources, to please Debian project.


0.8.5:

- Build fix for 0.8.4, otherwise functionaly identical.


0.8.4: 15 May 2004

- Fixed a bogus pointer argument passed from serialize_list(). Thanks
  to martin f. krafft for catching that one.

- Adding some extra includes to s11n.h, to make it a "one-stop #include
  file". Thanks again to martin for catching that omission.

- Fixed a classload registration bug which would show up when
  loading types without having saved one beforehand. Thanks to
  Keven Weber for allowing ssh access to his box, which was
  essential in tracking this down.

- Fixed a classname quoting bug in the funtxt serializer.

- Fixed weird bug: parens serializer broke when parsing in class
  nodes with certain single-letter names: A, C, E, P, S
  An anonymous sourceforge user noticed that ACEPS is an anagram
  for SPACE, which pinpointed the bug in the lexer code. (Thanks,
  whoever you are!)

- Removed the 4-arg versions of s11n::de/serialize_subnode(),
  as it relied on a function which was removed in 0.8.3.
  It's usage was not in line with the core lib's way of doing
  things, in any case.

- Added std::multiset support.

- Renamed demo app's binary from demo_struct to demo_s11n,
  since it now encompasses several demos.

- Added client/sample/demo_hierarchy, demonstrating a serializable
  class hierarchy.

- Renamed s11nlite::serialize( NodeT, string, SerT ) to
  serialize_subnode(), because that's what it's called in the rest
  of the API.

- Several documentation updates & corrections. Many thanks to
  Marshall Cline for his input on these!

- Pre-flexed lexers are now used whenever lib/node/lex/flexes.tar
  is found, to get around some incompatibilities in flexers built
  on other boxes (in particular, on Debian hosting flex 2.5.31).

- Side note: Many thanks to martin f. krafft for a) including
  s11n into Debian unstable and b) giving me access to a Debian box
  on which to test fixes.

(************************************************** end 0.8.4)


0.8.3: 12 April 2004

- This release probably holds the record for the least number of
  "significant"   changes, not counting the last compile-error
  quick-release (0.8.2b). That's a great sign! So far,
  client-side usage hasn't revealed a case which 0.8.2b couldn't
  fundamentally handle. :)

- std::set and std::multimap are now transparently supported, thanks
  to code from Gary Boone. Added --multimap and --set demos to
  client/sample/demo_struct (it's not just a struct demo any more,
  i guess).

- fixed typo-induced compile error in the 3-arg version of
  serialize_streamable_list().

- fixed demo app output: the NDEBUG macro is set to 1 when doing
  non-debug builds, and when this is set assert()s have no
  effect. Since the demo wraps all test calls in assert(),
  they produced no output on non-debug builds. :/ As i *always*
  build in debug mode, i never noticed this problem: Gary (again)
  brought this one to my attention. (Finding the reason for the
  missing output took me a while, though! ;)

- Added 3-argument forms of de/serialize_{list,map}(), which accept
  a subnode name.

- Removed the forms of s11n::de/serialize() which accepted a de/ser
  functor, as they a) allowed clients to inadvertently bypass
  API marshaling and b) were never used by the lib. These were
  removed some time ago, but a CVS slip-up re-introduced them. :/

- Several corrections in the library manual, mainly to bring it
  up-to-date for 0.8.x.

- Removed pair_second_deleter, as it is obsoleted by
  pair_entry_deallocator.

(************************************************** end 0.8.3)

0.8.2b:

- Fixed a compile error in map.h which didn't show up until compiling against
  a client app.

0.8.2: 21 March 2004

- i'd like to welcome Gary Boone to the development team! We're now
  at a whopping TWO members! :)

- Can now de/serialize std::maps/vector/list/pair without having
  to register them! The only registrations which need to happen are
  for their contained types. This is a HUGE IMPROVEMENT in usability
  and flexibility! Adding such default support for other container
  types is relatively trivial (see sam_stl_containers.h). See
  client/sample/demo_struct for a complete demonstration. Note that
  you may still install custom proxies for specific container
  instantiations, for complete control over their serialization.

- Lots of header re-orgs and API changes, in the interest
  of dependencies reduction, improving ease of understanding the API,
  and simplifying source organization:
  - list-related algos/functors are now in <s11n/list.h> and
    live in namespace s11n::list.
  - map-related functions/functors --> <s11n/map.h> and
    s11n::map namespace.
  - s11n::de/serialize_value_list() ==> renamed:
        s11n::list::de/serialize_streamable_list()
    As "value" is extremely ambiguous, and therefor confusing.

- Various deserialize_subnode() convenience functions added.

- Added s11nlite::serializer_class(string), to set the name of the
  Serializer class s11nlite should use for save() operations.
  This supercedes the macro-based method, which is ineffective
  on client app builds. See demo_struct.cpp for an example of it's
  usage.

- s11nlite:: functions which are not necessary vis-a-vis template
  type resolution have been (are being) removed, as they provide
  no benefit except to clutter s11nlite with a bunch of 1-line
  functions. Those which *do* keep the user from having to explicitely
  specify a NodeType are kept. It is hoped that the new namespaces,
  e.g. s11n::list, will help avoid confusion in using s11nlite with
  the API living in non-s11nlite namespaces.

- Two "frivilous" internal template-based layers have been removed,
  to help reduce compile times and object/binary file sizes.

- Added reg_map_serializable.h, to simplify the registration of
  std::map types containing any mix of PODs or Serializables. This
  is ONLY necessary if you want to proxy a map in a customized way,
  otherwise maps are supported by default.


(************************************************************ end 0.8.2)

0.8.1: 18 March 2004

- Fixed a bad ODR collision bug when s11nlite.h was included
  by more than one implementation file in a project.



0.8.0: 17 March 2004

- Many, MANY thanks to Gary Boone for all of his feedback
  and interaction with me on these changes!

  This release is so HUGE, in fundamental ways,
  that it deserves a codename:

        "Hol den Vorschlaghammer!"
         (Get the sledgehammer!)

- Recent developments have provided some exciting new
  ways to register arbitrary information with s11n,
  using ONLY in-language techniques which COMPLETELY
  avoid ALL of the various problems related to using the
  conventional registration macros for complex
  types (i.e., those with template parts).
  Experimentation suggests that s11n just got 100x
  times easier to use when it comes to handling some
  of the most "difficult" cases, like awkward
  container combinations.

- impl_class() is now handled AUTOMATICALLY (once again!)
  for registered MONOMORPHIC types - POLYMORPHIC types must
  still set this in their serialize operator, as usual :(.
  (i might finally have a workaround for this... need to
  experiment...)

- New demo app: client/sample/src/demo_struct.cpp  shows
  several proxying samples, including lists, vectors
  and maps. Run client/sample/demo_struct.

- Some header file re-orgs. Now most algorithms are really in
  the algos header, and functors in the functors header.

- Both pointer- and non-pointer Serializables should now be supported
  in an identical manner for all de/serialize() operations. This greatly
  simplifies some generic serialization code, which no longer needs
  to know if it is dealing with pointers or not. This means that these
  now work identically:
      MyType foo(); MyType *fooptr = &foo;
      ...
      s11nlite::save( foo, std::cout );
      s11nlite::save( fooptr, std::cout );
  As do these:
      s11nlite::deserialize( node, foo );
      s11nlite::deserialize( node, fooptr ); // must be non-0


- Developed a whole new way of registering class meta-information,
  such as proxies, which completely avoids ALL macro-related
  problems, can be used to avoid ODR violations, and can still be
  performed at compile-time. It is based on including header
  file snippets and defining certain "one-time-use" macros
  which are consumed by the registration process. Each snippet
  may, of course, have it's own requirements, interface, and
  benefits. This allows EASY EASY EASY EASY EASY swapping-out
  of proxy types at compile time, potentially even based on,
  e.g., #defines from config.h.

- New weird class: abstract_creator<>
  Can abstractly create and destroy objects regardless of whether they
  are heap- or stack-based, further simplifying some generic serialization
  algorithms. (This is a strange class, with strange usage, but it
  makes possible some previously impossible-to-consolidate code
  cases involving mixing pointer/reference types. i.e., some
  functors can handle pointer and value types properly, including
  de/allocation, regardless of the underlying type. Previously
  such code had to implemented in two slightly-different
  implementations, only for relatively minor syntactic reasons.

- New function: s11n[lite]::s11n_cast(), can "cast" any
  Serialiable to a "compatible" type, e.g., list<Foo*> to
  vector<Foo> (pointerness is irrelevant!).

- New function: free_map_entries() cleans up all pointers in maps,
  without having to know if the map stores value types or pointers,
  allowing some more-generic map-centric template code in places.
  See also, free_map_entries().

- Removed functions: de/serialize_pointer_list(), in favour of
  newer, more generic de/serialize_list().

- lots of algo/functor reorgs, to implement the functors on top
  of the algos, instead of the other way around.

- Fixed: not all parsers handled all class names nicely.
  (e.g., "list<int *>", "std::map<std::string, SomeType<Foo *> *>").
  Required minor grammar changes to parens and funtxt: they are
  read-compatible with older data but data written with these versions
  is not readable with older versions of those input parsers.

- Significant changes (simplifications) in the underlying classloader
  library's interface: cllite, the class_loader<> equivalent of s11nlite.
  See cllite.h and the class_loader ChangeLog
  (in that lib's source tree).

- It is now possible to change the default s11nlite serializer
  at compile time via client code: see s11nlite.h for info.

- Removed some of the member functions from s11n::data_node - the ones
  which have appropriate algorithm-based substitutes:
  node.child(string) -->
        s11n::find_child_by_name(node,string)
  node.children(string,container) -->
        s11n::find_children_by_name(node,string,container)

- Doubled the size of the manual. It now weighs in at almost 60 pages...
  and there's no end in sight to what /could/ potentially go into it.
  (Publishing deal, anyone?)

- Added the beginnings of an index to the manual: all major Terms and
  Definitions are there, anyway.
- After adding about 100 index entries for the manual, lyx now
  craps out when exporting the library manual. AAARRRRGGGGG!!!

- Globally replaced the S11N_NAMESPACE token (the namespace
  placeholder) to the more approachable S11N_NS, saving not only
  my fingers, but literally tens of k of wasted file space ;).
  (Should have done that AGES ago.)

- Added experimental support for generic meta-data nodes in the
  Serializers, available via their base interface.


(*********************************************************** end 0.7.2)


0.7.1: 10 March 2004

- old-mode s11n code left out of the distribution tarball. Contact
  me if you'd like it and i'll gladly hand it over. It hasn't changed
  since the last release, and is unlikely to change at all... ever
  again.

- Major change to the registration macros introduced in 0.7.0:
  the NodeType argument (first arg) has been removed, as i realized
  that having that here hard-codes proxies and clients to specific
  Node Types. We now let automatic type resolution call the shots.
  This greatly simplifies some things and makes maintenance
  easier later on. Also, it has interesting implications for classes
  implementing *multiple* Serializable interfaces, and for
  writing generic Container-Serializer proxies.

- Fixed dumb bug: a misplaced 'static' meant that s11nconvert wrote
  the wrong magic cookie when used in a pipe context, or two serializers
  used one-after-the-other.

- Added some more demo code in client/sample/src/main.cpp, showing how
  turn a, e.g., std::map into a Serializable.

- s11n::io:save_serializable(): re-ordered the template args (it's easier
  to use this way) and removed the nodename argument (because in practice
  we NEVER care what the name of the root node is, so the func now provides
  a dummy name).

- A number of corrections and additions to the docs. (My favourite typo
  in the 0.7.0 docs was: "returns true on false and success on error.")
  
- funxml_serializer<> fixed to translate XML chars in class templates'
  names. (The supplied parser has always supported reading these, but
  a real XML parser wouldn't handle them before this change.)

- Added function: s11n::de/serialize_value_pair()

- Several other fixes/additions... undocumented here.

- Updated web site to match this API, removing references to the old API.

(*********************************************************** end 0.7.1)

	
0.7.0: 7 March 2004

########################################################################
# ACHTUNG: MAJOR CHANGES!
# 
# There is a new s11n subsystem, which will eventually replace much of
# the current way of serializing objects. The new way is much more
# flexible, allowing clients to go so far as define their own s11n_node
# type. This new model is infantile, but shows a lot of promise and is
# moving along quickly. (In only two days most of the framework was
# replaced.)
#
########################################################################


The long list of notable changes and additions in the new code:

- Code based around the older model is not built by default.
  To enable it use:  ./configure --enable-old-s11n

- Fair warning: this is 50+% BRAND NEW CODE. It's only lightly tested,
  but "seems to mostly work okay." The s11nlibconfig client app
  is not yet ported to support the new model yet, and s11nconvert
  has changed significantly.

- The code based around s11n_node is "officially deprecated" as of 1
  March 2004. It will  still be supported for a while (i've got a lot
  of code which uses it!) but the newer model is much preferred and
  already overshadows the old code enough to give little hope of the
  old model surviving much longer.

- Implemented independently of the "old" code, to facilitate phasing
  away from the older model. The new tree is much slimmer, as it does
  away with much of the "evolution cruft" the API has developed.

- Introducing 's11nlite', a namespace which encapsulates most
  common de/serialize options without having to use so many
  templated types. This is provides an extremely simple interface
  into s11n. It is also a demonstration of how easy it is to
  implement your own serialization front-ends on top of libs11n.
  This can be used, e.g., to completely insulte client-side objects
  from s11n behind a client-side serialization interface, while
  letting s11n do the back-door work.

- A completely new library manual: doc/s11nlite.lyx. The old manual
  (s11n.lyx) is currently empty, but will be filled out with information
  which is "too deep for s11nlite."

- The core interface is made up of a handful of de/serialize() overloads,
  all of which work on types supporting some general conventions, which
  means clients can *completely* swap out the underlying framework if
  they like, while keeping the core interface, or vice versa.

- Is implemeneted in parallel to the to the "older" model (if you can
  call 6 months "old"), so it doesn't interfere with any older code.

- s11n_node is replaced with s11n::data_node, a pure container type.
  data_node defines some conventions for generic DOM-style containers
  compatible with s11n. data_node is only hard-coded in as few places
  as possible, so users can provide their own node types and create
  their own serialization interfaces using the framework provided by
  this library.

- Proxying serialization is now easier than ever. Arbitrary functors
  can be installed as proxies for a given BaseType in one line
  of code, and these functors automatically apply to all subtypes
  of BaseType. This allows easy serialization of many generic container
  types, like std::map and std::list, as well as your own class
  templates. Additionally, it allows serialization accounting, logging,
  call chaining, etc., without a Serializable type needing to know about
  it.

- Base Serializable types which conform to a "default" interface
  no longer need to be registered as serializables - the library
  will pick them up automatically or fail at compile-time.

- The de/serialize() free functions now work on all node and Serializable
  types conforming to certain (minimal) conventions, instead of using
  hard-coded types.

- Classloader registration has been moved to a separate macro, and the
  framework's access to the built-in classloader has been reduced to
  fewer points. It is now possible, with a small amount of hacking, to use
  client-side classloaders for all deserialization operations.

- The new registration macros are now simpler to use (i hope), and
  are even optional for classes which support 2 operator() overloads
  (the so-called serialization operators).
  
- Simplified the s11n<-->lex interface, so class templates can now
  communicate with them without some of the former type-related
  problems. Also, lexers should be able to parse out any node
  type which can fit within the data_node_tree_builder's interface
  (no more hard-coded node type in the lexers).

- i/o layer moved to the s11n::io namespace. The core is 100%
  independent of it.

- Clients must now only include one of two header files:
  s11nlite.h (recommended) or s11n.h (the core library)

- Overall less code: lib build time is cut by approximately half.
  (Client code build times are "probably unaffected.")

- Fixed a compile error caused by a missing header, plus fixed
  FlexLexer.h-related build problems reported by Gary.
  (Thanks, Gary!)

- Created missing README and INSTALL files, after Gary Boone
  pointed out that s11n didn't have these.

- List/vector serializers fixed to keep proper ordering of the
  re/stored elements. Additionally, de/serializing ANY
  value-based list or map is a one-line operation, as is
  de/serializing lists of pointers to Serializables.

- Several macros fixed to accept single-arg template types
  as argument (multi-arg templates still won't work because
  the commas break the C macros).	

- Slightly faster than 0.6.x: up to 20% in tests on large data
  sets (100k random serializable objects).

- Gawd only knows what else...

- See also: the ChangeLog for class_loader 0.7.0


(*********************************************************** end 0.7.0)

########################################################################
# Everything below this line pertains to the "old-style" s11n code,
# i.e., that built around the s11n_node data structure.
# That code is "officially deprecated" as of 1 March 2004. It will
# still be supported (i've got a lot of code which uses it!) but
# the newer model (versions 0.7.0+) represent newer ways of doing things.
########################################################################


0.6.1: 29 Feb 2004

- Added free functions serialize<>() and deserialize<>(),
  both of which accept a node, an arbitrary object, and functor. The
  functor is responsible for the serialization of an object, aiding
  in the serialization of non-Serializables and 3rd-party classes,
  as well as serializing class templates.

- It is now possible, e.g., to de/serialize a 
  std::map<std::string,std::string> using the same
  client-side interface as is used for all other objects.
  The file parsers now accept C++ template names as
  class names, helping to fix a deficiency caught by
  Ton Oguara: s11n deserialize class templates before.
  It now can, but requires a bit of client-side work
  (details coming later in the manual...)
  See lib/s11n/createS11n{Proxy,Functor} (installed under $prefix/bin)
  for helper scripts which create the necessary boilerplate
  code.
  
- Re-enabled hex_serializer, but don't use it yet: it's got a
  bug or two.

- Work has begun on a slightly different, more flexible,
  model for s11n, using pure data containers of user-defined
  types (with defaults included, of course). This should 
  add a lot of flexibility to client-side usage. It already
  removes or reduces several limitations of the library.
  See lib/s11n/data_node*.* for details, and the test functions
  in client/s11nlibconfig/main.cpp for samples & test code.

- Side note: experimentation has shown that functors can be used to
  apply client-side serialization logic to for arbitrary s11n
  operations. e.g., normally the same de/serialize logic is applied
  to the same TYPES on all calls involving those TYPES. Functors
  allow you to custom-serialize   an object (or objects). It also
  potentially allows serializer chaining, which opens up some weird
  possibilities...




0.6.0: 12 Jan 2004

- Added the s11nlibconfig, a tool for manipulating
  the library config object. Please don't confuse this
  with...

- s11n-config, a new script which is useful
  for configuring libs11n clients to compile/link
  against this library.

(i appologize for the naming confusion. The first
one does not have a better name alternative and
the second one follows existing naming conventions
for such scripts, e.g., gtk-config.)

- Added save_serializable( Serializable &, ostream & )
  to s11n_globals.h.

- Removed the 'static' specifier from the free functions
  in s11n_globals.h (it shouldn't have been there).

- Removed the bogus string argument for property_store's ctor:
  this was a leftover from long-gone code.

- Some minor post-main() fixes.

- Minor documentation corrections/additions.

- See the ChangeLog for class_loader 0.6.0.


0.5.3: 6 Jan 2004

- Eliminated the need for linking with libs11n_class_loader.

- Added s11n-config script, to help client configure scripts determine the
  properies of libs11n. This is created at configure-time and installed
  under ${prefix}/bin.

- Changed compact_serializer to use 4-byte size tokens instead of 8-byte,
  saving considerable file space. The parser can read in older data but
  will always write with the newer format. It uses a new magic cookie,
  so older versions will never get asked to read newer-format data.

- node_loader now buffers all input coming from streams so it can pass
  the whole thing, including magic cookie, to the selected input parser.
  This was required for formats which accept more than one cookie, so they
  can internally distinquish some details (e.g., compact_serializer).
  It's less efficient than before, especially for very large input streams.
  i'm looking for a better way to do this, since this could "potentially"
  overflow the maximum size of a std::string.

- The distribution tarball now comes with pre-flexed lex parsers. flex
  is used if it is found, otherwise pre-generated lexers are used. Use
  --without-flex to explicitely use the pre-built lexer. (i've had to
  do this on one Solaris box, where it's flex didn't play nice.)

- Removed the auto-saving of ~/.libs11n.conf, as it can Cause Grief in
  several common cases. As a side-effect of this, calls to s11n::config()
  made post-main() are not guaranteed to get any changes made to the
  config object during application session.

- Some minor documentation corrections.

- Some source tree re-orgs.

- See the ChangeLog for class_loader 0.5.2

- Fixed a class naming mistake in the previous ChangeLog:
  property_list --> pointer_list


0.5.2: 1 Jan 2004

- Fixed a broken loop in ~pointer_list() which caused a post-main
  hang at times. The fix means that pointer_list can no longer safely
  be used for holding the same child pointer multiple times. In practice
  this capability has never been used, so i'm not gonna sweat it. See
  the comments for pointer_list::delete_all() for the explanation.


	
0.5.1: 25 Dec 2003

- Again overhauled the internal handling of Serializers'
  translation maps, to take advantage of phoenix<>.

- See the ChangeLog for class_loader 0.5.1


0.5.0: 19 Dec 2003

- Overhauled the way serializers handle their character
  translation tables, to avoid some post-main() crashes
  caused by destruction of static objects "in the wrong order."
  i'm still not 100% tickled with this approach, because it
  requires more map<> objects than is really necessary, but it
  is the safest approach, i think. (Another alternative would be
  to get a Phoenix Singleton and plug it in there for the
  translation maps.)

- Fixed a couple other obscure, post-main()-static-destruction
  bugs.

- Added the s11n::config(), a persistant s11n_node which holds
  library-wide configuration information, stored in ~/.libs11n.conf.
  (This is what revealed the statics bugs mentioned above.)

- Added experimental support for toggling the use of indention to
  "pretty up" the serializers for which indention might be
  useful. See basic_serializer::use_indention().
  The default behaviour is to use human-friendly indention.

- Added a couple free functions and s11n_node members to simplify some
  complex client-side de/serialization cases.

- Fixed a bug in funtxt which broke input parsing when property values
  had '=' characters in them.

- Changed many unsigned types to size_t.

- Found that there is a need to be able to de/ser std::maps of
  Serializable pointers. How best to do this is still under
  consideration.

- Minor documentation corrections.

- Fixed a potential crash in s11n_io::save( s11n_node, string )
  when the given filename could not be opened.

- Added experimental support for persistent compression_policy()
  settings. This may be a nuisance, as it will be applied to all
  clients, so it may go away. Clients can, of course, store app-specific
  compression policies in s11n::config().
	
- See class_loader 0.5.0 ChangeLog.

	
0.4.1: 8 Dec 2003

- Stress again (introduced in 0.4.0): client-supplied Serializable
  types should call s11n_node::impl_class() from their serialize()
  methods, as practice has now shown that the template-based cannot
  handle several common cases. Grrrrrr...

- Fixed the broken copying of s11n_node's properties
  in it's copy() method.

- Added config option --s11n-namespace, to build
  the whole lib under a different namespace (defaulting
  of course s11n). Use this sparingly, as it has
  very wide-reaching, and not always obvious, effects
  on client usage of the library. If the namespace
  is not 's11n' then the linked library will take on the
  name libNAMESPACE_s11n.so, to allow it to co-exist
  with the s11n distribution on the same system.
  If you're bored, try ./configure --namespace bob.
  (To be safest, do a 'make distclean' first.)

- Minor documentation changes.

- Please see the changelog for class_loader 0.4.1,
  from http://s11n.net/class_loader/ as this tree
  includes that code.

- fixed an installation bug: config.h wasn't going to the correct
  dir.

- A whole slew of build-related changes, largely to take
  advantage of new file-filtering capabilities provided
  by toc. (Okay, that's a bit of a lie: that support was
  added to toc because this tree wanted it. ;)


0.4.0: 1 Dec 2003

- Added copy ctor/operator and copy() to s11n_node.

- All sorts of refactoring to support making the lib
  namespace settable at build-time. This allow us to
  share cvs trees in multiple projects with
  different namespaces and to compile this library
	with clients who use two different-namespaced
	versions of this library. Collisions which happened
  in earlier versions of this lib which happened
  in these cases have been resolved.

- All (significant) classes now use STL-style naming
  conventions, for consistency. e.g., ParenSerializer is now
	paren_serializer. There are a couple classes still hanging
  out with the OldNamingStyle, but they will be phased out
  eventually.

- Several documentation corrections and updates. i can't
  believe i still had my home page as the URL :/.

- Experience now shows that automatically setting
  a node's impl_class() via behind-the-scenes templates
  cannot be done 100% reliably. This means that client
  Serializable classes are now encouraged to set this
  from their serialize() methods. :/
  Unfortunate, but the only other reliable option is to
  add this to Serializable interfaces, which is actually
  more work for clients and less reliable because it
  would require modifying all Serializable ctors to call
  impl_class().

0.3.2: 11 Nov 2003

- Lots of changes to class_loader, as described in
  the ChangeLog for libclass_loader 0.3.{0,1}.

- Split the classloader and core lib into separate
  DLLs, for maintenance reasons. Static lib is still
  one library. This shouldn't affect client usage.


0.3.1: 31 Oct 2003

- Lots of build/source re-orgs to consolidate everything
  into one namespace (s11n, of course).

- Added support for libltdl: if it is found it is preferred
  over libdl. Hid the dlopen-related code in
  dll_loader::open/close_dll(). (Thanks to Roger Leigh,
  from comp.lang.c++, for introducing me to libltdl!)

- Simplified usage of node_loader a bit and added
  another convenience method.

- Added load_serializable<>( string||stream ) functions.
  For some reason doxygen refuses to list them,
  so please see s11n_globals.h for the docs.

- SimpleXMLSerializer: fixed a horrible set of bugs in the
  property reading and entity translation. Newline translation
  in property values /might/ not be 100% correct yet, though.

- FunTxtSerializer: changed the way backslashed newlines are
  handled in input, for consistency with other formats and
  to fix some whitespace-related data portability problems.

- hex_serializer has been removed until it's parsing bugs are
  fixed.


0.3.0: 29 Oct 2003

- ChangeLog started

- refactored to support changing class_loader's namespace at
library configure/build-time, so we can maintain identical code and
build files in both the s11n and class_loader trees yet have different
lib names and namespaces for class_loader.

- class_loader and friends have been moved to the s11n namespace.

- Dependencies on the toolbox namespace have been reduced,
  via the above refactoring.

- removed the bogus int return value from class_loader::register_xxx().
  (Thanks go to Tom on comp.lang.c++ for that!)

[a couple 0.2.x releases missing...]

0.2.0:
  - Domain online :). First public release.
