/* This file contains OMG IDL from  CORBA V2.0, July 1995.

  It has been edited in a few places to accomodate
  the OMG IDL Java language mapping and DynAnys

  $Id: Corba.idl,v 1.2 2001/09/22 14:51:13 jso Exp $	


*/


#ifndef __CORBA_IDL
#define __CORBA_IDL

#pragma prefix "omg.org"

module CORBA 
{
    typedef unsigned short ServiceType;
    typedef unsigned short ServiceOption;
    typedef unsigned short ServiceDetailType;

    const ServiceType Security = 1;

    struct ServiceDetail {
        ServiceDetailType service_detail_type;
        sequence <octet> service_detail;
    };

    struct ServiceInformation {
        sequence <ServiceOption> service_options;
        sequence <ServiceDetail> service_details;
    };

    typedef unsigned long PolicyType;

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

    typedef sequence <Policy> PolicyList;

    typedef short PolicyErrorCode;
    const PolicyErrorCode BAD_POLICY = 0;
    // ... to be continued

    exception PolicyError
    {
	PolicyErrorCode reason;
    };

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

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

    enum exception_type  {NO_EXCEPTION,USER_EXCEPTION,SYSTEM_EXCEPTION} ;

    // Note: this used to be 'completion_status' but was renamed to
    // CompletionStatus in the Java mapping

    enum CompletionStatus {COMPLETED_YES, COMPLETED_NO, COMPLETED_MAYBE } ;


    interface ImplementationDef {};


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

    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;

    interface Environment {};
	
    typedef unsigned long Flags;
	
    interface TypeCode; // forward declaration
	
    // NamedValues are defined with a Java ORB in mind
    // and follow the standard Java language mapping
	
    const Flags ARG_IN = 1;
    const Flags ARG_OUT = 2;
    const Flags ARG_INOUT = 3;
    const Flags CTX_RESTRICT_SCOPE = 15;

    exception Bounds {};

    interface ExceptionList { // PIDL mapped according to Java mapping, not listed here
    }; 


    interface ContextList { // PIDL mapped according to Java mapping, not listed here
    }; 


    interface NamedValue // PIDL mapped according to Java mapping, not listed here
	{
	};

    interface NVList // PIDL, mapped according to Java mapping, not listed here
	{
	};
	
    // interface Object;

    interface _Context // PIDL, not listed here
	{ 
	};

    interface Request  // PIDL, mapped according to Java mapping, not listed here
	{ 
	};

    interface ServerRequest // PIDL, mapped according to Java mapping, not listed here
	{
	};



    // Interface Repository

 
    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;
    interface ValueDef;

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

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

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


  
  
    typedef sequence <StructMember> StructMemberSeq;

    struct Initializer {
        #pragma version Initializer 2.3
        StructMemberSeq members;
        Identifier name;
    };

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


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

    interface ValueDef : Container, Contained, IDLType {
        // read/write interface
        attribute InterfaceDefSeq       supported_interfaces;
        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    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;
        RepositoryIdSeq                 supported_interfaces;
        RepositoryIdSeq                 abstract_base_values;
        boolean                         is_truncatable;
        RepositoryId                    base_value; 
    };
    // CORBA 2.1

    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;

    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);
	
	unsigned short fixed_scale () raises (BadKind);
	unsigned short fixed_digits () raises (BadKind);
    };


    // the usual mapping of Object will be 
    // replaced by a separate Object.java
    // which cannot be derived by simply applying the
    // mapping rules to this interface. This interface is
    // listed here simply for completeness' sake.

    /* 
       interface Object {				
       ImplementationDef get_implementation ();
       InterfaceDef get_interface ();
       boolean is_nil();
       Object duplicate ();
       void release ();
       boolean is_a (in string logical_type_id);
       boolean non_existent();
       boolean is_equivalent (in Object other_object);
       unsigned long hash(in unsigned long maximum);
	
       Status create_request (			
       in Context ctx,
       in Identifier  operation,
       in NVList arg_list,
       inout NamedValue result,
       out Request request,
       in Flags req_flags 
       );

       Policy get_policy(in PolicyType policy_type);

       DomainManagersList get_domain_managers();
		
       };
    */


    /* Domain Manager new in 2.2 */

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

    const PolicyType SecConstruction = 11;

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

    typedef sequence <DomainManager> DomainManagersList;


    interface Current {};
/*
    interface ORB 
    {

        exception InvalidName {}; 
	
        // Getting initial object references 
        typedef string ObjectId;
        typedef sequence <ObjectId> ObjectIdList; 
	
        boolean get_service_information(in ServiceType service_type,
                                        out ServiceInformation service_information);

        ObjectIdList list_initial_services (); 
        Object resolve_initial_references (in ObjectId identifier)
            raises (InvalidName); 
	
        string object_to_string (in Object obj);
        Object string_to_object (in string str);
		
        NVList create_list ( in long count );
        NVList create_operation_list ( in OperationDef oper );

        NamedValue create_named_value( in string name, in any value, 
                                       in Flags flags);
	
	
        _Context get_default_context();
        Environment create_environment();
	
        typedef sequence< Request > RequestSeq;
	
        void send_multiple_requests_oneway(in RequestSeq req);
        void send_multiple_requests_deferred(in RequestSeq req);

        boolean poll_next_response();
        Request get_next_response();
	
        Current get_current();
	
        TypeCode get_primitive_tc( in TCKind tcKind);
        any create_any();
		
        ExceptionList create_exception_list();
        ContextList create_context_list();
	
        // there will be additional operations
        // in the mapped Java class

        // later: 

        // OutputStream create_output_stream();
        // void connect( Object obj);
        // void disconnect( Object o);	
	
        TypeCode create_struct_tc (
                                   in RepositoryId id,
                                   in Identifier name,
                                   in StructMemberSeq members
                                   );
	
        TypeCode create_union_tc (
                                  in RepositoryId id,
                                  in Identifier name,
                                  in TypeCode discriminator_type,
                                  in UnionMemberSeq members
                                  );
	
        TypeCode create_enum_tc (
                                 in RepositoryId id,
                                 in Identifier name,
                                 in EnumMemberSeq members
                                 );
	
        TypeCode create_alias_tc (
                                  in RepositoryId id,
                                  in Identifier name,
                                  in TypeCode original_type
                                  );
	
        TypeCode create_exception_tc (
                                      in RepositoryId id,
                                      in Identifier name,
                                      in StructMemberSeq members
                                      );
	
        TypeCode create_interface_tc (
                                      in RepositoryId id,
                                      in Identifier name
                                      );
	
        TypeCode create_string_tc (
                                   in unsigned long bound
                                   );
	
        TypeCode create_sequence_tc (
                                     in unsigned long bound,
                                     in TypeCode element_type
                                     );
	
        TypeCode create_recursive_sequence_tc (
                                               in unsigned long bound,
                                               in unsigned long offset
                                               );
	
        TypeCode create_array_tc (
                                  in unsigned long length,
                                  in TypeCode element_type
                                  );
	
	}; 
*/
}; // CORBA module

#endif