// File: CORBA_InterfaceRepository.idl
// CORBA 3.0, Chapter 10

#ifdef _PRE_3_0_COMPILER_
#pragma prefix "omg.org"
#else
typeprefix CORBA "omg.org"
#endif

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,
   dk_LocalInterface,
   dk_Component, dk_Home,
   dk_Factory, dk_Finder,
   dk_Emits, dk_Publishes, dk_Consumes,
   dk_Provides, dk_Uses,
   dk_Event
};

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
                            );
};

interface ModuleDef;
interface ConstantDef;
interface IDLType;
interface StructDef;
interface UnionDef;
interface EnumDef;
interface AliasDef;
interface ExceptionDef;
interface NativeDef;
interface InterfaceDef;
typedef sequence <InterfaceDef> InterfaceDefSeq;
interface ValueDef;
typedef sequence <ValueDef> ValueDefSeq;
interface ValueBoxDef;
interface AbstractInterfaceDef;
typedef sequence <AbstractInterfaceDef> AbstractInterfaceDefSeq;
interface LocalInterfaceDef;
typedef sequence <LocalInterfaceDef> LocalInterfaceDefSeq;
interface ExtInterfaceDef;
typedef sequence <ExtInterfaceDef> ExtInterfaceDefSeq;
interface ExtValueDef;
typedef sequence <ExtValueDef> ExtValueDefSeq;
interface ExtAbstractInterfaceDef;
typedef sequence <ExtAbstractInterfaceDef> ExtAbstractInterfaceDefSeq;
interface ExtLocalInterfaceDef;
typedef sequence <ExtLocalInterfaceDef> ExtLocalInterfaceDefSeq;
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;
};

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

typedef sequence <ExceptionDescription> ExcDescriptionSeq;

struct ExtInitializer {
   StructMemberSeq members;
   ExcDescriptionSeq exceptions;
   Identifier name;
};

typedef sequence <ExtInitializer> ExtInitializerSeq;

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
#ifndef JACORB
      // Removed: http://www.omg.org/issues/issue3015.txt
      ,in boolean                      is_abstract
#endif
    );
   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
                                                  );
   LocalInterfaceDef create_local_interface (
      in RepositoryId                 id,
      in Identifier                   name,
      in VersionSpec                  version,
      in InterfaceDefSeq              base_interfaces
                                            );
   ExtValueDef create_ext_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 ExtInitializerSeq initializers
                                );
};
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;
};
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;
};
struct ExtAttributeDescription {
   Identifier name;
   RepositoryId id;
   RepositoryId defined_in;
   VersionSpec version;
   TypeCode type;
   AttributeMode mode;
   ExcDescriptionSeq get_exceptions;
   ExcDescriptionSeq put_exceptions;
};
interface ExtAttributeDef : AttributeDef {
   // read/write interface
   attribute ExcDescriptionSeq get_exceptions;
   attribute ExcDescriptionSeq set_exceptions;
   // read interface
   ExtAttributeDescription describe_attribute ();
};
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;

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;
typedef sequence <ExtAttributeDescription> ExtAttrDescriptionSeq;

interface InterfaceDef : Container, Contained, IDLType {
   // read/write interface
   attribute InterfaceDefSeq       base_interfaces;

#ifndef JACORB
      // Removed: http://www.omg.org/issues/issue3015.txt
      attribute boolean               is_abstract;
#endif

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

#ifndef JACORB
      // Removed: http://www.omg.org/issues/issue3015.txt
      boolean                     is_abstract;
#endif
   };
   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;

#ifndef JACORB
      // Removed: http://www.omg.org/issues/issue3015.txt
      boolean                     is_abstract;
#endif
};

interface InterfaceAttrExtension {
   // read interface
   struct ExtFullInterfaceDescription {
      Identifier name;
      RepositoryId id;
      RepositoryId defined_in;
      VersionSpec version;
      OpDescriptionSeq operations;
      ExtAttrDescriptionSeq attributes;
      RepositoryIdSeq base_interfaces;
      TypeCode type;
   };
   ExtFullInterfaceDescription describe_ext_interface ();
   // write interface
   ExtAttributeDef create_ext_attribute (
      in RepositoryId id,
      in Identifier name,
      in VersionSpec version,
      in IDLType type,
      in AttributeMode mode,
      in ExceptionDefSeq get_exceptions,
      in ExceptionDefSeq set_exceptions
                                        );
};

interface ExtInterfaceDef : InterfaceDef, InterfaceAttrExtension {};

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 ExtValueDef : ValueDef {
   // read/write interface
   attribute ExtInitializerSeq ext_initializers;
   // read interface
   struct ExtFullValueDescription {
      Identifier name;
      RepositoryId id;
      boolean is_abstract;
      boolean is_custom;
      RepositoryId defined_in;
      VersionSpec version;
      OpDescriptionSeq operations;
      ExtAttrDescriptionSeq attributes;
      ValueMemberSeq members;
      ExtInitializerSeq initializers;
      RepositoryIdSeq supported_interfaces;
      RepositoryIdSeq abstract_base_values;
      boolean is_truncatable;
      RepositoryId base_value;
      TypeCode type;
   };
   ExtFullValueDescription describe_ext_value ();
   // write interface
   ExtAttributeDef create_ext_attribute (
      in RepositoryId id,
      in Identifier name,
      in VersionSpec version,
      in IDLType type,
      in AttributeMode mode,
      in ExceptionDefSeq get_exceptions,
      in ExceptionDefSeq set_exceptions
                                        );
};

interface ValueBoxDef : TypedefDef {
   attribute IDLType original_type_def;
};
interface AbstractInterfaceDef : InterfaceDef {
};
interface ExtAbstractInterfaceDef : AbstractInterfaceDef,
InterfaceAttrExtension {
};
interface LocalInterfaceDef : InterfaceDef {
};
interface ExtLocalInterfaceDef : LocalInterfaceDef,
InterfaceAttrExtension {
};

#ifdef _COMPONENT_REPOSITORY_

module ComponentIR {
   typeprefix ComponentIR "omg.org";
   interface ComponentDef;
   interface HomeDef;
   interface EventDef : ExtValueDef {};
   interface Container{
      ComponentDef create_component (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in ComponentDef base_component,
         in InterfaceDefSeq supports_interfaces
                                    );
      HomeDef create_home (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in HomeDef base_home,
         in ComponentDef managed_component,
         in InterfaceDefSeq supports_interfaces,
         in ValueDef primary_key
                          );
      EventDef create_event (
         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 ExtInitializerSeq initializers
                            );
   };
   interface ModuleDef : CORBA::ModuleDef, Container{};
   interface Repository : CORBA::Repository, Container{};
   interface ProvidesDef : Contained {
      attribute InterfaceDef interface_type;
   };
   struct ProvidesDescription {
      Identifier name;
      RepositoryId id;
      RepositoryId defined_in;
      VersionSpec version;
      RepositoryId interface_type;
   };
   interface UsesDef : Contained {
      attribute InterfaceDef interface_type;
      attribute boolean is_multiple;
   };
   struct UsesDescription {
      Identifier name;
      RepositoryId id;
      RepositoryId defined_in;
      VersionSpec version;
      RepositoryId interface_type;
      boolean is_multiple;
   };
   interface EventPortDef : Contained {
      // read/write interface
      attribute EventDef event;
      // read interface
      boolean is_a (in RepositoryId event_id);
   };
   struct EventPortDescription {
      Identifier name;
      RepositoryId id;
      RepositoryId defined_in;
      VersionSpec version;
      RepositoryId event;
   };
   interface EmitsDef : EventPortDef {};
   interface PublishesDef : EventPortDef {};
   interface ConsumesDef : EventPortDef {};
   interface ComponentDef : ExtInterfaceDef {
      // read/write interface
      attribute ComponentDef base_component;
      attribute InterfaceDefSeq supported_interfaces;
      // write interface
      ProvidesDef create_provides (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in InterfaceDef interface_type
                                  );
      UsesDef create_uses (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in InterfaceDef interface_type,
         in boolean is_multiple
                          );
      EmitsDef create_emits (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in EventDef event
                            );
      PublishesDef create_publishes (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in EventDef event
                                    );
      ConsumesDef create_consumes (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in EventDef event
                                  );
   };
   typedef sequence<ProvidesDescription>
   ProvidesDescriptionSeq;
   typedef sequence<UsesDescription> UsesDescriptionSeq;
   typedef sequence<EventPortDescription>
   EventPortDescriptionSeq;
   struct ComponentDescription {
      Identifier name;
      RepositoryId id;
      RepositoryId defined_in;
      VersionSpec version;
      RepositoryId base_component;
      RepositoryIdSeq supported_interfaces;
      ProvidesDescriptionSeq provided_interfaces;
      UsesDescriptionSeq used_interfaces;
      EventPortDescriptionSeq emits_events;
      EventPortDescriptionSeq publishes_events;
      EventPortDescriptionSeq consumes_events;
      ExtAttrDescriptionSeq attributes;
      TypeCode type;
   };
   interface FactoryDef : OperationDef {};
   interface FinderDef : OperationDef {};
   interface HomeDef : ExtInterfaceDef {
      // read/write interface
      attribute HomeDef base_home;
      attribute InterfaceDefSeq supported_interfaces;
      attribute ComponentDef managed_component;
      attribute ValueDef primary_key;
      // write interface
      FactoryDef create_factory (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in ParDescriptionSeq params,
         in ExceptionDefSeq exceptions
                                );
      FinderDef create_finder (
         in RepositoryId id,
         in Identifier name,
         in VersionSpec version,
         in ParDescriptionSeq params,
         in ExceptionDefSeq exceptions
                              );
   };
   struct HomeDescription {
      Identifier name;
      RepositoryId id;
      RepositoryId defined_in;
      VersionSpec version;
      RepositoryId base_home;
      RepositoryId managed_component;
      ValueDescription primary_key;
      OpDescriptionSeq factories;
      OpDescriptionSeq finders;
      OpDescriptionSeq operations;
      ExtAttrDescriptionSeq attributes;
      TypeCode type;
   };
};
#endif // _COMPONENT_REPOSITORY_
