
#include <mico/ir_base.idl>

#pragma prefix "omg.org"

module CORBA {
  
typedef string ScopedName;

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

interface ModuleDef;
interface ConstantDef;
interface StructDef;
interface ExceptionDef;
interface UnionDef;
interface EnumDef;
interface AliasDef;
interface InterfaceDef;
interface ValueDef;
interface ValueBoxDef;
interface NativeDef;

typedef sequence <ValueDef> ValueDefSeq;
typedef sequence <InterfaceDef> InterfaceDefSeq;
typedef sequence <Contained> ContainedSeq;

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

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
				    );
  
  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
			   );
  
  ExceptionDef create_exception (
				 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 InterfaceDef supported_interface,
			 in InitializerSeq initializers
			 );

  ValueBoxDef create_value_box (
				in RepositoryId id,
				in Identifier name,
				in VersionSpec version,
				in IDLType original_type_def
				);

  NativeDef create_native (
                           in RepositoryId id,
			   in Identifier name,
			   in VersionSpec version
			   );

  /* MICO extensions */
  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 PrimitiveDef;
interface StringDef;
interface WstringDef;
interface SequenceDef;
interface ArrayDef;
interface FixedDef;

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,
  /* missing from specs */ pk_ValueBase, pk_AbstractBase
};

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

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 {
  
  attribute InterfaceDefSeq base_interfaces;
  attribute boolean is_abstract;
  
  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();
  
  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;
};

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

interface ValueDef : Container, Contained, IDLType {
  attribute InterfaceDef supported_interface;
  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 value_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;
    //XXX spec says this is a RepositoryIdSeq ...
    RepositoryId supported_interface;
    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;
  RepositoryId supported_interface;
  RepositoryIdSeq abstract_base_values;
  boolean is_truncatable;
  RepositoryId base_value;
};

// XXX spec derives it from IDLType, but that seems to be wrong ...
interface ValueBoxDef : TypedefDef {
  attribute IDLType original_type_def;
};

};
