#pragma prefix "omg.org"

module CORBA {
  typedef string Identifier;
  typedef string ScopedName;
  typedef string RepositoryId;
  
  enum DefinitionKind {
    // #pragma version DefinitionKind 2.3
    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 {
    //#   pragma version IRObject 2.3
    // read interface
    readonly attribute DefinitionKind def_kind;
    // write interface
    void destroy ();
  };
  
  typedef string VersionSpec;
  
  interface Contained;
  interface Repository;
  interface Container;
  
  interface Contained : IRObject {
    //#   pragma version Contained 2.3
    
    // 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;
  struct StructMember {
    Identifier name;
    TypeCode type;
    IDLType type_def;
  };
  
  typedef sequence <StructMember> StructMemberSeq;
  
  struct Initializer {
    //# pragma version Initializer 2.3
    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 {
    //# pragma version Container 2.3
    // 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
			    );
    
    /* MICO extensions */
    Contained find( in ScopedName search_name );
    ContainedSeq find_name( in Identifier search_name,
                            in DefinitionKind limit_type );

    Contained locate_id( in RepositoryId id );
    Contained locate_name( in Identifier name,
			   in boolean include_enclosing_scopes,
			   in boolean is_first_level );
    void remove_contained( in Contained con );
    void add_contained( in Contained con );
  };
  
  
  interface IDLType : IRObject {
    //# pragma version IRObject 2.3
    readonly attribute TypeCode type;
  };
  
  interface PrimitiveDef;
  interface StringDef;
  interface SequenceDef;
  interface ArrayDef;
  interface WstringDef;
  interface FixedDef;
  
  enum PrimitiveKind {
    //# pragma version PrimitiveKind 2.3
    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 {
    //# pragma version Container 2.3
    // 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 {
    //# pragma version ModuleDef 2.3
  };
  
  struct ModuleDescription {
    //# pragma version ModuleDescription 2.3
    Identifier name; 
    RepositoryId id; 
    RepositoryId defined_in;
    VersionSpec version;
  };
  
  interface ConstantDef : Contained {
    //# pragma version ConstantDef 2.3
    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 {
    //# pragma version TypedefDef 2.3
  };
  
  struct TypeDescription {
    Identifier name; 
    RepositoryId id; 
    RepositoryId defined_in; 
    VersionSpec version;
    TypeCode type; 
  };
  
  interface StructDef : TypedefDef, Container {
    //# pragma version StructDef 2.3
    attribute StructMemberSeq members;
  };
  
  interface UnionDef : TypedefDef, Container {
    //# pragma version UnionDef 2.3
    readonly attribute TypeCode discriminator_type;
    attribute IDLType discriminator_type_def;
    attribute UnionMemberSeq members;
  };
  
  interface EnumDef : TypedefDef {
    //# pragma version EnumDef 2.3
    attribute EnumMemberSeq members;
  };
  
  interface AliasDef : TypedefDef {
    //# pragma version AliasDef 2.3
    attribute IDLType original_type_def;
  };
  
  interface NativeDef : TypedefDef{
    //# pragma version NativeDef 2.3
  };
  
  interface PrimitiveDef: IDLType {
    //# pragma version PrimitiveDef 2.3
    readonly attribute PrimitiveKind kind;
  };
  
  interface StringDef : IDLType {
    //# pragma version StringDef 2.3
    attribute unsigned long bound;
  };
  
  interface WstringDef : IDLType {
    //# pragma version WstringDef 2.3
    attribute unsigned long bound;
  };
  
  interface FixedDef : IDLType {
    //# pragma version FixedDef 2.3
    attribute unsigned short digits;
    attribute short scale;
  };
  
  interface SequenceDef : IDLType {
    //# pragma version SequenceDef 2.3
    attribute unsigned long bound;
    readonly attribute TypeCode element_type;
    attribute IDLType element_type_def;
  };
  
  interface ArrayDef : IDLType {
    //# pragma version ArrayDef 2.3
    attribute unsigned long length;
    readonly attribute TypeCode element_type;
    attribute IDLType element_type_def;
  };
  
  interface ExceptionDef : Contained, Container {
    //# pragma version ExceptionDef 2.3
    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 {
    //# pragma version AttributeDef 2.3
    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 { 
    //# pragma version OperationDef 2.3
    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 {
    //#  pragma version InterfaceDef 2.3
    // read/write interface
    
    attribute InterfaceDefSeq base_interfaces;
    attribute boolean is_abstract;
    
    // read interface
    
    boolean is_a (in RepositoryId interface_id);
    
    struct FullInterfaceDescription {
      //#  pragma version FullInterfaceDescription 2.3
      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 {
    //#  pragma version InterfaceDescription 2.3
    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{
    //#  pragma version ValueMember 2.3
    Identifier name; 
    RepositoryId id; 
    RepositoryId defined_in; 
    VersionSpec version;
    TypeCode type;
    IDLType type_def;
    Visibility access;
  };
  
  typedef sequence<ValueMember> ValueMemberSeq;
  
  interface ValueMemberDef : Contained{
    //#  pragma version ValuememberDef 2.3
    readonly attribute TypeCode type;
    attribute IDLType type_def;
    attribute Visibility access;
  };

  interface ValueDef : Container, Contained, IDLType{
    //#  pragma version ValueDef 2.3
    // 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{
      //#  pragma version FullValueDescription 2.3
      Identifier name;
      RepositoryId id;
      boolean is_abstract;
      boolean is_custom;
      RepositoryId defined_in;
      VersionSpec version;
      OpDescriptionSeq operationsl;
      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{
    //# pragma version ValueDescription 2.3
    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{  
    //# pragma version ValueBoxDef 2.3
    attribute IDLType original_type_def;
  };
};