First of all, I've updated the README.md to show the license. It's a
BSD 3 clause license.

Yeah, I hadn't thought of the issue of the refs, but I don't think
it's a exceptionally hard problem to solve. What we are discussing is
basically the same thing that mutable languages deal with every day.
At work I'm forced to work with a business object library known as
CSLA.NET and although most of the library is the best example of
complected code I've ever seen, the serialization isn't all that bad.

Basically you follow this method:

Serialize the tree putting each ref into a list. Then you write the
indexed id of that ref instead of the contents of that ref. When you
are done serializing the object, you loop through every object in the
ref list and serialize the contents of the refs. The same pattern is
followed each time. If the ref is in the list, you write the id (index
in the list) of the ref. If it's not in the list, you add it to the
list and write the id.

This sort of serialization is needed in mutable languages such as C#
because it's fairly easy to create loops in the data that would cause
a simpler serializer to enter a infinite loop.

Does anyone see any issues with this method?

Timothy

-- 
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your 
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en

Reply via email to