use Moose;
use Method::Signatures::Simple;
use Data::Perl::Stream::Array;
+use Data::Perl::Collection::Set;
use Scalar::Util qw(weaken refaddr);
has _store => (is => 'ro', required => 1, init_arg => 'store');
values %{$self->_key_cache}
}
+method _set_key_cache_members ($members) {
+ %{$self->_key_cache} = (map +($self->_object_to_id($_) => $_), @$members);
+ return
+}
+
## observers
has _observer_callbacks => (
$self->_remove_from_caches($payload);
} elsif ($event eq 'all_members') {
# separate arrayref since future add will trigger push()
- $self->_set_member_cache([ @$payload ]);
+ $self->_set_caches([ @$payload ]);
}
});
return
# (this is used for pk-generated values and later lazy loading)
#
# _deflate_spec is attributes of final repr -> raw data
+# _merge_spec is final repr + extra attributes and update repr
method _inflate ($raw) {
bless($raw, $self->_class) if $self->_has_class;
$spec
}
+method _merge_spec ($obj, $spec) {
+ @{$obj}{keys %$spec} = values %$spec;
+ $obj
+}
+
## methods to get ids
method _raw_to_id ($raw) {
## array-ish operations - i.e. get all members
method _new_raw_stream {
- $self->_store->new_select_command([])->execute
+ $self->_store->new_select_command({})->execute
}
method flatten {
Data::Perl::Stream::Array->new(array => $self->_member_cache);
}
+# theoretically inefficient except that if we're being asked this then
+# either the data should have been pre-loaded or we're going to get all
+# elements anyway
+
+method count {
+ scalar $self->flatten
+}
+
+method map ($sub) {
+ Data::Perl::Collection::Set->new(
+ members => [ map $sub->($_), $self->flatten ]
+ )
+}
+
+method _set_caches ($members) {
+ $self->_set_member_cache($members);
+ $self->_set_key_cache_members($members);
+ return
+}
+
## load single row
method get ($spec) {
$self->_store->new_select_single_command($raw)->execute
}
-## add to set
+## add member
method add ($new) {
$self->_add_to_store($new);
$new
}
-## remove from set
+## remove member
method remove ($old) {
$self->_remove_from_store($old);
$old
}
-## update
+## update member
method _update_in_store ($obj) {
# this is currently a call command but we should think about it
$self->_store->new_update_single_command($self->_deflate($obj))->execute
}
+# I do wonder if we needed _merge_spec or if we'd be better off with
+# just using the raw merge routine ...
+
+method _update_set_in_store ($spec) {
+ $self->_store->new_update_command($self->_deflate_spec($spec))->execute;
+ if ($self->_member_cache_built) {
+ my $cache = $self->_member_cache;
+ foreach my $obj (@{$cache}) {
+ $self->_merge_spec($obj, $spec);
+ }
+ $self->_notify_observers(all_members => $cache);
+ }
+ return
+}
+
+method _remove_set_from_store {
+ $self->_store->new_delete_command->execute;
+ $self->_set_caches([]);
+ $self->_notify_observers(all_members => []);
+ return
+}
+
1;