File Coverage

blib/lib/Pixie/Store.pm

Criterion	Covered	Total	%
statement	36	72	50.0
branch	5	14	35.7
condition	2	2	100.0
subroutine	9	23	39.1
pod	4	18	22.2
total	56	129	43.4

package Pixie::Store;

use strict;
our $VERSION="2.06";
my %typemap = ( memory => 'Pixie::Store::Memory',
                bdb => 'Pixie::Store::BerkeleyDB',
                dbi => 'Pixie::Store::DBI', );

use Scalar::Util qw/weaken/;
use Carp;

#use overload
#  '""' => 'as_string';

sub as_string {
  my $proto = shift;
  my $str;
  if (ref $proto) {
    $str .= ref($proto);
    $str .= ": $proto->{spec}" if $proto->{spec};
  }
  else {
    $str .= $proto;
  }
  return $str;
}

sub connect {
  my $proto = shift;
  my $spec = shift;
  my($type, $path) = split(':', $spec, 2);

  $type = lc($type);
  die "Invalid database spec" unless exists $typemap{$type};

  eval "require " . $typemap{$type};
  die $@ if $@;

  my $self = $typemap{$type}->connect($path,@_);
  $self->{spec} = $spec;
  return $self;
}

sub object_graph_for {
  my $self = shift;
  my $pixie = shift;

  my $graph = $pixie->get_object_named('PIXIE::Node Graph');
  unless ($graph) {
    $graph = Pixie::ObjectGraph->new;
    $pixie->bind_name('PIXIE::Node Graph' => $graph);
  }
  return $graph;
}


sub remove_from_store {
  my $self = shift;
  my($oid) = @_;

  $self->remove_from_rootset($oid)
       ->_delete($oid);
}

# Low level locking

sub locked_set {
    my $self = shift;
    return $self->{locked_set} ||= {};
}

sub lock_object_for {
    my $self = shift;
    my($oid, $locker) = @_;
    $self->locked_set->{ $oid } = $locker->_oid;
    return 1;
}

sub unlock_object_for {
    my $self = shift;
    my $oid = shift;
    delete $self->locked_set->{$oid};
}

sub release_all_locks {
    my $self = shift;
    my $locked_set = $self->locked_set;
    $self->unlock_object_for(@$_)
        for map {[$_ => $locked_set->{$_}]}
            keys %$locked_set;
    return $self;
}

sub add_to_rootset {
  my $self = shift;
  my $thing = shift;
  $self->_add_to_rootset($thing) unless $self->is_hidden($thing);
}

sub is_hidden {
  my $self = shift;
  my $thing = shift;

  $thing->PIXIE::oid =~ /^
}

sub _add_to_rootset { $_[0]->subclass_responsibility(@_) }

sub remove_from_rootset {
  $_[0]->subclass_responsibility($_[0]);
}

sub rootset {
  $_[0]->subclass_responsibility;
}

sub lock     { $_[0]->subclass_responsibility(@_) }
sub unlock   { $_[0]->subclass_responsibility(@_) }
sub rollback { $_[0]->subclass_responsibility(@_) }


sub lock_for_GC {
  my $self = shift;
  $self->lock;
}

sub unlock_after_GC {
  my $self = shift;
  $self->unlock;
}

sub subclass_responsibility {
  my $self = shift;
  require Carp;
  Carp::carp( (caller(1))[3], " not implemented for ", ref($self) );
  return wantarray ? @_ : $_[-1];
}

sub DESTROY {
    my $self = shift;
    $self->release_all_locks;
}

1;

__END__