NAME

OP::Hash - Hashtable object

DESCRIPTION

Extends OP::Object to handle Perl HASH refs as OP Objects. Provides constructor, getters, setters, "Ruby-esque" collection, and other methods which one might expect a Hash table object to respond to.

INHERITANCE

This class inherits additional class and object methods from the following packages:

OP::Class > OP::Object > OP::Hash

SYNOPSIS

use OP::Hash;

my $hash = OP::Hash->new();

my $hashFromNonRef = OP::Hash->new(%hash); # Makes new ref

my $hashFromRef = OP::Hash->new($hashref); # Keeps orig ref

PUBLIC CLASS METHODS

• $class->assert(*@rules)

  Return a new OP::Type::Hash instance.

  Hash() simply specifies that the attribute's value is a free-form hashtable. No further validation will be performed against the value, other than to make sure it's a HASH (or OP::Hash) reference.

  Hash() is intended for cases where arbitrary, extrinsic hashtable- formatted data, with keys not known in advance, needs to be stored within an object. It should not be used as a replacement for ExtID() linked to a properly modeled class.

  The key/value pairs in the stored hash live in a dynamically subclassed linked table, with foreign key constraints against the parent table.

  #
  # File: Example.pm
  #
  use OP;
  
  create "OP::Example" => {
    inlineHash => OP::Hash->assert()
  };

  In caller:

  #!/bin/env perl
  #
  # File: somecaller.pl
  #
  
  use strict;
  use warnings;
  
  use OP::Example;
  
  my $example = OP::Example->spawn("Inline Hash Example");
  
  $example->setInlineHash({ foo => bar });
  
  $example->save();

PUBLIC INSTANCE METHODS

• $hash->collect($sub), yield(item, [item, ...]), emit(item, [item...])

  Ruby-esque key iterator method. Returns a new OP::Array, containing the yielded results of calling the received sub for each key in $hash.

  $hash->collect is shorthand for $hash->keys->collect, so you're really calling collect in OP::Array. yield and emit are exported by OP::Array. Please see the documentation for OP::Array regarding usage of collect, yield, and emit.

  #
  # For example, quickly wrap <a> tags around array elements:
  #
  my $tagged = $object->collect( sub {
    print "Key $_ is $object->{$_}\n";
  
    emit "<a name=\"$_\">$object->{$_}</a>";
  } );

• $self->each($sub)

  List iterator method. Runs $sub for each element in self; returns true on success.

  my $hash = OP::Hash->new(
    foo => "uno",
    bar => "dos",
    rebar => "tres"
  );
  
  $hash->each( sub {
    print "Have key: $_, value: $hash->{$_}\n";
  } );
  
  #
  # Expected output:
  #
  # Have key: foo, value: uno
  # Have key: bar, value: dos
  # Have key: rebar, value: tres
  #

• $self->keys()

  Returns an OP::Array object containing self's alpha sorted keys.

  my $hash = OP::Hash->new(foo=>'alpha', bar=>'bravo');
  
  my $keys = $hash->keys();
  
  print $keys->join(','); # Prints out "bar,foo"

• $self->values()

  Returns an OP::Array object containing self's values, alpha sorted by key.

  my $hash = OP::Hash->new(foo=>'alpha', bar=>'bravo');
  
  my $values = $hash->values();
  
  print $values->join(','); # Prints out "bravo,alpha"

• $self->set($key,$value);

  Set the received instance variable. Extends OP::Object::set to always use OP::Hash and OP::Array when it can.

  my $hash = OP::Hash->new(foo=>'alpha', bar=>'bravo');
  
  $hash->set('bar', 'foxtrot'); # bar was "bravo", is now "foxtrot"

• $self->size()

  Returns the number of key/value pairs in self

• $self->isEmpty()

  Returns true if self's size is 0, otherwise false.

SEE ALSO

This file is part of OP.