// **********************************************************************
//
// 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_Messaging_h__
#define __OB_Messaging_h__

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


#include <OB/Policy.h>
#include <OB/IOP.h>
#include <OB/TimeBase.h>
#include <OB/Messaging_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_Messaging
{

} // End of namespace OBStubImpl_Messaging

namespace OBStubImpl_Messaging
{

} // End of namespace OBStubImpl_Messaging

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

//
// IDL:omg.org/Messaging/RebindMode:1.0
//
typedef ::CORBA::Short RebindMode;
typedef ::CORBA::Short_out RebindMode_out;
OB_IMPORT extern OB::TypeCodeConst _tc_RebindMode;

//
// IDL:omg.org/Messaging/TRANSPARENT:1.0
//
const RebindMode TRANSPARENT = 0;

//
// IDL:omg.org/Messaging/NO_REBIND:1.0
//
const RebindMode NO_REBIND = 1;

//
// IDL:omg.org/Messaging/NO_RECONNECT:1.0
//
const RebindMode NO_RECONNECT = 2;

//
// IDL:omg.org/Messaging/SyncScope:1.0
//
typedef ::CORBA::Short SyncScope;
typedef ::CORBA::Short_out SyncScope_out;
OB_IMPORT extern OB::TypeCodeConst _tc_SyncScope;

//
// IDL:omg.org/Messaging/SYNC_NONE:1.0
//
const SyncScope SYNC_NONE = 0;

//
// IDL:omg.org/Messaging/SYNC_WITH_TRANSPORT:1.0
//
const SyncScope SYNC_WITH_TRANSPORT = 1;

//
// IDL:omg.org/Messaging/SYNC_WITH_SERVER:1.0
//
const SyncScope SYNC_WITH_SERVER = 2;

//
// IDL:omg.org/Messaging/SYNC_WITH_TARGET:1.0
//
const SyncScope SYNC_WITH_TARGET = 3;

//
// IDL:omg.org/Messaging/RoutingType:1.0
//
typedef ::CORBA::Short RoutingType;
typedef ::CORBA::Short_out RoutingType_out;
OB_IMPORT extern OB::TypeCodeConst _tc_RoutingType;

//
// IDL:omg.org/Messaging/ROUTE_NONE:1.0
//
const RoutingType ROUTE_NONE = 0;

//
// IDL:omg.org/Messaging/ROUTE_FORWARD:1.0
//
const RoutingType ROUTE_FORWARD = 1;

//
// IDL:omg.org/Messaging/ROUTE_STORE_AND_FORWARD:1.0
//
const RoutingType ROUTE_STORE_AND_FORWARD = 2;

//
// IDL:omg.org/Messaging/Priority:1.0
//
typedef ::CORBA::Short Priority;
typedef ::CORBA::Short_out Priority_out;
OB_IMPORT extern OB::TypeCodeConst _tc_Priority;

//
// IDL:omg.org/Messaging/Ordering:1.0
//
typedef ::CORBA::UShort Ordering;
typedef ::CORBA::UShort_out Ordering_out;
OB_IMPORT extern OB::TypeCodeConst _tc_Ordering;

//
// IDL:omg.org/Messaging/ORDER_ANY:1.0
//
const Ordering ORDER_ANY = 1;

//
// IDL:omg.org/Messaging/ORDER_TEMPORAL:1.0
//
const Ordering ORDER_TEMPORAL = 2;

//
// IDL:omg.org/Messaging/ORDER_PRIORITY:1.0
//
const Ordering ORDER_PRIORITY = 4;

//
// IDL:omg.org/Messaging/ORDER_DEADLINE:1.0
//
const Ordering ORDER_DEADLINE = 8;

//
// IDL:omg.org/Messaging/REBIND_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType REBIND_POLICY_TYPE = 23U;

//
// IDL:omg.org/Messaging/RebindPolicy:1.0
//
class RebindPolicy : virtual public ::CORBA::Policy
{
    RebindPolicy(const RebindPolicy&);
    void operator=(const RebindPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    RebindPolicy() { }
    virtual ~RebindPolicy() { }

    typedef RebindPolicy_ptr _ptr_type;
    typedef RebindPolicy_var _var_type;

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

    static inline RebindPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/RebindPolicy/rebind_mode:1.0
    //
    virtual RebindMode rebind_mode() = 0;
};

//
// IDL:omg.org/Messaging/SYNC_SCOPE_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType SYNC_SCOPE_POLICY_TYPE = 24U;

//
// IDL:omg.org/Messaging/SyncScopePolicy:1.0
//
class SyncScopePolicy : virtual public ::CORBA::Policy
{
    SyncScopePolicy(const SyncScopePolicy&);
    void operator=(const SyncScopePolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    SyncScopePolicy() { }
    virtual ~SyncScopePolicy() { }

    typedef SyncScopePolicy_ptr _ptr_type;
    typedef SyncScopePolicy_var _var_type;

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

    static inline SyncScopePolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/SyncScopePolicy/synchronization:1.0
    //
    virtual SyncScope synchronization() = 0;
};

//
// IDL:omg.org/Messaging/REQUEST_PRIORITY_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType REQUEST_PRIORITY_POLICY_TYPE = 25U;

//
// IDL:omg.org/Messaging/PriorityRange:1.0
//
struct PriorityRange;
typedef OB::FixVar< PriorityRange > PriorityRange_var;
typedef PriorityRange& PriorityRange_out;

struct PriorityRange
{
    typedef PriorityRange_var _var_type;

    Priority min;
    Priority max;

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

OB_IMPORT extern OB::TypeCodeConst _tc_PriorityRange;

//
// IDL:omg.org/Messaging/RequestPriorityPolicy:1.0
//
class RequestPriorityPolicy : virtual public ::CORBA::Policy
{
    RequestPriorityPolicy(const RequestPriorityPolicy&);
    void operator=(const RequestPriorityPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    RequestPriorityPolicy() { }
    virtual ~RequestPriorityPolicy() { }

    typedef RequestPriorityPolicy_ptr _ptr_type;
    typedef RequestPriorityPolicy_var _var_type;

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

    static inline RequestPriorityPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/RequestPriorityPolicy/priority_range:1.0
    //
    virtual PriorityRange priority_range() = 0;
};

//
// IDL:omg.org/Messaging/REPLY_PRIORITY_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType REPLY_PRIORITY_POLICY_TYPE = 26U;

//
// IDL:omg.org/Messaging/ReplyPriorityPolicy:1.0
//
class ReplyPriorityPolicy : virtual public ::CORBA::Policy
{
    ReplyPriorityPolicy(const ReplyPriorityPolicy&);
    void operator=(const ReplyPriorityPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    ReplyPriorityPolicy() { }
    virtual ~ReplyPriorityPolicy() { }

    typedef ReplyPriorityPolicy_ptr _ptr_type;
    typedef ReplyPriorityPolicy_var _var_type;

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

    static inline ReplyPriorityPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/ReplyPriorityPolicy/priority_range:1.0
    //
    virtual PriorityRange priority_range() = 0;
};

//
// IDL:omg.org/Messaging/REQUEST_START_TIME_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType REQUEST_START_TIME_POLICY_TYPE = 27U;

//
// IDL:omg.org/Messaging/RequestStartTimePolicy:1.0
//
class RequestStartTimePolicy : virtual public ::CORBA::Policy
{
    RequestStartTimePolicy(const RequestStartTimePolicy&);
    void operator=(const RequestStartTimePolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    RequestStartTimePolicy() { }
    virtual ~RequestStartTimePolicy() { }

    typedef RequestStartTimePolicy_ptr _ptr_type;
    typedef RequestStartTimePolicy_var _var_type;

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

    static inline RequestStartTimePolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/RequestStartTimePolicy/start_time:1.0
    //
    virtual ::TimeBase::UtcT start_time() = 0;
};

//
// IDL:omg.org/Messaging/REQUEST_END_TIME_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType REQUEST_END_TIME_POLICY_TYPE = 28U;

//
// IDL:omg.org/Messaging/RequestEndTimePolicy:1.0
//
class RequestEndTimePolicy : virtual public ::CORBA::Policy
{
    RequestEndTimePolicy(const RequestEndTimePolicy&);
    void operator=(const RequestEndTimePolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    RequestEndTimePolicy() { }
    virtual ~RequestEndTimePolicy() { }

    typedef RequestEndTimePolicy_ptr _ptr_type;
    typedef RequestEndTimePolicy_var _var_type;

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

    static inline RequestEndTimePolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/RequestEndTimePolicy/end_time:1.0
    //
    virtual ::TimeBase::UtcT end_time() = 0;
};

//
// IDL:omg.org/Messaging/REPLY_START_TIME_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType REPLY_START_TIME_POLICY_TYPE = 29U;

//
// IDL:omg.org/Messaging/ReplyStartTimePolicy:1.0
//
class ReplyStartTimePolicy : virtual public ::CORBA::Policy
{
    ReplyStartTimePolicy(const ReplyStartTimePolicy&);
    void operator=(const ReplyStartTimePolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    ReplyStartTimePolicy() { }
    virtual ~ReplyStartTimePolicy() { }

    typedef ReplyStartTimePolicy_ptr _ptr_type;
    typedef ReplyStartTimePolicy_var _var_type;

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

    static inline ReplyStartTimePolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/ReplyStartTimePolicy/start_time:1.0
    //
    virtual ::TimeBase::UtcT start_time() = 0;
};

//
// IDL:omg.org/Messaging/REPLY_END_TIME_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType REPLY_END_TIME_POLICY_TYPE = 30U;

//
// IDL:omg.org/Messaging/ReplyEndTimePolicy:1.0
//
class ReplyEndTimePolicy : virtual public ::CORBA::Policy
{
    ReplyEndTimePolicy(const ReplyEndTimePolicy&);
    void operator=(const ReplyEndTimePolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    ReplyEndTimePolicy() { }
    virtual ~ReplyEndTimePolicy() { }

    typedef ReplyEndTimePolicy_ptr _ptr_type;
    typedef ReplyEndTimePolicy_var _var_type;

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

    static inline ReplyEndTimePolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/ReplyEndTimePolicy/end_time:1.0
    //
    virtual ::TimeBase::UtcT end_time() = 0;
};

//
// IDL:omg.org/Messaging/RELATIVE_REQ_TIMEOUT_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType RELATIVE_REQ_TIMEOUT_POLICY_TYPE = 31U;

//
// IDL:omg.org/Messaging/RelativeRequestTimeoutPolicy:1.0
//
class RelativeRequestTimeoutPolicy : virtual public ::CORBA::Policy
{
    RelativeRequestTimeoutPolicy(const RelativeRequestTimeoutPolicy&);
    void operator=(const RelativeRequestTimeoutPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    RelativeRequestTimeoutPolicy() { }
    virtual ~RelativeRequestTimeoutPolicy() { }

    typedef RelativeRequestTimeoutPolicy_ptr _ptr_type;
    typedef RelativeRequestTimeoutPolicy_var _var_type;

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

    static inline RelativeRequestTimeoutPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/RelativeRequestTimeoutPolicy/relative_expiry:1.0
    //
    virtual ::TimeBase::TimeT relative_expiry() = 0;
};

//
// IDL:omg.org/Messaging/RELATIVE_RT_TIMEOUT_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType RELATIVE_RT_TIMEOUT_POLICY_TYPE = 32U;

//
// IDL:omg.org/Messaging/RelativeRoundTripTimeoutPolicy:1.0
//
class RelativeRoundTripTimeoutPolicy : virtual public ::CORBA::Policy
{
    RelativeRoundTripTimeoutPolicy(const RelativeRoundTripTimeoutPolicy&);
    void operator=(const RelativeRoundTripTimeoutPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    RelativeRoundTripTimeoutPolicy() { }
    virtual ~RelativeRoundTripTimeoutPolicy() { }

    typedef RelativeRoundTripTimeoutPolicy_ptr _ptr_type;
    typedef RelativeRoundTripTimeoutPolicy_var _var_type;

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

    static inline RelativeRoundTripTimeoutPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/RelativeRoundTripTimeoutPolicy/relative_expiry:1.0
    //
    virtual ::TimeBase::TimeT relative_expiry() = 0;
};

//
// IDL:omg.org/Messaging/ROUTING_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType ROUTING_POLICY_TYPE = 33U;

//
// IDL:omg.org/Messaging/RoutingTypeRange:1.0
//
struct RoutingTypeRange;
typedef OB::FixVar< RoutingTypeRange > RoutingTypeRange_var;
typedef RoutingTypeRange& RoutingTypeRange_out;

struct RoutingTypeRange
{
    typedef RoutingTypeRange_var _var_type;

    RoutingType min;
    RoutingType max;

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

OB_IMPORT extern OB::TypeCodeConst _tc_RoutingTypeRange;

//
// IDL:omg.org/Messaging/RoutingPolicy:1.0
//
class RoutingPolicy : virtual public ::CORBA::Policy
{
    RoutingPolicy(const RoutingPolicy&);
    void operator=(const RoutingPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    RoutingPolicy() { }
    virtual ~RoutingPolicy() { }

    typedef RoutingPolicy_ptr _ptr_type;
    typedef RoutingPolicy_var _var_type;

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

    static inline RoutingPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/RoutingPolicy/routing_range:1.0
    //
    virtual RoutingTypeRange routing_range() = 0;
};

//
// IDL:omg.org/Messaging/MAX_HOPS_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType MAX_HOPS_POLICY_TYPE = 34U;

//
// IDL:omg.org/Messaging/MaxHopsPolicy:1.0
//
class MaxHopsPolicy : virtual public ::CORBA::Policy
{
    MaxHopsPolicy(const MaxHopsPolicy&);
    void operator=(const MaxHopsPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    MaxHopsPolicy() { }
    virtual ~MaxHopsPolicy() { }

    typedef MaxHopsPolicy_ptr _ptr_type;
    typedef MaxHopsPolicy_var _var_type;

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

    static inline MaxHopsPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/MaxHopsPolicy/max_hops:1.0
    //
    virtual ::CORBA::UShort max_hops() = 0;
};

//
// IDL:omg.org/Messaging/QUEUE_ORDER_POLICY_TYPE:1.0
//
const ::CORBA::PolicyType QUEUE_ORDER_POLICY_TYPE = 35U;

//
// IDL:omg.org/Messaging/QueueOrderPolicy:1.0
//
class QueueOrderPolicy : virtual public ::CORBA::Policy
{
    QueueOrderPolicy(const QueueOrderPolicy&);
    void operator=(const QueueOrderPolicy&);

protected:

    static OB_IMPORT const char* ids_[];

public:

    QueueOrderPolicy() { }
    virtual ~QueueOrderPolicy() { }

    typedef QueueOrderPolicy_ptr _ptr_type;
    typedef QueueOrderPolicy_var _var_type;

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

    static inline QueueOrderPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/Messaging/QueueOrderPolicy/allowed_orders:1.0
    //
    virtual Ordering allowed_orders() = 0;
};

//
// IDL:omg.org/Messaging/PolicyValue:1.0
//
struct PolicyValue;
typedef OB::VarVar< PolicyValue > PolicyValue_var;
typedef OB::VarOut< PolicyValue > PolicyValue_out;

struct PolicyValue
{
#ifdef OB_CLEAR_MEM
    PolicyValue();
#else
    PolicyValue() { }
#endif
    PolicyValue(const PolicyValue&);
    PolicyValue& operator=(const PolicyValue&);

    typedef PolicyValue_var _var_type;

    ::CORBA::PolicyType ptype;
    class OBUnique_pvalue { };
    typedef OB::FixSeq< ::CORBA::Octet, OBUnique_pvalue > _pvalue_seq;
    _pvalue_seq pvalue;

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

OB_IMPORT extern OB::TypeCodeConst _tc_PolicyValue;

//
// IDL:omg.org/Messaging/PolicyValueSeq:1.0
//
class OBUnique_PolicyValueSeq { };

typedef OB::VarSeq< PolicyValue, OBUnique_PolicyValueSeq > PolicyValueSeq;
typedef OB::SeqVar< OB::VarSeq< PolicyValue, OBUnique_PolicyValueSeq > > PolicyValueSeq_var;
typedef OB::SeqOut< OB::VarSeq< PolicyValue, OBUnique_PolicyValueSeq > > PolicyValueSeq_out;
OB_IMPORT extern OB::TypeCodeConst _tc_PolicyValueSeq;

struct OBInfo_PolicyValueSeq : public OB::ConstructedInfo
{
    OBInfo_PolicyValueSeq() { }

    virtual void free(void* p) const
    {
        delete (PolicyValueSeq*)p;
    }

    virtual void* dup(const void* p) const
    {
        return new PolicyValueSeq(*(const PolicyValueSeq*)p);
    }

    virtual void marshal(const void*, OB::OutputStreamImpl*) const;
    virtual void unmarshal(void*, OB::InputStreamImpl*) const;
};

//
// IDL:omg.org/Messaging/TAG_POLICIES:1.0
//
const ::IOP::ComponentId TAG_POLICIES = 2U;

//
// IDL:omg.org/Messaging/INVOCATION_POLICIES:1.0
//
const ::IOP::ServiceId INVOCATION_POLICIES = 7U;

} // End of namespace Messaging

//
// IDL:omg.org/Messaging:1.0
//
namespace OBProxy_Messaging
{

} // End of namespace OBProxy_Messaging

//
// IDL:omg.org/Messaging:1.0
//
namespace OBStubImpl_Messaging
{

} // End of namespace OBStubImpl_Messaging

//
// IDL:omg.org/Messaging:1.0
//
namespace OBMarshalStubImpl_Messaging
{

} // End of namespace OBMarshalStubImpl_Messaging

//
// IDL:omg.org/Messaging:1.0
//
namespace OBV_Messaging
{

} // End of namespace OBV_Messaging

//
// IDL:omg.org/Messaging/RebindPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::RebindPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::RebindPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/SyncScopePolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::SyncScopePolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::SyncScopePolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

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

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

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

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

//
// IDL:omg.org/Messaging/RequestPriorityPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::RequestPriorityPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::RequestPriorityPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/ReplyPriorityPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::ReplyPriorityPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::ReplyPriorityPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/RequestStartTimePolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::RequestStartTimePolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::RequestStartTimePolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/RequestEndTimePolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::RequestEndTimePolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::RequestEndTimePolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/ReplyStartTimePolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::ReplyStartTimePolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::ReplyStartTimePolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/ReplyEndTimePolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::ReplyEndTimePolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::ReplyEndTimePolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/RelativeRequestTimeoutPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::RelativeRequestTimeoutPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::RelativeRequestTimeoutPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/RelativeRoundTripTimeoutPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::RelativeRoundTripTimeoutPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::RelativeRoundTripTimeoutPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

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

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

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

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

//
// IDL:omg.org/Messaging/RoutingPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::RoutingPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::RoutingPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/MaxHopsPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::MaxHopsPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::MaxHopsPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/Messaging/QueueOrderPolicy:1.0
//
namespace CORBA
{

inline void
release(::Messaging::QueueOrderPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::Messaging::QueueOrderPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

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

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

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

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

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

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

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

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

#endif
