#pragma prefix "omg.org"
#include "shared.idl"

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

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

typedef string VersionSpec;

  interface Contained;
  interface Repository;
  interface Container;

  // Jason: forward reference fixups
  interface ExceptionDef;
  interface WstringDef;
  interface FixedDef;    

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

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


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

	Contained lookup_id (in RepositoryId search_id);

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

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



