/**
 * Some definitions from the CORBA module which are not covered
 * by the OMG's standard Java mapping files. We need the classes
 * generated from this file, but it is not suitable to be
 * included in user-defined IDL files!
 *
 * DO NOT INCLUDE THIS FILE, INCLUDE <orb.idl> instead!
 *
 * $Id: Corba.idl,v 1.11 2006/05/15 14:35:52 alphonse.bendt Exp $
 */

#ifndef _MYORB_IDL
#define _MYORB_IDL


#pragma prefix "omg.org"

module CORBA
{

    typedef unsigned long PolicyType;

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

    typedef sequence <Policy> PolicyList;
    typedef sequence <PolicyType> PolicyTypeSeq;
    exception InvalidPolicies { sequence <unsigned short> indices; };

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


    interface InterfaceDef; // forward

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

    typedef sequence <DomainManager> DomainManagersList;


    typedef short PolicyErrorCode;
    const PolicyErrorCode BAD_POLICY = 0;
    const PolicyErrorCode UNSUPPORTED_POLICY = 1;
    const PolicyErrorCode BAD_POLICY_TYPE = 2;
    const PolicyErrorCode BAD_POLICY_VALUE = 3;
    const PolicyErrorCode UNSUPPORTED_POLICY_VALUE = 4;

    exception PolicyError
    {
    PolicyErrorCode reason;
    };

    enum SetOverrideType {SET_OVERRIDE, ADD_OVERRIDE};

    local interface PolicyManager
    {
        PolicyList get_policy_overrides(in PolicyTypeSeq ts);

        void set_policy_overrides(in PolicyList policies,
                                  in SetOverrideType set_add
                                  ) raises (InvalidPolicies);
    };

    local interface Current {}; // dummy

    local interface PolicyCurrent : PolicyManager, Current {
    };


    //    exception UserException {};
    //pseudo interface ExceptionList {};

    typedef string Identifier;

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


    // Chapter 10, Interface Repository

    interface TypeCode; // forward declaration

    //#include <InterfaceRepository.idl>

    interface AliasDef;
    interface ArrayDef;
    interface AttributeDef;
    interface ConstantDef;
    interface Contained;
    interface Container;
    interface EnumDef;
    interface ExceptionDef;
    interface FixedDef;
    interface IDLType;
    interface InterfaceDef;
    interface IRObject;
    interface ModuleDef;
    interface NativeDef;
    interface OperationDef;
    interface PrimitiveDef;
    interface Repository;
    interface SequenceDef;
    interface StringDef;
    interface StructDef;
    interface TypeCode;
    interface TypedefDef;
    interface UnionDef;
    interface ValueDef;
    interface ValueBoxDef;
    interface ValueMemberDef;
    interface WstringDef;

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

    interface IRObject {
        // read interface
        readonly attribute  DefinitionKind  def_kind;
        // write interface
        void                destroy ();
    };

    typedef string VersionSpec;

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

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

    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,
                                       in boolean                      is_abstract
                                       );
        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
                                );
    };
    interface IDLType : IRObject {
        readonly attribute TypeCode     type;
    };

    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;
        attribute boolean               is_abstract;

        // 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;
            boolean                     is_abstract;
        };

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

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

    enum TCKind {                               // PIDL
        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,
        tk_local_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);
        boolean     equivalent  (in TypeCode tc);
        TypeCode    get_compact_typecode();
        TCKind      kind ();
        // for tk_objref, tk_struct,    tk_union,  tk_enum, tk_alias,
        //     tk_value,  tk_value_box, tk_native, tk_abstract_interface
        // and tk_except
        RepositoryId    id () raises (BadKind);
        // for tk_objref, tk_struct,    tk_union,  tk_enum, tk_alias,
        //     tk_value,  tk_value_box, tk_native, tk_abstract_interface
        // and tk_except
        Identifier name () raises (BadKind);
        // for tk_struct, tk_union, tk_enum, tk_value,
        // and tk_except
        unsigned long   member_count () raises (BadKind);
        Identifier      member_name (in unsigned long index)
            raises (BadKind, Bounds);
        // for tk_struct, tk_union, tk_value, 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, tk_value_box, and tk_alias
        TypeCode        content_type ()         raises (BadKind);
        // for tk_fixed
        unsigned short  fixed_digits()          raises (BadKind);
        short           fixed_scale()           raises (BadKind);
        // for tk_value
        Visibility      member_visibility(in unsigned long index)
            raises(BadKind, Bounds);
        ValueModifier   type_modifier()         raises(BadKind);
        TypeCode        concrete_base_type()    raises(BadKind);
    };



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

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


    //need to have this because the OMG supplied helper classes for
    //these exceptions always throw NO_IMPLEMENT
    interface ORB
    {
       exception InvalidName {};
       exception InconsistentTypeCode {};
    };

    typedef sequence<any> AnySeq;
    typedef sequence<boolean> BooleanSeq;
    typedef sequence<char> CharSeq;
    typedef sequence<double> DoubleSeq;
    typedef sequence<float> FloatSeq;
    typedef sequence<long> LongSeq;
    typedef sequence<long long> LongLongSeq;
    typedef sequence<short> ShortSeq;
    typedef sequence<unsigned long> ULongSeq;
    typedef sequence<unsigned long long> ULongLongSeq;
    typedef sequence<unsigned short> UShortSeq;
    typedef sequence<wchar> WCharSeq;


   // Taken from 04-03-12 CORBA 3.0.3
   valuetype StringValue string;
   valuetype WStringValue wstring;

   exception WrongTransaction {};
};


#endif /* _MYORB_IDL */
