Class

    package MyClass ;
    
    # implement constructor without options
    use Class::constr ;
    
    # with all the possible options
    use Class::constr { name        => 'new_object' ,
                        pre_process => \&change_input,
                        default     => { propA => 'something' },
                        init        => [ qw( init1 init2 ) ] ,
                        copy        => 1
                        no_strict   => 1
                      } ;
                    
    # init1 and init2 will be called at run-time

Usage

    # creates a new object and eventually validates
    # the properties if any validation property option is set
    my $object = MyClass->new(digits => '123');

Examples

name => $name

no_strict => 0 | 1

skip_autoload => 0 | 1

pre_process => \&$code

The original @_ is passed to the referenced pre_process CODE. Modify @_ in the CODE to change the actual input value.

    # This code will transform the @_ on input
    # if it's passed a ref to an ARRAY
    # [ qw|a b c| ] will become
    # ( a=>'a', b=>'b', c=>'c')
    
    use Class::constr
        { name       => 'new'
        , pre_process=> sub
                         { if ( ref $_[1] eq 'ARRAY' )
                            { $_[1] = { map { $_=>$_ } @{$_[1]} }
                            }
                         }
        }

default => \%props | \&$method

You can set the default to a HASH reference or to a method name or method reference. In case you use a method, it will be called at runtime with the blessed object passed in $_[0] and the other properties in the remaining @_; it must return a HASH reference.

init => $method | \@methods

After the assignation and validation of the properties (i.e. those passed to the constructor, the default properties and the copied properties), the initialization methods in the "init" option will be called. Each init method will receive the blessed object passed in $_[0] and the other properties in the remaining @_.

Any "init" method can cancel construction of the object by undefining $_[0]. This will cause the constructor to return undef. If you prefer, you can explicitly "croak" from your init method.

   use Class::constr
      { name       => 'new'
      , init       => 'too_many'
      }
   ;
   sub too_many
      { if ( $MyClass::num_instances > $MyClass::max_instances)
         { $_[0] = undef # Do not allow new object to be returned
         }
        else
         { $MyClass::num_instances++
         }
      }

copy => 0 | 1

Warning: The copy constructor will only perform a shallow copy, which means that after a copy any references stored in properties will point to the same variable in both objects (the objects will share a single variable instead of each having its own private copy). If you don't want this behavior, you should reset these properties in your "init" method. Properties created by the Object::groups pragma are effected by this. Such properties should be explicitly set to "undef" in your "init" method for sane behavior.

Copy constructors may also be called as traditional class method constructors, but of course there will be no values to be copied into the new object. Generally, you will want to have a normal constructor to use when you don't need the copy functionality.

   package My::Class;
   use Class::constr
      ( { name       => 'new'
        , init       => '_init'
        }
      , { name       => 'copy_me'
        , copy       => 1
        , init       => '_init_copy' # Special init undefs properties
                                     # containing shared references
        }
      )
   
   # Then in your program somewhere
   my $obj = My::Class->new( property => 1); 
   my $copy = $obj->copy_me(); # $copy->property == 1