path: root/TAO/tao/Interface.pidl

//$Id$
#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,
	dk_Wstring, dk_Fixed,
        dk_Value, 
        dk_ValueBox, dk_ValueMember, 
        dk_Native
 };

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

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;
        interface ExceptionDef; 
        interface NativeDef;
	typedef sequence <InterfaceDef> InterfaceDefSeq;
        interface ValueDef; 
        typedef sequence <ValueDef> ValueDefSeq; 
        interface ValueBoxDef;

 	typedef sequence <Contained> ContainedSeq;

   		struct StructMember {
		Identifier name;
		TypeCode type;
		IDLType type_def;
 	 };

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

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

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

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

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

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


        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; 
        interface ValueMemberDef : Contained { 
        readonly attribute TypeCode type; 
        attribute IDLType type_def; 
        attribute Visibility access; }; 

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

        // read interface 
        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; 
        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; 
         RepositoryId supported_interface; 
         RepositoryIdSeq abstract_base_values; 
         boolean is_truncatable; 
         RepositoryId base_value; 
       }; 

       interface ValueBoxDef : IDLType 
       { attribute IDLType original_type_def; };

       

       typedef short ValueModifier; 
       const ValueModifier VM_NONE = 0; 
       const ValueModifier VM_CUSTOM = 1; 
       const ValueModifier VM_ABSTRACT = 2; 
       const ValueModifier VM_TRUNCATABLE = 3;

        };