File Coverage

blib/lib/Sys/Export/Extent.pm

Criterion	Covered	Total	%
statement	97	98	98.9
branch	33	42	78.5
condition	22	34	64.7
subroutine	17	17	100.0
pod	9	9	100.0
total	178	200	89.0

package Sys::Export::Extent;

our $VERSION = '0.005'; # VERSION
# ABSTRACT: Represents a range of bytes and data that needs written there

use v5.26;
use warnings;
use experimental qw( signatures );
use Scalar::Util qw( blessed );
use Sys::Export qw( round_up_to_multiple :isa );
use Carp;


sub new($class, %attrs) {
   my $self= bless { name => delete $attrs{name} }, $class;
   # Some fields need to be initialized in a specific order:
   $self->block_size(delete $attrs{block_size}) if defined $attrs{block_size};
   $self->size(delete $attrs{size}) if defined $attrs{size};
   $self->data(delete $attrs{data}) if defined $attrs{data};
   $self->device_offset(delete $attrs{device_offset}) if defined $attrs{device_offset};
   $self->start_lba(delete $attrs{start_lba}) if defined $attrs{start_lba};
   # The rest have no interdependencies
   for (keys %attrs) {
      my $m= $self->can($_) or croak "Unknown attribute '$_'";
      $m->($self, $attrs{$_});
   }
   $self;
}


sub coerce($class, $x) {
   return $x if blessed($x) && $x->isa($class);
   return $class->new(%$x) if isa_hash $x;
   croak "Don't know how to coerce $x into $class";
}


sub name($self) { $self->{name} // 'extent' }

sub block_size($self, @v) {
   if (@v) {
      croak "block_size $v[0] not a power of 2" unless isa_pow2 $v[0];
      $self->{block_size}= $v[0];
   }
   $self->{block_size} // 512;
}


sub size($self, @v) {
   if (@v) {
      croak "Attempt to change ector length of ".$self->name." after choosing LBA"
         if ($self->{size} // 0) > 0 && ($self->device_offset // -1) >= 0
            && round_up_to_multiple($v[0], $self->block_size) != round_up_to_multiple($self->{size}, $self->block_size);
      $self->{size}= $v[0];
   }
   $self->{size}
}


sub device_offset($self, @v) {
   if (@v) {
      croak "device_offset $v[0] not a multiple of ".$self->block_size
         if ($v[0]//0) > 0 && ($v[0] & ($self->block_size-1));
      $self->{device_offset}= $v[0];
   }
   $self->{device_offset}
}


sub start_lba($self, @v) {
   if (@v) {
      $self->device_offset($v[0] && ($v[0] * $self->block_size));
   }
   my $ofs= $self->device_offset;
   use integer;
   return defined $ofs && $ofs >= 0? ($ofs / $self->block_size) : undef;
}

*lba= *start_lba;

sub end_lba($self, @v) {
   if (@v) {
      my $lba= $self->start_lba;
      croak "Can't set end_lba until start_lba is defined"
         unless defined $lba;
      # Using 'size' accessor would trigger the check for altering the size after setting
      # device offset, which is less likely to be a useful safeguard when someone is setting
      # start_lba/end_lba.
      $self->{size}= ($v[0] + 1 - $lba) * $self->block_size;
   }
   my ($ofs, $size)= ($self->device_offset, $self->size);
   use integer;
   return ($ofs//-1) < 0 || !$size ? undef : ($ofs + $size - 1) / $self->block_size;
}


sub data($self, @v) {
   if (@v) {
      croak "data must be a scalar-ref or LazyFileData object"
         if defined $v[0] && !isa_data_ref $v[0];
      $self->{data}= $v[0];
   }
   $self->{data}
}

# Avoiding dependency on namespace::clean
delete @{Sys::Export::Extent::}{qw(
   carp croak confess blessed isa_array isa_data_ref isa_export_dst isa_exporter isa_group
   isa_handle isa_hash isa_int isa_pow2 isa_user isa_userdb round_up_to_multiple
)};
1;

__END__