1 package Parse::Binary::Nested;
11 my ($class, $format) = @_;
12 ref $format eq 'ARRAY'
13 or croak "Invalid Parse::Binary::Nested format: should be an array ref";
14 bless $format, $class;
18 my ($self, $format) = @_;
19 # total (flattened) unpack template from nested format definitions
21 my $value = $format->[-($_ << 1) - 1];
22 if (ref $value eq 'ARRAY') {
23 my $count = $value->[0];
24 $value = $self->template($value);
25 $value = $count =~ s/^([*\d]+)// ? "$count($value)$1"
26 : $count."X[$count]$count/($value)";
29 $value =~ s/^C(a)(\d+)/$1 . ($2 + 1)/e; # length prefix
32 } reverse 0 .. ($#$format - 1) >> 1;
36 my ($self, $format, $data) = @_;
37 # map flat results into a named and nested hash
39 while (my ($field, $template) = splice @$format, 0, 2) {
40 if (ref $template eq 'ARRAY') {
41 my ($count, @subformat) = @$template;
42 my $max = $count =~ s/^(\d+)// ? $1 : 0;
43 $count = !$count ? $max
44 : $count eq '*' ? $res{levelcount}->{total} : shift @$data;
45 $res{$field}->[$_] = $self->convert([@subformat], $data) for 0 .. ($max || $count)-1;
46 splice @{ $res{$field} }, $count if $max > $count;
47 $res{$field} = $res{$field}->[0] if $max == 1;
50 elsif ($template =~ /^Ca/) {
51 $data->[0] = unpack 'C/a', $data->[0];
53 elsif ($template =~ /^(?:[xX]\d*)*$/) {
56 $res{$field} = shift @$data;
62 my ($self, $input) = @_;
63 my @data = unpack $self->template($self), $input;
64 return $self->convert([@$self], \@data);
71 Parse::Binary::Nested - Structured unpack
75 use Parse::Binary::Nested;
76 my $parser = Parser::Binary::Nested->new([
85 my $data = $parser->unpackf("\1foo\0.rest");
86 print $data->{foos}->[0]->{message};
90 Converts a string into a hash of values, just like C<unpack>
91 except that it allows you to name and nest the resulting elements.
93 Format declarations are simalar to C<pack> templates,
94 with the following additions:
100 An array ref groups additional declarations,
101 with the first value specifying a repetition. If this count is variable,
102 the resulting value will be an array ref of hashes.
104 repeat => ['C', name => 'a*', value => 'S']
106 With a count of 1, it will return only a hash ref,
107 thereby simply grouping declarations:
110 test => [1, foo => 'C']
114 A template value of C<Ca$length> is recognised as a length-preceded string
115 with a constant (maximal) size, and will return only the string adjusted
117 This behaviour is very similar to C<(C/a@x$length)>, except that it never reads
118 more than the given number of bytes.
124 Mischa POSLAWSKY <perl@shiar.org>