File Coverage

tmp/TestPkg.pm

Criterion	Covered	Total	%
statement	162	624	25.9
branch	68	330	20.6
condition	12	27	44.4
subroutine	21	110	19.0
pod	104	104	100.0
total	367	1195	30.7

package tmp::TestPkg;

use 5.020000;
use strict;
use warnings;
use Error qw(:try);

# Used by _value_is_allowed
our %ALLOW_ISA = (
    'm10' => [ 'isaBar', 'isaFoo' ],
    'm3' => [ 'isaBar', 'isaFoo' ],
    'm4' => [ 'isaBar', 'isaFoo' ],
    'm5' => [ 'isaBar', 'isaFoo' ],
    'm6' => [ 'isaBar', 'isaFoo' ],
    'm7' => [ 'isaBar', 'isaFoo' ],
    'm8' => [ 'isaBar', 'isaFoo' ],
    'm9' => [ 'isaBar', 'isaFoo' ],
    's3' => [ 'isaBar', 'isaFoo' ],
    's4' => [ 'isaBar', 'isaFoo' ],
    's5' => [ 'isaBar', 'isaFoo' ],
    's6' => [ 'isaBar', 'isaFoo' ],
);

# Used by _value_is_allowed
our %ALLOW_REF = (
    'm10' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    'm4' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    'm5' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    'm6' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    'm7' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    'm8' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    'm9' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    's4' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    's5' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
    's6' => {
        'refBar' => 1,
        'refFoo' => 1,
    },
);

# Used by _value_is_allowed
our %ALLOW_RX = (
    'm10' => [ '^\S+$', '^\d+$' ],
);

# Used by _value_is_allowed
our %ALLOW_VALUE = (
    'm10' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
    'm5' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
    'm6' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
    'm7' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
    'm8' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
    'm9' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
    's5' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
    's6' => {
        'valueBar' => 1,
        'valueFoo' => 1,
    },
);

# Used by _initialize
our %DEFAULT_VALUE = (
    'b2' => 1,
    'b4' => 1,
);

# Package version
our ($VERSION) = '$Revision: 0.0.0.0 $' =~ /\$Revision:\s+([^\s]+)/;

=head1 NAME

tmp::TestPkg - NO DESCRIPTION AVAILABLE

=head1 SYNOPSIS

 TODO

=head1 ABSTRACT

TODO

=head1 DESCRIPTION

C TODO

=head1 CONSTRUCTOR

=over

=item new(OPT_HASH_REF)

Creates a new C object. C is a hash reference used to pass initialization options. C is mandatory. On error an exception C is thrown.

Options for C may include:

=over

=item B>

Passed to L.

=item B>

Passed to L. Defaults to B<1>.

=item B>

Passed to L. Mandatory option.

=item B>

Passed to L. Mandatory option. Defaults to B<1>.

=item B>

Passed to L. Must be an C reference.

=item B>

Passed to L. Must be an C reference. Mandatory option.

=item B>

Passed to L. Must be an C reference.

=item B>

Passed to L. Must be an C reference.

=item B>

Passed to L. Must be an C reference.

=item B>

Passed to L. Must be an C reference.

=item B>

Passed to L. Must be an C reference. Mandatory option.

=item B>

Passed to L. Must be an C reference. Mandatory option.

=item B>

Passed to L. Must be an C reference. Mandatory option.

=item B>

Passed to L. Must be an C reference. Mandatory option.

=item B>

Passed to L.

=item B>

Passed to L.

=item B>

Passed to L.

=item B>

Passed to L.

=item B>

Passed to L.

=item B>

Passed to L. Mandatory option.

=back

=item new_by_foo(FOO)

Constructs a new object using foo. C must be a C reference. On error an exception C is thrown.

=back

=head1 METHODS

=over

=item add_m10( [ KEY, VALUE ... ] )

Add additional keys/values on not described option. C are key/value pairs. The addition may not yield to multiple identical keys in the list. Hence, multiple occurrences of the same key cause the last occurrence to be inserted. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must match regular expression:

=over

=item ^\S+$

=item ^\d+$

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item add_m8(ARRAY)

Add additional values on not described option. C is the list value. The addition may not yield to multiple identical elements in the list. Hence, multiple occurrences of the same element cause the last occurrence to be inserted. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item delete_m10(ARRAY)

Delete elements from not described option. After deleting at least one element must remain. Returns the number of deleted elements. On error an exception C is thrown.

=item delete_m8(ARRAY)

Delete elements from not described option. After deleting at least one element must remain. Returns the number of deleted elements. On error an exception C is thrown.

=item do_foo(BAR)

Does foo. C must be a C reference. On error an exception C is thrown.

=item exists_m1(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m10(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m2(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m3(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m4(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m5(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m6(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m7(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m8(ARRAY)

Returns the count of items in C that are in not described option.

=item exists_m9(ARRAY)

Returns the count of items in C that are in not described option.

=item get_m1( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_m2( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_m3( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_m4( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_m5( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_m6( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_m7( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_m9( [ INDEX_ARRAY ] )

Returns an C containing not described option. C is an optional list of indexes which when specified causes only the indexed elements in the ordered list to be returned. If not specified, all elements are returned.

=item get_s1()

Returns not described option.

=item get_s2()

Returns not described option.

=item get_s3()

Returns not described option.

=item get_s4()

Returns not described option.

=item get_s5()

Returns not described option.

=item get_s6()

Returns not described option.

=item is_b1()

Returns whether not described option or not.

=item is_b2()

Returns whether not described option or not.

=item is_b3()

Returns whether not described option or not.

=item is_b4()

Returns whether not described option or not.

=item keys_m10()

Returns an C containing the keys of not described option.

=item pop_m1()

Pop and return an element off not described option. On error an exception C is thrown.

=item pop_m2()

Pop and return an element off not described option. After popping at least one element must remain. On error an exception C is thrown.

=item pop_m3()

Pop and return an element off not described option. After popping at least one element must remain. On error an exception C is thrown.

=item pop_m4()

Pop and return an element off not described option. After popping at least one element must remain. On error an exception C is thrown.

=item pop_m5()

Pop and return an element off not described option. After popping at least one element must remain. On error an exception C is thrown.

=item pop_m6()

Pop and return an element off not described option. After popping at least one element must remain. On error an exception C is thrown.

=item pop_m7()

Pop and return an element off not described option. After popping at least one element must remain. On error an exception C is thrown.

=item pop_m9()

Pop and return an element off not described option. After popping at least one element must remain. On error an exception C is thrown.

=item push_m1(ARRAY)

Push additional values on not described option. C is the list value. On error an exception C is thrown.

=item push_m2(ARRAY)

Push additional values on not described option. C is the list value. On error an exception C is thrown.

=item push_m3(ARRAY)

Push additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=back

=item push_m4(ARRAY)

Push additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=back

=item push_m5(ARRAY)

Push additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item push_m6(ARRAY)

Push additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item push_m7(ARRAY)

Push additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item push_m9(ARRAY)

Push additional values on not described option. C is the list value. The push may not yield to multiple identical elements in the list. Hence, multiple occurrences of the same element are ignored. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_b1(VALUE)

State that not described option. C is the value. On error an exception C is thrown.

=item set_b2(VALUE)

State that not described option. C is the value. Default value at initialization is C<1>. On error an exception C is thrown.

=item set_b3(VALUE)

State that not described option. C is the value. On error an exception C is thrown.

=item set_b4(VALUE)

State that not described option. C is the value. Default value at initialization is C<1>. On error an exception C is thrown.

=item set_idx_m1( INDEX, VALUE )

Set value in not described option. C is the integer index which is greater than or equal to C<0>. C is the value.

=item set_idx_m2( INDEX, VALUE )

Set value in not described option. C is the integer index which is greater than or equal to C<0>. C is the value.

=item set_idx_m3( INDEX, VALUE )

Set value in not described option. C is the integer index which is greater than or equal to C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=back

=item set_idx_m4( INDEX, VALUE )

Set value in not described option. C is the integer index which is greater than or equal to C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=back

=item set_idx_m5( INDEX, VALUE )

Set value in not described option. C is the integer index which is greater than or equal to C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_idx_m6( INDEX, VALUE )

Set value in not described option. C is the integer index which is greater than or equal to C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_idx_m7( INDEX, VALUE )

Set value in not described option. C is the integer index which is greater than or equal to C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_m1(ARRAY)

Set not described option absolutely. C is the list value. On error an exception C is thrown.

=item set_m10( [ KEY, VALUE ... ] )

Set not described option absolutely using keys/values. C are key/value pairs. 0 or more of these pairs may be supplied. Each key in is allowed to occur only once. Multiple occurrences of the same key yield in the last occurring key to be inserted and the rest to be ignored. C must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must match regular expression:

=over

=item ^\S+$

=item ^\d+$

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_m2(ARRAY)

Set not described option absolutely. C is the list value. It must at least have one element. On error an exception C is thrown.

=item set_m3(ARRAY)

Set not described option absolutely. C is the list value. It must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=back

=item set_m4(ARRAY)

Set not described option absolutely. C is the list value. It must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=back

=item set_m5(ARRAY)

Set not described option absolutely. C is the list value. It must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_m6(ARRAY)

Set not described option absolutely. C is the list value. It must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_m7(ARRAY)

Set not described option absolutely. C is the list value. It must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_m8(ARRAY)

Set not described option absolutely. C is the list value. Each element in the list is allowed to occur only once. Multiple occurrences of the same element yield in the last occurring element to be inserted and the rest to be ignored. C must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_m9(ARRAY)

Set not described option absolutely. C is the list value. Each element in the list is allowed to occur only once. Multiple occurrences of the same element yield in the first occurring element to be inserted and the rest to be ignored. C must at least have one element. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_num_m1( NUMBER, VALUE )

Set value in not described option. C is the integer index which is greater than C<0>. C is the value.

=item set_num_m2( NUMBER, VALUE )

Set value in not described option. C is the integer index which is greater than C<0>. C is the value.

=item set_num_m3( NUMBER, VALUE )

Set value in not described option. C is the integer index which is greater than C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=back

=item set_num_m4( NUMBER, VALUE )

Set value in not described option. C is the integer index which is greater than C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=back

=item set_num_m5( NUMBER, VALUE )

Set value in not described option. C is the integer index which is greater than C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_num_m6( NUMBER, VALUE )

Set value in not described option. C is the integer index which is greater than C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_num_m7( NUMBER, VALUE )

Set value in not described option. C is the integer index which is greater than C<0>. C is the value.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_s1(VALUE)

Set not described option. C is the value. On error an exception C is thrown.

=item set_s2(VALUE)

Set not described option. C is the value. C may not be C. On error an exception C is thrown.

=item set_s3(VALUE)

Set not described option. C is the value. C may not be C. On error an exception C is thrown.

=over

=item VALUE must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=back

=item set_s4(VALUE)

Set not described option. C is the value. C may not be C. On error an exception C is thrown.

=over

=item VALUE must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, VALUE must be a reference of:

=over

=item refBar

=item refFoo

=back

=back

=item set_s5(VALUE)

Set not described option. C is the value. C may not be C. On error an exception C is thrown.

=over

=item VALUE must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, VALUE must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, VALUE must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item set_s6(VALUE)

Set not described option. C is the value. C may not be C. On error an exception C is thrown.

=over

=item VALUE must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, VALUE must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, VALUE must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item shift_m1()

Shift and return an element off not described option. On error an exception C is thrown.

=item shift_m2()

Shift and return an element off not described option. After shifting at least one element must remain. On error an exception C is thrown.

=item shift_m3()

Shift and return an element off not described option. After shifting at least one element must remain. On error an exception C is thrown.

=item shift_m4()

Shift and return an element off not described option. After shifting at least one element must remain. On error an exception C is thrown.

=item shift_m5()

Shift and return an element off not described option. After shifting at least one element must remain. On error an exception C is thrown.

=item shift_m6()

Shift and return an element off not described option. After shifting at least one element must remain. On error an exception C is thrown.

=item shift_m7()

Shift and return an element off not described option. After shifting at least one element must remain. On error an exception C is thrown.

=item shift_m9()

Shift and return an element off not described option. After shifting at least one element must remain. On error an exception C is thrown.

=item unshift_m1(ARRAY)

Unshift additional values on not described option. C is the list value. On error an exception C is thrown.

=item unshift_m2(ARRAY)

Unshift additional values on not described option. C is the list value. On error an exception C is thrown.

=item unshift_m3(ARRAY)

Unshift additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=back

=item unshift_m4(ARRAY)

Unshift additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=back

=item unshift_m5(ARRAY)

Unshift additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item unshift_m6(ARRAY)

Unshift additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item unshift_m7(ARRAY)

Unshift additional values on not described option. C is the list value. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item unshift_m9(ARRAY)

Unshift additional values on not described option. C is the list value. The push may not yield to multiple identical elements in the list. Hence, multiple occurrences of the same element are ignored. On error an exception C is thrown.

=over

=item The values in C must be a (sub)class of:

=over

=item isaBar

=item isaFoo

=back

=item Or, the values in C must be a reference of:

=over

=item refBar

=item refFoo

=back

=item Or, the values in C must be a one of:

=over

=item valueBar

=item valueFoo

=back

=back

=item values_m10( [ KEY_ARRAY ] )

Returns an C containing the values of not described option. If C contains one or more Cs the values related to the Cs are returned. If no Cs specified all values are returned.

=item values_m8()

Returns an C containing all values of not described option.

=back

=head1 SEE ALSO

TODO

=head1 BUGS

None known (yet.)

=head1 HISTORY

First development: September 2014
Last update: September 2014

=head1 AUTHOR

root

=head1 COPYRIGHT

Copyright 2014 by root

=head1 LICENSE

TODO
=cut

sub new {
    my $class = shift;

    my $self = {};
    bless( $self, ( ref($class) || $class ) );
    return( $self->_initialize(@_) );
}

sub new_by_foo {
}

sub _initialize {
    my $self = shift;
    my $opt = defined($_[0]) ? shift : {};

    # Check $opt
    ref($opt) eq 'HASH' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, first argument must be 'HASH' reference.");

    # b1, BOOLEAN
    exists( $opt->{b1} ) && $self->set_b1( $opt->{b1} );

    # b2, BOOLEAN, with default value
    $self->set_b2( exists( $opt->{b2} ) ? $opt->{b2} : $DEFAULT_VALUE{b2} );

    # b3, BOOLEAN, mandatory
    exists( $opt->{b3} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 'b3' is mandatory.");
    $self->set_b3( $opt->{b3} );

    # b4, BOOLEAN, mandatory, with default value
    exists( $opt->{b4} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 'b4' is mandatory.");
    $self->set_b4( $opt->{b4} );

    # m1, MULTI
    if ( exists( $opt->{m1} ) ) {
        ref( $opt->{m1} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm1' must be an 'ARRAY' reference.");
        $self->set_m1( @{ $opt->{m1} } );
    }
    else {
        $self->set_m1();
    }

    # m10, MULTI, mandatory
    exists( $opt->{m10} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 'm10' is mandatory.");
    ref( $opt->{m10} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm10' must be an 'ARRAY' reference.");
    $self->set_m10( @{ $opt->{m10} } );

    # m2, MULTI
    if ( exists( $opt->{m2} ) ) {
        ref( $opt->{m2} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm2' must be an 'ARRAY' reference.");
        $self->set_m2( @{ $opt->{m2} } );
    }
    else {
        $self->set_m2();
    }

    # m3, MULTI
    if ( exists( $opt->{m3} ) ) {
        ref( $opt->{m3} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm3' must be an 'ARRAY' reference.");
        $self->set_m3( @{ $opt->{m3} } );
    }
    else {
        $self->set_m3();
    }

    # m4, MULTI
    if ( exists( $opt->{m4} ) ) {
        ref( $opt->{m4} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm4' must be an 'ARRAY' reference.");
        $self->set_m4( @{ $opt->{m4} } );
    }
    else {
        $self->set_m4();
    }

    # m5, MULTI
    if ( exists( $opt->{m5} ) ) {
        ref( $opt->{m5} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm5' must be an 'ARRAY' reference.");
        $self->set_m5( @{ $opt->{m5} } );
    }
    else {
        $self->set_m5();
    }

    # m6, MULTI, mandatory
    exists( $opt->{m6} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 'm6' is mandatory.");
    ref( $opt->{m6} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm6' must be an 'ARRAY' reference.");
    $self->set_m6( @{ $opt->{m6} } );

    # m7, MULTI, mandatory
    exists( $opt->{m7} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 'm7' is mandatory.");
    ref( $opt->{m7} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm7' must be an 'ARRAY' reference.");
    $self->set_m7( @{ $opt->{m7} } );

    # m8, MULTI, mandatory
    exists( $opt->{m8} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 'm8' is mandatory.");
    ref( $opt->{m8} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm8' must be an 'ARRAY' reference.");
    $self->set_m8( @{ $opt->{m8} } );

    # m9, MULTI, mandatory
    exists( $opt->{m9} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 'm9' is mandatory.");
    ref( $opt->{m9} ) eq 'ARRAY' || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, specified value for option 'm9' must be an 'ARRAY' reference.");
    $self->set_m9( @{ $opt->{m9} } );

    # s1, SINGLE
    exists( $opt->{s1} ) && $self->set_s1( $opt->{s1} );

    # s2, SINGLE
    exists( $opt->{s2} ) && $self->set_s2( $opt->{s2} );

    # s3, SINGLE
    exists( $opt->{s3} ) && $self->set_s3( $opt->{s3} );

    # s4, SINGLE
    exists( $opt->{s4} ) && $self->set_s4( $opt->{s4} );

    # s5, SINGLE
    exists( $opt->{s5} ) && $self->set_s5( $opt->{s5} );

    # s6, SINGLE, mandatory
    exists( $opt->{s6} ) || throw Error::Simple("ERROR: tmp::TestPkg::_initialize, option 's6' is mandatory.");
    $self->set_s6( $opt->{s6} );

    # Return $self
    return($self);
}

sub _value_is_allowed {
    my $name = shift;

    # Value is allowed if no ALLOW clauses exist for the named attribute
    if ( ! exists( $ALLOW_ISA{$name} ) && ! exists( $ALLOW_REF{$name} ) && ! exists( $ALLOW_RX{$name} ) && ! exists( $ALLOW_VALUE{$name} ) ) {
        return(1);
    }

    # At this point, all values in @_ must to be allowed
    CHECK_VALUES:
    foreach my $val (@_) {
        # Check ALLOW_ISA
        if ( ref($val) && exists( $ALLOW_ISA{$name} ) ) {
            foreach my $class ( @{ $ALLOW_ISA{$name} } ) {
                &UNIVERSAL::isa( $val, $class ) && next CHECK_VALUES;
            }
        }

        # Check ALLOW_REF
        if ( ref($val) && exists( $ALLOW_REF{$name} ) ) {
            exists( $ALLOW_REF{$name}{ ref($val) } ) && next CHECK_VALUES;
        }

        # Check ALLOW_RX
        if ( defined($val) && ! ref($val) && exists( $ALLOW_RX{$name} ) ) {
            foreach my $rx ( @{ $ALLOW_RX{$name} } ) {
                $val =~ /$rx/ && next CHECK_VALUES;
            }
        }

        # Check ALLOW_VALUE
        if ( ! ref($val) && exists( $ALLOW_VALUE{$name} ) ) {
            exists( $ALLOW_VALUE{$name}{$val} ) && next CHECK_VALUES;
        }

        # We caught a not allowed value
        return(0);
    }

    # OK, all values are allowed
    return(1);
}

sub add_m10 {
    my $self = shift;

    # Separate keys/values
    my @key = ();
    my @value = ();
    while ( my $key = shift(@_) ) {
        push( @key, $key );
        push( @value, shift(@_) );
    }

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm10', @value ) || throw Error::Simple("ERROR: tmp::TestPkg::add_m10, one or more specified value(s) '@value' is/are not allowed.");

    # Add keys/values
    foreach my $key (@key) {
        $self->{tmp_TestPkg}{m10}{$key} = shift(@value);
    }
}

sub add_m8 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm8', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::add_m8, one or more specified value(s) '@_' is/are not allowed.");

    # Add values
    foreach my $val (@_) {
        $self->{tmp_TestPkg}{m8}{$val} = $val;
    }
}

sub delete_m10 {
    my $self = shift;

    # List value for 'm10' is not allowed to be empty
    my %would_delete = ();
    foreach my $val (@_) {
        $would_delete{$val} = $val if ( exists( $self->{tmp_TestPkg}{m10}{$val} ) )
    }
    ( scalar( keys( %{ $self->{tmp_TestPkg}{m10} } ) ) == scalar( keys( %would_delete) ) ) && throw Error::Simple("ERROR: tmp::TestPkg::delete_m10, list value may not be empty.");

    # Delete values
    my $del = 0;
    foreach my $val (@_) {
        exists( $self->{tmp_TestPkg}{m10}{$val} ) || next;
        delete( $self->{tmp_TestPkg}{m10}{$val} );
        $del ++;
    }
    return($del);
}

sub delete_m8 {
    my $self = shift;

    # List value for 'm8' is not allowed to be empty
    my %would_delete = ();
    foreach my $val (@_) {
        $would_delete{$val} = $val if ( exists( $self->{tmp_TestPkg}{m8}{$val} ) );
    }
    ( scalar( keys( %{ $self->{tmp_TestPkg}{m8} } ) ) == scalar( keys(%would_delete) ) ) && throw Error::Simple("ERROR: tmp::TestPkg::delete_m8, list value may not be empty.");

    # Delete values
    my $del = 0;
    foreach my $val (@_) {
        exists( $self->{tmp_TestPkg}{m8}{$val} ) || next;
        delete( $self->{tmp_TestPkg}{m8}{$val} );
        $del ++;
    }
    return($del);
}

sub do_foo {
}

sub exists_m1 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val1 (@_) {
        foreach my $val2 ( @{ $self->{tmp_TestPkg}{m1} } ) {
            ( $val1 eq $val2 ) && $count ++;
        }
    }
    return($count);
}

sub exists_m10 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val (@_) {
        $count += exists( $self->{tmp_TestPkg}{m10}{$val} );
    }
    return($count);
}

sub exists_m2 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val1 (@_) {
        foreach my $val2 ( @{ $self->{tmp_TestPkg}{m2} } ) {
            ( $val1 eq $val2 ) && $count ++;
        }
    }
    return($count);
}

sub exists_m3 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val1 (@_) {
        foreach my $val2 ( @{ $self->{tmp_TestPkg}{m3} } ) {
            ( $val1 eq $val2 ) && $count ++;
        }
    }
    return($count);
}

sub exists_m4 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val1 (@_) {
        foreach my $val2 ( @{ $self->{tmp_TestPkg}{m4} } ) {
            ( $val1 eq $val2 ) && $count ++;
        }
    }
    return($count);
}

sub exists_m5 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val1 (@_) {
        foreach my $val2 ( @{ $self->{tmp_TestPkg}{m5} } ) {
            ( $val1 eq $val2 ) && $count ++;
        }
    }
    return($count);
}

sub exists_m6 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val1 (@_) {
        foreach my $val2 ( @{ $self->{tmp_TestPkg}{m6} } ) {
            ( $val1 eq $val2 ) && $count ++;
        }
    }
    return($count);
}

sub exists_m7 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val1 (@_) {
        foreach my $val2 ( @{ $self->{tmp_TestPkg}{m7} } ) {
            ( $val1 eq $val2 ) && $count ++;
        }
    }
    return($count);
}

sub exists_m8 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val (@_) {
        $count += exists( $self->{tmp_TestPkg}{m8}{$val} );
    }
    return($count);
}

sub exists_m9 {
    my $self = shift;

    # Count occurrences
    my $count = 0;
    foreach my $val (@_) {
        $count += exists( $self->{tmp_TestPkg}{m9}{HASH}{$val} );
    }
    return($count);
}

sub get_m1 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m1}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the full list
        return( @{ $self->{tmp_TestPkg}{m1} } );
    }
}

sub get_m2 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m2}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the full list
        return( @{ $self->{tmp_TestPkg}{m2} } );
    }
}

sub get_m3 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m3}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the full list
        return( @{ $self->{tmp_TestPkg}{m3} } );
    }
}

sub get_m4 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m4}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the full list
        return( @{ $self->{tmp_TestPkg}{m4} } );
    }
}

sub get_m5 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m5}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the full list
        return( @{ $self->{tmp_TestPkg}{m5} } );
    }
}

sub get_m6 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m6}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the full list
        return( @{ $self->{tmp_TestPkg}{m6} } );
    }
}

sub get_m7 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m7}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the full list
        return( @{ $self->{tmp_TestPkg}{m7} } );
    }
}

sub get_m9 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $i (@_) {
            push( @ret, $self->{tmp_TestPkg}{m9}{ARRAY}[ int($i) ] );
        }
        return(@ret);
    }
    else {
        # Return the list
        return( @{ $self->{tmp_TestPkg}{m9}{ARRAY} } );
    }
}

sub get_s1 {
    my $self = shift;

    return( $self->{tmp_TestPkg}{s1} );
}

sub get_s2 {
    my $self = shift;

    return( $self->{tmp_TestPkg}{s2} );
}

sub get_s3 {
    my $self = shift;

    return( $self->{tmp_TestPkg}{s3} );
}

sub get_s4 {
    my $self = shift;

    return( $self->{tmp_TestPkg}{s4} );
}

sub get_s5 {
    my $self = shift;

    return( $self->{tmp_TestPkg}{s5} );
}

sub get_s6 {
    my $self = shift;

    return( $self->{tmp_TestPkg}{s6} );
}

sub is_b1 {
    my $self = shift;

    if ( $self->{tmp_TestPkg}{b1} ) {
        return(1);
    }
    else {
        return(0);
    }
}

sub is_b2 {
    my $self = shift;

    if ( $self->{tmp_TestPkg}{b2} ) {
        return(1);
    }
    else {
        return(0);
    }
}

sub is_b3 {
    my $self = shift;

    if ( $self->{tmp_TestPkg}{b3} ) {
        return(1);
    }
    else {
        return(0);
    }
}

sub is_b4 {
    my $self = shift;

    if ( $self->{tmp_TestPkg}{b4} ) {
        return(1);
    }
    else {
        return(0);
    }
}

sub keys_m10 {
    my $self = shift;

    # Return all keys
    return( keys( %{ $self->{tmp_TestPkg}{m10} } ) );
}

sub pop_m1 {
    my $self = shift;

    # Pop an element from the list
    return( pop( @{ $self->{tmp_TestPkg}{m1} } ) );
}

sub pop_m2 {
    my $self = shift;

    # List value for 'm2' is not allowed to be empty
    (scalar(@_) > 1) || throw Error::Simple("ERROR: tmp::TestPkg::pop_m2, list value may not be empty.");

    # Pop an element from the list
    return( pop( @{ $self->{tmp_TestPkg}{m2} } ) );
}

sub pop_m3 {
    my $self = shift;

    # List value for 'm3' is not allowed to be empty
    (scalar(@_) > 1) || throw Error::Simple("ERROR: tmp::TestPkg::pop_m3, list value may not be empty.");

    # Pop an element from the list
    return( pop( @{ $self->{tmp_TestPkg}{m3} } ) );
}

sub pop_m4 {
    my $self = shift;

    # List value for 'm4' is not allowed to be empty
    (scalar(@_) > 1) || throw Error::Simple("ERROR: tmp::TestPkg::pop_m4, list value may not be empty.");

    # Pop an element from the list
    return( pop( @{ $self->{tmp_TestPkg}{m4} } ) );
}

sub pop_m5 {
    my $self = shift;

    # List value for 'm5' is not allowed to be empty
    (scalar(@_) > 1) || throw Error::Simple("ERROR: tmp::TestPkg::pop_m5, list value may not be empty.");

    # Pop an element from the list
    return( pop( @{ $self->{tmp_TestPkg}{m5} } ) );
}

sub pop_m6 {
    my $self = shift;

    # List value for 'm6' is not allowed to be empty
    (scalar(@_) > 1) || throw Error::Simple("ERROR: tmp::TestPkg::pop_m6, list value may not be empty.");

    # Pop an element from the list
    return( pop( @{ $self->{tmp_TestPkg}{m6} } ) );
}

sub pop_m7 {
    my $self = shift;

    # List value for 'm7' is not allowed to be empty
    (scalar(@_) > 1) || throw Error::Simple("ERROR: tmp::TestPkg::pop_m7, list value may not be empty.");

    # Pop an element from the list
    return( pop( @{ $self->{tmp_TestPkg}{m7} } ) );
}

sub pop_m9 {
    my $self = shift;

    # List value for 'm9' is not allowed to be empty
    ( scalar(@_) > 1) || throw Error::Simple("ERROR: tmp::TestPkg::pop_m9, list value may not be empty.");

    # Pop value
    my $val = pop( @{ $self->{tmp_TestPkg}{m9}{ARRAY} } );
    delete( $self->{tmp_TestPkg}{m9}{HASH}{$val} );
    return($val);
}

sub push_m1 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm1', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m1, one or more specified value(s) '@_' is/are not allowed.");

    # Push the list
    push( @{ $self->{tmp_TestPkg}{m1} }, @_ );
}

sub push_m2 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm2', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m2, one or more specified value(s) '@_' is/are not allowed.");

    # Push the list
    push( @{ $self->{tmp_TestPkg}{m2} }, @_ );
}

sub push_m3 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm3', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m3, one or more specified value(s) '@_' is/are not allowed.");

    # Push the list
    push( @{ $self->{tmp_TestPkg}{m3} }, @_ );
}

sub push_m4 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm4', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m4, one or more specified value(s) '@_' is/are not allowed.");

    # Push the list
    push( @{ $self->{tmp_TestPkg}{m4} }, @_ );
}

sub push_m5 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm5', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m5, one or more specified value(s) '@_' is/are not allowed.");

    # Push the list
    push( @{ $self->{tmp_TestPkg}{m5} }, @_ );
}

sub push_m6 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm6', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m6, one or more specified value(s) '@_' is/are not allowed.");

    # Push the list
    push( @{ $self->{tmp_TestPkg}{m6} }, @_ );
}

sub push_m7 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm7', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m7, one or more specified value(s) '@_' is/are not allowed.");

    # Push the list
    push( @{ $self->{tmp_TestPkg}{m7} }, @_ );
}

sub push_m9 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm9', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::push_m9, one or more specified value(s) '@_' is/are not allowed.");

    # Push values
    foreach my $val (@_) {
        next if ( exists( $self->{tmp_TestPkg}{m9}{HASH}{$val} ) );
        push( @{ $self->{tmp_TestPkg}{m9}{ARRAY} }, $val );
        $self->{tmp_TestPkg}{m9}{HASH}{$val} = $val;
    }
}

sub set_b1 {
    my $self = shift;

    if (shift) {
        $self->{tmp_TestPkg}{b1} = 1;
    }
    else {
        $self->{tmp_TestPkg}{b1} = 0;
    }
}

sub set_b2 {
    my $self = shift;

    if (shift) {
        $self->{tmp_TestPkg}{b2} = 1;
    }
    else {
        $self->{tmp_TestPkg}{b2} = 0;
    }
}

sub set_b3 {
    my $self = shift;

    if (shift) {
        $self->{tmp_TestPkg}{b3} = 1;
    }
    else {
        $self->{tmp_TestPkg}{b3} = 0;
    }
}

sub set_b4 {
    my $self = shift;

    if (shift) {
        $self->{tmp_TestPkg}{b4} = 1;
    }
    else {
        $self->{tmp_TestPkg}{b4} = 0;
    }
}

sub set_idx_m1 {
    my $self = shift;
    my $idx = shift;
    my $val = shift;

    # Check if index is a positive integer or zero
    ( $idx == int($idx) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m1, the specified index '$idx' is not an integer.");
    ( $idx >= 0 ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m1, the specified index '$idx' is not a positive integer or zero.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm1', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m1, one or more specified value(s) '@_' is/are not allowed.");

    # Set the value in the list
    $self->{tmp_TestPkg}{m1}[$idx] = $val;
}

sub set_idx_m2 {
    my $self = shift;
    my $idx = shift;
    my $val = shift;

    # Check if index is a positive integer or zero
    ( $idx == int($idx) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m2, the specified index '$idx' is not an integer.");
    ( $idx >= 0 ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m2, the specified index '$idx' is not a positive integer or zero.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm2', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m2, one or more specified value(s) '@_' is/are not allowed.");

    # Set the value in the list
    $self->{tmp_TestPkg}{m2}[$idx] = $val;
}

sub set_idx_m3 {
    my $self = shift;
    my $idx = shift;
    my $val = shift;

    # Check if index is a positive integer or zero
    ( $idx == int($idx) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m3, the specified index '$idx' is not an integer.");
    ( $idx >= 0 ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m3, the specified index '$idx' is not a positive integer or zero.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm3', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m3, one or more specified value(s) '@_' is/are not allowed.");

    # Set the value in the list
    $self->{tmp_TestPkg}{m3}[$idx] = $val;
}

sub set_idx_m4 {
    my $self = shift;
    my $idx = shift;
    my $val = shift;

    # Check if index is a positive integer or zero
    ( $idx == int($idx) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m4, the specified index '$idx' is not an integer.");
    ( $idx >= 0 ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m4, the specified index '$idx' is not a positive integer or zero.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm4', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m4, one or more specified value(s) '@_' is/are not allowed.");

    # Set the value in the list
    $self->{tmp_TestPkg}{m4}[$idx] = $val;
}

sub set_idx_m5 {
    my $self = shift;
    my $idx = shift;
    my $val = shift;

    # Check if index is a positive integer or zero
    ( $idx == int($idx) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m5, the specified index '$idx' is not an integer.");
    ( $idx >= 0 ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m5, the specified index '$idx' is not a positive integer or zero.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm5', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m5, one or more specified value(s) '@_' is/are not allowed.");

    # Set the value in the list
    $self->{tmp_TestPkg}{m5}[$idx] = $val;
}

sub set_idx_m6 {
    my $self = shift;
    my $idx = shift;
    my $val = shift;

    # Check if index is a positive integer or zero
    ( $idx == int($idx) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m6, the specified index '$idx' is not an integer.");
    ( $idx >= 0 ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m6, the specified index '$idx' is not a positive integer or zero.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm6', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m6, one or more specified value(s) '@_' is/are not allowed.");

    # Set the value in the list
    $self->{tmp_TestPkg}{m6}[$idx] = $val;
}

sub set_idx_m7 {
    my $self = shift;
    my $idx = shift;
    my $val = shift;

    # Check if index is a positive integer or zero
    ( $idx == int($idx) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m7, the specified index '$idx' is not an integer.");
    ( $idx >= 0 ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m7, the specified index '$idx' is not a positive integer or zero.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm7', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_idx_m7, one or more specified value(s) '@_' is/are not allowed.");

    # Set the value in the list
    $self->{tmp_TestPkg}{m7}[$idx] = $val;
}

sub set_m1 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm1', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m1, one or more specified value(s) '@_' is/are not allowed.");

    # Set the list
    @{ $self->{tmp_TestPkg}{m1} } = @_;
}

sub set_m10 {
    my $self = shift;

    # List value for 'm10' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m10, list value may not be empty.");

    # Separate keys/values
    my @key = ();
    my @value = ();
    while ( my $key = shift(@_) ) {
        push( @key, $key );
        push( @value, shift(@_) );
    }

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm10', @value ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m10, one or more specified value(s) '@value' is/are not allowed.");

    # Empty list
    $self->{tmp_TestPkg}{m10} = {};

    # Add keys/values
    foreach my $key (@key) {
        $self->{tmp_TestPkg}{m10}{$key} = shift(@value);
    }
}

sub set_m2 {
    my $self = shift;

    # List value for 'm2' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m2, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm2', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m2, one or more specified value(s) '@_' is/are not allowed.");

    # Set the list
    @{ $self->{tmp_TestPkg}{m2} } = @_;
}

sub set_m3 {
    my $self = shift;

    # List value for 'm3' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m3, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm3', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m3, one or more specified value(s) '@_' is/are not allowed.");

    # Set the list
    @{ $self->{tmp_TestPkg}{m3} } = @_;
}

sub set_m4 {
    my $self = shift;

    # List value for 'm4' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m4, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm4', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m4, one or more specified value(s) '@_' is/are not allowed.");

    # Set the list
    @{ $self->{tmp_TestPkg}{m4} } = @_;
}

sub set_m5 {
    my $self = shift;

    # List value for 'm5' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m5, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm5', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m5, one or more specified value(s) '@_' is/are not allowed.");

    # Set the list
    @{ $self->{tmp_TestPkg}{m5} } = @_;
}

sub set_m6 {
    my $self = shift;

    # List value for 'm6' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m6, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm6', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m6, one or more specified value(s) '@_' is/are not allowed.");

    # Set the list
    @{ $self->{tmp_TestPkg}{m6} } = @_;
}

sub set_m7 {
    my $self = shift;

    # List value for 'm7' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m7, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm7', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m7, one or more specified value(s) '@_' is/are not allowed.");

    # Set the list
    @{ $self->{tmp_TestPkg}{m7} } = @_;
}

sub set_m8 {
    my $self = shift;

    # List value for 'm8' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m8, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm8', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m8, one or more specified value(s) '@_' is/are not allowed.");

    # Empty list
    $self->{tmp_TestPkg}{m8} = {};

    # Add values
    foreach my $val (@_) {
        $self->{tmp_TestPkg}{m8}{$val} = $val;
    }
}

sub set_m9 {
    my $self = shift;

    # List value for 'm9' is not allowed to be empty
    scalar(@_) || throw Error::Simple("ERROR: tmp::TestPkg::set_m9, list value may not be empty.");

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm9', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::set_m9, one or more specified value(s) '@_' is/are not allowed.");

    # Empty list
    $self->{tmp_TestPkg}{m9}{ARRAY} = [];
    $self->{tmp_TestPkg}{m9}{HASH} = {};

    # Push values
    foreach my $val (@_) {
        next if ( exists( $self->{tmp_TestPkg}{m9}{HASH}{$val} ) );
        push( @{ $self->{tmp_TestPkg}{m9}{ARRAY} }, $val );
        $self->{tmp_TestPkg}{m9}{HASH}{$val} = $val;
    }
}

sub set_num_m1 {
    my $self = shift;
    my $num = shift;

    # Check if index is an integer
    ( $num == int($num) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_num_m1, the specified number '$num' is not an integer.");

    # Call set_idx_m1
    $self->set_idx_m1( $num - 1, @_ );
}

sub set_num_m2 {
    my $self = shift;
    my $num = shift;

    # Check if index is an integer
    ( $num == int($num) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_num_m2, the specified number '$num' is not an integer.");

    # Call set_idx_m2
    $self->set_idx_m2( $num - 1, @_ );
}

sub set_num_m3 {
    my $self = shift;
    my $num = shift;

    # Check if index is an integer
    ( $num == int($num) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_num_m3, the specified number '$num' is not an integer.");

    # Call set_idx_m3
    $self->set_idx_m3( $num - 1, @_ );
}

sub set_num_m4 {
    my $self = shift;
    my $num = shift;

    # Check if index is an integer
    ( $num == int($num) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_num_m4, the specified number '$num' is not an integer.");

    # Call set_idx_m4
    $self->set_idx_m4( $num - 1, @_ );
}

sub set_num_m5 {
    my $self = shift;
    my $num = shift;

    # Check if index is an integer
    ( $num == int($num) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_num_m5, the specified number '$num' is not an integer.");

    # Call set_idx_m5
    $self->set_idx_m5( $num - 1, @_ );
}

sub set_num_m6 {
    my $self = shift;
    my $num = shift;

    # Check if index is an integer
    ( $num == int($num) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_num_m6, the specified number '$num' is not an integer.");

    # Call set_idx_m6
    $self->set_idx_m6( $num - 1, @_ );
}

sub set_num_m7 {
    my $self = shift;
    my $num = shift;

    # Check if index is an integer
    ( $num == int($num) ) || throw Error::Simple("ERROR: tmp::TestPkg::set_num_m7, the specified number '$num' is not an integer.");

    # Call set_idx_m7
    $self->set_idx_m7( $num - 1, @_ );
}

sub set_s1 {
    my $self = shift;
    my $val = shift;

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 's1', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_s1, the specified value '$val' is not allowed.");

    # Assignment
    $self->{tmp_TestPkg}{s1} = $val;
}

sub set_s2 {
    my $self = shift;
    my $val = shift;

    # Value for 's2' is not allowed to be empty
    defined($val) || throw Error::Simple("ERROR: tmp::TestPkg::set_s2, value may not be empty.");

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 's2', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_s2, the specified value '$val' is not allowed.");

    # Assignment
    $self->{tmp_TestPkg}{s2} = $val;
}

sub set_s3 {
    my $self = shift;
    my $val = shift;

    # Value for 's3' is not allowed to be empty
    defined($val) || throw Error::Simple("ERROR: tmp::TestPkg::set_s3, value may not be empty.");

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 's3', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_s3, the specified value '$val' is not allowed.");

    # Assignment
    $self->{tmp_TestPkg}{s3} = $val;
}

sub set_s4 {
    my $self = shift;
    my $val = shift;

    # Value for 's4' is not allowed to be empty
    defined($val) || throw Error::Simple("ERROR: tmp::TestPkg::set_s4, value may not be empty.");

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 's4', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_s4, the specified value '$val' is not allowed.");

    # Assignment
    $self->{tmp_TestPkg}{s4} = $val;
}

sub set_s5 {
    my $self = shift;
    my $val = shift;

    # Value for 's5' is not allowed to be empty
    defined($val) || throw Error::Simple("ERROR: tmp::TestPkg::set_s5, value may not be empty.");

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 's5', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_s5, the specified value '$val' is not allowed.");

    # Assignment
    $self->{tmp_TestPkg}{s5} = $val;
}

sub set_s6 {
    my $self = shift;
    my $val = shift;

    # Value for 's6' is not allowed to be empty
    defined($val) || throw Error::Simple("ERROR: tmp::TestPkg::set_s6, value may not be empty.");

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 's6', $val ) || throw Error::Simple("ERROR: tmp::TestPkg::set_s6, the specified value '$val' is not allowed.");

    # Assignment
    $self->{tmp_TestPkg}{s6} = $val;
}

sub shift_m1 {
    my $self = shift;

    # Shift an element from the list
    return( shift( @{ $self->{tmp_TestPkg}{m1} } ) );
}

sub shift_m2 {
    my $self = shift;

    # List value for 'm2' is not allowed to be empty
    ( scalar(@_) > 1 ) || throw Error::Simple("ERROR: tmp::TestPkg::shift_m2, list value may not be empty.");

    # Shift an element from the list
    return( shift( @{ $self->{tmp_TestPkg}{m2} } ) );
}

sub shift_m3 {
    my $self = shift;

    # List value for 'm3' is not allowed to be empty
    ( scalar(@_) > 1 ) || throw Error::Simple("ERROR: tmp::TestPkg::shift_m3, list value may not be empty.");

    # Shift an element from the list
    return( shift( @{ $self->{tmp_TestPkg}{m3} } ) );
}

sub shift_m4 {
    my $self = shift;

    # List value for 'm4' is not allowed to be empty
    ( scalar(@_) > 1 ) || throw Error::Simple("ERROR: tmp::TestPkg::shift_m4, list value may not be empty.");

    # Shift an element from the list
    return( shift( @{ $self->{tmp_TestPkg}{m4} } ) );
}

sub shift_m5 {
    my $self = shift;

    # List value for 'm5' is not allowed to be empty
    ( scalar(@_) > 1 ) || throw Error::Simple("ERROR: tmp::TestPkg::shift_m5, list value may not be empty.");

    # Shift an element from the list
    return( shift( @{ $self->{tmp_TestPkg}{m5} } ) );
}

sub shift_m6 {
    my $self = shift;

    # List value for 'm6' is not allowed to be empty
    ( scalar(@_) > 1 ) || throw Error::Simple("ERROR: tmp::TestPkg::shift_m6, list value may not be empty.");

    # Shift an element from the list
    return( shift( @{ $self->{tmp_TestPkg}{m6} } ) );
}

sub shift_m7 {
    my $self = shift;

    # List value for 'm7' is not allowed to be empty
    ( scalar(@_) > 1 ) || throw Error::Simple("ERROR: tmp::TestPkg::shift_m7, list value may not be empty.");

    # Shift an element from the list
    return( shift( @{ $self->{tmp_TestPkg}{m7} } ) );
}

sub shift_m9 {
    my $self = shift;

    # List value for 'm9' is not allowed to be empty
    ( scalar(@_) > 1 ) || throw Error::Simple("ERROR: tmp::TestPkg::shift_m9, list value may not be empty.");

    # Shift value
    my $val = shift( @{ $self->{tmp_TestPkg}{m9}{ARRAY} } );
    delete( $self->{tmp_TestPkg}{m9}{HASH}{$val} );
    return($val);
}

sub unshift_m1 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm1', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m1, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift the list
    unshift( @{ $self->{tmp_TestPkg}{m1} }, @_ );
}

sub unshift_m2 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm2', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m2, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift the list
    unshift( @{ $self->{tmp_TestPkg}{m2} }, @_ );
}

sub unshift_m3 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm3', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m3, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift the list
    unshift( @{ $self->{tmp_TestPkg}{m3} }, @_ );
}

sub unshift_m4 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm4', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m4, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift the list
    unshift( @{ $self->{tmp_TestPkg}{m4} }, @_ );
}

sub unshift_m5 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm5', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m5, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift the list
    unshift( @{ $self->{tmp_TestPkg}{m5} }, @_ );
}

sub unshift_m6 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm6', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m6, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift the list
    unshift( @{ $self->{tmp_TestPkg}{m6} }, @_ );
}

sub unshift_m7 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm7', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m7, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift the list
    unshift( @{ $self->{tmp_TestPkg}{m7} }, @_ );
}

sub unshift_m9 {
    my $self = shift;

    # Check if isas/refs/rxs/values are allowed
    &_value_is_allowed( 'm9', @_ ) || throw Error::Simple("ERROR: tmp::TestPkg::unshift_m9, one or more specified value(s) '@_' is/are not allowed.");

    # Unshift values
    foreach my $val ( reverse(@_) ) {
        next if ( exists( $self->{tmp_TestPkg}{m9}{HASH}{$val} ) );
        unshift( @{ $self->{tmp_TestPkg}{m9}{ARRAY} }, $val );
        $self->{tmp_TestPkg}{m9}{HASH}{$val} = $val;
    }
}

sub values_m10 {
    my $self = shift;

    if ( scalar(@_) ) {
        my @ret = ();
        foreach my $key (@_) {
            exists( $self->{tmp_TestPkg}{m10}{$key} ) && push( @ret, $self->{tmp_TestPkg}{m10}{$key} );
        }
        return(@ret);
    }
    else {
        # Return all values
        return( values( %{ $self->{tmp_TestPkg}{m10} } ) );
    }
}

sub values_m8 {
    my $self = shift;

    # Return all values
    return( values( %{ $self->{tmp_TestPkg}{m8} } ) );
}

1;