File Coverage

blib/lib/Storable/AMF0.pm

Criterion	Covered	Total	%
statement	77	78	98.7
branch	24	32	75.0
condition	4	4	100.0
subroutine	15	15	100.0
pod	6	6	100.0
total	126	135	93.3

package Storable::AMF0;
# vim: ts=8 sw=4 sts=4 et
use strict;
use warnings;
use Fcntl qw(:flock);
our $VERSION = '1.23';
use subs qw(freeze thaw);
use Exporter 'import';
use Carp qw(croak);
{   our @Bool = (bless( do{\(my $o = 0)},'JSON::PP::Boolean'), bless( do{\(my $o = 1)},'JSON::PP::Boolean'));
    local $@;
    eval {
	require Types::Serialiser;
	@Bool = (Types::Serialiser::false(), Types::Serialiser::true());
	1
    } or
    eval {
	require JSON::XS;
	@Bool = (JSON::XS::false(), JSON::XS::true());
	1
    };
};

# Items to export into callers namespace by default. Note: do not export
# names by default without a very good reason. Use EXPORT_OK instead.
# Do not simply export all your public functions/methods/constants.

our @EXPORT_TAGS_ALL = qw(
    freeze thaw	dclone
    retrieve lock_retrieve lock_store lock_nstore store nstore
    ref_lost_memory ref_clear
    deparse_amf new_amfdate perl_date
	    new_date
	    parse_option
	    parse_serializator_option
    );

our %EXPORT_TAGS = ( 'all' => \@EXPORT_TAGS_ALL);
our @EXPORT_OK = ( @EXPORT_TAGS_ALL );

sub retrieve($) {
    my $file = shift;
    my $lock = shift;

    open my $fh, "<:raw", $file or croak "Fail on open file \"$file\" for reading $!";
    flock $fh, LOCK_SH if $lock;
    my $buf;
    sysread $fh, $buf, (( sysseek $fh, 0, 2 ), sysseek $fh, 0,0)[0] ;
    return thaw($buf);
}

sub lock_retrieve($) {
    $_[1] = 1;
    goto &retrieve;
}

sub store($$) {
    my ( $object, $file, $lock ) = @_;

    my $freeze = \freeze($object);
    unless (defined $$freeze ){
        croak "Bad object $@";
    }
    else  {
        my $fh;
        if ($lock){
            open $fh, ">>:raw", $file or croak "Fail on open file \"$file\" for writing $!";
            flock $fh, LOCK_EX if $lock;
            truncate $fh, 0;
            seek $fh,0,0;
        }
        else {
            open $fh, ">:raw", $file or croak "Fail on open file \"$file\" for writing $!";
        }
        print $fh $$freeze if defined $$freeze;
        close $fh;
    };
}

sub lock_store($$) {
    $_[2] = 1;
    goto &store;
}
sub ref_lost_memory($);
sub ref_clear($);
{{
	require XSLoader;
	XSLoader::load( 'Storable::AMF', $VERSION );
        no warnings 'once';
        *nstore = \&store;
        *lock_nstore = \&lock_store;

	no strict 'refs';

	my $my_package = __PACKAGE__ . "::";
	for my $other_package ( "Storable::AMF::", "Storable::AMF3::" ){
            *{ $other_package . $_ } = *{ $my_package . $_} for qw(ref_clear ref_lost_memory VERSION);
	}
	*{"Storable::AMF::$_"} = *{"Storable::AMF0::$_"} for grep m/retrieve|store/, @EXPORT_OK;
}};

*refaddr = \&Scalar::Util::refaddr;
*reftype = \&Scalar::Util::reftype;

sub _ref_selfref($$);
sub _ref_selfref($$){
    require Scalar::Util;
    my $obj_addr = shift;
    my $value    = shift;
    my $addr     = refaddr($value);
    return unless defined $addr;
    if ( reftype($value) eq 'ARRAY' ) {

        return $$obj_addr{$addr} if exists $$obj_addr{$addr};
        $$obj_addr{$addr} = 1;
        _ref_selfref( $obj_addr, $_ ) && return 1 for @$value;
        $$obj_addr{$addr} = 0;
    }
    elsif ( reftype($value) eq 'HASH' ) {

        return $$obj_addr{$addr} if exists $$obj_addr{$addr};
        $$obj_addr{$addr} = 1;
        _ref_selfref( $obj_addr, $_ ) && return 1 for values %$value;
        $$obj_addr{$addr} = 0;
    }

    return;
}

sub ref_clear($) {
    my $ref = shift;
    my %addr;
    require Scalar::Util;
    return unless ( refaddr($ref));
    my @r;
    if ( reftype($ref) eq 'ARRAY' ) {
        @r    = @$ref;
        @$ref = ();
        ref_clear($_) for @r;
    }
    elsif ( reftype($ref) eq 'HASH' ) {
        @r    = values %$ref;
        %$ref = ();
        ref_clear($_) for @r;
    }
}

sub ref_lost_memory($) {
    my $ref = shift;
    my %obj_addr;
    return _ref_selfref( \%obj_addr, $ref );
}

1;
__END__