path: root/lib/ic/test/ic_SUITE_data/Corba.idl

// This file contains OMG IDL from  CORBA V2.0, July 1995. 
// Includes IDL for CORBA Core
// (Interface Repository, ORB Interface, Basic Object Adapter Interface)
// and CORBA Interoperability (IOP, GIOP, IIOP, and DCE CIOP modules)

// Complete OMG IDL for Interface Repository starts on pg 6-42, CORBA V2.0 July 1995
// IRObject interface described on pg 6-9 CORBA V2.0, July 1995
// Contained interface: pg 6-11 CORBA V2, 7-95
// Container interface: pg 6-12 thru 6-15 CORBA V2, 7-95
// IDLType interface: pg 6-15 CORBA V2, 7-95
// Repository interface: pg 6-16 CORBA V2, 7-95
// ModuleDef interface: pg 6-17 CORBA V2, 7-95
// ConstantDef interface: pg 6-18 CORBA V2, 7-95
// TypeDef interface: pg 6-19 CORBA V2, 7-95
// StructDef interface: pg 6-19 CORBA V2, 7-95
// UnionDef interface: pg 6-19 CORBA V2, 7-95
// EnumDef interface: pg 6-20 CORBA V2, 7-95
// AliasDef interface: pg 6-21 CORBA V2, 7-95
// PrimitiveDef interface: pg 6-21 CORBA V2, 7-95
// StringDef interface: pg 6-22 CORBA V2, 7-95
// SequenceDef interface: pg 6-22 CORBA V2, 7-95
// ArrayDef interface: pg 6-23 CORBA V2, 7-95
// ExceptionDef interface: pg 6-24 CORBA V2, 7-95
// AttributeDef interface: pg 6-25 CORBA V2, 7-95
// OperationDef interface: pg 6-26 CORBA V2, 7-95
// InterfaceDef interface: pg 6-28 CORBA V2, 7-95
// TypeCode interface (PIDL): pg 6-34 CORBA V2, 7-95
// ORB interface: pg 6-40 CORBA V2, 7-95 

#ifndef __CORBA_IDL
#define __CORBA_IDL

// #pragma prefix "omg.org"
module CORBA {

  interface TypeCode;
  typedef string Identifier;
  typedef string ScopedName;
  typedef string RepositoryId;

  /*
   * start of section added by Christian Blum
   */

  typedef enum  new_type {NO,USER,SYSTEM_EXCEPTION} exception_type;

  /** 
   * no definition for this type 
   */ 
  interface ImplementationDef
    { 
    };

  /** 
   * no definition for this type 
   */ 
  //interface Principal	
  struct Principal	
  { 
    string str;
  };     

  /** 
   * no definition for this type 
   */ 
  interface Environment
    { 

    };

  typedef unsigned long Flags;
  typedef unsigned long Status;

  struct NamedValue  // PIDL
  {
    Identifier name; // argument name
    any argument;    // argument
    long len;        // length/count of argument value
    Flags arg_modes; // argument mode flags

  };

  typedef sequence<NamedValue> NVList; /* C */

  interface Request  // PIDL
    { 

      Status add_arg ( 
		      in Identifier name,   // argument name
		      in TypeCode arg_type, // argument datatype
		      //  in void *  value,     // argument value to be added
		      in any  value_LOOK_AT_SOURCE,        // changed by blum
		      in long len,          // length/count of argument value
		      in Flags arg_flags    // argument flags
		      );

      Status invoke ( 
		     in Flags invoke_flags // invocation flags
		     );

      Status delete ();
      Status send (
		   in Flags invoke_flags // invocation flags 
		   );

      Status get_response ( 
			   in Flags response_flags // response flags
			   );

    };


  interface Context // PIDL
    { 

      Status set_one_value (
			    in Identifier prop_name, // property name to add
			    in string value // property value to add
			    );

      Status set_values (
			 in NVList values // property values to be changed
			 );

      Status get_values (
			 in Identifier start_scope, // search scope
			 in Flags op_flags, // operation flags
			 in Identifier prop_name, // name of property(s) to retrieve
			 out NVList values // requested property(s)
			 );

      Status delete_values (
			    in Identifier prop_name // name of property(s) to delete
			    );

      Status create_child (
			   in Identifier ctx_name, // name of context object
			   out Context child_ctx // newly created context object
			   );

      Status delete (
		     in Flags del_flags // flags controlling deletion
		     );

    };

  /*
   * end of section added by Christian Blum
   */


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



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



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

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

    // deprecated interface
    long param_count (); 
    any parameter (in long index) raises (Bounds); 
  };


  /*
   * following line added by Christian Blum
   */
  interface BOA;

  interface ORB {
    // other operations ...

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

    /*
     * following line commented out by Christian Blum
     */
    //    };

    // The ORB interface (PIDL) is described in Chapter 7, CORBA V2.0 July 1995
    // Object interface (object reference operations): pg 7-3 CORBA V2, 7-95
    // ORB initialization: pg 7-7 CORBA V2, 7-95
    // Object Adapter and Basic Object Adapter initialization: pg 7-8 CORBA V2 7-95
    // Getting initial references: pg 7-10 CORBA V2 7-95
    //PIDL	

    /*
     * following line commented out by Christian Blum
     */
    //interface		 ORB {	


    string object_to_string (in Object obj);
    Object	 	string_to_object (in string str);
	
    Status 		create_list (
				     in long	count,	 
				     out NVList new_list
				     );
    Status		 create_operation_list (	
						in OperationDef oper, 
						out NVList new_list
						);
    Status get_default_context (out	 Context ctx);

    // Initializing the ORB
    typedef string ORBid;
    typedef sequence <string> arg_list;
    ORB ORB_init (inout arg_list argv, in ORBid orb_identifier);

    // Initializing an object adapter and the Basic Object Adapter 
    typedef string OAid;

    // Template for OA initialization operations
    // <OA> <OA>_init (inout arg_list argv, 
    // in OAid oa_identifier);



    BOA BOA_init (inout arg_list argv,
		  in OAid boa_identifier); 



    // Getting initial object references 
    typedef string ObjectId;
    typedef sequence <ObjectId> ObjectIdList; 

    exception InvalidName {}; 

    ObjectIdList list_initial_services (); 

    Object resolve_initial_references (in ObjectId identifier)
      raises (InvalidName); 
  }; 

  // had to be changed..., Gerald Brose 1996
  interface ORBject {				

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


  // Basic Object Adapter interface described in Chapter 8, CORBA V2.0, July 1995
  //  interface InterfaceDef;			// from Interface Repository // PIDL
  //  interface ImplementationDef;  		// from Implementation Repository
  // interface Object;  			// an object reference
  //  interface Principal;			// for the authentication service
  typedef sequence <octet, 1024> ReferenceData;

  interface BOA {
    Object create (
		   in ReferenceData  id, 
		   in InterfaceDef intf,
		   in ImplementationDef impl
		   );
    void dispose (in Object obj);
    ReferenceData get_id (in Object obj);

    void change_implementation (in Object obj,
				in ImplementationDef impl
				);

    Principal get_principal (in Object  obj, 
			     in Environment ev
			     );

    void set_exception (in exception_type  major, 	// NO, USER, 
			//or SYSTEM_EXCEPTION
			in string  userid,			// exception type id
			in any param_LOOK_AT_SOURCE
			// in void  *param		    // pointer to associated data
			);

    void impl_is_ready (in ImplementationDef impl);
    void deactivate_impl (in ImplementationDef impl);
    void obj_is_ready (in Object obj, in ImplementationDef impl);
    void deactivate_obj (in Object obj);
  };
};

// IOP module described in chap 10 CORBA V2, 7-95 
module IOP{  // IDL
  //
  // Standard Protocol Profile tag values 
  // 
  typedef unsigned long  ProfileId;
  const ProfileId	 TAG_INTERNET_IOP = 0;
  const ProfileId	 TAG_MULTIPLE_COMPONENTS = 1;

  struct TaggedProfile {
    ProfileId  tag;
    sequence <octet> profile_data;
  };

  //
  // an Interoperable Object Reference is a sequence of
  // object-specific protocol profiles, plus a type ID.
  //
  struct IOR {
    string	type_id;
    sequence <TaggedProfile> profiles;
  };

  //
  // Standard way of representing multicomponent profiles.
  // This would be encapsulated in a TaggedProfile.
  //
  typedef unsigned long ComponentId;
  struct TaggedComponent {
    ComponentId  tag;
    sequence <octet> component_data;
  };
  typedef sequence <TaggedComponent> MultipleComponentProfile;


  typedef unsigned long ServiceID;

  struct ServiceContext {
    ServiceID context_id;
    sequence <octet> context_data;
  };
  typedef sequence <ServiceContext> ServiceContextList;

  const ServiceID	TransactionService = 0;



};
// GIOP module described in CORBA V2, 7-95 chap 12
// Complete IDL for GIOP module in CORBA
// V2.0, 7-95 p 10-29
// GIOP message header: CORBA V2, 7-95 p 12-16
// GIOP request header:  CORBA V2, 7-95 p 12-17
// GIOP reply header: CORBA V2, 7-95 p 12-19
// GIOP cancel request and locate request: CORBA V2, 7-95 pp 12-20 -- 12-21
// GIOP locate reply: CORBA V2, 7-95 p 12-22
module GIOP {					    // IDL
  enum MsgType {
    Request, Reply, CancelRequest,
    LocateRequest, LocateReply,
    CloseConnection, MessageError
  };

  struct Version {
    char			major;
    char			minor;
  };

  struct MessageHeader {
    char			magic [4];
    Version			GIOP_version;
    boolean			byte_order;
    octet			message_type;
    unsigned long			message_size;
  };

  struct RequestHeader {
    ::IOP::ServiceContextList	service_context;
    unsigned long  request_id;
    boolean	response_expected;
    sequence <octet>  object_key;
    string operation;

    /*
     * ::CORBA:: added for correct scope
     */
    ::CORBA::Principal requesting_principal;
  };

  enum ReplyStatusType {
    NO_EXCEPTION,
    USER_EXCEPTION,
    SYSTEM_EXCEPTION,
    LOCATION_FORWARD
  };

  struct ReplyHeader {
    ::IOP::ServiceContextList	 service_context;
    unsigned long request_id;
    ReplyStatusType	reply_status;
  };

  struct CancelRequestHeader {
    unsigned long request_id;
  };

  struct LocateRequestHeader {
    unsigned long request_id;
    sequence <octet> object_key;
  };

  enum LocateStatusType {
    UNKNOWN_OBJECT,
    OBJECT_HERE,
    OBJECT_FORWARD
  };

  struct LocateReplyHeader {
    unsigned long request_id;
    LocateStatusType  locate_status;
  };
};
//  IIOP module described in CORBA V2, 7-95 chap 12
// Complete IDL for IIOP module: CORBA V2, 7-95 p 12-31
module IIOP {			// IDL
  struct Version {
    char			major;
    char			minor;
  };

  struct ProfileBody {
    Version				iiop_version;
    string				host;
    unsigned short			port;
    sequence <octet>		object_key;
  };
};
// DCE CIOP module described in CORBA V2, 7-95 chap 13
// IDL for DCE CIOP module: CORBA V2, 7-95  p 13-2
module DCE_CIOP {
  struct InvokeRequestHeader {
    boolean byte_order;
    ::IOP::ServiceContextList service_context;
    sequence <octet> object_key;
    string endpoint_id;
    string operation;
    ::CORBA::Principal principal;
    sequence <string> client_context;

    // in and inout parameters follow
  };
  enum InvokeResponseStatus {
    INVOKE_NO_EXCEPTION,
    INVOKE_USER_EXCEPTION,
    INVOKE_SYSTEM_EXCEPTION,
    INVOKE_LOCATION_FORWARD,
    INVOKE_TRY_AGAIN
  };

  struct InvokeResponseHeader {
    boolean byte_order;
    ::IOP::ServiceContextList service_context;
    InvokeResponseStatus status;

    // if status = INVOKE_NO_EXCEPTION,
    // result then inouts and outs follow

    // if status = INVOKE_USER_EXCEPTION or
    // INVOKE_SYSTEM_EXCEPTION, an exception follows

    // if status = INVOKE_LOCATION_FORWARD, an 
    // ::IOP::MultipleComponentsProfile follows
  };

  struct LocateRequestHeader {
    boolean byte_order;
    sequence <octet> object_key;
    string endpoint_id;
    string operation;

    // no body follows
  };

  module IOP {

    /*
     * ::IOP:: added to get the right scope
     */
    const ::IOP::ComponentId TAG_OBJECT_KEY = 10;
    const ::IOP::ComponentId TAG_ENDPOINT_ID = 11;
    const ::IOP::ComponentId TAG_LOCATION_POLICY = 12;
    // illegal IDL
    /*	const octet LOCATE_NEVER = 0;
	const octet LOCATE_OBJECT = 1;
	const octet LOCATE_OPERATION = 2;
	const octet LOCATE_ALWAYS = 3;
	*/
  };
};

#endif