HH::Unispool::Config::Entry::RemoteSystem::3 - UNISPOOL type 3 remote system

 # Information on remote system type 0 is obtained through an
 # informal document. I guess this remote system type is out
 # of fashion...

 use strict;

 use HH::Unispool::Config;
 use HH::Unispool::Config::OS;
 use HH::Unispool::Config::Scope;
 use HH::Unispool::Config::Entry::System;
 use HH::Unispool::Config::Entry::RemoteSystem::3;

 # Create a config from scratch with a _Local_ scope
 my $conf = HH::Unispool::Config->new( {
     scope => HH::Unispool::Config::Scope->new ( {
         scope => [ qw( _Local_) ],
     } ),
 } );

 # Create the _Local_ system and add it to the configuration
 my $sysn = HH::Unispool::Config::Entry::System->new( {
     name => '_Local_',
     local_system_name => 'foo',
     network_name => 'foo.bar.org',
     os => HH::Unispool::Config::OS->new( {
         os => 'Solaris',
     } ),
 } );
 $conf->add_system($sysn);

 # Add a type 3 remote system to _Local_
 my $dev = HH::Unispool::Config::Entry::RemoteSystem::3->new( {
     name => 'rsys3',
     acct => 'fred',
     apass => '123wilma',
     upass => '123pebbles',
     remote_node_name => 'barney.bedrock.org',
 } );
 $sysn->add_remote_system($dev);

 # Write the configuration
 $conf->write('t/config.sample.r3.out');

package HH::Unispool::Config::Entry::RemoteSystem::3;

use 5.006;
use base qw( HH::Unispool::Config::Entry::RemoteSystem );
use strict;
use warnings;
use AutoLoader qw(AUTOLOAD);
use Error qw(:try);

# Used by _value_is_allowed
our %ALLOW_ISA = (
);

# Used by _value_is_allowed
our %ALLOW_REF = (
);

# Used by _value_is_allowed
our %ALLOW_RX = (
    'acct' => [ '^.*$' ],
    'apass' => [ '^.*$' ],
    'remote_node_name' => [ '^[\w\.]+$' ],
    'timeout' => [ '^\d*$' ],
    'upass' => [ '^.*$' ],
);

# Used by _value_is_allowed
our %ALLOW_VALUE = (
);

# Used by _initialize
our %DEFAULT_VALUE = (
    'high_priority_login' => 0,
    'timeout' => 180,
);

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

1;

__END__

sub new_from_tokenizer {
    my $class = shift;
    my $tokenizer = shift;

    # First token must be a HH::Unispool::Config::File::Token::Numbered::System::3
    my $s = $tokenizer->get();
    $s->isa('HH::Unispool::Config::File::Token::Numbered::System::3') || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::new_from_tokenizer, expected a first token from 'TOKENIZER' of class 'HH::Unispool::Config::File::Token::Numbered::System::3'.");

    # Fill the initialization option hash
    my %opt = ();
    $opt{number} = $s->get_number() if ( $s->get_number() );
    $opt{name} = $s->get_remote_system_name() if ( $s->get_remote_system_name() );
    $opt{acct} = $s->get_acct() if ( $s->get_acct() );
    $opt{apass} = $s->get_apass() if ( $s->get_apass() );
    $opt{upass} = $s->get_upass() if ( $s->get_upass() );
    $opt{timeout} = $s->get_timeout() if ( $s->get_timeout() );
    $opt{high_priority_login} = $s->is_high_priority_login() if ( $s->is_high_priority_login() );
    $opt{initially_open} = $s->is_initially_open() if ( $s->is_initially_open() );
    $opt{execution_priority} = $s->get_execution_priority() if ( $s->get_execution_priority() );

    # Allow an I and N token
    my $i = undef;
    my $n = undef;
    while ( my $tok = $tokenizer->get() ) {
        if ( ! $tok->isa('HH::Unispool::Config::File::Token::Numbered') || $tok->get_number() != $s->get_number() ) {
            $tokenizer->unget();
            last;
        }
        elsif ( $tok->isa('HH::Unispool::Config::File::Token::Numbered::System::Info') ) {
            defined ($i) && throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::new_from_tokenizer, multiple tokens obtained from 'TOKENIZER' for entry $opt{name}/$opt{number} from class 'HH::Unispool::Config::File::Token::Numbered::System::Info'.");
            $i = $tok;
            $opt{description} = $i->get_description() if ( $i->get_description() );
        }
        elsif ( $tok->isa('HH::Unispool::Config::File::Token::Numbered::Network') ) {
            defined ($n) && throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::new_from_tokenizer, multiple tokens obtained from 'TOKENIZER' for entry $opt{name}/$opt{number} from class 'HH::Unispool::Config::File::Token::Numbered::Network'.");
            $n = $tok;
            $opt{remote_node_name} = $n->get_remote_node_name() if ( $n->get_remote_node_name() );
        }
        else {
            throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::new_from_tokenizer, expected tokens from 'TOKENIZER' for entry $opt{name}/$opt{number} from either class 'HH::Unispool::Config::File::Token::Numbered::System::Info' or 'HH::Unispool::Config::File::Token::Numbered::Network'.");
        }
    }

    # Construct a new object and return it
    return( HH::Unispool::Config::Entry::RemoteSystem::3->new(\%opt) );
}

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

    # Check $opt
    ref($opt) eq 'HASH' || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::_initialize, first argument must be 'HASH' reference.");

    # acct, SINGLE
    exists( $opt->{acct} ) && $self->set_acct( $opt->{acct} );

    # apass, SINGLE
    exists( $opt->{apass} ) && $self->set_apass( $opt->{apass} );

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

    # initially_open, BOOLEAN
    exists( $opt->{initially_open} ) && $self->set_initially_open( $opt->{initially_open} );

    # remote_node_name, SINGLE, mandatory
    exists( $opt->{remote_node_name} ) || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::_initialize, option 'remote_node_name' is mandatory.");
    $self->set_remote_node_name( $opt->{remote_node_name} );

    # timeout, SINGLE, with default value
    $self->set_timeout( exists( $opt->{timeout} ) ? $opt->{timeout} : $DEFAULT_VALUE{timeout} );

    # upass, SINGLE
    exists( $opt->{upass} ) && $self->set_upass( $opt->{upass} );

    # Call the superclass' _initialize
    $self->SUPER::_initialize($opt);

    # 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 diff {
    my $from = shift;
    my $to = shift;
    my $diff_number = shift;
    $diff_number = $from->is_diff_number() if ( ! defined( $diff_number ) );

    # Reference types must be identical
    if ( ref($from) ne ref($to) ) {
        my $rf = ref($from);
        my $rt = ref($to);

        throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::diff, FROM ($rf) and TO ($rt) reference types differ.");
    }

    # Diff message
    my $diff = $from->SUPER::diff($to, $diff_number);

    # Diff the acct
    if ( $from->get_acct() ne $to->get_acct() ) {
        my $ref = ref($from);
        my $vf = $from->get_acct();
        my $vt = $to->get_acct();
        my $name = $from->get_name();
        my $number = $from->get_number();
        $diff .= "$ref/$name/$number: acct difference: $vf <-> $vt\n";
    }

    # Diff the apass
    if ( $from->get_apass() ne $to->get_apass() ) {
        my $ref = ref($from);
        my $vf = $from->get_apass();
        my $vt = $to->get_apass();
        my $name = $from->get_name();
        my $number = $from->get_number();
        $diff .= "$ref/$name/$number: apass difference: $vf <-> $vt\n";
    }

    # Diff the high priority login state
    if ( $from->is_high_priority_login() != $to->is_high_priority_login() ) {
        my $ref = ref($from);
        my $vf = $from->is_high_priority_login();
        my $vt = $to->is_high_priority_login();
        my $name = $from->get_name();
        my $number = $from->get_number();
        $diff .= "$ref/$name/$number: high priority login difference: $vf <-> $vt\n";
    }

    # Diff the initially open state
    if ( $from->is_initially_open() != $to->is_initially_open() ) {
        my $ref = ref($from);
        my $vf = $from->is_initially_open();
        my $vt = $to->is_initially_open();
        my $name = $from->get_name();
        my $number = $from->get_number();
        $diff .= "$ref/$name/$number: initially open difference: $vf <-> $vt\n";
    }

    # Diff the remote node name
    if ( $from->get_remote_node_name() ne $to->get_remote_node_name() ) {
        my $ref = ref($from);
        my $vf = $from->get_remote_node_name();
        my $vt = $to->get_remote_node_name();
        my $name = $from->get_name();
        my $number = $from->get_number();
        $diff .= "$ref/$name/$number: remote node name difference: $vf <-> $vt\n";
    }

    # Diff the timeout
    if ( $from->get_timeout() ne $to->get_timeout() ) {
        my $ref = ref($from);
        my $vf = $from->get_timeout();
        my $vt = $to->get_timeout();
        my $name = $from->get_name();
        my $number = $from->get_number();
        $diff .= "$ref/$name/$number: timeout difference: $vf <-> $vt\n";
    }

    # Diff the upass
    if ( $from->get_upass() ne $to->get_upass() ) {
        my $ref = ref($from);
        my $vf = $from->get_upass();
        my $vt = $to->get_upass();
        my $name = $from->get_name();
        my $number = $from->get_number();
        $diff .= "$ref/$name/$number: upass difference: $vf <-> $vt\n";
    }

    # Return diff
    return($diff);
}

sub get_acct {
    my $self = shift;

    return( $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{acct} );
}

sub get_apass {
    my $self = shift;

    return( $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{apass} );
}

sub get_remote_node_name {
    my $self = shift;

    return( $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{remote_node_name} );
}

sub get_timeout {
    my $self = shift;

    return( $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{timeout} );
}

sub get_upass {
    my $self = shift;

    return( $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{upass} );
}

sub is_high_priority_login {
    my $self = shift;

    if ( $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{high_priority_login} ) {
        return(1);
    }
    else {
        return(0);
    }
}

sub is_initially_open {
    my $self = shift;

    if ( $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{initially_open} ) {
        return(1);
    }
    else {
        return(0);
    }
}

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

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 'acct', $val ) || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::set_acct, the specified value '$val' is not allowed.");

    # Assignment
    $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{acct} = $val;
}

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

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 'apass', $val ) || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::set_apass, the specified value '$val' is not allowed.");

    # Assignment
    $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{apass} = $val;
}

sub set_high_priority_login {
    my $self = shift;

    if (shift) {
        $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{high_priority_login} = 1;
    }
    else {
        $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{high_priority_login} = 0;
    }
}

sub set_initially_open {
    my $self = shift;

    if (shift) {
        $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{initially_open} = 1;
    }
    else {
        $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{initially_open} = 0;
    }
}

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

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 'remote_node_name', $val ) || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::set_remote_node_name, the specified value '$val' is not allowed.");

    # Assignment
    $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{remote_node_name} = $val;
}

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

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 'timeout', $val ) || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::set_timeout, the specified value '$val' is not allowed.");

    # Assignment
    $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{timeout} = $val;
}

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

    # Check if isa/ref/rx/value is allowed
    &_value_is_allowed( 'upass', $val ) || throw Error::Simple("ERROR: HH::Unispool::Config::Entry::RemoteSystem::3::set_upass, the specified value '$val' is not allowed.");

    # Assignment
    $self->{HH_Unispool_Config_Entry_RemoteSystem_3}{upass} = $val;
}

sub write {
    my $self = shift;
    my $fh = shift;

    # Make the three tokens
    require HH::Unispool::Config::File::Token::Numbered::System::3;
    my $s = HH::Unispool::Config::File::Token::Numbered::System::3->new( {
        number => $self->get_number(),
        remote_system_name => $self->get_name(),
        acct => $self->get_acct(),
        apass => $self->get_apass(),
        upass => $self->get_upass(),
        timeout => $self->get_timeout(),
        high_priority_login => $self->is_high_priority_login(),
        initially_open => $self->is_initially_open(),
        execution_priority => $self->get_execution_priority(),
    } );

    require HH::Unispool::Config::File::Token::Numbered::System::Info;
    my $i = HH::Unispool::Config::File::Token::Numbered::System::Info->new( {
        number => $self->get_number(),
        description => $self->get_description(),
    } );

    require HH::Unispool::Config::File::Token::Numbered::Network;
    my $n = HH::Unispool::Config::File::Token::Numbered::Network->new( {
        number => $self->get_number(),
        remote_node_name => $self->get_remote_node_name(),
        device_token => 0,
    } );

    # Print the tokens
    $fh->print( $s->write_string() );
    $fh->print( $i->write_string() );
    $fh->print( $n->write_string() );
}