// This file is generated by omniidl (C++ backend) - omniORB_4_3. Do not edit.

static ::CORBA::TypeCode::_Tracker _0RL_tcTrack(__FILE__);

static CORBA::TypeCode_ptr _0RL_ft_CORBA_mPollable = CORBA::TypeCode::PR_forward_tc("IDL:omg.org/CORBA/Pollable:1.0", &_0RL_tcTrack);
#define _0RL_tc_CORBA_mPollable _0RL_ft_CORBA_mPollable

static CORBA::PR_valueMember* _0RL_valuemember_CORBA_mPollable = 0;

#ifdef _0RL_tc_CORBA_mPollable
#  undef _0RL_tc_CORBA_mPollable
#endif
static CORBA::TypeCode_ptr _0RL_tc_CORBA_mPollable = CORBA::TypeCode::PR_value_tc("IDL:omg.org/CORBA/Pollable:1.0", "Pollable", CORBA::VM_ABSTRACT, CORBA::TypeCode::PR_null_tc(), _0RL_valuemember_CORBA_mPollable, 0, &_0RL_tcTrack);

#if defined(OMNI_HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace CORBA { 
  const ::CORBA::TypeCode_ptr _tc_Pollable = _0RL_tc_CORBA_mPollable;
} 
#else
const ::CORBA::TypeCode_ptr CORBA::_tc_Pollable = _0RL_tc_CORBA_mPollable;
#endif


static CORBA::TypeCode_ptr _0RL_ft_CORBA_mDIIPollable = CORBA::TypeCode::PR_forward_tc("IDL:omg.org/CORBA/DIIPollable:1.0", &_0RL_tcTrack);
#define _0RL_tc_CORBA_mDIIPollable _0RL_ft_CORBA_mDIIPollable

static CORBA::PR_valueMember* _0RL_valuemember_CORBA_mDIIPollable = 0;

#ifdef _0RL_tc_CORBA_mDIIPollable
#  undef _0RL_tc_CORBA_mDIIPollable
#endif
static CORBA::TypeCode_ptr _0RL_tc_CORBA_mDIIPollable = CORBA::TypeCode::PR_value_tc("IDL:omg.org/CORBA/DIIPollable:1.0", "DIIPollable", CORBA::VM_ABSTRACT, CORBA::TypeCode::PR_null_tc(), _0RL_valuemember_CORBA_mDIIPollable, 0, &_0RL_tcTrack);

#if defined(OMNI_HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace CORBA { 
  const ::CORBA::TypeCode_ptr _tc_DIIPollable = _0RL_tc_CORBA_mDIIPollable;
} 
#else
const ::CORBA::TypeCode_ptr CORBA::_tc_DIIPollable = _0RL_tc_CORBA_mDIIPollable;
#endif



static CORBA::TypeCode_ptr _0RL_tc_CORBA_mPollableSet_mNoPossiblePollable = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CORBA/PollableSet/NoPossiblePollable:1.0", "NoPossiblePollable", (CORBA::PR_structMember*) 0, 0, &_0RL_tcTrack);
const CORBA::TypeCode_ptr CORBA::PollableSet::_tc_NoPossiblePollable = _0RL_tc_CORBA_mPollableSet_mNoPossiblePollable;



static CORBA::TypeCode_ptr _0RL_tc_CORBA_mPollableSet_mUnknownPollable = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CORBA/PollableSet/UnknownPollable:1.0", "UnknownPollable", (CORBA::PR_structMember*) 0, 0, &_0RL_tcTrack);
const CORBA::TypeCode_ptr CORBA::PollableSet::_tc_UnknownPollable = _0RL_tc_CORBA_mPollableSet_mUnknownPollable;


#if defined(OMNI_HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace CORBA { 
  const ::CORBA::TypeCode_ptr _tc_PollableSet = CORBA::TypeCode::PR_local_interface_tc("IDL:omg.org/CORBA/PollableSet:1.0", "PollableSet", &_0RL_tcTrack);
} 
#else
const ::CORBA::TypeCode_ptr CORBA::_tc_PollableSet = CORBA::TypeCode::PR_local_interface_tc("IDL:omg.org/CORBA/PollableSet:1.0", "PollableSet", &_0RL_tcTrack);
#endif

static void _0RL_CORBA_mPollable_marshal_fn(cdrStream& _s, void* _v)
{
  CORBA::Pollable* _p = (CORBA::Pollable*)_v;
  CORBA::Pollable::_NP_marshal(_p, _s);
}
static void _0RL_CORBA_mPollable_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CORBA::Pollable* _p = CORBA::Pollable::_NP_unmarshal(_s);
  _v = _p;
}
static void _0RL_CORBA_mPollable_destructor_fn(void* _v)
{
  CORBA::Pollable* _p = (CORBA::Pollable*)_v;
  ::CORBA::remove_ref(_p);
}

void operator<<=(::CORBA::Any& _a, CORBA::Pollable* _v)
{
  ::CORBA::add_ref(_v);
  _a.PR_insert(_0RL_tc_CORBA_mPollable,
               _0RL_CORBA_mPollable_marshal_fn,
               _0RL_CORBA_mPollable_destructor_fn,
               _v);
}
void operator<<=(::CORBA::Any& _a, CORBA::Pollable** _vp)
{
  _a.PR_insert(_0RL_tc_CORBA_mPollable,
               _0RL_CORBA_mPollable_marshal_fn,
               _0RL_CORBA_mPollable_destructor_fn,
               *_vp);
  *_vp = 0;
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CORBA::Pollable*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CORBA_mPollable,
                    _0RL_CORBA_mPollable_unmarshal_fn,
                    _0RL_CORBA_mPollable_marshal_fn,
                    _0RL_CORBA_mPollable_destructor_fn,
                    _v)) {
    _sp = (CORBA::Pollable*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CORBA_mDIIPollable_marshal_fn(cdrStream& _s, void* _v)
{
  CORBA::DIIPollable* _p = (CORBA::DIIPollable*)_v;
  CORBA::DIIPollable::_NP_marshal(_p, _s);
}
static void _0RL_CORBA_mDIIPollable_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CORBA::DIIPollable* _p = CORBA::DIIPollable::_NP_unmarshal(_s);
  _v = _p;
}
static void _0RL_CORBA_mDIIPollable_destructor_fn(void* _v)
{
  CORBA::DIIPollable* _p = (CORBA::DIIPollable*)_v;
  ::CORBA::remove_ref(_p);
}

void operator<<=(::CORBA::Any& _a, CORBA::DIIPollable* _v)
{
  ::CORBA::add_ref(_v);
  _a.PR_insert(_0RL_tc_CORBA_mDIIPollable,
               _0RL_CORBA_mDIIPollable_marshal_fn,
               _0RL_CORBA_mDIIPollable_destructor_fn,
               _v);
}
void operator<<=(::CORBA::Any& _a, CORBA::DIIPollable** _vp)
{
  _a.PR_insert(_0RL_tc_CORBA_mDIIPollable,
               _0RL_CORBA_mDIIPollable_marshal_fn,
               _0RL_CORBA_mDIIPollable_destructor_fn,
               *_vp);
  *_vp = 0;
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CORBA::DIIPollable*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CORBA_mDIIPollable,
                    _0RL_CORBA_mDIIPollable_unmarshal_fn,
                    _0RL_CORBA_mDIIPollable_marshal_fn,
                    _0RL_CORBA_mDIIPollable_destructor_fn,
                    _v)) {
    _sp = (CORBA::DIIPollable*)_v;
    return 1;
  }
  return 0;
}


static void _0RL_CORBA_mPollableSet_mNoPossiblePollable_marshal_fn(cdrStream& _s, void* _v)
{
  const CORBA::PollableSet::NoPossiblePollable* _p = (const CORBA::PollableSet::NoPossiblePollable*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CORBA_mPollableSet_mNoPossiblePollable_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CORBA::PollableSet::NoPossiblePollable* _p = new CORBA::PollableSet::NoPossiblePollable;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CORBA_mPollableSet_mNoPossiblePollable_destructor_fn(void* _v)
{
  CORBA::PollableSet::NoPossiblePollable* _p = (CORBA::PollableSet::NoPossiblePollable*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CORBA::PollableSet::NoPossiblePollable& _s)
{
  CORBA::PollableSet::NoPossiblePollable* _p = new CORBA::PollableSet::NoPossiblePollable(_s);
  _a.PR_insert(_0RL_tc_CORBA_mPollableSet_mNoPossiblePollable,
               _0RL_CORBA_mPollableSet_mNoPossiblePollable_marshal_fn,
               _0RL_CORBA_mPollableSet_mNoPossiblePollable_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CORBA::PollableSet::NoPossiblePollable* _sp)
{
  _a.PR_insert(_0RL_tc_CORBA_mPollableSet_mNoPossiblePollable,
               _0RL_CORBA_mPollableSet_mNoPossiblePollable_marshal_fn,
               _0RL_CORBA_mPollableSet_mNoPossiblePollable_destructor_fn,
               (CORBA::PollableSet::NoPossiblePollable*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CORBA::PollableSet::NoPossiblePollable*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CORBA_mPollableSet_mNoPossiblePollable,
                    _0RL_CORBA_mPollableSet_mNoPossiblePollable_unmarshal_fn,
                    _0RL_CORBA_mPollableSet_mNoPossiblePollable_marshal_fn,
                    _0RL_CORBA_mPollableSet_mNoPossiblePollable_destructor_fn,
                    _v)) {
    _sp = (const CORBA::PollableSet::NoPossiblePollable*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCORBA_mPollableSet_mNoPossiblePollable(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CORBA::PollableSet::NoPossiblePollable & _ex = (const CORBA::PollableSet::NoPossiblePollable &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCORBA_mPollableSet_mNoPossiblePollable (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CORBA::PollableSet::NoPossiblePollable* _ex = (const CORBA::PollableSet::NoPossiblePollable*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mNoPossiblePollable {
public:
  _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mNoPossiblePollable() {
    CORBA::PollableSet::NoPossiblePollable::insertToAnyFn = _0RL_insertToAny__cCORBA_mPollableSet_mNoPossiblePollable;
    CORBA::PollableSet::NoPossiblePollable::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCORBA_mPollableSet_mNoPossiblePollable;
  }
};
static _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mNoPossiblePollable _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mNoPossiblePollable_;


static void _0RL_CORBA_mPollableSet_mUnknownPollable_marshal_fn(cdrStream& _s, void* _v)
{
  const CORBA::PollableSet::UnknownPollable* _p = (const CORBA::PollableSet::UnknownPollable*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CORBA_mPollableSet_mUnknownPollable_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CORBA::PollableSet::UnknownPollable* _p = new CORBA::PollableSet::UnknownPollable;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CORBA_mPollableSet_mUnknownPollable_destructor_fn(void* _v)
{
  CORBA::PollableSet::UnknownPollable* _p = (CORBA::PollableSet::UnknownPollable*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CORBA::PollableSet::UnknownPollable& _s)
{
  CORBA::PollableSet::UnknownPollable* _p = new CORBA::PollableSet::UnknownPollable(_s);
  _a.PR_insert(_0RL_tc_CORBA_mPollableSet_mUnknownPollable,
               _0RL_CORBA_mPollableSet_mUnknownPollable_marshal_fn,
               _0RL_CORBA_mPollableSet_mUnknownPollable_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CORBA::PollableSet::UnknownPollable* _sp)
{
  _a.PR_insert(_0RL_tc_CORBA_mPollableSet_mUnknownPollable,
               _0RL_CORBA_mPollableSet_mUnknownPollable_marshal_fn,
               _0RL_CORBA_mPollableSet_mUnknownPollable_destructor_fn,
               (CORBA::PollableSet::UnknownPollable*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CORBA::PollableSet::UnknownPollable*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CORBA_mPollableSet_mUnknownPollable,
                    _0RL_CORBA_mPollableSet_mUnknownPollable_unmarshal_fn,
                    _0RL_CORBA_mPollableSet_mUnknownPollable_marshal_fn,
                    _0RL_CORBA_mPollableSet_mUnknownPollable_destructor_fn,
                    _v)) {
    _sp = (const CORBA::PollableSet::UnknownPollable*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCORBA_mPollableSet_mUnknownPollable(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CORBA::PollableSet::UnknownPollable & _ex = (const CORBA::PollableSet::UnknownPollable &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCORBA_mPollableSet_mUnknownPollable (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CORBA::PollableSet::UnknownPollable* _ex = (const CORBA::PollableSet::UnknownPollable*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mUnknownPollable {
public:
  _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mUnknownPollable() {
    CORBA::PollableSet::UnknownPollable::insertToAnyFn = _0RL_insertToAny__cCORBA_mPollableSet_mUnknownPollable;
    CORBA::PollableSet::UnknownPollable::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCORBA_mPollableSet_mUnknownPollable;
  }
};
static _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mUnknownPollable _0RL_insertToAny_Singleton__cCORBA_mPollableSet_mUnknownPollable_;

static void _0RL_CORBA_mPollableSet_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_CORBA_mPollableSet_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(CORBA::PollableSet::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_CORBA_mPollableSet_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, CORBA::PollableSet_ptr _o)
{
  CORBA::PollableSet_ptr _no = CORBA::PollableSet::_duplicate(_o);
  _a.PR_insert(CORBA::_tc_PollableSet,
               _0RL_CORBA_mPollableSet_marshal_fn,
               _0RL_CORBA_mPollableSet_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, CORBA::PollableSet_ptr* _op)
{
  _a.PR_insert(CORBA::_tc_PollableSet,
               _0RL_CORBA_mPollableSet_marshal_fn,
               _0RL_CORBA_mPollableSet_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = CORBA::PollableSet::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CORBA::PollableSet_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(CORBA::_tc_PollableSet,
                    _0RL_CORBA_mPollableSet_unmarshal_fn,
                    _0RL_CORBA_mPollableSet_marshal_fn,
                    _0RL_CORBA_mPollableSet_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (CORBA::PollableSet_ptr)_r->_ptrToObjRef(CORBA::PollableSet::_PD_repoId);
    else
      _o = CORBA::PollableSet::_nil();
    return 1;
  }
  return 0;
}

