#pragma prefix "omg.org"
module CORBA {

    typedef string Identifier;
    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
    };


    interface IRObject {
	// read interface
	readonly attribute DefinitionKind def_kind;

	// write interface
	void destroy ();
    };

    interface Principal;

    typedef string VersionSpec;

    interface Contained;
    interface Repository;
    interface Container;

    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 InterfaceDef;
    typedef sequence <InterfaceDef> InterfaceDefSeq;

    typedef sequence <Contained> ContainedSeq;

    struct StructMember {
	Identifier name;
	TypeCode type;
	IDLType type_def;
    };
    typedef sequence <StructMember> StructMemberSeq;

    struct UnionMember {
	Identifier name;
	any label;
	TypeCode type;
	IDLType type_def;
    };
    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
	    );
    };



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

    interface Repository : Container {
	// read interface

	Contained lookup_id (in RepositoryId search_id);

	PrimitiveDef get_primitive (in PrimitiveKind kind);

	// write interface

	StringDef create_string (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
	    );
    };


    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 {
	attribute StructMemberSeq members;
    };


    interface UnionDef : TypedefDef {
	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 PrimitiveDef: IDLType {
	readonly attribute PrimitiveKind kind;
    };


    interface StringDef : IDLType {
	attribute unsigned long bound;
    };


    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 {
	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 {
	// read/write interface

	attribute InterfaceDefSeq base_interfaces;

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

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

};