Bread::Board::Types - types and coercions for Bread::Board

       Stevan Little <stevan@iinteractive.com>

       Please    report    any    bugs     or     feature     requests     on     the     bugtracker     website
       https://github.com/stevan/BreadBoard/issues

       When  submitting  a  bug  or request, please include a test-file or a patch to an existing test-file that
       illustrates the bug or desired feature.

       This software is copyright (c) 2019, 2017, 2016, 2015, 2014, 2013, 2011, 2009 by 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.

perl v5.36.0                                       2022-12-12                           Bread::Board::Types(3pm)

       This package defines types and coercions for Bread::Board.

       Bread::Board::Types - types and coercions for Bread::Board

"Bread::Board::Container::SubContainerList"
       A hashref mapping strings to instances of Bread::Board::Container or
       Bread::Board::Container::Parameterized.

       Can be coerced from an arrayref of containers: the keys will be the containers' names.

   "Bread::Board::Container::ServiceList"
       A hashref mapping strings to instances of Bread::Board::Service.

       Can be coerced from an arrayref of services: the keys will be the services' names.

   "Bread::Board::Service::Dependencies"
       Hashref mapping strings to instances of Bread::Board::Dependency.

       The values of the hashref can be coerced in several different ways:

       a string
           will be interpreted as the "service_path"

       a hashref with a single key
           the key will be interpreted as a "service_path", and the value as a hashref for "service_params"

       an arrayref
           each  element  will  be interpreted as a dependency (possibly through all the coercions listed here);
           see below for an example

       a service object
           will be interpreted as a dependency on that service

       a dependency object
           will be taken as-is

       Instead of a hashref of any of the above things, you can use an arrayref: it will be coerced to  hashref,
       using the (coerced) dependencies' names as keys.

       Examples

          service foo => (
            class => 'Foo',
            dependencies => {
              { bar => { attribute => 12 } },
            },
          );

       The  service "foo" depends on the parameterized service "bar", and "bar" will be instantiated passing the
       hashref "{ attribute => 12 }" to its "get" method.

          service foo => (
            class => 'Foo',
            dependencies => {
              things => [ 'bar', 'baz' ],
            },
          );

       The service "foo" depends on the services "bar" and "baz", and when instantiating "foo", its  constructor
       will receive something like "things => [ $instance_of_bar, $instance_of_baz ]".

          service foo => (
            class => 'Foo',
            dependencies => {
              things => [
                { bar => { attribute => 12 } },
                { bar => { attribute => 27 } },
              ],
            },
          );

       You  can  mix&match  the  coercions! This "foo" will get two different instances of "bar" in its "things"
       attribute, each "bar" instantiated with a different value.

   "Bread::Board::Service::Parameters"
       Hashref mapping strings to MooseX::Params::Validate specifications.

       Can be coerced from an arrayref of strings:

         [qw(a b c)]

       becomes:

         {
           a => { optional => 0 },
           b => { optional => 0 },
           c => { optional => 0 },
         }

       version 0.37