Great reference about serializing inside-out objects. If I give an extended version of the talk at a conference, I'll probably include that.

For now these options are specified as string values representing the method names. Its possible a later version will extend this to also handle codrefs.

I'm still a little fuzzy on DDS's freeze/thaw handlers. Part of your description reads as if DDS might look for a Freeze() method, but the docs read like one has to register the freezing method name via DDS->Freeze (or rather DDS->FreezeClass) first. Could you give a code example?

So I think that's different from what Storable does looking for a STORABLE_freeze method. Any thought of supporting a DDS_freeze method directly if one exists?

Regarding the equivelent to Storable, just use the Freeze()/Thaw() method (as per Data::Dumper) to register the method. Im reluctant to hard code the method names as I dont think it scales well.

use DDS;

sub Popsicle::Freeze {
    my ($self)=@_;
    $_[0]=bless \do{my $x=join "-",@$self},ref $self;
}

sub Popsicle::Thaw {
    my ($self)=@_;
    $_[0]=bless [ map {split /-/,$_ } $$self ],ref $self;
}

my $ig=bless ["A".."C"],"Popsicle";
my %h=(One=>1,Two=>2,Three=>$ig);

# "fix" statement thaw...
Dump->Names('first')
   ->FreezeClass('Popsicle'=>'Freeze')
   ->ThawClass('Popsicle'=>'Thaw')
   ->Data( \%h )->Out;
print "\n";

# inline thaw....
Dump->Names('second')
   ->FreezeClass('Popsicle'=>'Freeze')
   ->ThawClass('Popsicle'=>'->Thaw')
   ->Data( \%h )->Out;
print "\n";


# clear the hooks for Popsicle
Dump->Names('third')
   ->FreezeClass('Popsicle'=>'')
   ->ThawClass('Popsicle'=>'')
   ->Data( \%h )->Out;
print "\n";

# Using FreezeThaw to make it a bit easier...
Dump->Names('fourth')
    ->FreezeThaw('Popsicle'=>'Freeze','->Thaw')
    ->Data( \%h )->Out;
print "\n";

# Using generic hooks and not class specific ones
Dump->Names('fifth')
    ->Freeze('Freeze')
    ->Thaw('->Thaw')
    ->Data( \%h )->Out;
print "\n";

__END__
$first = {
           One   => 1,
           Three => bless( \do { my $v = 'A-B-C' }, 'Popsicle' ),
           Two   => 2
         };
$first->{Three}->Thaw();

$second = {
            One   => 1,
            Three => bless( \do { my $v = 'A-B-C' }, 'Popsicle' )->Tha
+w(),
            Two   => 2
          };

$third = {
           One   => 1,
           Three => bless( [
                      'A',
                      'B',
                      'C'
                    ], 'Popsicle' ),
           Two   => 2
         };

$fourth = {
            One   => 1,
            Three => bless( \do { my $v = 'A-B-C' }, 'Popsicle' )->Tha
+w(),
            Two   => 2
          };

$fifth = {
           One   => 1,
           Three => bless( \do { my $v = 'A-B-C' }, 'Popsicle' )->Thaw
+(),
           Two   => 2
         };
[download]

---
$world=~s/war/peace/g

Im reluctant to hard code the method names as I dont think it scales well.

I'd like to better understand your reasoning. One advantage of the Storable approach is that it's defines an interface that modules can implement in order to manage their interoperability with Storable. E.g. Object::InsideOut and Class::Std::Storable.

-xdg

Code written by xdg and posted on PerlMonks is public domain. It is provided as is with no warranties, express or implied, of any kind. Posted code may not have been tested. Use of posted code is at your own risk.