
#pragma prefix "omg.org"

#include <corbaidl.idl>


//////////////////////////////////////////////////////////////////////
module CORBA {
//////////////////////////////////////////////////////////////////////

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


interface IRObject {
  readonly attribute DefinitionKind def_kind;
  void destroy();
};


typedef string VersionSpec;


interface Contained;
interface Repository;
interface Container;


interface Contained : IRObject {
  attribute RepositoryId id;
  attribute Identifier name;
  attribute VersionSpec version;

  readonly attribute Container defined_in;
  readonly attribute ScopedName absolute_name;
  readonly attribute Repository containing_repository;

  struct Description {
    DefinitionKind kind;
    any value;
  };

  Description describe();

  void move(in Container new_container,
            in Identifier new_name,
            in VersionSpec new_version);
};


#if !defined(__VAX) && !defined(__DECCXX)
interface ModuleDef;
interface ConstantDef;
interface IDLType;
interface StructDef;
interface UnionDef;
interface EnumDef;
interface AliasDef;
interface InterfaceDef;
interface ExceptionDef;
#endif
interface WstringDef;
interface FixedDef;

#if !defined(__VAX) && !defined(__DECCXX)
typedef sequence<InterfaceDef> InterfaceDefSeq;
#endif
typedef sequence<Contained> ContainedSeq;


interface Container : IRObject {
  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);

#if !defined(__VAX) && !defined(__DECCXX)

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

  ExceptionDef create_exception(in RepositoryId id,
                                in Identifier name,
                                in VersionSpec version,
                                in StructMemberSeq members);

#endif

};


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

interface PrimitiveDef;
interface StringDef;
interface SequenceDef;
interface ArrayDef;


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


interface Repository : Container {
  Contained lookup_id(in RepositoryId search_id);

  PrimitiveDef get_primitive(in PrimitiveKind kind);

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


#if !defined(__VAX) && !defined(__DECCXX)

interface ModuleDef : Container, Contained {
  // empty
};

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 {
  // empty
};


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

#endif

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

#if !defined(__VAX) && !defined(__DECCXX)

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 {

  attribute InterfaceDefSeq base_interfaces;

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

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

#else

interface InterfaceDef {};
interface OperationDef {};
typedef sequence<RepositoryId> RepositoryIdSeq;

#endif

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


//////////////////////////////////////////////////////////////////////
};
//////////////////////////////////////////////////////////////////////
