dtRdr::Annotation::Range - range-derived annotations

  my $new_obj = $obj->renode($node, %props);

  $new_obj = $obj->dummy(%props);

  $hl->get_book;

  my $plain_hashref = $object->serialize;

  my $object = MyClass->deserialize($hashref, book => $book);

  $obj->clone;

package dtRdr::Annotation::Range;
$VERSION = eval{require version}?version::qv($_):$_ for(0.10.1);

use warnings;
use strict;
use Carp;


use base 'dtRdr::Annotation';
use base 'dtRdr::Selection';

use Class::Accessor::Classy;
rw 'title';
no  Class::Accessor::Classy;

{
  # a class for search results, currently pretty sparse
  package dtRdr::AnnoSelection;
  our @ISA = qw(dtRdr::Annotation::Range);
  use constant {ANNOTATION_TYPE => 'annoselection'};
}

use constant {IS_RANGE_TYPE => 1};

sub renode {
  my $self = shift;
  my $node = shift;
  (@_ % 2) and croak('odd number of elements in argument hash');
  my %props = @_;

  my $package = ref($self);
  return($package->create(
    range => $self,
    %props,
    id => $self->id,
    node => $node,
    is_fake => 1, # always set this
  ));
} # end subroutine renode definition
########################################################################

sub dummy {
  my $self = shift;
  (@_ % 2) and croak('odd number of elements in argument hash');
  my %props = @_;
  my $package = ref($self);
  my $new_obj = {%$self, %props};
  bless($new_obj, $package);
  return($new_obj);
} # end subroutine dummy definition
########################################################################

sub get_book {
  my $self = shift;
  $self->node->book;
} # end subroutine get_book definition
########################################################################

sub _IF_CANS () {
  qw(
    content
    title
    selected
    context
    revision
    create_time
    mod_time
  );
}
sub serialize {
  my $self = shift;
  $self->is_fake and
    croak("cannot serialize a fake (localized) annotation");

  my $get_loc = sub { $_[0]->offset};
  my $get_id  = sub { $_[0]->id};
  my %serializer = (
    book   => $get_id,
    node   => $get_id,
    start  => $get_loc,
    end    => $get_loc,
    id     => sub {$_[0]}, # by definition
    public => sub {return({%{$_[0]}})}, # so long as it stays plain
  );

  my %hash = map({
      my $val = $self->$_;
      defined($val) ? ($_ => $serializer{$_}->($val)) : ()
    }
    keys(%serializer)
  );

  # some special cases
  foreach my $attribute (_IF_CANS) {
    if($self->can($attribute)) {
      $hash{$attribute} = $self->$attribute;
    }
  }

  # generic special case
  if($self->can('augment_serialize')) {
    my %props = $self->augment_serialize;
    $hash{$_} = $props{$_} for(keys(%props));
  }

  # and remember our type
  $hash{type} = ref($self);

  return(\%hash);
} # end subroutine serialize definition
########################################################################

sub deserialize {
  my $package = shift;
  my ($hashref, @args) = @_;
  (@args % 2) and croak('odd number of elements in argument hash');
  my %args = @args;

  (ref($hashref) || '' eq 'HASH') or
    croak("'$hashref' is not a hash reference");

  my $book = $args{book};
  defined($book) or croak("must have a book");
  ($hashref->{book} eq $book->id) or croak("wrong book");

  my $node = $hashref->{node};
  defined($node) or croak "no node";
  $node = $book->toc->get_by_id($node);
  defined($node) or die;
  my %deserializer = (
    public => sub { dtRdr::AnnotationMeta::Public->new(%{$_[0]}) },
  );

  my $object = $package->create(
    map({
      ($package->can($_) ? ($_ => $hashref->{$_}) : ())
    } _IF_CANS
    ),
    node  => $node,
    range => [$hashref->{start}, $hashref->{end}],
    id    => $hashref->{id},
    map({exists($hashref->{$_}) ?
          ($_ => $deserializer{$_}->($hashref->{$_})) : ()
      } keys(%deserializer)
    ),
    # generic special case
    ($package->can('augment_deserialize') ?
      ($package->augment_deserialize(%$hashref, book => $book)) : ()
    ),
  );
  return($object);
} # end subroutine deserialize definition
########################################################################

sub clone {
  my $self = shift;
  my $clone = ref($self)->deserialize(
    $self->serialize, book => $self->book
  );
  return($clone);
} # end subroutine clone definition
########################################################################

# vi:ts=2:sw=2:et:sta
1;