Nano::Nodes

Persistable Index

Persistable Index Super Class

method: add method: all method: count method: drop method: first method: get method: last method: order method: scope method: search method: serialize method: set

use Nano::Nodes;

my $nodes = Nano::Nodes->new(
  type => 'Nano::Node',
);

# $nodes->save;

Nano::Types

Nano::Node

orders: ro, opt, ArrayRef[CodeRef] scopes: ro, opt, ArrayRef[CodeRef] type: ro, req, Str

This package provides a persistable index super class. It is meant to be subclassed but can be used directly as well.

The add method creates a new object, adds it to the index, and returns the created object.

add(HashRef $data) : Object

=example-1 add

# given: synopsis

my $node = $nodes->add({ rand => time });

The all method proxies to the attached Nano::Search instance and returns the results.

all() : ArrayRef[Object]

=example-1 all

# given: synopsis

my $all = $nodes->all;

The count method proxies to the attached Nano::Search instance and returns the results.

count() : Int

=example-1 count

# given: synopsis

my $count = $nodes->count;

The drop method deletes the entire index and all of its indices.

drop() : Object

=example-1 drop

# given: synopsis

$nodes = $nodes->drop;

The first method proxies to the attached Nano::Search instance and returns the result.

first() : Maybe[Object]

=example-1 first

# given: synopsis

my $first = $nodes->first;

The get method returns the object (based on ID) from the index (if found).

get(Str $name) : Maybe[Object]

=example-1 get

# given: synopsis

my $result = $nodes->get('0000001');

The last method proxies to the attached Nano::Search instance and returns the result.

last() : Maybe[Object]

=example-1 last

# given: synopsis

my $last = $nodes->last;

The next method proxies to the attached Nano::Search instance and returns the result.

next() : Maybe[Object]

=example-1 next

# given: synopsis

my $next = $nodes->next;

The prev method proxies to the attached Nano::Search instance and returns the result.

prev() : Maybe[Object]

=example-1 prev

# given: synopsis

my $prev = $nodes->prev;

The order method registers a sort order (search ordering) and returns a new invocant instance.

order(CodeRef $callback) : Object

=example-1 order

# given: synopsis

$nodes = $nodes->order(sub {
  my ($a, $b) = @_;

  $a->id cmp $b->id
});

The scope method registers a scope (search filter) and returns a new invocant instance.

scope(CodeRef $callback) : Object

=example-1 scope

# given: synopsis

$nodes = $nodes->scope(sub {
  my ($node) = @_;

  !!$node->{active}
});

The search method returns a Nano::Search object associated with the invocant.

search() : Search

=example-1 search

# given: synopsis

my $search = $nodes->search;

The serialize method returns a persistence representaton of the invocant. Circular dependencies can result in a deep recursion error, however, circular dependencies can be persisted if modeled properly. Note: blessed objects which are neither Nano::Node nor Nano::Nodes will be ignored.

serialize() : HashRef

=example-1 serialize

# given: synopsis

my $serial = $nodes->serialize;

The set method adds the node object provided to the index and returns the provided object.

set(Node $object) : Object

=example-1 set

# given: synopsis

use Nano::Node;

my $node = Nano::Node->new(id => '0000003');

$node = $nodes->set($node);

cpanm Nano

perl -MCPAN -e shell
install Nano