NAME

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

VERSION

       version 0.56

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) 2013 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.