--- CBOR-XS/XS.pm 2013/11/20 02:03:08 1.20 +++ CBOR-XS/XS.pm 2013/11/28 12:08:07 1.25 @@ -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]) @@ -184,7 +188,13 @@ 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 +(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 @@ -195,15 +205,76 @@ 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 -for L). +with L). -If C<$enable> is false (the default), then C will encode -exception when it encounters anything it cannot encode as CBOR. +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 +(http://cbor.schmorp.de/stringref), 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) @@ -282,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 tagged values -=item CBOR tag 55799 (magic header) +Tagged items consists of a numeric tag and another CBOR value. -The tag 55799 is ignored (this tag implements the magic header). - -=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 @@ -352,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 @@ -602,21 +661,31 @@ =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) -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 ) @@ -624,6 +693,11 @@ shared values in the decoded object. They are only encoded, however, when C is enabled. +=item , (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 @@ -637,6 +711,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 @@ -728,6 +890,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