# $Id: IR.pm 1354 2006-06-14 00:27:26Z rvosa $
# Subversion: $Rev: 117 $

# Automatically generated stub code.  DO NOT EDIT.
# Generated on Wed May 10 20:43:02 2000 by idl2perl 2.7 with command:
# bin/idl2perl -outdir lib/COPE -combine -scoped-enums IR.idl
use COPE::IR_types;
use COPE::CORBA::Object;
use Log::Log4perl;
use COPE::CORBA::ORB;
Log::Log4perl::init( COPE::CORBA::ORB->LOGPERLCONF );

# interface CORBA::IRObject (IDL:omg.org/CORBA/IRObject:1.0)
package CORBA::IRObject;

my $logger = Log::Log4perl::get_logger('CORBA.IRObject');

# attribute def_kind (IDL:omg.org/CORBA/IRObject/def_kind:1.0)
sub def_kind {
    $logger->info("Returning definition kind");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'def_kind', $CORBA::DefinitionKind::_tc, @rest );
}

# operation destroy (IDL:omg.org/CORBA/IRObject/destroy:1.0)
sub destroy {
    $logger->info("Destroying");
    my $self     = shift;
    my $result_  = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'destroy',
        'arg_list'  => [],
        'result'    => $result_
    );
    $request_->invoke(0);
}
1;

# interface CORBA::Contained (IDL:omg.org/CORBA/Contained:1.0)
package CORBA::Contained;

$logger = Log::Log4perl::get_logger('CORBA.Contained');

# attribute id (IDL:omg.org/CORBA/Contained/id:1.0)
sub id {
    $logger->info("Returning ID");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'id', $CORBA::RepositoryId::_tc, @rest );
}

# attribute name (IDL:omg.org/CORBA/Contained/name:1.0)
sub name {
    $logger->info("Returning name");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'name', $CORBA::Identifier::_tc, @rest );
}

# attribute version (IDL:omg.org/CORBA/Contained/version:1.0)
sub version {
    $logger->info("Returning version");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'version', $CORBA::VersionSpec::_tc, @rest );
}

# attribute defined_in (IDL:omg.org/CORBA/Contained/defined_in:1.0)
sub defined_in {
    $logger->info("Returning \"defined_in\"");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute(
        'defined_in',
        CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/Container:1.0', 'Container'
        ),
        @rest
    );
}

# attribute absolute_name (IDL:omg.org/CORBA/Contained/absolute_name:1.0)
sub absolute_name {
    $logger->info("Returning absolute name");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'absolute_name', $CORBA::ScopedName::_tc, @rest );
}

# attribute containing_repository (IDL:omg.org/CORBA/Contained/containing_repository:1.0)
sub containing_repository {
    $logger->info("Returning containing repository");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute(
        'containing_repository',
        CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/Repository:1.0', 'Repository'
        ),
        @rest
    );
}

# operation describe (IDL:omg.org/CORBA/Contained/describe:1.0)
sub describe {
    $logger->info("Describing");
    my $self     = shift;
    my $result_  = { _type => $CORBA::Contained::Description::_tc };
    my $request_ = $self->create_request(
        'operation' => 'describe',
        'arg_list'  => [],
        'result'    => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation move (IDL:omg.org/CORBA/Contained/move:1.0)
sub move {
    $logger->info("Moving");
    my ( $self, $new_container, $new_name, $new_version ) = @_;
    my $result_ = { _type => $CORBA::_tc_void };
    my $request_ = $self->create_request(
        'operation' => 'move',
        'arg_list'  => [
            {
                'argument' => {
                    '_type' => CORBA::TypeCode::_create_interface_tc(
                        'IDL:omg.org/CORBA/Container:1.0', 'Container'
                    ),
                    '_value' => $new_container
                },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, '_value' => $new_name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, '_value' => $new_version },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
}
1;

# interface CORBA::Container (IDL:omg.org/CORBA/Container:1.0)
package CORBA::Container;

$logger = Log::Log4perl::get_logger('CORBA.Container');

# operation lookup (IDL:omg.org/CORBA/Container/lookup:1.0)
sub lookup {
    $logger->info("Looking up");
    my ( $self, $search_name ) = @_;
    my $result_ = { _type => $CORBA::Contained::_tc };
    my $request_ = $self->create_request(
        'operation' => 'lookup',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::ScopedName::_tc, _value => $search_name },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation contents (IDL:omg.org/CORBA/Container/contents:1.0)
sub contents {
    $logger->info("Returning contents");
    my ( $self, $limit_type, $exclude_inherited ) = @_;
    my $result_ = { '_type' => $CORBA::ContainedSeq::_tc };
    my $request_ = $self->create_request(
        'operation' => 'contents',
        'arg_list'  => [
            {
                'argument' => {
                    '_type'  => $CORBA::DefinitionKind::_tc,
                    '_value' => $limit_type
                },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    '_type'  => $CORBA::_tc_boolean,
                    '_value' => $exclude_inherited
                },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{'_value'};
}

# operation lookup_name (IDL:omg.org/CORBA/Container/lookup_name:1.0)
sub lookup_name {
    $logger->info("Looking up name");
    my ( $self, $search_name, $levels_to_search, $limit_type,
        $exclude_inherited )
      = @_;
    my $result_ = { _type => $CORBA::ContainedSeq::_tc };
    my $request_ = $self->create_request(
        'operation' => 'lookup_name',
        'arg_list'  => [
            {
                'argument' =>
                  { '_type' => $CORBA::Identifier::_tc, '_value' => $search_name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { '_type' => $CORBA::_tc_long, '_value' => $levels_to_search },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    '_type'  => $CORBA::DefinitionKind::_tc,
                    '_value' => $limit_type
                },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    '_type'  => $CORBA::_tc_boolean,
                    '_value' => $exclude_inherited
                },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation describe_contents (IDL:omg.org/CORBA/Container/describe_contents:1.0)
sub describe_contents {
    $logger->info("Describing contents");
    my ( $self, $limit_type, $exclude_inherited, $max_returned_objs ) = @_;
    my $result_ = { _type => $CORBA::Container::DescriptionSeq::_tc };
    my $request_ = $self->create_request(
        'operation' => 'describe_contents',
        'arg_list'  => [
            {
                'argument' => {
                    '_type'  => $CORBA::DefinitionKind::_tc,
                    '_value' => $limit_type
                },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    '_type'  => $CORBA::_tc_boolean,
                    '_value' => $exclude_inherited
                },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { '_type' => $CORBA::_tc_long, '_value' => $max_returned_objs },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{'_value'};
}

# operation create_module (IDL:omg.org/CORBA/Container/create_module:1.0)
sub create_module {
    $logger->info("Creating module");
    my ( $self, $id, $name, $version ) = @_;
    my $result_ = {
        '_type' => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/ModuleDef:1.0', 'ModuleDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_module',
        'arg_list'  => [
            {
                'argument' =>
                  { '_type' => $CORBA::RepositoryId::_tc, '_value' => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { '_type' => $CORBA::Identifier::_tc, '_value' => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { '_type' => $CORBA::VersionSpec::_tc, '_value' => $version },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{'_value'};
}

# operation create_constant (IDL:omg.org/CORBA/Container/create_constant:1.0)
sub create_constant {
    $logger->info("Creating constant");
    my ( $self, $id, $name, $version, $type, $value ) = @_;
    my $result_ = {
        '_type' => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/ConstantDef:1.0',
            'ConstantDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_constant',
        'arg_list'  => [
            {
                'argument' =>
                  { '_type' => $CORBA::RepositoryId::_tc, '_value' => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { '_type' => $CORBA::Identifier::_tc, '_value' => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { '_type' => $CORBA::VersionSpec::_tc, '_value' => $version },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    '_type' => CORBA::TypeCode::_create_interface_tc(
                        'IDL:omg.org/CORBA/IDLType:1.0', 'IDLType'
                    ),
                    '_value' => $type
                },
                'arg_modes' => 0,
            },
            {
                'argument'  => { '_type' => $CORBA::_tc_any, '_value' => $value },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{'_value'};
}

# operation create_struct (IDL:omg.org/CORBA/Container/create_struct:1.0)
sub create_struct {
    $logger->info("Creating struct");
    my ( $self, $id, $name, $version, $members ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/StructDef:1.0', 'StructDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_struct',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::StructMemberSeq::_tc, _value => $members },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_union (IDL:omg.org/CORBA/Container/create_union:1.0)
sub create_union {
    $logger->info("Creating union");
    my ( $self, $id, $name, $version, $discriminator_type, $members ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/UnionDef:1.0', 'UnionDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_union',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    _type => CORBA::TypeCode::_create_interface_tc(
                        'IDL:omg.org/CORBA/IDLType:1.0', 'IDLType'
                    ),
                    _value => $discriminator_type
                },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::UnionMemberSeq::_tc, _value => $members },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_enum (IDL:omg.org/CORBA/Container/create_enum:1.0)
sub create_enum {
    $logger->info("Creating enum");
    my ( $self, $id, $name, $version, $members ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/EnumDef:1.0', 'EnumDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_enum',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::EnumMemberSeq::_tc, _value => $members },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_alias (IDL:omg.org/CORBA/Container/create_alias:1.0)
sub create_alias {
    $logger->info("Creating alias");
    my ( $self, $id, $name, $version, $original_type ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/AliasDef:1.0', 'AliasDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_alias',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    _type => CORBA::TypeCode::_create_interface_tc(
                        'IDL:omg.org/CORBA/IDLType:1.0', 'IDLType'
                    ),
                    _value => $original_type
                },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_interface (IDL:omg.org/CORBA/Container/create_interface:1.0)
sub create_interface {
    $logger->info("Creating interface");
    my ( $self, $id, $name, $version, $base_interfaces ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/InterfaceDef:1.0',
            'InterfaceDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_interface',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    _type  => $CORBA::InterfaceDefSeq::_tc,
                    _value => $base_interfaces
                },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_exception (IDL:omg.org/CORBA/Container/create_exception:1.0)
sub create_exception {
    $logger->info("Creating exception");
    my ( $self, $id, $name, $version, $members ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/ExceptionDef:1.0',
            'ExceptionDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_exception',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::StructMemberSeq::_tc, _value => $members },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}
1;

# interface CORBA::IDLType (IDL:omg.org/CORBA/IDLType:1.0)
package CORBA::IDLType;

$logger = Log::Log4perl::get_logger('CORBA.IDLType');

# attribute type (IDL:omg.org/CORBA/IDLType/type:1.0)
sub type {
    $logger->info("Retrieving type");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'type', $CORBA::_tc_TypeCode, @rest );
}
1;

# interface CORBA::Repository (IDL:omg.org/CORBA/Repository:1.0)
package CORBA::Repository;

$logger = Log::Log4perl::get_logger('CORBA.Repository');

# operation lookup_id (IDL:omg.org/CORBA/Repository/lookup_id:1.0)
sub lookup_id {
    $logger->info("Looking up ID");
    my ( $self, $search_id ) = @_;
    my $result_ = { _type => $CORBA::Contained::_tc };
    my $request_ = $self->create_request(
        'operation' => 'lookup_id',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $search_id },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation get_primitive (IDL:omg.org/CORBA/Repository/get_primitive:1.0)
sub get_primitive {
    $logger->info("Retrieving primitive");
    my ( $self, $kind ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/PrimitiveDef:1.0',
            'PrimitiveDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'get_primitive',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::PrimitiveKind::_tc, _value => $kind },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_string (IDL:omg.org/CORBA/Repository/create_string:1.0)
sub create_string {
    $logger->info("Creating string");
    my ( $self, $bound ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/StringDef:1.0', 'StringDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_string',
        'arg_list'  => [
            {
                'argument'  => { _type => $CORBA::_tc_ulong, _value => $bound },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_wstring (IDL:omg.org/CORBA/Repository/create_wstring:1.0)
sub create_wstring {
    $logger->info("Creating wstring");
    my ( $self, $bound ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/WstringDef:1.0', 'WstringDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_wstring',
        'arg_list'  => [
            {
                'argument'  => { _type => $CORBA::_tc_ulong, _value => $bound },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_sequence (IDL:omg.org/CORBA/Repository/create_sequence:1.0)
sub create_sequence {
    $logger->info("Creating sequence");
    my ( $self, $bound, $element_type ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/SequenceDef:1.0',
            'SequenceDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_sequence',
        'arg_list'  => [
            {
                'argument'  => { _type => $CORBA::_tc_ulong, _value => $bound },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::IDLType::_tc, _value => $element_type },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_array (IDL:omg.org/CORBA/Repository/create_array:1.0)
sub create_array {
    $logger->info("Creating array");
    my ( $self, $length, $element_type ) = @_;
    my $result_ = {
        _type => CORBA::TypeCode::_create_interface_tc(
            'IDL:omg.org/CORBA/ArrayDef:1.0', 'ArrayDef'
        )
    };
    my $request_ = $self->create_request(
        'operation' => 'create_array',
        'arg_list'  => [
            {
                'argument' => { _type => $CORBA::_tc_ulong, _value => $length },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::IDLType::_tc, _value => $element_type },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}
1;

# interface CORBA::ModuleDef (IDL:omg.org/CORBA/ModuleDef:1.0)
package CORBA::ModuleDef;
1;

# interface CORBA::ConstantDef (IDL:omg.org/CORBA/ConstantDef:1.0)
package CORBA::ConstantDef;

$logger = Log::Log4perl::get_logger('CORBA.ConstantDef');

# attribute type (IDL:omg.org/CORBA/ConstantDef/type:1.0)
sub type {
    $logger->info("Returning type");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'type', $CORBA::_tc_TypeCode, @rest );
}

# attribute type_def (IDL:omg.org/CORBA/ConstantDef/type_def:1.0)
sub type_def {
    $logger->info("Returning type def");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'type_def', $CORBA::IDLType::_tc, @rest );
}

# attribute value (IDL:omg.org/CORBA/ConstantDef/value:1.0)
sub value {
    $logger->info("Returning value");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'value', $CORBA::_tc_any, @rest );
}
1;

# interface CORBA::TypedefDef (IDL:omg.org/CORBA/TypedefDef:1.0)
package CORBA::TypedefDef;
1;

# interface CORBA::StructDef (IDL:omg.org/CORBA/StructDef:1.0)
package CORBA::StructDef;

$logger = Log::Log4perl::get_logger('CORBA.StructDef');

# attribute members (IDL:omg.org/CORBA/StructDef/members:1.0)
sub members {
    $logger->info("Returning members");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'members', $CORBA::StructMemberSeq::_tc, @rest );
}
1;

# interface CORBA::UnionDef (IDL:omg.org/CORBA/UnionDef:1.0)
package CORBA::UnionDef;

$logger = Log::Log4perl::get_logger('CORBA.UnionDef');

# attribute discriminator_type (IDL:omg.org/CORBA/UnionDef/discriminator_type:1.0)
sub discriminator_type {
    $logger->info("Returning discriminator type");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'discriminator_type', $CORBA::_tc_TypeCode,
        @rest );
}

# attribute discriminator_type_def (IDL:omg.org/CORBA/UnionDef/discriminator_type_def:1.0)
sub discriminator_type_def {
    $logger->info("Returning discriminator type def");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'discriminator_type_def', $CORBA::IDLType::_tc,
        @rest );
}

# attribute members (IDL:omg.org/CORBA/UnionDef/members:1.0)
sub members {
    $logger->info("Returning members");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'members', $CORBA::UnionMemberSeq::_tc, @rest );
}
1;

# interface CORBA::EnumDef (IDL:omg.org/CORBA/EnumDef:1.0)
package CORBA::EnumDef;

$logger = Log::Log4perl::get_logger('CORBA.EnumDef');

# attribute members (IDL:omg.org/CORBA/EnumDef/members:1.0)
sub members {
    $logger->info("Returning members");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'members', $CORBA::EnumMemberSeq::_tc, @rest );
}
1;

# interface CORBA::AliasDef (IDL:omg.org/CORBA/AliasDef:1.0)
package CORBA::AliasDef;

$logger = Log::Log4perl::get_logger('CORBA.AliasDef');

# attribute original_type_def (IDL:omg.org/CORBA/AliasDef/original_type_def:1.0)
sub original_type_def {
    $logger->info("Returning original type def");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'original_type_def', $CORBA::IDLType::_tc,
        @rest );
}
1;

# interface CORBA::PrimitiveDef (IDL:omg.org/CORBA/PrimitiveDef:1.0)
package CORBA::PrimitiveDef;

$logger = Log::Log4perl::get_logger('CORBA.PrimitiveDef');

# attribute kind (IDL:omg.org/CORBA/PrimitiveDef/kind:1.0)
sub kind {
    $logger->info("Returning kind");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'kind', $CORBA::PrimitiveKind::_tc, @rest );
}
1;

# interface CORBA::StringDef (IDL:omg.org/CORBA/StringDef:1.0)
package CORBA::StringDef;

$logger = Log::Log4perl::get_logger('CORBA.StringDef');

# attribute bound (IDL:omg.org/CORBA/StringDef/bound:1.0)
sub bound {
    $logger->info("Returning bound");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'bound', $CORBA::_tc_ulong, @rest );
}
1;

# interface CORBA::WstringDef (IDL:omg.org/CORBA/WstringDef:1.0)
package CORBA::WstringDef;

$logger = Log::Log4perl::get_logger('CORBA.WstringDef');

# attribute bound (IDL:omg.org/CORBA/WstringDef/bound:1.0)
sub bound {
    $logger->info("Returning bound");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'bound', $CORBA::_tc_ulong, @rest );
}
1;

# interface CORBA::FixedDef (IDL:omg.org/CORBA/FixedDef:1.0)
package CORBA::FixedDef;

$logger = Log::Log4perl::get_logger('CORBA.FixedDef');

# attribute digits (IDL:omg.org/CORBA/FixedDef/digits:1.0)
sub digits {
    $logger->info("Returning digits");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'digits', $CORBA::_tc_ushort, @rest );
}

# attribute scale (IDL:omg.org/CORBA/FixedDef/scale:1.0)
sub scale {
    $logger->info("Returning scale");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'scale', $CORBA::_tc_short, @rest );
}
1;

# interface CORBA::SequenceDef (IDL:omg.org/CORBA/SequenceDef:1.0)
package CORBA::SequenceDef;

$logger = Log::Log4perl::get_logger('CORBA.SequenceDef');

# attribute bound (IDL:omg.org/CORBA/SequenceDef/bound:1.0)
sub bound {
    $logger->info("Returning bound");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'bound', $CORBA::_tc_ulong, @rest );
}

# attribute element_type (IDL:omg.org/CORBA/SequenceDef/element_type:1.0)
sub element_type {
    $logger->info("Returning element type");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'element_type', $CORBA::_tc_TypeCode, @rest );
}

# attribute element_type_def (IDL:omg.org/CORBA/SequenceDef/element_type_def:1.0)
sub element_type_def {
    $logger->info("Returning element type def");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'element_type_def', $CORBA::IDLType::_tc, @rest );
}
1;

# interface CORBA::ArrayDef (IDL:omg.org/CORBA/ArrayDef:1.0)
package CORBA::ArrayDef;

$logger = Log::Log4perl::get_logger('CORBA.ArrayDef');

# attribute length (IDL:omg.org/CORBA/ArrayDef/length:1.0)
sub length {
    $logger->info("Returning length");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'length', $CORBA::_tc_ulong, @rest );
}

# attribute element_type (IDL:omg.org/CORBA/ArrayDef/element_type:1.0)
sub element_type {
    $logger->info("Returning element type");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'element_type', $CORBA::_tc_TypeCode, @rest );
}

# attribute element_type_def (IDL:omg.org/CORBA/ArrayDef/element_type_def:1.0)
sub element_type_def {
    $logger->info("Returning element type def");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'element_type_def', $CORBA::IDLType::_tc, @rest );
}
1;

# interface CORBA::ExceptionDef (IDL:omg.org/CORBA/ExceptionDef:1.0)
package CORBA::ExceptionDef;

$logger = Log::Log4perl::get_logger('CORBA.ExceptionDef');

# attribute type (IDL:omg.org/CORBA/ExceptionDef/type:1.0)
sub type {
    $logger->info("Returning type");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'type', $CORBA::_tc_TypeCode, @rest );
}

# attribute members (IDL:omg.org/CORBA/ExceptionDef/members:1.0)
sub members {
    $logger->info("Returning members");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'members', $CORBA::StructMemberSeq::_tc, @rest );
}
1;

# interface CORBA::AttributeDef (IDL:omg.org/CORBA/AttributeDef:1.0)
package CORBA::AttributeDef;

$logger = Log::Log4perl::get_logger('CORBA.AttributeDef');

# attribute type (IDL:omg.org/CORBA/AttributeDef/type:1.0)
sub type {
    $logger->info("Returning type");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'type', $CORBA::_tc_TypeCode, @rest );
}

# attribute type_def (IDL:omg.org/CORBA/AttributeDef/type_def:1.0)
sub type_def {
    $logger->info("Returning type def");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'type_def', $CORBA::IDLType::_tc, @rest );
}

# attribute mode (IDL:omg.org/CORBA/AttributeDef/mode:1.0)
sub mode {
    $logger->info("Returning mode");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'mode', $CORBA::AttributeMode::_tc, @rest );
}
1;

# interface CORBA::OperationDef (IDL:omg.org/CORBA/OperationDef:1.0)
package CORBA::OperationDef;

$logger = Log::Log4perl::get_logger('CORBA.OperationDef');

# attribute result (IDL:omg.org/CORBA/OperationDef/result:1.0)
sub result {
    $logger->info("Returning result");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'result', $CORBA::_tc_TypeCode, @rest );
}

# attribute result_def (IDL:omg.org/CORBA/OperationDef/result_def:1.0)
sub result_def {
    $logger->info("Returning result def");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'result_def', $CORBA::IDLType::_tc, @rest );
}

# attribute params (IDL:omg.org/CORBA/OperationDef/params:1.0)
sub params {
    $logger->info("Returning params");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'params', $CORBA::ParDescriptionSeq::_tc, @rest );
}

# attribute mode (IDL:omg.org/CORBA/OperationDef/mode:1.0)
sub mode {
    $logger->info("Returning mode");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'mode', $CORBA::OperationMode::_tc, @rest );
}

# attribute contexts (IDL:omg.org/CORBA/OperationDef/contexts:1.0)
sub contexts {
    $logger->info("Returning contexts");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'contexts', $CORBA::ContextIdSeq::_tc, @rest );
}

# attribute exceptions (IDL:omg.org/CORBA/OperationDef/exceptions:1.0)
sub exceptions {
    $logger->info("Returning exceptions");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'exceptions', $CORBA::ExceptionDefSeq::_tc,
        @rest );
}
1;

# interface CORBA::InterfaceDef (IDL:omg.org/CORBA/InterfaceDef:1.0)
package CORBA::InterfaceDef;

$logger = Log::Log4perl::get_logger('CORBA.InterfaceDef');

# attribute base_interfaces (IDL:omg.org/CORBA/InterfaceDef/base_interfaces:1.0)
sub base_interfaces {
    $logger->info("Returning base interfaces");
    my $self = shift;
    my @rest = @_;
    return $self->_attribute( 'base_interfaces', $CORBA::InterfaceDefSeq::_tc,
        @rest );
}

# operation is_a (IDL:omg.org/CORBA/InterfaceDef/is_a:1.0)
sub is_a {
    $logger->info("Recursing inheritance tree");
    my ( $self, $interface_id ) = @_;
    my $result_ = { _type => $CORBA::_tc_boolean };
    my $request_ = $self->create_request(
        'operation' => 'is_a',
        'arg_list'  => [
            {
                'argument' => {
                    _type  => $CORBA::RepositoryId::_tc,
                    _value => $interface_id
                },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation describe_interface (IDL:omg.org/CORBA/InterfaceDef/describe_interface:1.0)
sub describe_interface {
    $logger->info("Describing interface");
    my $self    = shift;
    my $result_ =
      { _type => $CORBA::InterfaceDef::FullInterfaceDescription::_tc };
    my $request_ = $self->create_request(
        'operation' => 'describe_interface',
        'arg_list'  => [],
        'result'    => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_attribute (IDL:omg.org/CORBA/InterfaceDef/create_attribute:1.0)
sub create_attribute {
    $logger->info("Creating attribute");
    my ( $self, $id, $name, $version, $type, $mode ) = @_;
    my $result_ = { _type => $CORBA::AttributeDef::_tc };
    my $request_ = $self->create_request(
        'operation' => 'create_attribute',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::IDLType::_tc, _value => $type },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::AttributeMode::_tc, _value => $mode },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}

# operation create_operation (IDL:omg.org/CORBA/InterfaceDef/create_operation:1.0)
sub create_operation {
    $logger->info("Creating operation");
    my (
        $self, $id,     $name,       $version, $result,
        $mode, $params, $exceptions, $contexts
      )
      = @_;
    my $result_ = { _type => $CORBA::OperationDef::_tc };
    my $request_ = $self->create_request(
        'operation' => 'create_operation',
        'arg_list'  => [
            {
                'argument' =>
                  { _type => $CORBA::RepositoryId::_tc, _value => $id },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::Identifier::_tc, _value => $name },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::VersionSpec::_tc, _value => $version },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::IDLType::_tc, _value => $result },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::OperationMode::_tc, _value => $mode },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    _type  => $CORBA::ParDescriptionSeq::_tc,
                    _value => $params
                },
                'arg_modes' => 0,
            },
            {
                'argument' => {
                    _type  => $CORBA::ExceptionDefSeq::_tc,
                    _value => $exceptions
                },
                'arg_modes' => 0,
            },
            {
                'argument' =>
                  { _type => $CORBA::ContextIdSeq::_tc, _value => $contexts },
                'arg_modes' => 0,
            },
        ],
        'result' => $result_
    );
    $request_->invoke(0);
    return $result_->{_value};
}
1;

__END__

=head1 NAME

CORBA::InterfaceDef

A class to ...

=head1 SYNOPSIS

use CORBA::InterfaceDef;

=head1 DESCRIPTION

The CORBA::InterfaceDef class implements ...

=head1 OPTIONS

 -D            - show debugging information
 -h            - show help
 -v            - show version
 Other options ...

=head1 SUBROUTINES

=head2 def_kind (method)

Parameters:
    none

Insert description of method here...

=head2 destroy (method)

Parameters:
    none

Insert description of method here...

=head2 id (method)

Parameters:
    none

Insert description of method here...

=head2 name (method)

Parameters:
    none

Insert description of method here...

=head2 version (method)

Parameters:
    none

Insert description of method here...

=head2 defined_in (method)

Parameters:
    none

Insert description of method here...

=head2 absolute_name (method)

Parameters:
    none

Insert description of method here...

=head2 containing_repository (method)

Parameters:
    none

Insert description of method here...

=head2 describe (method)

Parameters:
    none

Insert description of method here...

=head2 move (method)

Parameters:
    new_container
    new_name
    new_version

Insert description of method here...

=head2 lookup (method)

Parameters:
    search_name

Insert description of method here...

=head2 contents (method)

Parameters:
    limit_type
    exclude_inherited

Insert description of method here...

=head2 lookup_name

Parameters:
    none

Insert description of subroutine here...

=head2 describe_contents (method)

Parameters:
    limit_type
    exclude_inherited
    max_returned_objs

Insert description of method here...

=head2 create_module (method)

Parameters:
    id
    name
    version

Insert description of method here...

=head2 create_constant (method)

Parameters:
    id
    name
    version
    type
    value

Insert description of method here...

=head2 create_struct (method)

Parameters:
    id
    name
    version
    members

Insert description of method here...

=head2 create_union (method)

Parameters:
    id
    name
    version
    discriminator_type
    members

Insert description of method here...

=head2 create_enum (method)

Parameters:
    id
    name
    version
    members

Insert description of method here...

=head2 create_alias (method)

Parameters:
    id
    name
    version
    original_type

Insert description of method here...

=head2 create_interface (method)

Parameters:
    id
    name
    version
    base_interfaces

Insert description of method here...

=head2 create_exception (method)

Parameters:
    id
    name
    version
    members

Insert description of method here...

=head2 type (method)

Parameters:
    none

Insert description of method here...

=head2 lookup_id (method)

Parameters:
    search_id

Insert description of method here...

=head2 get_primitive (method)

Parameters:
    kind

Insert description of method here...

=head2 create_string (method)

Parameters:
    bound

Insert description of method here...

=head2 create_wstring (method)

Parameters:
    bound

Insert description of method here...

=head2 create_sequence (method)

Parameters:
    bound
    element_type

Insert description of method here...

=head2 create_array (method)

Parameters:
    length
    element_type

Insert description of method here...

=head2 type (method)

Parameters:
    none

Insert description of method here...

=head2 type_def (method)

Parameters:
    none

Insert description of method here...

=head2 value (method)

Parameters:
    none

Insert description of method here...

=head2 members (method)

Parameters:
    none

Insert description of method here...

=head2 discriminator_type (method)

Parameters:
    none

Insert description of method here...

=head2 discriminator_type_def (method)

Parameters:
    none

Insert description of method here...

=head2 members (method)

Parameters:
    none

Insert description of method here...

=head2 members (method)

Parameters:
    none

Insert description of method here...

=head2 original_type_def (method)

Parameters:
    none

Insert description of method here...

=head2 kind (method)

Parameters:
    none

Insert description of method here...

=head2 bound (method)

Parameters:
    none

Insert description of method here...

=head2 bound (method)

Parameters:
    none

Insert description of method here...

=head2 digits (method)

Parameters:
    none

Insert description of method here...

=head2 scale (method)

Parameters:
    none

Insert description of method here...

=head2 bound (method)

Parameters:
    none

Insert description of method here...

=head2 element_type (method)

Parameters:
    none

Insert description of method here...

=head2 element_type_def (method)

Parameters:
    none

Insert description of method here...

=head2 length (method)

Parameters:
    none

Insert description of method here...

=head2 element_type (method)

Parameters:
    none

Insert description of method here...

=head2 element_type_def (method)

Parameters:
    none

Insert description of method here...

=head2 type (method)

Parameters:
    none

Insert description of method here...

=head2 members (method)

Parameters:
    none

Insert description of method here...

=head2 type (method)

Parameters:
    none

Insert description of method here...

=head2 type_def (method)

Parameters:
    none

Insert description of method here...

=head2 mode (method)

Parameters:
    none

Insert description of method here...

=head2 result (method)

Parameters:
    none

Insert description of method here...

=head2 result_def (method)

Parameters:
    none

Insert description of method here...

=head2 params (method)

Parameters:
    none

Insert description of method here...

=head2 mode (method)

Parameters:
    none

Insert description of method here...

=head2 contexts (method)

Parameters:
    none

Insert description of method here...

=head2 exceptions (method)

Parameters:
    none

Insert description of method here...

=head2 base_interfaces (method)

Parameters:
    none

Insert description of method here...

=head2 is_a (method)

Parameters:
    interface_id

Insert description of method here...

=head2 describe_interface (method)

Parameters:
    none

Insert description of method here...

=head2 create_attribute (method)

Parameters:
    id
    name
    version
    type
    mode

Insert description of method here...

=head2 create_operation

Parameters:
    none

Insert description of subroutine here...

=head1 FILES

Files used by the CORBA::InterfaceDef class ...

=head1 SEE ALSO

Related information ...

=head1 WARNINGS

...

=head1 NOTES

...

=head1 BUGS

What?

=cut