kiokudb::role::scan(3pm) [debian man page]

KiokuDB::Role::Scan(3pm)				User Contributed Perl Documentation				  KiokuDB::Role::Scan(3pm)

NAME

       KiokuDB::Role::Scan - A role for entry scanning.

SYNOPSIS

	   package My::Entry::Processor;
	   use Moose;

	   with 'KiokuDB::Role::Scan' => { result_class => "My::Entry::Processor::Results" };

	   sub process_block {
	       my ( $self, %args ) = @_;

	       $args{results}; # intermediate results

	       foreach my $entry ( @{ $args{block} } ) {

	       }
	   }

	   my $scan = My::Entry::Processor->new(
	       backend => $some_backend,
	   );

	   my $res = $scan->results;

	   $res->foo;

	   $scan->foo; # delegates to result

DESCRIPTION

       This role is used by classes like KiokuDB::LinkChecker to scan the whole database and computing summary results.

ROLE PARAMETERS

       result_class
	   The class of the results.

	   Will be used when creating the results initially by calling "new" and also sets up an attribute with delegations.

perl v5.12.4							    2010-10-11						  KiokuDB::Role::Scan(3pm)

KiokuDB::TypeMap::Composite(3pm)			User Contributed Perl Documentation			  KiokuDB::TypeMap::Composite(3pm)

NAME

       KiokuDB::TypeMap::Composite - A role for KiokuDB::TypeMaps created out of many smaller typemaps

SYNOPSIS

	   package MyTypeMap;
	   use Moose;

	   extends qw(KiokuDB::TypeMap);

	       with qw(KiokuDB::TypeMap::Composite);

	   # declare typemaps to inherit from using the KiokuDB::TypeMap trait
	   # the 'includes' attribute will be built by collecting these attrs:

	   has foo_typemap => (
	       traits => [qw(KiokuDB::TypeMap)], # register for inclusion
	       does   => "KiokUDB::Role::TypeMap",
	       is     => "ro",
	       lazy_build => 1,
	   );

	   # this role also provides convenience methods for creating typemap objects
	   # easily:
	   sub _build_foo_typemap {
	       my $self = shift;

	       $self->_create_typemap(
		   isa_entries => {
		       $class => {
			   type      => 'KiokuDB::TypeMap::Entry::Callback',
			   intrinsic => 1,
			   collapse  => "collapse",
			   expand    => "new",
		       },
		   },
	       );
	   }

	   sub _build_bar_typemap {
	       my $self = shift;

	       # create a typemap with one naive isa entry
	       $self->_naive_isa_typemap("Class::Foo", @entry_args);
	   }

	   # you also get some construction time customization:

	   MyTypeMap->new(
	       exclude => [qw(Class::Blort foo)],
	       override => {
		   "Class::Blah", => $alternate_entry,
	       },
	   );

DESCRIPTION

       This role provides a declarative, customizable way to set values for KiokuDB::TypeMap's "includes" attribute.

       Any class consuming this role can declare attributes with the trait "KiokuDB::TypeMap".

       The result is a typemap instance that inherits from the specified typemap in a way that is composable for the author and flexible for the
       user.

       KiokuDB::TypeMap::Default is created using this role.

ATTRIBUTES

       exclude
	   An array reference containing typemap attribute names (e.g. "path_class" in the default typemap) or class name to exclude.

	   Class exclusions are handled by "_create_typemap" and do not apply to already constructed typemaps.

       override
	   A hash reference of classes to KiokuDB::TypeMap::Entry objects.

	   Class overrides are handled by "_create_typemap" and do not apply to already constructed typemaps.

	   Classes which don't have a definition will not be merged into the resulting typemap, simply create a typemap of your own and inherit if
	   that's what you want.

METHODS

       _create_typemap %args
	   Creates a new typemap.

	   The entry arguments are converted before passing to "new" in KiokuDB::TypeMap:

	       $self->_create_typemap(
		   entries => {
		       Foo => {
			   type => "KiokuDB::TypeMap::Entry::Naive",
			   intrinsic => 1,
		       },
		   },
	       );

	   The nested hashref will be used as arguments to "new" in KiokuDB::TypeMap::Entry::Naive in this example.

	   "exclude" and "override" are taken into account by the hashref conversion code.

       _naive_isa_typemap $class, %entry_args
	   A convenience method to create a one entry typemap with a single inherited entry for $class of the type KiokuDB::TypeMap::Entry::Naive.

	   This is useful for when you have a base class that you'd like KiokuDB to persist automatically:

	       sub _build_my_class_typemap {
		   shift->_naive_isa_typemap( "My::Class::Base" );
	       }

perl v5.12.4							    2010-10-11					  KiokuDB::TypeMap::Composite(3pm)