src/ObjectUtilities/ObjectStore.pm

#
# ObjectStore.pm
#
# Originally Written by Christopher Williams
#
# Description
# -----------
# An very simple object persistency manager for small scale use.
# Objects are saved and recovered on demand
# Objects to be stored in this manager must implement the following interface
#             new(ObjectStore)   : 
#             store(location)    : dump out to location
#             restore(location)  : restore from location
#               objects must inherit from StorableObject
#
# Interface
# ---------
# new(store_directory,[object]) : A new ObjectStore object. An alternative
#                                 object can be specified with which to
#                                 construct the stored objects with by
#                                 supplying the object reference
# store(oref,@keys)             : store an object - each object must have
#                                 a unique key
# find(@keys)                   : find and recover object(s) from the store
#                                 that match keys. Returned as a list of oref
# sequence(@keys)               : return the sequence number of the object
#                                 matching the keys
#                                 An object is assigned a new sequence number
#                                 with each store.
# delete(@keys)                 : Delete the object with the given key
# alias(\@refofkeys,\@aliaskeys) : attatch another set of keys to objects that 
#                                  match the refofkeys
#                                  note that these are references to the arrays
# unalias(@aliaskeys)            :remove an alias
# location()                     : return the top directory where the store is
#                                       located

package ObjectUtilities::ObjectStore;
require 5.004;
use Utilities::AddDir;
use Utilities::HashDB;

sub new {
        my $class=shift;
        my $dir=shift;
        $self={};
        # do we have an alternative object to instantiate objects with
        if ( @_ ) {
          $self->{storeobject}=shift;
        }
        else {
          $self->{storeobject}=$self;
        }
        bless $self, $class;
        $self->{location}=$dir;
        $self->{admindir}=$dir."/admin";
        AddDir::adddir($self->{admindir});
        if ( -d $dir ) { 
           $self->{storage}=$dir."/objects";
           AddDir::adddir($self->{storage});
           $self->_init();
        }
        else {
           return undef;
        }
        #print "ObjectStore  -- $self->{storeobject}\n";
        return $self;
}

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

sub store {
        my $self=shift;
        my $oref=shift;
        my @keys=@_;

        my $oreftype=ref($oref);
        #print "$self: Storing an object of type : $oreftype\n";
        my $filename=$self->_filename(@keys);
        $oref->store($self->_fullfilename($filename));
        # Update the sequence number to track changes
        my @seqnumbers=$self->{filehash}->getdata("__seq_number",@keys);
        my $seqnumb=((@seqnumbers)?$seqnumbers[0]:-1)+1;
        $self->{filehash}->deletedata("__seq_number",@keys);
        $self->{filehash}->setdata($seqnumb,"__seq_number",@keys);
        
        $self->{filehash}->deletedata(@keys);
        $self->{filehash}->setdata($filename,@keys); # persistent
        $self->{typehash}->deletedata($filename);
        $self->{typehash}->setdata($oreftype,$filename); # persistent
        $self->{orefhash}->deletedata($filename);
        $self->{orefhash}->setdata($oref,$filename); # transient
        $self->_storedb();
}

sub sequence {
        my $self=shift;
        my @keys=@_;

        my @seq=$self->{filehash}->getdata("__seq_number",@keys);
        return (($#seq == 0)?$seq[0]:-1);
}

sub find {
        my $self=shift;
        my @keys=@_;

        my @oref=();
        my $oref;
        my @types;
        my $type;
        my @validobjs=();
        my $fh;

        #print "$self: Searching for : @keys\n";
        my @datafiles=$self->{filehash}->getdata(@keys);
        foreach $file ( @datafiles ) {
          @oref=$self->{orefhash}->getdata($file);
          if ( $#oref < 0 ) {   # we need to instatniate it
             @types=$self->{typehash}->getdata($file);
             $type=$types[0];
             eval "require $type";
             $oref=$type->new($self->{storeobject});
             $oref->restore($self->_fullfilename($file));
          }
          else {
            $oref=$oref[0];
          }
          push @validobjs, $oref; 
        }
        return @validobjs;
}

sub alias {
        my $self=shift;
        $self->{filehash}->alias(@_);
        $self->_storedb();
}

sub unalias {
        my $self=shift;
        $self->{filehash}->unalias(@_);
        $self->_storedb();
}

sub delete {
        my $self=shift;
        my @keys=@_;

        my $filename=$self->_filename(@keys);
        $self->{filehash}->deletedata("__seq_number",@keys);
        $self->{filehash}->deletedata(@keys);
        $self->{typehash}->deletedata($filename);
        $self->{orefhash}->deletedata($filename);
        $self->_storedb();
        print "Deleting ".$self->_fullfilename($filename)."\n";
        unlink $self->_fullfilename($filename);
}

#
# Private routines
#
sub _filename {
        my $self=shift;
        my @keys=@_;

        my ($file)=$self->{filehash}->getdata(@keys);
        if ( ! defined $file ) {
          # need to generate a new filename - a random number will do
          srand();
          do {
            $file=int(rand 99999999)+1;
          } until ( ! ( -e $self->_fullfilename($file) ) );
        }       
        return $file;
}

sub _fullfilename {
        my $self=shift;
        my $file=shift;

        if ( $file!~/^\//  ) { # return only full path names
          $file=$self->{storage}."/".$file;
        }
        return $file;
}

sub _storedb {
        my $self=shift;
        $self->{filehash}->store($self->{admindir}."/filedb");
        $self->{typehash}->store($self->{admindir}."/typedb");
}

sub _restoredb {
        my $self=shift;
        if ( -f $self->{admindir}."/filedb" ) {
          $self->{filehash}->restore($self->{admindir}."/filedb");
          $self->{typehash}->restore($self->{admindir}."/typedb");
        }
}

sub _openfile {
        my $self=shift;
        my $filename=shift;

        local $fh=FileHandle->new();
        open ( $fh, $filename) or die "Unable to open $filename\n $!\n";
        return $fh;
}

sub _init {
        my $self=shift;
        $self->{filehash}=Utilities::HashDB->new();
        $self->{typehash}=Utilities::HashDB->new();
        $self->{orefhash}=Utilities::HashDB->new();
        $self->_restoredb();
}
Revision:	1.12
Committed:	Mon Aug 28 08:35:14 2000 UTC (24 years, 8 months ago) by williamc
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+7 -0 lines
Log Message:	remove Interface.pm
#	User	Rev	Content
1	williamc	1.1	#
2			# ObjectStore.pm
3			#
4			# Originally Written by Christopher Williams
5			#
6			# Description
7			# -----------
8			# An very simple object persistency manager for small scale use.
9			# Objects are saved and recovered on demand
10			# Objects to be stored in this manager must implement the following interface
11	williamc	1.2	# new(ObjectStore) :
12			# store(location) : dump out to location
13			# restore(location) : restore from location
14	williamc	1.5	# objects must inherit from StorableObject
15	williamc	1.1	#
16			# Interface
17			# ---------
18	williamc	1.3	# new(store_directory,[object]) : A new ObjectStore object. An alternative
19			# object can be specified with which to
20			# construct the stored objects with by
21			# supplying the object reference
22	williamc	1.1	# store(oref,@keys) : store an object - each object must have
23			# a unique key
24			# find(@keys) : find and recover object(s) from the store
25			# that match keys. Returned as a list of oref
26	williamc	1.2	# sequence(@keys) : return the sequence number of the object
27			# matching the keys
28			# An object is assigned a new sequence number
29			# with each store.
30	williamc	1.9	# delete(@keys) : Delete the object with the given key
31			# alias(\@refofkeys,\@aliaskeys) : attatch another set of keys to objects that
32			# match the refofkeys
33			# note that these are references to the arrays
34			# unalias(@aliaskeys) :remove an alias
35	williamc	1.12	# location() : return the top directory where the store is
36			# located
37	williamc	1.1
38			package ObjectUtilities::ObjectStore;
39			require 5.004;
40			use Utilities::AddDir;
41			use Utilities::HashDB;
42
43			sub new {
44			my $class=shift;
45			my $dir=shift;
46			$self={};
47	williamc	1.3	# do we have an alternative object to instantiate objects with
48			if ( @_ ) {
49			$self->{storeobject}=shift;
50			}
51			else {
52			$self->{storeobject}=$self;
53			}
54	williamc	1.1	bless $self, $class;
55	williamc	1.12	$self->{location}=$dir;
56	williamc	1.1	$self->{admindir}=$dir."/admin";
57			AddDir::adddir($self->{admindir});
58			if ( -d $dir ) {
59			$self->{storage}=$dir."/objects";
60			AddDir::adddir($self->{storage});
61			$self->_init();
62			}
63			else {
64			return undef;
65			}
66	williamc	1.9	#print "ObjectStore -- $self->{storeobject}\n";
67	williamc	1.1	return $self;
68			}
69
70	williamc	1.12	sub location {
71			my $self=shift;
72			return $self->{location};
73			}
74	williamc	1.1
75			sub store {
76			my $self=shift;
77			my $oref=shift;
78			my @keys=@_;
79
80			my $oreftype=ref($oref);
81	williamc	1.11	#print "$self: Storing an object of type : $oreftype\n";
82	williamc	1.2	my $filename=$self->_filename(@keys);
83	williamc	1.8	$oref->store($self->_fullfilename($filename));
84	williamc	1.2	# Update the sequence number to track changes
85			my @seqnumbers=$self->{filehash}->getdata("__seq_number",@keys);
86			my $seqnumb=((@seqnumbers)?$seqnumbers[0]:-1)+1;
87			$self->{filehash}->deletedata("__seq_number",@keys);
88			$self->{filehash}->setdata($seqnumb,"__seq_number",@keys);
89
90	williamc	1.1	$self->{filehash}->deletedata(@keys);
91			$self->{filehash}->setdata($filename,@keys); # persistent
92			$self->{typehash}->deletedata($filename);
93			$self->{typehash}->setdata($oreftype,$filename); # persistent
94			$self->{orefhash}->deletedata($filename);
95			$self->{orefhash}->setdata($oref,$filename); # transient
96			$self->_storedb();
97			}
98
99	williamc	1.2	sub sequence {
100			my $self=shift;
101			my @keys=@_;
102
103			my @seq=$self->{filehash}->getdata("__seq_number",@keys);
104	williamc	1.4	return (($#seq == 0)?$seq[0]:-1);
105	williamc	1.2	}
106
107	williamc	1.1	sub find {
108			my $self=shift;
109	williamc	1.3	my @keys=@_;
110	williamc	1.1
111			my @oref=();
112			my $oref;
113			my @types;
114			my $type;
115			my @validobjs=();
116			my $fh;
117
118	williamc	1.11	#print "$self: Searching for : @keys\n";
119	williamc	1.1	my @datafiles=$self->{filehash}->getdata(@keys);
120			foreach $file ( @datafiles ) {
121			@oref=$self->{orefhash}->getdata($file);
122			if ( $#oref < 0 ) { # we need to instatniate it
123			@types=$self->{typehash}->getdata($file);
124			$type=$types[0];
125			eval "require $type";
126	williamc	1.3	$oref=$type->new($self->{storeobject});
127	williamc	1.8	$oref->restore($self->_fullfilename($file));
128	williamc	1.1	}
129			else {
130			$oref=$oref[0];
131			}
132			push @validobjs, $oref;
133			}
134			return @validobjs;
135	williamc	1.9	}
136
137			sub alias {
138			my $self=shift;
139			$self->{filehash}->alias(@_);
140	williamc	1.10	$self->_storedb();
141	williamc	1.9	}
142
143			sub unalias {
144			my $self=shift;
145			$self->{filehash}->unalias(@_);
146	williamc	1.10	$self->_storedb();
147	williamc	1.9	}
148
149			sub delete {
150			my $self=shift;
151			my @keys=@_;
152
153			my $filename=$self->_filename(@keys);
154			$self->{filehash}->deletedata("__seq_number",@keys);
155			$self->{filehash}->deletedata(@keys);
156			$self->{typehash}->deletedata($filename);
157			$self->{orefhash}->deletedata($filename);
158			$self->_storedb();
159			print "Deleting ".$self->_fullfilename($filename)."\n";
160			unlink $self->_fullfilename($filename);
161	williamc	1.1	}
162
163			#
164			# Private routines
165			#
166			sub _filename {
167			my $self=shift;
168			my @keys=@_;
169
170	williamc	1.2	my ($file)=$self->{filehash}->getdata(@keys);
171	williamc	1.3	if ( ! defined $file ) {
172	williamc	1.2	# need to generate a new filename - a random number will do
173			srand();
174			do {
175	williamc	1.7	$file=int(rand 99999999)+1;
176			} until ( ! ( -e $self->_fullfilename($file) ) );
177	williamc	1.2	}
178	williamc	1.7	return $file;
179			}
180
181			sub _fullfilename {
182			my $self=shift;
183			my $file=shift;
184
185			if ( $file!~/^\// ) { # return only full path names
186			$file=$self->{storage}."/".$file;
187			}
188	williamc	1.2	return $file;
189	williamc	1.1	}
190
191			sub _storedb {
192			my $self=shift;
193			$self->{filehash}->store($self->{admindir}."/filedb");
194			$self->{typehash}->store($self->{admindir}."/typedb");
195			}
196
197			sub _restoredb {
198			my $self=shift;
199			if ( -f $self->{admindir}."/filedb" ) {
200			$self->{filehash}->restore($self->{admindir}."/filedb");
201			$self->{typehash}->restore($self->{admindir}."/typedb");
202			}
203			}
204
205			sub _openfile {
206			my $self=shift;
207			my $filename=shift;
208
209			local $fh=FileHandle->new();
210			open ( $fh, $filename) or die "Unable to open $filename\n $!\n";
211			return $fh;
212			}
213
214			sub _init {
215			my $self=shift;
216			$self->{filehash}=Utilities::HashDB->new();
217			$self->{typehash}=Utilities::HashDB->new();
218			$self->{orefhash}=Utilities::HashDB->new();
219			$self->_restoredb();
220			}