// **********************************************************************
//
// 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_POAPolicies_h__
#define __OB_POAPolicies_h__

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


#include <OB/Policy.h>
#include <OB/POAPolicies_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_PortableServer
{

} // End of namespace OBStubImpl_PortableServer

namespace OBStubImpl_PortableServer
{

} // End of namespace OBStubImpl_PortableServer

//
// IDL:omg.org/PortableServer:2.3
//
namespace PortableServer
{

//
// IDL:omg.org/PortableServer/THREAD_POLICY_ID:1.0
//
const ::CORBA::PolicyType THREAD_POLICY_ID = 16U;

//
// IDL:omg.org/PortableServer/LIFESPAN_POLICY_ID:1.0
//
const ::CORBA::PolicyType LIFESPAN_POLICY_ID = 17U;

//
// IDL:omg.org/PortableServer/ID_UNIQUENESS_POLICY_ID:1.0
//
const ::CORBA::PolicyType ID_UNIQUENESS_POLICY_ID = 18U;

//
// IDL:omg.org/PortableServer/ID_ASSIGNMENT_POLICY_ID:1.0
//
const ::CORBA::PolicyType ID_ASSIGNMENT_POLICY_ID = 19U;

//
// IDL:omg.org/PortableServer/IMPLICIT_ACTIVATION_POLICY_ID:1.0
//
const ::CORBA::PolicyType IMPLICIT_ACTIVATION_POLICY_ID = 20U;

//
// IDL:omg.org/PortableServer/SERVANT_RETENTION_POLICY_ID:1.0
//
const ::CORBA::PolicyType SERVANT_RETENTION_POLICY_ID = 21U;

//
// IDL:omg.org/PortableServer/REQUEST_PROCESSING_POLICY_ID:1.0
//
const ::CORBA::PolicyType REQUEST_PROCESSING_POLICY_ID = 22U;

//
// IDL:omg.org/PortableServer/ThreadPolicyValue:1.0
//
enum ThreadPolicyValue
{
    ORB_CTRL_MODEL,
    SINGLE_THREAD_MODEL
};

typedef ThreadPolicyValue& ThreadPolicyValue_out;

OB_IMPORT extern OB::TypeCodeConst _tc_ThreadPolicyValue;

//
// IDL:omg.org/PortableServer/LifespanPolicyValue:1.0
//
enum LifespanPolicyValue
{
    TRANSIENT,
    PERSISTENT
};

typedef LifespanPolicyValue& LifespanPolicyValue_out;

OB_IMPORT extern OB::TypeCodeConst _tc_LifespanPolicyValue;

//
// IDL:omg.org/PortableServer/IdUniquenessPolicyValue:1.0
//
enum IdUniquenessPolicyValue
{
    UNIQUE_ID,
    MULTIPLE_ID
};

typedef IdUniquenessPolicyValue& IdUniquenessPolicyValue_out;

OB_IMPORT extern OB::TypeCodeConst _tc_IdUniquenessPolicyValue;

//
// IDL:omg.org/PortableServer/IdAssignmentPolicyValue:1.0
//
enum IdAssignmentPolicyValue
{
    USER_ID,
    SYSTEM_ID
};

typedef IdAssignmentPolicyValue& IdAssignmentPolicyValue_out;

OB_IMPORT extern OB::TypeCodeConst _tc_IdAssignmentPolicyValue;

//
// IDL:omg.org/PortableServer/ImplicitActivationPolicyValue:1.0
//
enum ImplicitActivationPolicyValue
{
    IMPLICIT_ACTIVATION,
    NO_IMPLICIT_ACTIVATION
};

typedef ImplicitActivationPolicyValue& ImplicitActivationPolicyValue_out;

OB_IMPORT extern OB::TypeCodeConst _tc_ImplicitActivationPolicyValue;

//
// IDL:omg.org/PortableServer/ServantRetentionPolicyValue:1.0
//
enum ServantRetentionPolicyValue
{
    RETAIN,
    NON_RETAIN
};

typedef ServantRetentionPolicyValue& ServantRetentionPolicyValue_out;

OB_IMPORT extern OB::TypeCodeConst _tc_ServantRetentionPolicyValue;

//
// IDL:omg.org/PortableServer/RequestProcessingPolicyValue:1.0
//
enum RequestProcessingPolicyValue
{
    USE_ACTIVE_OBJECT_MAP_ONLY,
    USE_DEFAULT_SERVANT,
    USE_SERVANT_MANAGER
};

typedef RequestProcessingPolicyValue& RequestProcessingPolicyValue_out;

OB_IMPORT extern OB::TypeCodeConst _tc_RequestProcessingPolicyValue;

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    ThreadPolicy() { }
    virtual ~ThreadPolicy() { }

    typedef ThreadPolicy_ptr _ptr_type;
    typedef ThreadPolicy_var _var_type;

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

    static inline ThreadPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/PortableServer/ThreadPolicy/value:1.0
    //
    virtual ThreadPolicyValue value() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    LifespanPolicy() { }
    virtual ~LifespanPolicy() { }

    typedef LifespanPolicy_ptr _ptr_type;
    typedef LifespanPolicy_var _var_type;

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

    static inline LifespanPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/PortableServer/LifespanPolicy/value:1.0
    //
    virtual LifespanPolicyValue value() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    IdUniquenessPolicy() { }
    virtual ~IdUniquenessPolicy() { }

    typedef IdUniquenessPolicy_ptr _ptr_type;
    typedef IdUniquenessPolicy_var _var_type;

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

    static inline IdUniquenessPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/PortableServer/IdUniquenessPolicy/value:1.0
    //
    virtual IdUniquenessPolicyValue value() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    IdAssignmentPolicy() { }
    virtual ~IdAssignmentPolicy() { }

    typedef IdAssignmentPolicy_ptr _ptr_type;
    typedef IdAssignmentPolicy_var _var_type;

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

    static inline IdAssignmentPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/PortableServer/IdAssignmentPolicy/value:1.0
    //
    virtual IdAssignmentPolicyValue value() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    ImplicitActivationPolicy() { }
    virtual ~ImplicitActivationPolicy() { }

    typedef ImplicitActivationPolicy_ptr _ptr_type;
    typedef ImplicitActivationPolicy_var _var_type;

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

    static inline ImplicitActivationPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/PortableServer/ImplicitActivationPolicy/value:1.0
    //
    virtual ImplicitActivationPolicyValue value() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    ServantRetentionPolicy() { }
    virtual ~ServantRetentionPolicy() { }

    typedef ServantRetentionPolicy_ptr _ptr_type;
    typedef ServantRetentionPolicy_var _var_type;

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

    static inline ServantRetentionPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/PortableServer/ServantRetentionPolicy/value:1.0
    //
    virtual ServantRetentionPolicyValue value() = 0;
};

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

protected:

    static OB_IMPORT const char* ids_[];

public:

    RequestProcessingPolicy() { }
    virtual ~RequestProcessingPolicy() { }

    typedef RequestProcessingPolicy_ptr _ptr_type;
    typedef RequestProcessingPolicy_var _var_type;

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

    static inline RequestProcessingPolicy_ptr
    _nil()
    {
        return 0;
    }

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

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


    //
    // IDL:omg.org/PortableServer/RequestProcessingPolicy/value:1.0
    //
    virtual RequestProcessingPolicyValue value() = 0;
};

} // End of namespace PortableServer

//
// IDL:omg.org/PortableServer:2.3
//
namespace OBProxy_PortableServer
{

} // End of namespace OBProxy_PortableServer

//
// IDL:omg.org/PortableServer:2.3
//
namespace OBStubImpl_PortableServer
{

} // End of namespace OBStubImpl_PortableServer

//
// IDL:omg.org/PortableServer:2.3
//
namespace OBMarshalStubImpl_PortableServer
{

} // End of namespace OBMarshalStubImpl_PortableServer

//
// IDL:omg.org/PortableServer:2.3
//
namespace OBV_PortableServer
{

} // End of namespace OBV_PortableServer

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

//
// IDL:omg.org/PortableServer/ThreadPolicy:1.0
//
namespace CORBA
{

inline void
release(::PortableServer::ThreadPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableServer::ThreadPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/PortableServer/LifespanPolicy:1.0
//
namespace CORBA
{

inline void
release(::PortableServer::LifespanPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableServer::LifespanPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/PortableServer/IdUniquenessPolicy:1.0
//
namespace CORBA
{

inline void
release(::PortableServer::IdUniquenessPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableServer::IdUniquenessPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/PortableServer/IdAssignmentPolicy:1.0
//
namespace CORBA
{

inline void
release(::PortableServer::IdAssignmentPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableServer::IdAssignmentPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/PortableServer/ImplicitActivationPolicy:1.0
//
namespace CORBA
{

inline void
release(::PortableServer::ImplicitActivationPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableServer::ImplicitActivationPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/PortableServer/ServantRetentionPolicy:1.0
//
namespace CORBA
{

inline void
release(::PortableServer::ServantRetentionPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableServer::ServantRetentionPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

//
// IDL:omg.org/PortableServer/RequestProcessingPolicy:1.0
//
namespace CORBA
{

inline void
release(::PortableServer::RequestProcessingPolicy_ptr p)
{
    if(p)
        p -> _remove_ref();
}

inline Boolean
is_nil(::PortableServer::RequestProcessingPolicy_ptr p)
{
    return p == 0;
}

} // End of namespace CORBA

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

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

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

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

#endif
