New Features as of version 1.3.0

  May 2011

  Highlights:
    * Since XML is so pervasive, the PicklingTools toolkit has
      embraced XML:  There are conversion tools provided.
      In fact: you can convert back and forth between XML and Python 
      Dictionaries easily with the new tools.  That allows you to use 
      Python Dictionaries as your main currency, but still speak XML.
        * Python tools for converting between XML and Python dicts
        * C++ tools for converting between XML and Tabs
        - TODO: M2k tools for converting between XML and OpalTables
      A lot of care has been taken so that conversions between
      XML and dictionaries DO NOT lose any information.  For floats
      and complex values, numeric precision has been given strict attention.  
      For nested lists/dicts, attention has been paid so that all
      structure is preserved.  For POD data, the typetags and numeric
      precision are preserved.  

      Currently, the tools just allow conversion back and forth
      between XML and Python dictionaries:
      we don't (at the moment) use XML as another serialization.
      If you need XML, you have to do the conversions yourself.
      The easiest way:

          #include "xmltools.h"
          ConvertToXML(a_python_dict)     # returns XML in a string
          ConvertFromXML(xml_in_a_string) # return a Python dictionary

      There are many more options to do the conversions: 
      see the documentation for a full discussion.

    * A few minor changes so that the C++ pretty print and Python pretty
      print output the same


   Details:

    * Updated the documentation for some discussion of the XML
      support, including features and caveats for its usage:
      the new document is about 20 pages of examples and
      discussion: xmldoc.txt, xmldoc.pdf, xmldoc.html

    * Cleaned up the documentation in a few places: it was
      out of date, and mostly just pointed to the web site:
      the web-site has much easier to read documentation
      and is up-to-date.

    * Moved to new version of opencontainers: 1.7.0:
        * Added "pushback", "drop" to CircularBuffer, with new tests
        * ocport.h had a syntax error that MySQL has trouble parsing: fixed
        * changed version numbers   
        * updated ocreader to handle pushback, read continually from strems
          with new EOFComing() method 
        * added tests for ocreader 
        * Updated Makefiles for new version  
        * Fixed a minor bug when reading complexes with an negative imaginary
          component: it was ignoring the sign.  Added tests.
        * Val version of cout adds 'L' suffix to int_n/un: updated a bunch
          of tests in the tests area to deal with this.
          Example:
            int_n i = 100;
            cout << i << endl;  // output 1
            Val v = i;
            cout << v << endl;  // outputs 1L
          Philisophically and historically the Val version of output is more 
          explicit so less information is lost (floats output full precision,
          complexes output full precision, strings escape).
        * All Val constructs output strings the same way as Python
          (i.e., prefer single quotes, but use double-quotes on strings
           if the string contains no double quotes itself):
            * ocstringtools updated to allow this
            * octup.h, ocval.h updated
        * tests updated for output changes
            * valreader_test, tab_test. set_test, valbigint_test
 
    * A few minor changes so that the C++ pretty print and Python pretty
      print output the same
        * Python: 
           * extra space in the Python (after commas) is gone
           * Python pretty now prints Numeric arrays JUST like the C++
        * C++: 
           * int_un and int_n now print the suffix 'L' when printed as a Val
             to distinguish them from other ints.  
          
    * Updated m2ser.cc: M2K serialization still needed two last
      little tweaks (see PicklingTools 1.2.1) to handle Big-Endian
      numbers.