[ViewVC] Diff of: cvs/CBOR-XS/README

Comparing CBOR-XS/README (file contents):
Revision 1.10 by root, Thu Nov 28 16:09:04 2013 UTC vs.
Revision 1.11 by root, Sat Nov 30 18:42:27 2013 UTC

     about 20% smaller than the same data encoded as (compact) JSON or
     Storable.
     In addition to the core CBOR data format, this module implements a
     number of extensions, to support cyclic and shared data structures (see
-    "allow_sharing"), string deduplication (see "pack_strings") and scalar
+    "allow_sharing" and "allow_cycles"), string deduplication (see
-    references (always enabled).
+    "pack_strings") and scalar references (always enabled).
     The primary goal of this module is to be *correct* and the secondary
     goal is to be *fast*. To reach the latter goal it was written in C.
     See MAPPING, below, on how CBOR::XS maps perl values to CBOR values and
         instead will emit a reference to the earlier value.
         This means that such values will only be encoded once, and will not
         result in a deep cloning of the value on decode, in decoders
         supporting the value sharing extension. This also makes it possible
-        to encode cyclic data structures.
+        to encode cyclic data structures (which need "allow_cycles" to ne
+        enabled to be decoded by this module).
         It is recommended to leave it off unless you know your communication
         partner supports the value sharing extensions to CBOR
         (<http://cbor.schmorp.de/value-sharing>), as without decoder
         support, the resulting data structure might be unusable.
         Detecting shared values incurs a runtime overhead when values are
         encoded that have a reference counter large than one, and might
         unnecessarily increase the encoded size, as potentially shared
-        values are encode as sharable whether or not they are actually
+        values are encode as shareable whether or not they are actually
         shared.
         At the moment, only targets of references can be shared (e.g.
         scalars, arrays or hashes pointed to by a reference). Weirder
         constructs, such as an array with multiple "copies" of the *same*
         If $enable is false (the default), then "encode" will encode shared
         data structures repeatedly, unsharing them in the process. Cyclic
         data structures cannot be encoded in this mode.
         This option does not affect "decode" in any way - shared values and
+        references will always be decoded properly if present.
+    $cbor = $cbor->allow_cycles ([$enable])
+    $enabled = $cbor->get_allow_cycles
+        If $enable is true (or missing), then "decode" will happily decode
+        self-referential (cyclic) data structures. By default these will not
+        be decoded, as they need manual cleanup to avoid memory leaks, so
+        code that isn't prepared for this will not leak memory.
+        If $enable is false (the default), then "decode" will throw an error
+        when it encounters a self-referential/cyclic data structure.
+        This option does not affect "encode" in any way - shared values and
         references will always be decoded properly if present.
     $cbor = $cbor->pack_strings ([$enable])
     $enabled = $cbor->get_pack_strings
         If $enable is true (or missing), then "encode" will try not to
         the IEEE double format will be used. Perls that use formats other
         than IEEE double to represent numerical values are supported, but
         might suffer loss of precision.
   OBJECT SERIALISATION
+    This module implements both a CBOR-specific and the generic
+    Types::Serialier object serialisation protocol. The following
+    subsections explain both methods.
+   ENCODING
     This module knows two way to serialise a Perl object: The CBOR-specific
     way, and the generic way.
-    Whenever the encoder encounters a Perl object that it cnanot serialise
+    Whenever the encoder encounters a Perl object that it cannot serialise
     directly (most of them), it will first look up the "TO_CBOR" method on
     it.
     If it has a "TO_CBOR" method, it will call it with the object as only
     argument, and expects exactly one return value, which it will then
     "CBOR" as the second argument, to distinguish it from other serialisers.
     The "FREEZE" method can return any number of values (i.e. zero or more).
     These will be encoded as CBOR perl object, together with the classname.
+    These methods *MUST NOT* change the data structure that is being
+    serialised. Failure to comply to this can result in memory corruption -
+    and worse.
     If an object supports neither "TO_CBOR" nor "FREEZE", encoding will fail
     with an error.
+   DECODING
-    Objects encoded via "TO_CBOR" cannot be automatically decoded, but
+    Objects encoded via "TO_CBOR" cannot (normally) be automatically
-    objects encoded via "FREEZE" can be decoded using the following
+    decoded, but objects encoded via "FREEZE" can be decoded using the
-    protocol:
+    following protocol:
     When an encoded CBOR perl object is encountered by the decoder, it will
     look up the "THAW" method, by using the stored classname, and will fail
     if the method cannot be found.
     26 (perl-object, <http://cbor.schmorp.de/perl-object>)
         These tags are automatically created (and decoded) for serialisable
         objects using the "FREEZE/THAW" methods (the Types::Serialier object
         serialisation protocol). See "OBJECT SERIALISATION" for details.
-    28, 29 (sharable, sharedref, L <http://cbor.schmorp.de/value-sharing>)
+    28, 29 (shareable, sharedref, L <http://cbor.schmorp.de/value-sharing>)
-        These tags are automatically decoded when encountered, resulting in
+        These tags are automatically decoded when encountered (and they do
+        not result in a cyclic data structure, see "allow_cycles"),
-        shared values in the decoded object. They are only encoded, however,
+        resulting in shared values in the decoded object. They are only
-        when "allow_sharable" is enabled.
+        encoded, however, when "allow_sharing" is enabled.
+        Not all shared values can be successfully decoded: values that
+        reference themselves will *currently* decode as "undef" (this is not
+        the same as a reference pointing to itself, which will be
+        represented as a value that contains an indirect reference to itself
+        - these will be decoded properly).
+        Note that considerably more shared value data structures can be
+        decoded than will be encoded - currently, only values pointed to by
+        references will be shared, others will not. While non-reference
+        shared values can be generated in Perl with some effort, they were
+        considered too unimportant to be supported in the encoder. The
+        decoder, however, will decode these values as shared values.
     256, 25 (stringref-namespace, stringref, L
     <http://cbor.schmorp.de/stringref>)
         These tags are automatically decoded when encountered. They are only
         encoded, however, when "pack_strings" is enabled.
     uses long double to represent floating point values, they might not be
     encoded properly. Half precision types are accepted, but not encoded.
     Strict mode and canonical mode are not implemented.
+LIMITATIONS ON PERLS WITHOUT 64-BIT INTEGER SUPPORT
+    On perls that were built without 64 bit integer support (these are rare
+    nowadays, even on 32 bit architectures), support for any kind of 64 bit
+    integer in CBOR is very limited - most likely, these 64 bit values will
+    be truncated, corrupted, or otherwise not decoded correctly. This also
+    includes string, array and map sizes that are stored as 64 bit integers.
 THREADS
     This module is *not* guaranteed to be thread safe and there are no plans
     to change this until Perl gets thread support (as opposed to the
     horribly slow so-called "threads" which are simply slow and bloated
     process simulations - use fork, it's *much* faster, cheaper, better).

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing CBOR-XS/README (file contents): Revision 1.10 by root, Thu Nov 28 16:09:04 2013 UTC vs. Revision 1.11 by root, Sat Nov 30 18:42:27 2013 UTC

Diff Legend

Comparing CBOR-XS/README (file contents):
Revision 1.10 by root, Thu Nov 28 16:09:04 2013 UTC vs.
Revision 1.11 by root, Sat Nov 30 18:42:27 2013 UTC