// File: CORBA_InterfaceRepository.idl 

// (part of formal/00-04-01)

// CORBA 2.3, Chapter 10


#pragma prefix "omg.org"



// Forward references to Chapter 10, CORBA_InterfaceRepository.idl



#pragma prefix "omg.org"

    interface AliasDef;

    interface ArrayDef;

    interface AttributeDef;

    interface ConstantDef;

    interface Contained;

    interface Container;

    interface EnumDef;

    interface ExceptionDef;

    interface FixedDef;

    interface IDLType;

    interface InterfaceDef;

    interface IRObject;

    interface ModuleDef;

    interface NativeDef;

    interface OperationDef;

    interface PrimitiveDef; 

    interface Repository;

    interface SequenceDef;

    interface StringDef;

    interface StructDef;

    interface TypeCode;

    interface TypedefDef;

    interface UnionDef;

    interface ValueDef;

    interface ValueBoxDef;

    interface ValueMemberDef;

    interface WstringDef;



    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

    };

    

    interface IRObject {

        // read interface

        readonly attribute  DefinitionKind  def_kind;

        // write interface

        void                destroy ();

    };

    

    typedef string VersionSpec;



    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

                                    );

    };

    typedef sequence <InterfaceDef> InterfaceDefSeq;

    typedef sequence <ValueDef> ValueDefSeq;

    typedef sequence <Contained> ContainedSeq;

    

    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,

                                       in boolean                      is_abstract

                                       );

        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

                                );

    };

    interface IDLType : IRObject {

        readonly attribute TypeCode     type;

    };



    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;

        attribute boolean               is_abstract;



        // 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;

            boolean                     is_abstract;

        };



        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;

        boolean                         is_abstract;

    };



    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;

    };



    enum TCKind {                               // PIDL

        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;                        // PIDL

    const ValueModifier VM_NONE         = 0;

    const ValueModifier VM_CUSTOM       = 1;

    const ValueModifier VM_ABSTRACT     = 2;

    const ValueModifier VM_TRUNCATABLE  = 3;



    interface TypeCode {                            // PIDL

        exception   Bounds {};

        exception   BadKind {};

        // for all TypeCode kinds

        boolean     equal       (in TypeCode tc);

        boolean     equivalent  (in TypeCode tc); 

        TypeCode    get_compact_typecode(); 

        TCKind      kind ();

        // for tk_objref, tk_struct,    tk_union,  tk_enum, tk_alias, 

        //     tk_value,  tk_value_box, tk_native, tk_abstract_interface

        // and tk_except

        RepositoryId    id () raises (BadKind);

        // for tk_objref, tk_struct,    tk_union,  tk_enum, tk_alias, 

        //     tk_value,  tk_value_box, tk_native, tk_abstract_interface

        // and tk_except

        Identifier name () raises (BadKind);

        // for tk_struct, tk_union, tk_enum, tk_value, 

        // and tk_except

        unsigned long   member_count () raises (BadKind);

        Identifier      member_name (in unsigned long index) 

            raises (BadKind, Bounds);

        // for tk_struct, tk_union, tk_value, and tk_except

        TypeCode        member_type (in unsigned long index) 

            raises (BadKind, Bounds);

        // for tk_union

        any             member_label (in unsigned long index) 

            raises (BadKind, Bounds);

        TypeCode        discriminator_type ()   raises (BadKind);

        long            default_index ()        raises (BadKind); 

        // for tk_string, tk_sequence, and tk_array

        unsigned long   length ()               raises (BadKind);

        // for tk_sequence, tk_array, tk_value_box, and tk_alias

        TypeCode        content_type ()         raises (BadKind);

        // for tk_fixed

        unsigned short  fixed_digits()          raises (BadKind);

        short           fixed_scale()           raises (BadKind);

        // for tk_value

        Visibility      member_visibility(in unsigned long index)

            raises(BadKind, Bounds);

        ValueModifier   type_modifier()         raises(BadKind);

        TypeCode        concrete_base_type()    raises(BadKind);

    };



