//
// %Z%%W% %I%
// ===========================================================================
// Licensed Materials - Property of IBM
// "Restricted Materials of IBM"
//
// IBM Object Request Broker Edition, 2.00
// (C) Copyright IBM Corp. 1998, 2015. All Rights Reserved
//
// US Government Users Restricted Rights - Use, duplication or disclosure
// restricted by GSA ADP Schedule Contract with IBM Corp.
// ===========================================================================
//

//Updated:  December 1999
//This file contains OMG IDL from  CORBA V2.3 December 1999
//
// OMG IDL from Chapters 1 through 15 CORBA module
//
// Post CORBA 2.3 changes from core RTF bracketed
// in #ifdef CORBA_2_5 ... #endif
//
// Stuff from Messaging specification is bracketed 
// in #ifdef CORBA3 ... #endif

#pragma prefix "omg.org"
module CORBA {

// Chapter 10 Interface Repository

    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,
	dk_AbstractInterface
    };
    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;
    interface AbstractInterfaceDef;
    typedef sequence <AbstractInterfaceDef> AbstractInterfaceDefSeq;
    struct StructMember {
	Identifier 				name;
	TypeCode 				type;
	IDLType 				type_def;
    };
    typedef sequence <StructMember> StructMemberSeq;
    struct Initializer {
	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
	);
	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 InterfaceDefSeq			supported_interfaces,
	    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
	);
	NativeDef create_native(
	    in RepositoryId 			id,
	    in Identifier 			name,
	    in VersionSpec 			version
	);
	AbstractInterfaceDef create_abstract_interface (
	    in RepositoryId id,
	    in Identifier name,
	    in VersionSpec version,
	    in AbstractInterfaceDefSeq base_interfaces
	);
    };

    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, pk_value_base
    };
	
    interface Repository : Container {
	// read interface
	Contained lookup_id (in RepositoryId search_id);
	TypeCode get_canonical_typecode(in TypeCode tc); 
	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 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, 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;
    };

    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 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; 
    };
	
    interface ValueBoxDef : TypedefDef {
	attribute IDLType original_type_def;
    };
	
    interface AbstractInterfaceDef : InterfaceDef {
    };


    enum TCKind {				
#	pragma version TCKind 2.3
	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;	
	const ValueModifier VM_NONE = 0;
	const ValueModifier VM_CUSTOM = 1;
	const ValueModifier VM_ABSTRACT = 2;
	const ValueModifier VM_TRUNCATABLE = 3;
};