// **********************************************************************
//
// Generated by the ORBacus IDL-to-C++ Translator
//
// Copyright (c) 2003
// IONA Technologies, Inc.
// Waltham, MA, USA
//
// All Rights Reserved
//
// **********************************************************************

// Version: 4.1.3

#ifndef __OB_PIORBInit_h__
#define __OB_PIORBInit_h__

#ifndef OB_IMPORT
#   ifdef OB_DLL
#      define OB_IMPORT __declspec(dllimport)
#   else
#      define OB_IMPORT /**/
#   endif
#endif


#include <OB/Codec.h>
#include <OB/PICommon.h>
#include <OB/PIPolicy.h>
#include <OB/PIORBInit_fwd.h>

#ifndef OB_INTEGER_VERSION
#   error No ORBacus version defined! Is <OB/CORBA.h> included?
#endif

#ifndef OB_NO_VERSION_CHECK
#   if (OB_INTEGER_VERSION != 4010300L)
#       error ORBacus version mismatch!
#   endif
#endif

namespace OBStubImpl_PortableInterceptor
{

} // End of namespace OBStubImpl_PortableInterceptor

namespace OBStubImpl_PortableInterceptor
{

} // End of namespace OBStubImpl_PortableInterceptor

//
// IDL:omg.org/PortableInterceptor:1.0
//
namespace PortableInterceptor
{

//
// IDL:omg.org/PortableInterceptor/ORBInitInfo:1.0
//
class ORBInitInfo : virtual public ::CORBA::Object
{
    ORBInitInfo(const ORBInitInfo&);
    void operator=(const ORBInitInfo&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    ORBInitInfo() { }
    virtual ~ORBInitInfo() { }

    typedef ORBInitInfo_ptr _ptr_type;
    typedef ORBInitInfo_var _var_type;

    static inline ORBInitInfo_ptr
    _duplicate(ORBInitInfo_ptr p)
    {
        if(p)
            p -> _add_ref();
        return p;
    }

    static inline ORBInitInfo_ptr
    _nil()
    {
        return 0;
    }

    static ORBInitInfo_ptr _narrow(::CORBA::Object_ptr);

    static ORBInitInfo_ptr _narrow(::CORBA::AbstractBase_ptr);


    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/ObjectId:1.0
    //
    typedef char* ObjectId;
    typedef ::CORBA::String_var ObjectId_var;
    typedef ::CORBA::String_out ObjectId_out;
    OB_IMPORT static OB::TypeCodeConst _tc_ObjectId;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/DuplicateName:1.0
    //
    struct DuplicateName : public ::CORBA::UserException
    {
        DuplicateName() { }
        DuplicateName(const DuplicateName&);
        DuplicateName& operator=(const DuplicateName&);

        static DuplicateName* _downcast(::CORBA::Exception*);
        static const DuplicateName* _downcast(const ::CORBA::Exception*);
        virtual const char* _name() const;
        virtual void _raise() const { throw *this; }
        virtual const char* _rep_id() const;
        virtual char* _to_string() const;

        virtual ::CORBA::Exception* _OB_clone() const;
        virtual void _OB_insertInAny(::CORBA::Any&);

        OB::StrForStruct name;

        DuplicateName(const char*);

        virtual void _OB_marshal(OB::OutputStreamImpl*) const;
        static void _OB_unmarshal(DuplicateName&, OB::InputStreamImpl*);
    };

    OB_IMPORT static OB::TypeCodeConst _tc_DuplicateName;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/InvalidName:1.0
    //
    struct InvalidName : public ::CORBA::UserException
    {
        InvalidName() { }
        InvalidName(const InvalidName&);
        InvalidName& operator=(const InvalidName&);

        static InvalidName* _downcast(::CORBA::Exception*);
        static const InvalidName* _downcast(const ::CORBA::Exception*);
        virtual const char* _name() const;
        virtual void _raise() const { throw *this; }
        virtual const char* _rep_id() const;
        virtual char* _to_string() const;

        virtual ::CORBA::Exception* _OB_clone() const;
        virtual void _OB_insertInAny(::CORBA::Any&);

        static void _OB_unmarshal(InvalidName&, OB::InputStreamImpl*);
    };

    OB_IMPORT static OB::TypeCodeConst _tc_InvalidName;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/arguments:1.0
    //
    virtual ::CORBA::StringSeq* arguments() = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/orb_id:1.0
    //
    virtual char* orb_id() = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/codec_factory:1.0
    //
    virtual ::IOP::CodecFactory_ptr codec_factory() = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/register_initial_reference:1.0
    //
    virtual void register_initial_reference(const char* id,
                                            ::CORBA::Object_ptr obj) = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/resolve_initial_references:1.0
    //
    virtual ::CORBA::Object_ptr resolve_initial_references(const char* id) = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/add_client_request_interceptor:1.0
    //
    virtual void add_client_request_interceptor(ClientRequestInterceptor_ptr interceptor) = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/add_server_request_interceptor:1.0
    //
    virtual void add_server_request_interceptor(ServerRequestInterceptor_ptr interceptor) = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/add_ior_interceptor:1.0
    //
    virtual void add_ior_interceptor(IORInterceptor_ptr interceptor) = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/allocate_slot_id:1.0
    //
    virtual SlotId allocate_slot_id() = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitInfo/register_policy_factory:1.0
    //
    virtual void register_policy_factory(::CORBA::PolicyType type,
                                         PolicyFactory_ptr policy_factory) = 0;
};

//
// IDL:omg.org/PortableInterceptor/ORBInitializer:1.0
//
class ORBInitializer : virtual public ::CORBA::Object
{
    ORBInitializer(const ORBInitializer&);
    void operator=(const ORBInitializer&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    ORBInitializer() { }
    virtual ~ORBInitializer() { }

    typedef ORBInitializer_ptr _ptr_type;
    typedef ORBInitializer_var _var_type;

    static inline ORBInitializer_ptr
    _duplicate(ORBInitializer_ptr p)
    {
        if(p)
            p -> _add_ref();
        return p;
    }

    static inline ORBInitializer_ptr
    _nil()
    {
        return 0;
    }

    static ORBInitializer_ptr _narrow(::CORBA::Object_ptr);

    static ORBInitializer_ptr _narrow(::CORBA::AbstractBase_ptr);


    //
    // IDL:omg.org/PortableInterceptor/ORBInitializer/pre_init:1.0
    //
    virtual void pre_init(ORBInitInfo_ptr info) = 0;

    //
    // IDL:omg.org/PortableInterceptor/ORBInitializer/post_init:1.0
    //
    virtual void post_init(ORBInitInfo_ptr info) = 0;
};

} // End of namespace PortableInterceptor

//
// IDL:omg.org/PortableInterceptor:1.0
//
namespace OBProxy_PortableInterceptor
{

} // End of namespace OBProxy_PortableInterceptor

//
// IDL:omg.org/PortableInterceptor:1.0
//
namespace OBStubImpl_PortableInterceptor
{

} // End of namespace OBStubImpl_PortableInterceptor

//
// IDL:omg.org/PortableInterceptor:1.0
//
namespace OBMarshalStubImpl_PortableInterceptor
{

} // End of namespace OBMarshalStubImpl_PortableInterceptor

//
// IDL:omg.org/PortableInterceptor:1.0
//
namespace OBV_PortableInterceptor
{

} // End of namespace OBV_PortableInterceptor

//
// IDL:omg.org/PortableInterceptor/ORBInitInfo:1.0
//
namespace CORBA
{

inline void
release(::PortableInterceptor::ORBInitInfo_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableInterceptor::ORBInitInfo_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(::CORBA::Any&, PortableInterceptor::ORBInitInfo_ptr*);
void operator<<=(::CORBA::Any&, PortableInterceptor::ORBInitInfo_ptr);
CORBA::Boolean operator>>=(const ::CORBA::Any&, PortableInterceptor::ORBInitInfo_ptr&);

inline void
operator<<=(::CORBA::Any_var& any, PortableInterceptor::ORBInitInfo_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(::CORBA::Any_var& any, PortableInterceptor::ORBInitInfo_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const ::CORBA::Any_var& any, PortableInterceptor::ORBInitInfo_ptr& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/PortableInterceptor/ORBInitInfo/DuplicateName:1.0
//
void operator<<=(::CORBA::Any&, PortableInterceptor::ORBInitInfo::DuplicateName*);
void operator<<=(::CORBA::Any&, const PortableInterceptor::ORBInitInfo::DuplicateName&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const PortableInterceptor::ORBInitInfo::DuplicateName*&);

inline void
operator<<=(::CORBA::Any_var& any, PortableInterceptor::ORBInitInfo::DuplicateName* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(::CORBA::Any_var& any, const PortableInterceptor::ORBInitInfo::DuplicateName& val)
{
    any.inout() <<= val;
}

inline ::CORBA::Boolean
operator>>=(const ::CORBA::Any_var& any, const PortableInterceptor::ORBInitInfo::DuplicateName*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/PortableInterceptor/ORBInitInfo/InvalidName:1.0
//
void operator<<=(::CORBA::Any&, PortableInterceptor::ORBInitInfo::InvalidName*);
void operator<<=(::CORBA::Any&, const PortableInterceptor::ORBInitInfo::InvalidName&);
CORBA::Boolean operator>>=(const ::CORBA::Any&, const PortableInterceptor::ORBInitInfo::InvalidName*&);

inline void
operator<<=(::CORBA::Any_var& any, PortableInterceptor::ORBInitInfo::InvalidName* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(::CORBA::Any_var& any, const PortableInterceptor::ORBInitInfo::InvalidName& val)
{
    any.inout() <<= val;
}

inline ::CORBA::Boolean
operator>>=(const ::CORBA::Any_var& any, const PortableInterceptor::ORBInitInfo::InvalidName*& val)
{
    return any.in() >>= val;
}

//
// IDL:omg.org/PortableInterceptor/ORBInitializer:1.0
//
namespace CORBA
{

inline void
release(::PortableInterceptor::ORBInitializer_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableInterceptor::ORBInitializer_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

void operator<<=(::CORBA::Any&, PortableInterceptor::ORBInitializer_ptr*);
void operator<<=(::CORBA::Any&, PortableInterceptor::ORBInitializer_ptr);
CORBA::Boolean operator>>=(const ::CORBA::Any&, PortableInterceptor::ORBInitializer_ptr&);

inline void
operator<<=(::CORBA::Any_var& any, PortableInterceptor::ORBInitializer_ptr* val)
{
    any.inout() <<= val;
}

inline void
operator<<=(::CORBA::Any_var& any, PortableInterceptor::ORBInitializer_ptr val)
{
    any.inout() <<= val;
}

inline CORBA::Boolean
operator>>=(const ::CORBA::Any_var& any, PortableInterceptor::ORBInitializer_ptr& val)
{
    return any.in() >>= val;
}

#endif
