#ifndef _omniorb_ir_idl_
#define _omniorb_ir_idl_

#pragma prefix "omg.org"

#include "corbaidl.idl"


// This file contains the definitions for the CORBA 2.3.1 Interface
// Repository, as amended by revision issue 3015. See
//
//   http://www.omg.org/issues/issue3015.txt
//
// for the gory details.


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

  typedef string ScopedName;


  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 {
    readonly attribute DefinitionKind def_kind;
    void destroy();
  };


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


#ifndef OMNIORB_NO_IR_CLIENT
  interface ModuleDef;
  interface ConstantDef;
  interface IDLType;
  interface StructDef;
  interface UnionDef;
  interface EnumDef;
  interface AliasDef;
  interface InterfaceDef;
  interface ValueDef;
  interface ValueBoxDef;
  interface ExceptionDef;
  interface NativeDef;
  interface AbstractInterfaceDef;
#endif
  interface WstringDef;
  interface FixedDef;

#ifndef OMNIORB_NO_IR_CLIENT
  typedef sequence<InterfaceDef>         InterfaceDefSeq;
  typedef sequence<ValueDef>             ValueDefSeq;
  typedef sequence<AbstractInterfaceDef> AbstractInterfaceDefSeq;
#endif
  typedef sequence<Contained>    ContainedSeq;

  // StructMember is in corbaidl.idl

  struct Initializer {
    StructMemberSeq  members;
    Identifier       name;
  };
  typedef sequence <Initializer> InitializerSeq;

  // UnionMember is in corbaidl.idl

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

#ifndef OMNIORB_NO_IR_CLIENT

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


#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,
    pk_value_base
  };


  interface Repository : Container {
    Contained    lookup_id             (in RepositoryId   search_id);
    TypeCode     get_canonical_typecode(in TypeCode       tc);
    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);
  };


#ifndef OMNIORB_NO_IR_CLIENT

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

  interface NativeDef : TypedefDef {
  };

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

#ifndef OMNIORB_NO_IR_CLIENT

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


#ifndef OMNIORB_NO_IR_CLIENT

#if 0
  // In corbaidl.idl
  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;
#endif

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

  interface ValueDef : Container, Contained, IDLType {
    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;

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




#endif




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

#endif // _omniorb_ir_idl_
