Data-Rebuilder

 view release on metacpan or  search on metacpan

lib/Data/Rebuilder.pm  view on Meta::CPAN

               }
               elsif( $self->_is_cycled($v) ) {

                 push @body, "    undef,";
                 my $lazy = $self->_lazy->{ refaddr $v } ||= [];
                 push( @$lazy ,
                       sprintf('%s->[%s] = %s;',
                               $var, $i, $self->freeze($v)));
                 push( @$lazy ,
                       sprintf('Scalar::Util::weaken(%s->[%s]);',
                               $var, $i))
                   if isweak($ref->[$i]);

               }
               elsif( $self->poly->type($v) eq 'RefRef'  and
                      $self->_is_cycled($$v)){
                 push @body, "    undef, #cycled RefRef ";
                 my $lazy = $self->_lazy->{refaddr $$v} ||= [];
                 push @{$lazy}, sprintf('%s->[%s] = %s;',
                                        $var,
                                        $i,
                                        $self->poly->apply( $v => 'freeze'));
                 push( @$lazy ,
                       sprintf('Scalar::Util::weaken(%s->[%s]);',
                               $var, $i))
                   if isweak($ref->[$i]);
               }
               else {

                 push @body , "    ". $self->freeze($v).",";
                 push @weak , $i , if isweak( $ref->[$i] );

               }
             }

lib/Data/Rebuilder.pm  view on Meta::CPAN

                "do{ ",
                '  # ArrayRef',
                "  my \$__tmp = [",
                @body ,
                "  ];",
                "  "._indent( join "\n",
                              map{ $self->tier('$__tmp->['.$_->[0].']',
                                               'TIESCALAR',
                                               $_->[1]) } @tied ),
                "  "._indent( join "\n",
                              map{ sprintf(' Scalar::Util::weaken('.
                                           '  $__tmp->[%s] );' ,
                                           $_) } @weak ),
                '  $__tmp;',
                "}"
               );
           },

           #################################
           'HashRef' => sub{
             my $ref    = shift;

lib/Data/Rebuilder.pm  view on Meta::CPAN

                   sprintf('      %s => undef, # cycled', $self->freeze($key));

                 my $lazy = $self->_lazy->{ refaddr $v } ||= [];

                 push( @$lazy , sprintf('%s->{%s} = %s;',
                                         $var,
                                         $self->freeze($key),
                                         $self->freeze($v)));

                 push( @$lazy ,
                       sprintf('Scalar::Util::weaken(%s->{%s});',
                               $var,
                               $self->freeze($key)
                              )) if isweak($ref->{$key});

               }
               elsif( $self->poly->type($v) eq 'RefRef'  and
                      $self->_is_cycled($$v)){

                 push @body, sprintf('      %s => undef, # cycled RefRef',
                                    $self->freeze($key));

                 my $lazy = $self->_lazy->{refaddr $$v} ||= [];

                 push @{$lazy}, sprintf('%s->{%s} = %s;',
                                        $var,
                                        $self->freeze($key),
                                        $self->freeze($v));

                 push( @$lazy ,
                       sprintf('Scalar::Util::weaken(%s->{%s});',
                               $var,
                               $self->freeze($key),
                              )) if isweak($ref->{$key});

               }
               else {
                 push @body ,
                   sprintf('      %s => %s,',
                           $self->freeze($key), $self->freeze($v));
                 push @weak , $key, if isweak( $ref->{$key} );

lib/Data/Rebuilder.pm  view on Meta::CPAN

               (
                "\n" ,
                "do{ ",
                '  # HashRef',
                "  my \$__tmp = {",
                @body ,
                "  };",
                ( map{ $self->tier('$__tmp->{'.$self->freeze($_->[0]).'}',
                                   'TIESCALAR',
                                   $_->[1]) } @tied ),
                ( map{ sprintf(' Scalar::Util::weaken( \ $__tmp->{%s} );' ,
                               $self->freeze($_)) }
                  @weak ),
                '  $__tmp;',
                "}"
               );
           },

           #################################
           'GlobRef' => sub{
             my $glob   = shift;

t/40-weak.t  view on Meta::CPAN

BEGIN{ require "t/lib/t.pl"; &init; }
use Test::More tests => 4;
use Scalar::Util qw( isweak weaken );

{
  my $b = Data::Rebuilder->new;
  my $array = [ "hoge" ];
  $array->[1] = $array;
  weaken( $array->[1] );
  my $rebuilt =  $b->_t( $array );
  ok( isweak( $rebuilt->[1] ) );
}

{
  my $b = Data::Rebuilder->new;
  my $array = [ "hoge" ];
  $array->[1] = \$array;
  $array->[2] = \$array;
  weaken( $array->[1] );
  my $rebuilt =  $b->_t( $array );
  ok( isweak( $rebuilt->[1] ) );
}

{
  my $b = Data::Rebuilder->new;
  my $hash = { foo => "hoge" };
  $hash->{bar} = $hash;
  weaken( $hash->{bar} );
  my $rebuilt =  $b->_t( $hash );
  ok( isweak( $rebuilt->{bar} ) );
}

{
  my $b = Data::Rebuilder->new;
  my $hash = { foo => "hoge" };
  $hash->{bar} = \ $hash;
  $hash->{bazz} = \ $hash;
  weaken( $hash->{bar} );
  my $rebuilt =  $b->_t( $hash );
  ok( isweak( $rebuilt->{bar} ) );
}