/**
 * some definitions from the CORBA module which are not covered
 * by the OMG's standard Java mapping files. We need the classes
 * generated from this file, but it is not suitable to be
 * included in user-defined IDL files!
 *
 * $Id: _orb.idl,v 1.1 2000/03/23 16:48:33 brose Exp $
 */

#ifndef _MYORB_IDL
#define _MYORB_IDL


#pragma prefix "omg.org"

module CORBA 
{

    typedef unsigned long PolicyType;

    interface Policy
	{
	    readonly attribute PolicyType policy_type;
	    Policy copy();
	    void destroy();
	};

    typedef sequence <Policy> PolicyList;

    interface DomainManager
    {
	Policy get_domain_policy(in PolicyType policy_type);
    };


    interface InterfaceDef; // forward

    interface ConstructionPolicy: Policy
    {
	void make_domain_manager(in InterfaceDef object_type,
				 in boolean constr_policy);
    };

    typedef sequence <DomainManager> DomainManagersList;
	

    typedef short PolicyErrorCode;
    const PolicyErrorCode BAD_POLICY = 0;
    const PolicyErrorCode UNSUPPORTED_POLICY = 1;
    const PolicyErrorCode BAD_POLICY_TYPE = 2;
    const PolicyErrorCode BAD_POLICY_VALUE = 3;
    const PolicyErrorCode UNSUPPORTED_POLICY_VALUE = 4;
    // ... to be continued

    exception PolicyError
    {
	PolicyErrorCode reason;
    };

    enum CompletionStatus {COMPLETED_YES, COMPLETED_NO, COMPLETED_MAYBE } ;

    typedef string Identifier;
    typedef string ScopedName;
    typedef string RepositoryId;

    // for PortableInterceptors
    typedef sequence<string> StringSeq;
    typedef sequence<wstring> WStringSeq;
    typedef sequence<octet> OctetSeq;


    // Interface Repository

    interface TypeCode; // forward declaration


    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_ValueVox, 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;

    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,
	pk_longlong, pk_ulonglong, pk_longdouble, pk_wchar, pk_wstring,
	pk_value_base
    };

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




    // actually, Current is pseudo, but we need it this way so everything compiles
    //  interface Current {}; 

    // not suitable for deriving user-defined interfaces !
    enum TCKind { 
	tk_null, tk_void, 
	tk_short, tk_long, tk_ushort, tk_ulong, 
	tk_float, tk_double, tk_boolean, tk_char, 
	tk_octet, tk_any, tk_TypeCode, tk_Principal, tk_objref, 
	tk_struct, tk_union, tk_enum, tk_string, 
	tk_sequence, tk_array, tk_alias, tk_except, 
	tk_longlong, tk_ulonglong, tk_longdouble,
	tk_wchar, tk_wstring, tk_fixed, tk_value,
	tk_value_box, 
	tk_native, tk_abstract_interface
    };
    

    typedef short ValueModifier; //PIDL

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

    pseudo interface TypeCode { // PIDL
	exception Bounds {};
	exception BadKind {};
	
	// for all TypeCode kinds
	boolean equal (in TypeCode tc);
	TCKind kind ();
	
	// for tk_objref, tk_struct, tk_union, tk_enum, 
	// tk_alias, and tk_except
	RepositoryId id () raises (BadKind);
	
	// for tk_objref, tk_struct, tk_union, tk_enum, 
	// tk_alias, and tk_except
	Identifier name () raises (BadKind);
	
	// for tk_struct, tk_union, tk_enum, and tk_except
	unsigned long member_count () raises (BadKind);
	Identifier member_name (in unsigned long index) 
	    raises (BadKind, Bounds);
	
	// for tk_struct, tk_union, and tk_except
	TypeCode member_type (in unsigned long index) 
	    raises (BadKind, Bounds);
	
	// for tk_union
	any member_label (in unsigned long index) 
	    raises (BadKind, Bounds);
	TypeCode discriminator_type () raises (BadKind);
	long default_index () raises (BadKind); 
	
	// for tk_string, tk_sequence, and tk_array
	unsigned long length () raises (BadKind);
	
	// for tk_sequence, tk_array, and tk_alias
	TypeCode content_type () raises (BadKind);
	
    };




    /* this is the original PIDL from the lang. mapping, 
       but we do not use it! Instead...

    pseudo interface Principal
    { 
	attribute sequence<octet> name;
    };
    */

    /* ... we use this little hack. It saves us fiddling with 
       the generated code that uses  Principals. Actually, we 
       should not be doing this....
    */

    typedef sequence<octet> Principal;

	
};


#endif /* _MYORB_IDL */
