// **********************************************************************
//
// Copyright (c) 1999
// Object Oriented Concepts, Inc.
// Billerica, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

#ifndef INT_REP_IDL
#define INT_REP_IDL

#include <IntRepMember.idl>

#pragma prefix "omg.org"

module CORBA
{

typedef string VersionSpec;

interface Contained;
interface Repository;
interface Container;

interface Contained : IRObject
{
    attribute RepositoryId id;
    attribute Identifier name;
    attribute VersionSpec version;
    
    readonly attribute Container defined_in;
    readonly attribute ScopedName absolute_name;
    readonly attribute Repository containing_repository;

    struct Description
    {
	DefinitionKind kind;
	any value;
    };

    Description describe();
    
    void move(in Container new_container,
	      in Identifier new_name,
	      in VersionSpec new_version);
};

interface ModuleDef;
interface ConstantDef;
interface StructDef;
interface UnionDef;
interface EnumDef;
interface AliasDef;
interface InterfaceDef;
interface ExceptionDef;

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

interface Container : IRObject
{
    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);
    
    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);

    ExceptionDef create_exception(in RepositoryId id,
				  in Identifier name,
				  in VersionSpec version,
				  in StructMemberSeq members);
};

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
{
    Contained lookup_id(in RepositoryId search_id);
    
    PrimitiveDef get_primitive(in PrimitiveKind kind);
    
    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
{
    attribute InterfaceDefSeq base_interfaces;

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

}; // End module CORBA

#endif
