NAME

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

VERSION

version 0.57

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" );
}

AUTHOR

Yuval Kogman <nothingmuch@woobling.org>

COPYRIGHT AND LICENSE

This software is copyright (c) 2014 by Yuval Kogman, Infinity Interactive.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.