OS/2 Shareware BBS: 10 Tools/10-Tools.zip/omgidl.zip/ir.idl

Text File | 2002-09-04 | 15KB | 569 lines

//Updated:  December 1999
//This file contains OMG IDL from  CORBA V2.3 December 1999
//
// OMG IDL from Chapters 1 through 15 CORBA module
//
// Post CORBA 2.3 changes from core RTF bracketed
// in #ifdef CORBA_2_5 ... #endif
//
// Stuff from Messaging specification is bracketed
// in #ifdef CORBA3 ... #endif

#pragma prefix "omg.org"
module CORBA {

// Chapter 10 Interface Repository

    typedef string Identifier;
    typedef string ScopedName;
    typedef string RepositoryId;
    enum DefinitionKind {
    dk_none, dk_all,
    dk_Attribute, dk_Constant, dk_Exception, dk_Interface,
    dk_Module, dk_Operation, dk_Typedef,
    dk_Alias, dk_Struct, dk_Union, dk_Enum,
    dk_Primitive, dk_String, dk_Sequence, dk_Array,
    dk_Repository,
    dk_Wstring, dk_Fixed,
    dk_Value, dk_ValueBox, dk_ValueMember,
    dk_Native,
    dk_AbstractInterface
    };
    interface IRObject {
    // read interface
    readonly attribute DefinitionKind def_kind;
    // write interface
    void destroy ();
    };
    typedef string VersionSpec;
    interface Contained;
    interface Repository;
    interface Container;
    interface Contained : IRObject {

    // read/write interface
    attribute RepositoryId id;
    attribute Identifier name;
    attribute VersionSpec version;
    // read interface
    readonly attribute Container defined_in;
    readonly attribute ScopedName absolute_name;
    readonly attribute Repository containing_repository;
    struct Description {
        DefinitionKind kind;
        any value;
    };
    Description describe ();
    // write interface
    void move (
        in Container         new_container,
        in Identifier         new_name,
        in VersionSpec         new_version
    );
    };
    interface ModuleDef;
    interface ConstantDef;
    interface IDLType;
    interface StructDef;
    interface UnionDef;
    interface EnumDef;
    interface AliasDef;
    interface InterfaceDef;
    interface ExceptionDef;
    interface NativeDef;
    typedef sequence <InterfaceDef> InterfaceDefSeq;
    interface ValueDef;
    typedef sequence <ValueDef> ValueDefSeq;
    interface ValueBoxDef;
    typedef sequence <Contained> ContainedSeq;
    interface AbstractInterfaceDef;
    typedef sequence <AbstractInterfaceDef> AbstractInterfaceDefSeq;
    struct StructMember {
    Identifier                 name;
    TypeCode                 type;
    IDLType                 type_def;
    };
    typedef sequence <StructMember> StructMemberSeq;
    struct Initializer {
    StructMemberSeq             members;
    Identifier                name;
    };
    typedef sequence <Initializer> InitializerSeq;
    struct UnionMember {
    Identifier                 name;
    any                     label;
    TypeCode                 type;
    IDLType                 type_def;
    };
    typedef sequence <UnionMember> UnionMemberSeq;
    typedef sequence <Identifier> EnumMemberSeq;
    interface Container : IRObject {
    // read interface
    Contained lookup (
        in ScopedName             search_name
    );
    ContainedSeq contents (
        in DefinitionKind             limit_type,
        in boolean                 exclude_inherited
    );
    ContainedSeq lookup_name (
        in Identifier             search_name,
        in long                 levels_to_search,
        in DefinitionKind             limit_type,
        in boolean                 exclude_inherited
    );
    struct Description {
        Contained                 contained_object;
        DefinitionKind             kind;
        any                 value;
    };
    typedef sequence<Description> DescriptionSeq;
    DescriptionSeq describe_contents (
        in DefinitionKind             limit_type,
        in boolean                 exclude_inherited,
        in long                 max_returned_objs
    );
    // write interface
    ModuleDef create_module (
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version
    );
    ConstantDef create_constant (
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in IDLType                 type,
        in any                 value
    );
    StructDef create_struct (
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in StructMemberSeq             members
    );
    UnionDef create_union (
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in IDLType                 discriminator_type,
        in UnionMemberSeq             members
    );
    EnumDef create_enum (
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in EnumMemberSeq            members
    );
    AliasDef create_alias (
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in IDLType                 original_type
    );
    InterfaceDef create_interface (
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in InterfaceDefSeq            base_interfaces
    );
    ValueDef create_value(
        in RepositoryId            id,
        in Identifier            name,
        in VersionSpec            version,
        in boolean                is_custom,
        in boolean                is_abstract,
        in ValueDef                base_value,
        in boolean                is_truncatable,
        in ValueDefSeq            abstract_base_values,
        in InterfaceDefSeq            supported_interfaces,
        in InitializerSeq            initializers
    );
    ValueBoxDef create_value_box(
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in IDLType                 original_type_def
    );
    ExceptionDef create_exception(
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version,
        in StructMemberSeq             members
    );
    NativeDef create_native(
        in RepositoryId             id,
        in Identifier             name,
        in VersionSpec             version
    );
    AbstractInterfaceDef create_abstract_interface (
        in RepositoryId id,
        in Identifier name,
        in VersionSpec version,
        in AbstractInterfaceDefSeq base_interfaces
    );
    };

    interface IDLType : IRObject {
    readonly attribute TypeCode     type;
    };

    interface PrimitiveDef;
    interface StringDef;
    interface SequenceDef;
    interface ArrayDef;
    interface WstringDef;
    interface FixedDef;
    enum PrimitiveKind {
    pk_null, pk_void, pk_short, pk_long, pk_ushort, pk_ulong,
    pk_float, pk_double, pk_boolean, pk_char, pk_octet,
    pk_any, pk_TypeCode, pk_Principal, pk_string, pk_objref,
    pk_longlong, pk_ulonglong, pk_longdouble,
    pk_wchar, pk_wstring, pk_value_base
    };

    interface Repository : Container {
    // read interface
    Contained lookup_id (in RepositoryId search_id);
    TypeCode get_canonical_typecode(in TypeCode tc);
    PrimitiveDef get_primitive (in PrimitiveKind kind);
    // write interface
    StringDef create_string (in unsigned long bound);
    WstringDef create_wstring (in unsigned long bound);
    SequenceDef create_sequence (
        in unsigned long         bound,
        in IDLType             element_type
     );
    ArrayDef create_array (
        in unsigned long         length,
        in IDLType             element_type
    );
    FixedDef create_fixed (
        in unsigned short         digits,
        in short             scale
    );
    };

    interface ModuleDef : Container, Contained {
    };

    struct ModuleDescription {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    };

    interface ConstantDef : Contained {
    readonly attribute TypeCode type;
    attribute IDLType type_def;
    attribute any value;
    };

    struct ConstantDescription {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    TypeCode             type;
    any                 value;
    };

    interface TypedefDef : Contained, IDLType {
    };

    struct TypeDescription {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    TypeCode             type;
    };

    interface StructDef : TypedefDef, Container {
    attribute StructMemberSeq     members;
    };

    interface UnionDef : TypedefDef, Container {
    readonly attribute TypeCode     discriminator_type;
    attribute IDLType         discriminator_type_def;
    attribute UnionMemberSeq     members;
    };

    interface EnumDef : TypedefDef {
    attribute EnumMemberSeq     members;
    };

    interface AliasDef : TypedefDef {
    attribute IDLType         original_type_def;
    };

    interface NativeDef : TypedefDef {
    };

    interface PrimitiveDef: IDLType {
    readonly attribute PrimitiveKind kind;
    };

    interface StringDef : IDLType {
    attribute unsigned long     bound;
    };

    interface WstringDef : IDLType {
    attribute unsigned long     bound;
    };

    interface FixedDef : IDLType {
    attribute unsigned short     digits;
    attribute short         scale;
    };

    interface SequenceDef : IDLType {
    attribute unsigned long     bound;
    readonly attribute TypeCode     element_type;
    attribute IDLType         element_type_def;
    };

    interface ArrayDef : IDLType {
    attribute unsigned long     length;
    readonly attribute TypeCode     element_type;
    attribute IDLType         element_type_def;
    };

    interface ExceptionDef : Contained, Container {
    readonly attribute TypeCode     type;
    attribute StructMemberSeq     members;
    };

    struct ExceptionDescription {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    TypeCode             type;
    };

    enum AttributeMode {ATTR_NORMAL, ATTR_READONLY};

    interface AttributeDef : Contained {
    readonly attribute TypeCode     type;
    attribute IDLType         type_def;
    attribute AttributeMode        mode;
    };

    struct AttributeDescription {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    TypeCode             type;
    AttributeMode             mode;
    };

    enum OperationMode {OP_NORMAL, OP_ONEWAY};
    enum ParameterMode {PARAM_IN, PARAM_OUT, PARAM_INOUT};
    struct ParameterDescription {
    Identifier             name;
    TypeCode             type;
    IDLType             type_def;
    ParameterMode             mode;
    };

    typedef sequence <ParameterDescription> ParDescriptionSeq;
    typedef Identifier ContextIdentifier;
    typedef sequence <ContextIdentifier> ContextIdSeq;
    typedef sequence <ExceptionDef> ExceptionDefSeq;
    typedef sequence <ExceptionDescription> ExcDescriptionSeq;

    interface OperationDef : Contained {
    readonly attribute TypeCode    result;
    attribute IDLType         result_def;
    attribute ParDescriptionSeq     params;
    attribute OperationMode     mode;
    attribute ContextIdSeq         contexts;
    attribute ExceptionDefSeq     exceptions;
    };

    struct OperationDescription {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    TypeCode             result;
    OperationMode             mode;
    ContextIdSeq             contexts;
    ParDescriptionSeq         parameters;
    ExcDescriptionSeq         exceptions;
    };

    typedef sequence <RepositoryId> RepositoryIdSeq;
    typedef sequence <OperationDescription> OpDescriptionSeq;
    typedef sequence <AttributeDescription> AttrDescriptionSeq;

    interface InterfaceDef : Container, Contained, IDLType {
    // read/write interface
    attribute InterfaceDefSeq     base_interfaces;
       // read interface
    boolean is_a (
        in RepositoryId         interface_id
    );
    struct FullInterfaceDescription {
        Identifier             name;
        RepositoryId        id;
        RepositoryId         defined_in;
        VersionSpec         version;
        OpDescriptionSeq         operations;
        AttrDescriptionSeq         attributes;
        RepositoryIdSeq         base_interfaces;
        TypeCode             type;
    };
    FullInterfaceDescription describe_interface();
    // write interface
    AttributeDef create_attribute (
        in RepositoryId         id,
        in Identifier         name,
        in VersionSpec         version,
        in IDLType             type,
        in AttributeMode         mode
    );
    OperationDef create_operation (
           in RepositoryId         id,
        in Identifier         name,
        in VersionSpec         version,
        in IDLType             result,
        in OperationMode         mode,
        in ParDescriptionSeq     params,
        in ExceptionDefSeq         exceptions,
        in ContextIdSeq         contexts
    );
    };

    struct InterfaceDescription {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    RepositoryIdSeq         base_interfaces;
    };

    typedef short Visibility;
    const Visibility PRIVATE_MEMBER = 0;
    const Visibility PUBLIC_MEMBER = 1;

    struct ValueMember {
    Identifier             name;
    RepositoryId             id;
    RepositoryId             defined_in;
    VersionSpec             version;
    TypeCode             type;
    IDLType             type_def;
    Visibility             access;
    };

    typedef sequence <ValueMember> ValueMemberSeq;

    interface ValueMemberDef : Contained {
    readonly attribute TypeCode type;
    attribute IDLType type_def;
    attribute Visibility access;
    };

    interface ValueDef : Container, Contained, IDLType {
    // read/write interface
    attribute InterfaceDefSeq supported_interfaces;
    attribute InitializerSeq initializers;
    attribute ValueDef base_value;
    attribute ValueDefSeq abstract_base_values;
    attribute boolean is_abstract;
    attribute boolean is_custom;
    attribute boolean is_truncatable;
    // read interface
    boolean is_a(
        in RepositoryId         id
    );
    struct FullValueDescription {
        Identifier            name;
        RepositoryId        id;
        boolean            is_abstract;
        boolean            is_custom;
        RepositoryId        defined_in;
        VersionSpec            version;
        OpDescriptionSeq        operations;
        AttrDescriptionSeq        attributes;
        ValueMemberSeq        members;
        InitializerSeq        initializers;
        RepositoryIdSeq        supported_interfaces;
        RepositoryIdSeq        abstract_base_values;
        boolean            is_truncatable;
        RepositoryId        base_value;
        TypeCode            type;
    };
    FullValueDescription describe_value();
    ValueMemberDef create_value_member(
        in RepositoryId         id,
        in Identifier         name,
        in VersionSpec         version,
        in IDLType             type,
        in Visibility         access
    );
    AttributeDef create_attribute(
        in RepositoryId        id,
        in Identifier        name,
        in VersionSpec        version,
        in IDLType            type,
        in AttributeMode        mode
    );
    OperationDef create_operation (
        in RepositoryId        id,
        in Identifier        name,
        in VersionSpec        version,
        in IDLType            result,
        in OperationMode        mode,
        in ParDescriptionSeq    params,
        in ExceptionDefSeq        exceptions,
        in ContextIdSeq        contexts
    );
    };
    struct ValueDescription {
    Identifier            name;
    RepositoryId            id;
    boolean             is_abstract;
    boolean                is_custom;
    RepositoryId            defined_in;
    VersionSpec            version;
    RepositoryIdSeq            supported_interfaces;
    RepositoryIdSeq            abstract_base_values;
    boolean                is_truncatable;
    RepositoryId            base_value;
    };

    interface ValueBoxDef : TypedefDef {
    attribute IDLType original_type_def;
    };

    interface AbstractInterfaceDef : InterfaceDef {
    };


    enum TCKind {
#    pragma version TCKind 2.3
    tk_null, tk_void,
    tk_short, tk_long, tk_ushort, tk_ulong,
    tk_float, tk_double, tk_boolean, tk_char,
    tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref,
    tk_struct, tk_union, tk_enum, tk_string,
    tk_sequence, tk_array, tk_alias, tk_except,
    tk_longlong, tk_ulonglong, tk_longdouble,
    tk_wchar, tk_wstring, tk_fixed,
    tk_value, tk_value_box,
    tk_native,
    tk_abstract_interface
    };

    typedef short ValueModifier;
    const ValueModifier VM_NONE = 0;
    const ValueModifier VM_CUSTOM = 1;
    const ValueModifier VM_ABSTRACT = 2;
    const ValueModifier VM_TRUNCATABLE = 3;
};