File Coverage

blib/lib/Tie/Hash/ImmutableKeys.pm

Criterion	Covered	Total	%
statement	33	82	40.2
branch	7	28	25.0
condition	1	4	25.0
subroutine	8	12	66.6
pod	0	3	0.0
total	49	129	37.9

package Tie::Hash::ImmutableKeys;

use 5.008008;
use strict;
use warnings;

require Exporter;

use Tie::Hash;
use Carp;

#use vars qw($VERSION @ISA);

our @ISA = qw(Exporter Tie::StdHash);

# 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.

# This allows declaration	use Tie::Hash::ImmutableKeys ':all';
# If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
# will save memory.
#our %EXPORT_TAGS = (
#    'all' => [
#        qw(
#
#          )
#    ],
#);

our @EXPORT_OK = qw( error );

our @EXPORT = qw(

);

our $VERSION = sprintf "1.%02d", '$Revision: 14 $ ' =~ /(\d+)/;

our $__ERROR__ = "croak";

sub error
{
    $__ERROR__ = $_[1];
}

sub __HANDEL_ERROR__
{
    if ( $__ERROR__ =~ /croak/i )
    {
        Carp::croak "COULD NOT DELETE key=" . $_[0] . " the val=" . $_[1];
    }
    elsif ( $__ERROR__ =~ /exit/i )
    {
        exit;
    }
    else
    {
        Carp::carp "COULD NOT DELETE key=" . $_[0] . " the val=" . $_[1];
    }
}

sub TIEHASH
{
    my $class = $_[0];
    my $list  = $_[1];
    my %all;
    foreach my $k ( keys %$list )
    {
        if ( ( ref( $list->{ $k } ) ) =~ /HASH/i )
        {
            tie my %c, 'Tie::Hash::ImmutableKeys', $list->{ $k };
            $all{ $k } = \%c;
        }
        else
        {
            $all{ $k } = $list->{ $k };
        }
    }
    bless \%all, $class;
    return \%all;
}

sub DELETE
{
    if ( $_[2] )
    {
        delete $_[0]{ $_[1] };
    }
    else
    {

        my $line = ( caller( 0 ) )[2];
        my $sub = ( caller( 1 ) )[3] || "main";
        __HANDEL_ERROR__( $_[1], $_[2] );
    }
}

sub FORCE_DELETE
{
    my $class = $_[0];
    my $key   = $_[1];
    my $leaf  = $_[2];
    if ( ( ref( $key ) ) =~ /HASH/i )
    {
        foreach my $k ( keys %$key )
        {
            my %all;
            if ( ( ref( $key->{ $k } ) ) =~ /HASH/i )
            {
                tie( %all, 'Tie::Hash::ImmutableKeys', $class->{ $k } );
                my $obj = tied( %all );
                tie my %c, 'Tie::Hash::ImmutableKeys', $key->{ $k };
                $obj->FORCE_DELETE( $key->{ $k } );
                $class->{ $k } = \%all;
            }
            else
            {
                tie( %all, 'Tie::Hash::ImmutableKeys', $class->{ $k } );
                my $obj = tied( %all );
                $obj->FORCE_DELETE( $key->{ $k }, 1 );
                $class->{ $k } = \%all;
            }
        }
    }
    else
    {
        $class->SUPER::DELETE( $key ) if $leaf;
    }

}

sub STORE
{
    if ( $_[3] )
    {
        $_[0]{ $_[1] } = $_[2];
    }
    else
    {
        if ( exists $_[0]{ $_[1] } )
        {

            $_[0]{ $_[1] } = $_[2] if exists $_[0]{ $_[1] };
        }
        else
        {
            my $line = ( caller( 0 ) )[2];
            my $sub = ( caller( 1 ) )[3] || "main";
            __HANDEL_ERROR__( $_[1], $_[2] );
        }
    }
}

sub FORCE_STORE
{
    my $class = $_[0];
    my $key   = $_[1];
    my $val   = $_[2];
    if ( exists( $class->{ $key } ) )
    {
        if ( ( ref( $val ) ) =~ /HASH/i )
        {
            tie( my %all, 'Tie::Hash::ImmutableKeys', $class->{ $key } );
            my $obj = tied( %all );
            foreach my $k ( keys %$val )
            {
                if ( ( ref( $val->{ $k } ) ) =~ /HASH/i )
                {
                    tie my %c, 'Tie::Hash::ImmutableKeys', $val->{ $k };
                    $obj->FORCE_STORE( $k, \%c );
                }
                else
                {
                    $obj->STORE( $k, $val->{ $k }, 1 );
                }
            }
            $class->STORE( $key, \%all, 1 );
        }
        else
        {
            $class->SUPER::STORE( $key, $val );
        }
    }
    else
    {
        my %all;
        foreach my $k ( keys %$val )
        {
            if ( ( ref( $val->{ $k } ) ) =~ /HASH/i )
            {
                tie my %c, 'Tie::Hash::ImmutableKeys', $val->{ $k };
                $all{ $k } = \%c;
            }
            else
            {
                $all{ $k } = $val->{ $k };
            }
        }
        my %tmp;
        tie( %tmp, 'Tie::Hash::ImmutableKeys', \%all );
        $class->SUPER::STORE( $key, \%tmp );
    }
}

1;
__END__