---
name: "KiokuDB::TypeMap::Composite"
section: "3pm"
platform: "linux"
package: "libkiokudb-perl"
version: "0.57-3"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/KiokuDB::TypeMap::Composite"
---

# KiokuDB::TypeMap::Composite(3pm)

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

## 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.