Data-Serializer
view release on metacpan or search on metacpan
lib/Data/Serializer.pm view on Meta::CPAN
sub _compress {
my $self = (shift);
$self->_module_loader($self->compressor);
if ($self->compressor eq 'Compress::Zlib') {
return Compress::Zlib::compress((shift));
} elsif ($self->compressor eq 'Compress::PPMd') {
my $compressor = Compress::PPMd::Encoder->new();
return $compressor->encode((shift));
}
}
sub _decompress {
my $self = (shift);
$self->_module_loader($self->compressor);
if ($self->compressor eq 'Compress::Zlib') {
return Compress::Zlib::uncompress((shift));
} elsif ($self->compressor eq 'Compress::PPMd') {
my $compressor = Compress::PPMd::Decoder->new();
return $compressor->decode((shift));
}
}
sub _create_token {
my $self = (shift);
return '^' . join('|', @_) . '^';
}
sub _get_token {
my $self = (shift);
my $line = (shift);
#Should be anchored to beginning
#my ($token) = $line =~ /\^([^\^]+?)\^/;
my ($token) = $line =~ /^\^([^\^]{1,120}?)\^/;
return $token;
}
sub _extract_token {
my $self = (shift);
my $token = (shift);
return split('\|',$token);
}
sub _remove_token {
my $self = (shift);
my $line = (shift);
$line =~ s/^\^[^\^]{1,120}?\^//;
return $line;
}
sub _deserialize {
my $self = (shift);
my $input = (shift);
my $method = (shift);
$self->_module_loader($method,"Data::Serializer"); #load in serializer module if necessary
my $serializer_obj = $self->_serializer_obj($method);
$serializer_obj->deserialize($input);
}
sub _encrypt {
my $self = (shift);
my $value = (shift);
my $cipher = (shift);
my $digester = (shift);
my $secret = $self->secret;
croak "Cannot encrypt: No secret provided!" unless defined $secret;
$self->_module_loader('Crypt::CBC');
my $digest = $self->_endigest($value,$digester);
my $cipher_obj = Crypt::CBC->new($secret,$cipher);
return $cipher_obj->encrypt($digest);
}
sub _decrypt {
my $self = (shift);
my $input = (shift);
my $cipher = (shift);
my $digester = (shift);
my $secret = $self->secret;
croak "Cannot encrypt: No secret provided!" unless defined $secret;
$self->_module_loader('Crypt::CBC');
my $cipher_obj = Crypt::CBC->new($secret,$cipher);
my $digest = $cipher_obj->decrypt($input);
return $self->_dedigest($digest,$digester);
}
sub _endigest {
my $self = (shift);
my $input = (shift);
my $digester = (shift);
$self->_module_loader('Digest');
my $digest = $self->_get_digest($input,$digester);
return "$digest=$input";
}
sub _dedigest {
my $self = (shift);
my $input = (shift);
my $digester = (shift);
$self->_module_loader('Digest');
#my ($old_digest) = $input =~ /^([^=]+?)=/;
$input =~ s/^([^=]+?)=//;
my $old_digest = $1;
return undef unless (defined $old_digest);
my $new_digest = $self->_get_digest($input,$digester);
return undef unless ($new_digest eq $old_digest);
return $input;
}
sub _get_digest {
my $self = (shift);
my $input = (shift);
my $digester = (shift);
my $ctx = Digest->new($digester);
$ctx->add($input);
return $ctx->hexdigest;
}
sub _enhex {
my $self = (shift);
return join('',unpack 'H*',(shift));
}
sub _dehex {
my $self = (shift);
return (pack'H*',(shift));
}
sub _enb64 {
my $self = (shift);
$self->_module_loader('MIME::Base64');
my $b64 = MIME::Base64::encode_base64( (shift), '' );
return $b64;
}
sub _deb64 {
my $self = (shift);
$self->_module_loader('MIME::Base64');
return MIME::Base64::decode_base64( (shift) );
}
# do all 3 stages
sub freeze { (shift)->serialize(@_); }
sub thaw { (shift)->deserialize(@_); }
sub serialize {
lib/Data/Serializer.pm view on Meta::CPAN
$obj->compress(1);
=item B<raw> - all calls to serializer and deserializer will automatically use raw mode
Setting this to a true value will force serializer and deserializer to work in raw mode
(see raw_serializer and raw_deserializer). The default is for this to be off.
If you desire this functionality you should look at L<Data::Serializer::Raw(3)> instead, it is
faster and leaner.
=item B<serializer> - change the serializer
Currently supports the following serializers:
=over 4
=item L<Bencode(3)>
=item L<Convert::Bencode(3)>
=item L<Convert::Bencode_XS(3)>
=item L<Config::General(3)>
=item L<Data::Denter(3)>
=item L<Data::Dumper(3)>
=item L<Data::Taxi(3)>
=item L<FreezeThaw(3)>
=item L<JSON(3)>
=item L<JSON::Syck(3)>
=item L<PHP::Serialization(3)>
=item L<Storable(3)>
=item L<XML::Dumper(3)>
=item L<XML::Simple(3)>
=item L<YAML(3)>
=item L<YAML::Syck(3)>
=back
Default is to use Data::Dumper.
Each serializer has its own caveat's about usage especially when dealing with
cyclical data structures or CODE references. Please see the appropriate
documentation in those modules for further information.
=item B<cipher> - change the cipher method
Utilizes L<Crypt::CBC(3)> and can support any cipher method that it supports.
=item B<digester> - change digesting method
Uses L<Digest(3)> so can support any digesting method that it supports. Digesting
function is used internally by the encryption routine as part of data verification.
=item B<compressor> - changes compresing module
Currently L<Compress::Zlib(3)> and L<Compress::PPMd(3)> are the only options
=item B<encoding> - change encoding method
Encodes data structure in ascii friendly manner. Currently the only valid options
are hex, or b64.
The b64 option uses Base64 encoding provided by L<MIME::Base64(3)>, but strips out newlines.
=item B<serializer_token> - add usage hint to data
L<Data::Serializer(3)> prepends a token that identifies what was used to process its data.
This is used internally to allow runtime determination of how to extract serialized
data. Disabling this feature is not recommended. (Use L<Data::Serializer::Raw(3)> instead).
=item B<options> - pass options through to underlying serializer
Currently is only supported by L<Config::General(3)>, and L<XML::Dumper(3)>.
my $obj = Data::Serializer->new(serializer => 'Config::General',
options => {
-LowerCaseNames => 1,
-UseApacheInclude => 1,
-MergeDuplicateBlocks => 1,
-AutoTrue => 1,
-InterPolateVars => 1
},
) or die "$!\n";
or
my $obj = Data::Serializer->new(serializer => 'XML::Dumper',
options => { dtd => 1, }
) or die "$!\n";
=item B<store> - serialize data and write it to a file (or file handle)
$obj->store({a => [1,2,3],b => 5},$file, [$mode, $perm]);
or
$obj->store({a => [1,2,3],b => 5},$fh);
Serializes the reference specified using the B<serialize> method
and writes it out to the specified file or filehandle.
If a file path is specified you may specify an optional mode and permission as the
next two arguments. See L<IO::File> for examples.
Trips an exception if it is unable to write to the specified file.
lib/Data/Serializer.pm view on Meta::CPAN
the module which inspired the creation of L<Data::Serializer(3)>.
And thanks to all of you who have provided the feedback
that has improved this module over the years.
In particular I'd like to thank Florian Helmberger, for the
numerous suggestions and bug fixes.
=head1 DEDICATION
This module is dedicated to my beautiful wife Erica.
=head1 REPOSITORY
L<http://github.com/neilneely/Data-Serializer/>
=head1 SEE ALSO
=over 4
=item L<Bencode(3)>
=item L<Convert::Bencode(3)>
=item L<Convert::Bencode_XS(3)>
=item L<Config::General(3)>
=item L<Data::Denter(3)>
=item L<Data::Dumper(3)>
=item L<Data::Taxi(3)>
=item L<FreezeThaw(3)>
=item L<JSON(3)>
=item L<JSON::Syck(3)>
=item L<PHP::Serialization(3)>
=item L<Storable(3)>
=item L<XML::Dumper(3)>
=item L<XML::Simple(3)>
=item L<YAML(3)>
=item L<YAML::Syck(3)>
=item L<Compress::Zlib(3)>
=item L<Compress::PPMd(3)>
=item L<Digest(3)>
=item L<Digest::SHA(3)>
=item L<Crypt::CBC(3)>
=item L<MIME::Base64(3)>
=item L<IO::File(3)>
=item L<Data::Serializer::Config::Wrest(3)> - adds supports for L<Config::Wrest(3)>
=back
=cut
( run in 0.711 second using v1.01-cache-2.11-cpan-e1769b4cff6 )