//---------------------------------------------------------------------------
// Copyright (C) DSTC Pty Ltd (ACN 052 372 577) 1997, 1998, 1999
// All Rights Reserved.
//
// The software contained on this media is the property of the DSTC Pty
// Ltd.  Use of this software is strictly in accordance with the
// license agreement in the accompanying LICENSE.HTML file.  If your
// distribution of this software does not contain a LICENSE.HTML file
// then you have no rights to use this software in any manner and
// should contact DSTC at the address below to determine an appropriate
// licensing arrangement.
// 
//      DSTC Pty Ltd
//      Level 7, GP South
//      Staff House Road
//      University of Queensland
//      St Lucia, 4072
//      Australia
//      Tel: +61 7 3365 4310
//      Fax: +61 7 3365 4311
//      Email: enquiries@dstc.edu.au
// 
// This software is being provided "AS IS" without warranty of any
// kind.  In no event shall DSTC Pty Ltd be liable for damage of any
// kind arising out of or in connection with the use or performance of
// this software.
//
// Project:      Distributed Environment
// File:         $Source: /cvsroot/fnorb/fnorb/cos/interface_repository/IntRep.idl,v $
// Version:      @(#)$RCSfile: IntRep.idl,v $ $Revision: 1.8 $
//
//---------------------------------------------------------------------------

// Based on CORBA 2.6, formal/01-12-14.txt

#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,
	dk_AbstractInterface,
	dk_LocalInterface
    };

    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;
    interface ValueDef;
    interface ValueBoxDef;
    interface AbstractInterfaceDef;
    interface LocalInterfaceDef; 

    typedef sequence<InterfaceDef> InterfaceDefSeq;
    typedef sequence<Contained> ContainedSeq;
    typedef sequence <ValueDef> ValueDefSeq; 
    typedef sequence <AbstractInterfaceDef> AbstractInterfaceDefSeq; 
    typedef sequence <LocalInterfaceDef> LocalInterfaceDefSeq;

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

	LocalInterfaceDef create_local_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 WstringDef;
    interface SequenceDef;
    interface ArrayDef;
    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);
	
	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 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 { 
    }; 

    interface LocalInterfaceDef : InterfaceDef { 
    };
};