# Automatically generated stub code.  DO NOT EDIT.
# Generated on Wed May 10 20:28:22 2000 by idl2perl 2.7 with command:
# bin/idl2perl -outdir t/COPE Test.idl

use COPE::Test::Test1_types;
use COPE::CORBA::Object;

# interface Test::Test1 (IDL:smop.org/Test/Test1:1.0)

package Test::Test1;

# operation in_long (IDL:smop.org/Test/Test1/in_long:1.0)

sub in_long ($$) {
    my($self,$along) = @_;
    my $result_ = { _type => $CORBA::_tc_long };
    my $request_ = $self->create_request(
        'operation' => 'in_long',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $CORBA::_tc_long, _value => $along },
            'arg_modes' => 0,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation in_string (IDL:smop.org/Test/Test1/in_string:1.0)

sub in_string ($$) {
    my($self,$astring) = @_;
    my $result_ = { _type => $CORBA::_tc_string0 };
    my $request_ = $self->create_request(
        'operation' => 'in_string',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $CORBA::_tc_string0, _value => $astring },
            'arg_modes' => 0,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation in_long_sequence (IDL:smop.org/Test/Test1/in_long_sequence:1.0)

sub in_long_sequence ($$) {
    my($self,$asequence) = @_;
    my $result_ = { _type => $Test::Test1::LongSeq::_tc };
    my $request_ = $self->create_request(
        'operation' => 'in_long_sequence',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::LongSeq::_tc, _value => $asequence },
            'arg_modes' => 0,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation in_octet_sequence (IDL:smop.org/Test/Test1/in_octet_sequence:1.0)

sub in_octet_sequence ($$) {
    my($self,$asequence) = @_;
    my $result_ = { _type => $Test::Test1::OctetSeq::_tc };
    my $request_ = $self->create_request(
        'operation' => 'in_octet_sequence',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::OctetSeq::_tc, _value => $asequence },
            'arg_modes' => 0,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation in_struct (IDL:smop.org/Test/Test1/in_struct:1.0)

sub in_struct ($$) {
    my($self,$astruct) = @_;
    my $result_ = { _type => $Test::TestStruct::_tc };
    my $request_ = $self->create_request(
        'operation' => 'in_struct',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::TestStruct::_tc, _value => $astruct },
            'arg_modes' => 0,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation in_array (IDL:smop.org/Test/Test1/in_array:1.0)

sub in_array ($$) {
    my($self,$anarray) = @_;
    my $result_ = { _type => $Test::Test1::ShortArray::_tc };
    my $request_ = $self->create_request(
        'operation' => 'in_array',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::ShortArray::_tc, _value => $anarray },
            'arg_modes' => 0,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation inout_long (IDL:smop.org/Test/Test1/inout_long:1.0)

sub inout_long ($$) {
    my($self,$along) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'inout_long',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $CORBA::_tc_long, _value => $along },
            'arg_modes' => 2,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation inout_string (IDL:smop.org/Test/Test1/inout_string:1.0)

sub inout_string ($$) {
    my($self,$astring) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'inout_string',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $CORBA::_tc_string0, _value => $astring },
            'arg_modes' => 2,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation inout_long_sequence (IDL:smop.org/Test/Test1/inout_long_sequence:1.0)

sub inout_long_sequence ($$) {
    my($self,$asequence) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'inout_long_sequence',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::LongSeq::_tc, _value => $asequence },
            'arg_modes' => 2,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation inout_octet_sequence (IDL:smop.org/Test/Test1/inout_octet_sequence:1.0)

sub inout_octet_sequence ($$) {
    my($self,$asequence) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'inout_octet_sequence',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::OctetSeq::_tc, _value => $asequence },
            'arg_modes' => 2,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation inout_struct (IDL:smop.org/Test/Test1/inout_struct:1.0)

sub inout_struct ($$) {
    my($self,$astruct) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'inout_struct',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::TestStruct::_tc, _value => $astruct },
            'arg_modes' => 2,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation inout_array (IDL:smop.org/Test/Test1/inout_array:1.0)

sub inout_array ($$) {
    my($self,$anarray) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'inout_array',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::ShortArray::_tc, _value => $anarray },
            'arg_modes' => 2,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation out_long (IDL:smop.org/Test/Test1/out_long:1.0)

sub out_long ($$) {
    my($self,$along) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'out_long',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $CORBA::_tc_long, _value => $along },
            'arg_modes' => 1,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation out_string (IDL:smop.org/Test/Test1/out_string:1.0)

sub out_string ($$) {
    my($self,$astring) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'out_string',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $CORBA::_tc_string0, _value => $astring },
            'arg_modes' => 1,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation out_long_sequence (IDL:smop.org/Test/Test1/out_long_sequence:1.0)

sub out_long_sequence ($$) {
    my($self,$asequence) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'out_long_sequence',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::LongSeq::_tc, _value => $asequence },
            'arg_modes' => 1,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation out_octet_sequence (IDL:smop.org/Test/Test1/out_octet_sequence:1.0)

sub out_octet_sequence ($$) {
    my($self,$asequence) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'out_octet_sequence',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::OctetSeq::_tc, _value => $asequence },
            'arg_modes' => 1,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation out_struct (IDL:smop.org/Test/Test1/out_struct:1.0)

sub out_struct ($$) {
    my($self,$astruct) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'out_struct',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::TestStruct::_tc, _value => $astruct },
            'arg_modes' => 1,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation out_array (IDL:smop.org/Test/Test1/out_array:1.0)

sub out_array ($$) {
    my($self,$anarray) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'out_array',
        'arg_list'  => [
          { 'argument'  =>
            { _type  => $Test::Test1::ShortArray::_tc, _value => $anarray },
            'arg_modes' => 1,
          },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}

# operation ret_object (IDL:smop.org/Test/Test1/ret_object:1.0)

sub ret_object ($) {
    my($self) = @_;
    my $result_ = { _type => CORBA::TypeCode::_create_interface_tc('IDL:smop.org/Test/Test2:1.0', 'Test2') };
    my $request_ = $self->create_request(
        'operation' => 'ret_object',
        'arg_list'  => [
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

1;