NAME

MooseX::Types::FakeHash - Types for emulating Hash-like behaviours with ArrayRefs.

VERSION

version 0.1.2

SYNOPSIS

Standard Non-MooseX-Types style invocation

  package #
    Foo;

  use Moose;
  use MooseX::Types::FakeHash;

  has foo => (
    isa => 'KeyWith[ ArrayRef ]'
    is  => 'rw',
    required => 1,
  );

  has bar => (
    isa      => 'ArrayRef[ KeyWith[ Str ] ]',
    is       => 'rw',
    required => 1,
  );

  ....


  Foo->new(
    foo => [ Hello => [] ]
    bar => [
       [ "Content-Type" => "text/plain" ],
       [ "X-Zombies"    => "0"          ],
    ],
  );

MooseX-Types style invocation

  package #
    Foo;

  use Moose;
  use MooseX::Types::FakeHash qw( :all );
  use MooseX::Types::Moose    qw( :all );

  has foo => (
    isa => KeyWith[ ArrayRef ]
    is  => 'rw',
    required => 1,
  );

  has bar => (
    isa      => ArrayRef[ KeyWith[ Str ] ],
    is       => 'rw',
    required => 1,
  );

  ....


  Foo->new(
    foo => [ Hello => [] ]
    bar => [
       [ "Content-Type" => "text/plain" ],
       [ "X-Zombies"    => "0"          ],
    ],
  );

TYPES

KeyWith

KeyWith[ X ]

A parameterizable type intended to simulate a singular key/value pair stored in an array.

The keys is required to be of type Str, while the value is the parameterized type.

  has bar ( isa => KeyWith[ Foo ] , ... );

  ...

  ->new(
    bar => [ "Key" => $fooitem ] # [ Str, Foo ]
  );

FakeHash

FakeHash[ X ]

A parameterizable type intended to simulate the values of a HashRef, but stored in an ArrayRef instead as an even number of key/values.

The keys are required to be of type Str, while the value is the parameterized type.

  has bar ( isa => FakeHash[ Foo ] , ... );

  ...

  ->new(
    bar => [
      "Key"           => $fooitem,
      "AnotherKey"    => $baritem,
      "YetAnotherKey" => $quuxitem,
    ] # [ Str, Foo, Str, Foo, Str, Foo ]
  );

OrderedFakeHash

OrderedFakeHash[ X ]

A parameterizable type intended to simulate the values of a HashRef, but stored in an ArrayRef instead as an array of "KeyWith" items. This is much like a "FakeHash", but slightly different, in that the paring of the Key/Value is stricter, and numerical-offset based lookup is simpler.

  [
     [ "Key" => $value ],
     [ "Key" => $value ],
  ]

In essence, OrderedFakeHash[ x ] is ShortHand for ArrayRef[ KeyWith[ x ] ].

This makes it harder to convert to a native Perl 5 Hash, but somewhat easier to iterate pairwise.

  my $data = $object->orderedfakehashthing();
  for my $pair ( @($data) ){
    my ( $key, $value ) = @{ $pair };
    ....
  }

The keys are required to be of type Str, while the value is the parameterized type.

  has bar ( isa => OrderedFakeHash[ Foo ] , ... );

  ...

  ->new(
    bar => [
      [ "Key"           => $fooitem  ],
      [ "AnotherKey"    => $baritem  ],
      [ "YetAnotherKey" => $quuxitem ],
    ] # [ [ Str, Foo ],[ Str, Foo ],[ Str, Foo ] ]
  );

AUTHOR

Kent Fredric <kentnl@cpan.org>

COPYRIGHT AND LICENSE

This software is copyright (c) 2013 by Kent Fredric <kentnl@cpan.org>.

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