--- CBOR-XS/XS.pm 2013/11/20 01:09:46 1.19 +++ CBOR-XS/XS.pm 2013/11/28 15:43:24 1.27 @@ -28,12 +28,12 @@ =head1 DESCRIPTION -WARNING! This module is very new, and not very well tested (that's up to -you to do). Furthermore, details of the implementation might change freely -before version 1.0. And lastly, the object serialisation protocol depends -on a pending IANA assignment, and until that assignment is official, this -implementation is not interoperable with other implementations (even -future versions of this module) until the assignment is done. +WARNING! This module is very new, and not very well tested (that's up +to you to do). Furthermore, details of the implementation might change +freely before version 1.0. And lastly, most extensions depend on an IANA +assignment, and until that assignment is official, this implementation is +not interoperable with other implementations (even future versions of this +module) until the assignment is done. You are still invited to try out CBOR, and this module. @@ -56,6 +56,11 @@ As for compactness, C encoded data structures are usually about 20% smaller than the same data encoded as (compact) JSON or L. +In addition to the core CBOR data format, this module implements a number +of extensions, to support cyclic and self-referencing data structures +(see C), string deduplication (see C) and +scalar references (always enabled). + The primary goal of this module is to be I and the secondary goal is to be I. To reach the latter goal it was written in C. @@ -68,7 +73,7 @@ use common::sense; -our $VERSION = 0.08; +our $VERSION = 0.09; our @ISA = qw(Exporter); our @EXPORT = qw(encode_cbor decode_cbor); @@ -115,7 +120,6 @@ The mutators for flags all return the CBOR object again and thus calls can be chained: -#TODO my $cbor = CBOR::XS->new->encode ({a => [1,2]}); =item $cbor = $cbor->max_depth ([$maximum_nesting_depth]) @@ -173,38 +177,104 @@ This option does not affect C in any way, and it is recommended to leave it off unless you know your communications partner. -=item $cbor = $cbor->allow_sharable ([$enable]) +=item $cbor = $cbor->allow_sharing ([$enable]) -=item $enabled = $cbor->get_allow_sharable +=item $enabled = $cbor->get_allow_sharing If C<$enable> is true (or missing), then C will not double-encode -values that have been seen before (e.g. when the same object, such as an -array, is referenced multiple times), but instead will emit a reference to -the earlier value. +values that have been referenced before (e.g. when the same object, such +as an array, is referenced multiple times), but 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. +sharing extension. This also makes it possible to encode cyclic data +structures. + +It is recommended to leave it off unless you know your +communication partner supports the value sharing extensions to CBOR +(L), 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 shared. -At the moment, all shared values will be detected, even weird and unusual -cases, such as an array with multiple "copies" of the I scalar, -which are hard but not impossible to create in Perl (L for -example doesn't handle these cases). If this turns out ot be a performance -issue then future versions might limit the shared value detection to -references only. - -If C<$enable> is false (the default), then C will encode -exception when it encounters anything it cannot encode as CBOR. +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 I string, which are hard but +not impossible to create in Perl, are not supported (this is the same as +with L). + +If C<$enable> is false (the default), then C 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 C in any way - shared values and -references will always be decoded properly if present. It is recommended -to leave it off unless you know your communications partner supports the -value sharing extensions to CBOR (http://cbor.schmorp.de/value-sharing). +references will always be decoded properly if present. + +=item $cbor = $cbor->pack_strings ([$enable]) + +=item $enabled = $cbor->get_pack_strings + +If C<$enable> is true (or missing), then C will try not to encode +the same string twice, but will instead encode a reference to the string +instead. Depending on your data format, this can save a lot of space, but +also results in a very large runtime overhead (expect encoding times to be +2-4 times as high as without). + +It is recommended to leave it off unless you know your +communications partner supports the stringref extension to CBOR +(L), as without decoder support, the +resulting data structure might not be usable. + +If C<$enable> is false (the default), then C will encode strings +the standard CBOR way. + +This option does not affect C in any way - string references will +always be decoded properly if present. + +=item $cbor = $cbor->filter ([$cb->($tag, $value)]) + +=item $cb_or_undef = $cbor->get_filter + +Sets or replaces the tagged value decoding filter (when C<$cb> is +specified) or clears the filter (if no argument or C is provided). + +The filter callback is called only during decoding, when a non-enforced +tagged value has been decoded (see L for a +list of enforced tags). For specific tags, it's often better to provide a +default converter using the C<%CBOR::XS::FILTER> hash (see below). + +The first argument is the numerical tag, the second is the (decoded) value +that has been tagged. + +The filter function should return either exactly one value, which will +replace the tagged value in the decoded data structure, or no values, +which will result in default handling, which currently means the decoder +creates a C object to hold the tag and the value. + +When the filter is cleared (the default state), the default filter +function, C, is used. This function simply looks +up the tag in the C<%CBOR::XS::FILTER> hash. If an entry exists it must be +a code reference that is called with tag and value, and is responsible for +decoding the value. If no entry exists, it returns no values. + +Example: decode all tags not handled internally into CBOR::XS::Tagged +objects, with no other special handling (useful when working with +potentially "unsafe" CBOR data). + + CBOR::XS->new->filter (sub { })->decode ($cbor_data); + +Example: provide a global filter for tag 1347375694, converting the value +into some string form. + + $CBOR::XS::FILTER{1347375694} = sub { + my ($tag, $value); + + "tag 1347375694 value $value" + }; =item $cbor_data = $cbor->encode ($perl_scalar) @@ -255,7 +325,7 @@ =item byte strings -Byte strings will become octet strings in Perl (the byte values 0..255 +Byte strings will become octet strings in Perl (the Byte values 0..255 will simply become characters of the same value in Perl). =item UTF-8 strings @@ -283,24 +353,12 @@ C<1> and C<0> (for true and false) or to throw an exception on access (for error). See the L manpage for details. -=item CBOR tag 256 (perl object) - -The tag value C<256> (TODO: pending iana registration) will be used -to deserialise a Perl object serialised with C. See L, below, for details. - -=item CBOR tag 55799 (magic header) +=item tagged values -The tag 55799 is ignored (this tag implements the magic header). +Tagged items consists of a numeric tag and another CBOR value. -=item other CBOR tags - -Tagged items consists of a numeric tag and another CBOR value. Tags not -handled internally are currently converted into a L -object, which is simply a blessed array reference consisting of the -numeric tag value followed by the (decoded) CBOR value. - -In the future, support for user-supplied conversions might get added. +See L and the description of C<< ->filter >> +for details. =item anything else @@ -353,11 +411,11 @@ =item other blessed objects Other blessed objects are serialised via C or C. See -L, below, for details. +L for specific classes handled by this +module, and L for generic object serialisation. =item simple scalars -TODO Simple Perl scalars (any scalar that is not a reference) are the most difficult objects to encode: CBOR::XS will encode undefined scalars as CBOR null values, scalars that have last been used in a string context @@ -368,7 +426,7 @@ encode_cbor [-3.0e17] # yields [-3e+17] my $value = 5; encode_cbor [$value] # yields [5] - # used as string, so dump as string + # used as string, so dump as string (either byte or text) print $value; encode_cbor [$value] # yields ["5"] @@ -382,6 +440,16 @@ $x .= ""; # another, more awkward way to stringify print $x; # perl does it for you, too, quite often +You can force whether a string ie encoded as byte or text string by using +C and C): + + utf8::upgrade $x; # encode $x as text string + utf8::downgrade $x; # encode $x as byte string + +Perl doesn't define what operations up- and downgrade strings, so if the +difference between byte and text is important, you should up- or downgrade +your string as late as possible before encoding. + You can force the type to be a CBOR number by numifying it: my $x = "3"; # some variable containing a string @@ -603,28 +671,43 @@ =head1 TAG HANDLING AND EXTENSIONS -This section describes how this module handles specific tagged values and -extensions. If a tag is not mentioned here, then the default handling -applies (creating a CBOR::XS::Tagged object on decoding, and only encoding -the tag when explicitly requested). +This section describes how this module handles specific tagged values +and extensions. If a tag is not mentioned here and no additional filters +are provided for it, then the default handling applies (creating a +CBOR::XS::Tagged object on decoding, and only encoding the tag when +explicitly requested). + +Tags not handled specifically are currently converted into a +L object, which is simply a blessed array reference +consisting of the numeric tag value followed by the (decoded) CBOR value. Future versions of this module reserve the right to special case -additional tags (such as bigfloat or base64url). +additional tags (such as base64url). + +=head2 ENFORCED TAGS + +These tags are always handled when decoding, and their handling cannot be +overriden by the user. =over 4 -=item (perl-object, L) +=item 26 (perl-object, L) -These tags are automatically created for serialisable objects using the -C methods (the L object serialisation -protocol). +These tags are automatically created (and decoded) for serialisable +objects using the C methods (the L object +serialisation protocol). See L for details. -=item , (sharable, sharedref, L ) +=item 28, 29 (sharable, sharedref, L ) These tags are automatically decoded when encountered, resulting in shared values in the decoded object. They are only encoded, however, when C is enabled. +=item 256, 25 (stringref-namespace, stringref, L ) + +These tags are automatically decoded when encountered. They are only +encoded, however, when C is enabled. + =item 22098 (indirection, L) This tag is automatically generated when a reference are encountered (with @@ -638,6 +721,94 @@ =back +=head2 NON-ENFORCED TAGS + +These tags have default filters provided when decoding. Their handling can +be overriden by changing the C<%CBOR::XS::FILTER> entry for the tag, or by +providing a custom C callback when decoding. + +When they result in decoding into a specific Perl class, the module +usually provides a corresponding C method as well. + +When any of these need to load additional modules that are not part of the +perl core distribution (e.g. L), it is (currently) up to the user to +provide these modules. The decoding usually fails with an exception if the +required module cannot be loaded. + +=over 4 + +=item 2, 3 (positive/negative bignum) + +These tags are decoded into L objects. The corresponding +C method encodes "small" bigints into normal CBOR +integers, and others into positive/negative CBOR bignums. + +=item 4, 5 (decimal fraction/bigfloat) + +Both decimal fractions and bigfloats are decoded into L +objects. The corresponding C method I +encodes into a decimal fraction. + +CBOR cannot represent bigfloats with I large exponents - conversion +of such big float objects is undefined. + +Also, NaN and infinities are not encoded properly. + +=item 21, 22, 23 (expected later JSON conversion) + +CBOR::XS is not a CBOR-to-JSON converter, and will simply ignore these +tags. + +=item 32 (URI) + +These objects decode into L objects. The corresponding +C method again results in a CBOR URI value. + +=back + +=cut + +our %FILTER = ( + # 0 # rfc4287 datetime, utf-8 + # 1 # unix timestamp, any + + 2 => sub { # pos bigint + require Math::BigInt; + Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 3 => sub { # neg bigint + require Math::BigInt; + -Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 4 => sub { # decimal fraction, array + require Math::BigFloat; + Math::BigFloat->new ($_[1][1] . "E" . $_[1][0]) + }, + + 5 => sub { # bigfloat, array + require Math::BigFloat; + scalar Math::BigFloat->new ($_[1][1])->blsft ($_[1][0], 2) + }, + + 21 => sub { pop }, # expected conversion to base64url encoding + 22 => sub { pop }, # expected conversion to base64 encoding + 23 => sub { pop }, # expected conversion to base16 encoding + + # 24 # embedded cbor, byte string + + 32 => sub { + require URI; + URI->new (pop) + }, + + # 33 # base64url rfc4648, utf-8 + # 34 # base64 rfc46484, utf-8 + # 35 # regex pcre/ecma262, utf-8 + # 36 # mime message rfc2045, utf-8 +); + =head1 CBOR and JSON @@ -729,6 +900,72 @@ =cut +our %FILTER = ( + # 0 # rfc4287 datetime, utf-8 + # 1 # unix timestamp, any + + 2 => sub { # pos bigint + require Math::BigInt; + Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 3 => sub { # neg bigint + require Math::BigInt; + -Math::BigInt->new ("0x" . unpack "H*", pop) + }, + + 4 => sub { # decimal fraction, array + require Math::BigFloat; + Math::BigFloat->new ($_[1][1] . "E" . $_[1][0]) + }, + + 5 => sub { # bigfloat, array + require Math::BigFloat; + scalar Math::BigFloat->new ($_[1][1])->blsft ($_[1][0], 2) + }, + + 21 => sub { pop }, # expected conversion to base64url encoding + 22 => sub { pop }, # expected conversion to base64 encoding + 23 => sub { pop }, # expected conversion to base16 encoding + + # 24 # embedded cbor, byte string + + 32 => sub { + require URI; + URI->new (pop) + }, + + # 33 # base64url rfc4648, utf-8 + # 34 # base64 rfc46484, utf-8 + # 35 # regex pcre/ecma262, utf-8 + # 36 # mime message rfc2045, utf-8 +); + +sub CBOR::XS::default_filter { + &{ $FILTER{$_[0]} or return } +} + +sub URI::TO_CBOR { + my $uri = $_[0]->as_string; + utf8::upgrade $uri; + CBOR::XS::tag 32, $uri +} + +sub Math::BigInt::TO_CBOR { + if ($_[0] >= -2147483648 && $_[0] <= 2147483647) { + $_[0]->numify + } else { + my $hex = substr $_[0]->as_hex, 2; + $hex = "0$hex" if 1 & length $hex; # sigh + CBOR::XS::tag $_[0] >= 0 ? 2 : 3, pack "H*", $hex + } +} + +sub Math::BigFloat::TO_CBOR { + my ($m, $e) = $_[0]->parts; + CBOR::XS::tag 4, [$e->numify, $m] +} + XSLoader::load "CBOR::XS", $VERSION; =head1 SEE ALSO