A C++ reflection-based data dictionary / News: Recent posts

Having discovered boost::reflection, it seems to me that it is wise to redesign CRD in order to be more orthogonal to this Boost library, and allow more code reuse.
The idea is to use the existing enumeration of members provided by 'serialize' methods. This may be done by cerating special-purpose 'Archive' classes aimed at, for example, writing to a relational database.

- Suppressed memory leaks, tested with valgrind.
- Suppressed crd::singleton which is not necessary.
- Added counted_ptr.h as an example of smart pointer. It comes from http://ootips.org/yonat/4dev/
- Added get_field and set_field, as generalized accessors, with legal conversions only.
- Created a new test program, rpc_tst, with more XDR marshalling and code cleanup.
- Added SAX deserializing. Non-nested objects for the moment, still prototyping.
- Now SAX, HTTP and FIX deserializing can create dynamic fields. For example, if a FIX id is mapped to a structure field, a new ftor is created which stores the value deserialized from the FIX stream. This allows to deserialize
an entire message without idea of its structure. Created test programs for FIX, SAX and HTTP to demonstrate that a FIX message can be entirely read without knowing its tags in advance: Only the pre-known tags have their value written in a C++ object. The others are transparently 'injected' into an output definition list which can later be used in another algorithm.

JNI objects, output to XML format, nested objects, various debugging.

Many new features:
- Dynamic objects.
- Regular expressions OK.
- URL parsing and creation.
- CVS files parsing.
- Recursive definitions lists.
- hash functions, SAX parsing and FIX streams embryo (Feasibility OK).

Regex works. It is possible to fill an object with a regular expression parsing, given a field description.
Some progress for CSV files (Headers are parsed).
Code simplification and cleanup.
More examples.

Dynamic objects work.
CSV files can be read (Headers are not parsed yet).
Code clean-up.
Tagging fields is no longer std::type_info, can be customized.
More real-live examples (Parsing /etc/passwd).

The next release will add reading and writing CSV files, AND also dynamic objects. Dynamic objects have members defined at run-time: They do not need to be actual struct members, they will be processed must like plain members. This allows to wrap a blob with a dynamic properties list, and process it just like a struct. Most of the code is in the CVS repository.

The next release will provide tools for de/-serializing CSV (Comma-separated value) files with the same description lists (Lists of members for reflection purpose) that are already used for XDR, iostreams, SQL queries, etc...
In other words: The list of members, in CRD format, of any class can be reused for serializing into CSV files.

Minor code changes, portability enhanced. More comments, more 'TODO' things.

Several new features:
- Serialization with XDR functions.
- Compile-time iteration on class members.
... etc ...

The next release will bring XDR marshalling (RPC style) using xdr_long, xdr_float, etc... based on the same definitions of classes. It means that the same reflection-based definition can be used for generating SQL queries, serialising to a std::stream and marshalling with XDR routines, in a network-neutral format (The same used by RPCGEN).

Include file splitted into a core file and plug-ins: It is not necessary anymore to include everything. Separate test programs. Less mandatory template parameters due to default parameters. More comments.

The initial release is fully operational and ready to download. It is made of three files: Quick document, a test program, and the include file - nothing else is needed.