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

#include "Naming.hh"

OMNI_USING_NAMESPACE(omni)

static const char* _0RL_dyn_library_version = omniORB_4_3_dyn;

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

static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mIstring = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNaming/Istring:1.0", "Istring", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_CosNaming_mNameComponent[] = {
  {"id", _0RL_tc_CosNaming_mIstring},
  {"kind", _0RL_tc_CosNaming_mIstring}
};

#ifdef _0RL_tc_CosNaming_mNameComponent
#  undef _0RL_tc_CosNaming_mNameComponent
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNameComponent = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNaming/NameComponent:1.0", "NameComponent", _0RL_structmember_CosNaming_mNameComponent, 2, &_0RL_tcTrack);

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






static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mName = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNaming/Name:1.0", "Name", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_CosNaming_mNameComponent, &_0RL_tcTrack), &_0RL_tcTrack);


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

static const char* _0RL_enumMember_CosNaming_mBindingType[] = { "nobject", "ncontext" };
static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mBindingType = CORBA::TypeCode::PR_enum_tc("IDL:omg.org/CosNaming/BindingType:1.0", "BindingType", _0RL_enumMember_CosNaming_mBindingType, 2, &_0RL_tcTrack);
#if defined(OMNI_HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace CosNaming { 
  const ::CORBA::TypeCode_ptr _tc_BindingType = _0RL_tc_CosNaming_mBindingType;
} 
#else
const ::CORBA::TypeCode_ptr CosNaming::_tc_BindingType = _0RL_tc_CosNaming_mBindingType;
#endif


static CORBA::PR_structMember _0RL_structmember_CosNaming_mBinding[] = {
  {"binding_name", _0RL_tc_CosNaming_mName},
  {"binding_type", _0RL_tc_CosNaming_mBindingType}
};

#ifdef _0RL_tc_CosNaming_mBinding
#  undef _0RL_tc_CosNaming_mBinding
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mBinding = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNaming/Binding:1.0", "Binding", _0RL_structmember_CosNaming_mBinding, 2, &_0RL_tcTrack);


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










static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mBindingList = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNaming/BindingList:1.0", "BindingList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_CosNaming_mBinding, &_0RL_tcTrack), &_0RL_tcTrack);


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

static const char* _0RL_enumMember_CosNaming_mNamingContext_mNotFoundReason[] = { "missing_node", "not_context", "not_object" };
static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContext_mNotFoundReason = CORBA::TypeCode::PR_enum_tc("IDL:omg.org/CosNaming/NamingContext/NotFoundReason:1.0", "NotFoundReason", _0RL_enumMember_CosNaming_mNamingContext_mNotFoundReason, 3, &_0RL_tcTrack);
const CORBA::TypeCode_ptr CosNaming::NamingContext::_tc_NotFoundReason = _0RL_tc_CosNaming_mNamingContext_mNotFoundReason;


static CORBA::PR_structMember _0RL_structmember_CosNaming_mNamingContext_mNotFound[] = {
  {"why", _0RL_tc_CosNaming_mNamingContext_mNotFoundReason},
  {"rest_of_name", _0RL_tc_CosNaming_mName}
};

static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContext_mNotFound = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNaming/NamingContext/NotFound:1.0", "NotFound", _0RL_structmember_CosNaming_mNamingContext_mNotFound, 2, &_0RL_tcTrack);

const CORBA::TypeCode_ptr CosNaming::NamingContext::_tc_NotFound = _0RL_tc_CosNaming_mNamingContext_mNotFound;



static CORBA::PR_structMember _0RL_structmember_CosNaming_mNamingContext_mCannotProceed[] = {
  {"cxt", CORBA::TypeCode::PR_interface_tc("IDL:omg.org/CosNaming/NamingContext:1.0", "NamingContext", &_0RL_tcTrack)},
  {"rest_of_name", _0RL_tc_CosNaming_mName}
};

static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContext_mCannotProceed = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNaming/NamingContext/CannotProceed:1.0", "CannotProceed", _0RL_structmember_CosNaming_mNamingContext_mCannotProceed, 2, &_0RL_tcTrack);

const CORBA::TypeCode_ptr CosNaming::NamingContext::_tc_CannotProceed = _0RL_tc_CosNaming_mNamingContext_mCannotProceed;



static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContext_mInvalidName = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNaming/NamingContext/InvalidName:1.0", "InvalidName", (CORBA::PR_structMember*) 0, 0, &_0RL_tcTrack);
const CORBA::TypeCode_ptr CosNaming::NamingContext::_tc_InvalidName = _0RL_tc_CosNaming_mNamingContext_mInvalidName;



static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContext_mAlreadyBound = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNaming/NamingContext/AlreadyBound:1.0", "AlreadyBound", (CORBA::PR_structMember*) 0, 0, &_0RL_tcTrack);
const CORBA::TypeCode_ptr CosNaming::NamingContext::_tc_AlreadyBound = _0RL_tc_CosNaming_mNamingContext_mAlreadyBound;



static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContext_mNotEmpty = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNaming/NamingContext/NotEmpty:1.0", "NotEmpty", (CORBA::PR_structMember*) 0, 0, &_0RL_tcTrack);
const CORBA::TypeCode_ptr CosNaming::NamingContext::_tc_NotEmpty = _0RL_tc_CosNaming_mNamingContext_mNotEmpty;


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

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

static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContextExt_mStringName = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNaming/NamingContextExt/StringName:1.0", "StringName", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack), &_0RL_tcTrack);


const CORBA::TypeCode_ptr CosNaming::NamingContextExt::_tc_StringName = _0RL_tc_CosNaming_mNamingContextExt_mStringName;

static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContextExt_mAddress = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNaming/NamingContextExt/Address:1.0", "Address", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack), &_0RL_tcTrack);


const CORBA::TypeCode_ptr CosNaming::NamingContextExt::_tc_Address = _0RL_tc_CosNaming_mNamingContextExt_mAddress;

static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContextExt_mURLString = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNaming/NamingContextExt/URLString:1.0", "URLString", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack), &_0RL_tcTrack);


const CORBA::TypeCode_ptr CosNaming::NamingContextExt::_tc_URLString = _0RL_tc_CosNaming_mNamingContextExt_mURLString;


static CORBA::TypeCode_ptr _0RL_tc_CosNaming_mNamingContextExt_mInvalidAddress = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNaming/NamingContextExt/InvalidAddress:1.0", "InvalidAddress", (CORBA::PR_structMember*) 0, 0, &_0RL_tcTrack);
const CORBA::TypeCode_ptr CosNaming::NamingContextExt::_tc_InvalidAddress = _0RL_tc_CosNaming_mNamingContextExt_mInvalidAddress;


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

static void _0RL_CosNaming_mNameComponent_marshal_fn(cdrStream& _s, void* _v)
{
  CosNaming::NameComponent* _p = (CosNaming::NameComponent*)_v;
  *_p >>= _s;
}
static void _0RL_CosNaming_mNameComponent_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNaming::NameComponent* _p = new CosNaming::NameComponent;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mNameComponent_destructor_fn(void* _v)
{
  CosNaming::NameComponent* _p = (CosNaming::NameComponent*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::NameComponent& _s)
{
  CosNaming::NameComponent* _p = new CosNaming::NameComponent(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mNameComponent,
               _0RL_CosNaming_mNameComponent_marshal_fn,
               _0RL_CosNaming_mNameComponent_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNaming::NameComponent* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNameComponent,
               _0RL_CosNaming_mNameComponent_marshal_fn,
               _0RL_CosNaming_mNameComponent_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::NameComponent*& _sp)
{
  return _a >>= (const CosNaming::NameComponent*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::NameComponent*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mNameComponent,
                    _0RL_CosNaming_mNameComponent_unmarshal_fn,
                    _0RL_CosNaming_mNameComponent_marshal_fn,
                    _0RL_CosNaming_mNameComponent_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::NameComponent*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNaming_mName_marshal_fn(cdrStream& _s, void* _v)
{
  CosNaming::Name* _p = (CosNaming::Name*)_v;
  *_p >>= _s;
}
static void _0RL_CosNaming_mName_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNaming::Name* _p = new CosNaming::Name;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mName_destructor_fn(void* _v)
{
  CosNaming::Name* _p = (CosNaming::Name*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::Name& _s)
{
  CosNaming::Name* _p = new CosNaming::Name(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mName,
               _0RL_CosNaming_mName_marshal_fn,
               _0RL_CosNaming_mName_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNaming::Name* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mName,
               _0RL_CosNaming_mName_marshal_fn,
               _0RL_CosNaming_mName_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::Name*& _sp)
{
  return _a >>= (const CosNaming::Name*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::Name*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mName,
                    _0RL_CosNaming_mName_unmarshal_fn,
                    _0RL_CosNaming_mName_marshal_fn,
                    _0RL_CosNaming_mName_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::Name*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNaming_mBindingType_marshal_fn(cdrStream& _s, void* _v)
{
  CosNaming::BindingType* _p = (CosNaming::BindingType*)_v;
  *_p >>= _s;
}
static void _0RL_CosNaming_mBindingType_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNaming::BindingType* _p = (CosNaming::BindingType*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, CosNaming::BindingType _s)
{
  _a.PR_insert(_0RL_tc_CosNaming_mBindingType,
               _0RL_CosNaming_mBindingType_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::BindingType& _s)
{
  return _a.PR_extract(_0RL_tc_CosNaming_mBindingType,
                       _0RL_CosNaming_mBindingType_unmarshal_fn,
                       &_s);
}

static void _0RL_CosNaming_mBinding_marshal_fn(cdrStream& _s, void* _v)
{
  CosNaming::Binding* _p = (CosNaming::Binding*)_v;
  *_p >>= _s;
}
static void _0RL_CosNaming_mBinding_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNaming::Binding* _p = new CosNaming::Binding;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mBinding_destructor_fn(void* _v)
{
  CosNaming::Binding* _p = (CosNaming::Binding*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::Binding& _s)
{
  CosNaming::Binding* _p = new CosNaming::Binding(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mBinding,
               _0RL_CosNaming_mBinding_marshal_fn,
               _0RL_CosNaming_mBinding_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNaming::Binding* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mBinding,
               _0RL_CosNaming_mBinding_marshal_fn,
               _0RL_CosNaming_mBinding_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::Binding*& _sp)
{
  return _a >>= (const CosNaming::Binding*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::Binding*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mBinding,
                    _0RL_CosNaming_mBinding_unmarshal_fn,
                    _0RL_CosNaming_mBinding_marshal_fn,
                    _0RL_CosNaming_mBinding_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::Binding*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNaming_mBindingList_marshal_fn(cdrStream& _s, void* _v)
{
  CosNaming::BindingList* _p = (CosNaming::BindingList*)_v;
  *_p >>= _s;
}
static void _0RL_CosNaming_mBindingList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNaming::BindingList* _p = new CosNaming::BindingList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mBindingList_destructor_fn(void* _v)
{
  CosNaming::BindingList* _p = (CosNaming::BindingList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::BindingList& _s)
{
  CosNaming::BindingList* _p = new CosNaming::BindingList(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mBindingList,
               _0RL_CosNaming_mBindingList_marshal_fn,
               _0RL_CosNaming_mBindingList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNaming::BindingList* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mBindingList,
               _0RL_CosNaming_mBindingList_marshal_fn,
               _0RL_CosNaming_mBindingList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::BindingList*& _sp)
{
  return _a >>= (const CosNaming::BindingList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::BindingList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mBindingList,
                    _0RL_CosNaming_mBindingList_unmarshal_fn,
                    _0RL_CosNaming_mBindingList_marshal_fn,
                    _0RL_CosNaming_mBindingList_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::BindingList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNaming_mNamingContext_mNotFoundReason_marshal_fn(cdrStream& _s, void* _v)
{
  CosNaming::NamingContext::NotFoundReason* _p = (CosNaming::NamingContext::NotFoundReason*)_v;
  *_p >>= _s;
}
static void _0RL_CosNaming_mNamingContext_mNotFoundReason_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNaming::NamingContext::NotFoundReason* _p = (CosNaming::NamingContext::NotFoundReason*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, CosNaming::NamingContext::NotFoundReason _s)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mNotFoundReason,
               _0RL_CosNaming_mNamingContext_mNotFoundReason_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::NamingContext::NotFoundReason& _s)
{
  return _a.PR_extract(_0RL_tc_CosNaming_mNamingContext_mNotFoundReason,
                       _0RL_CosNaming_mNamingContext_mNotFoundReason_unmarshal_fn,
                       &_s);
}


static void _0RL_CosNaming_mNamingContext_mNotFound_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNaming::NamingContext::NotFound* _p = (const CosNaming::NamingContext::NotFound*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNaming_mNamingContext_mNotFound_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNaming::NamingContext::NotFound* _p = new CosNaming::NamingContext::NotFound;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mNamingContext_mNotFound_destructor_fn(void* _v)
{
  CosNaming::NamingContext::NotFound* _p = (CosNaming::NamingContext::NotFound*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::NotFound& _s)
{
  CosNaming::NamingContext::NotFound* _p = new CosNaming::NamingContext::NotFound(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mNotFound,
               _0RL_CosNaming_mNamingContext_mNotFound_marshal_fn,
               _0RL_CosNaming_mNamingContext_mNotFound_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::NotFound* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mNotFound,
               _0RL_CosNaming_mNamingContext_mNotFound_marshal_fn,
               _0RL_CosNaming_mNamingContext_mNotFound_destructor_fn,
               (CosNaming::NamingContext::NotFound*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::NamingContext::NotFound*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mNamingContext_mNotFound,
                    _0RL_CosNaming_mNamingContext_mNotFound_unmarshal_fn,
                    _0RL_CosNaming_mNamingContext_mNotFound_marshal_fn,
                    _0RL_CosNaming_mNamingContext_mNotFound_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::NamingContext::NotFound*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNaming_mNamingContext_mNotFound(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNaming::NamingContext::NotFound & _ex = (const CosNaming::NamingContext::NotFound &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mNotFound (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNaming::NamingContext::NotFound* _ex = (const CosNaming::NamingContext::NotFound*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotFound {
public:
  _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotFound() {
    CosNaming::NamingContext::NotFound::insertToAnyFn = _0RL_insertToAny__cCosNaming_mNamingContext_mNotFound;
    CosNaming::NamingContext::NotFound::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mNotFound;
  }
};
static _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotFound _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotFound_;


static void _0RL_CosNaming_mNamingContext_mCannotProceed_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNaming::NamingContext::CannotProceed* _p = (const CosNaming::NamingContext::CannotProceed*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNaming_mNamingContext_mCannotProceed_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNaming::NamingContext::CannotProceed* _p = new CosNaming::NamingContext::CannotProceed;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mNamingContext_mCannotProceed_destructor_fn(void* _v)
{
  CosNaming::NamingContext::CannotProceed* _p = (CosNaming::NamingContext::CannotProceed*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::CannotProceed& _s)
{
  CosNaming::NamingContext::CannotProceed* _p = new CosNaming::NamingContext::CannotProceed(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mCannotProceed,
               _0RL_CosNaming_mNamingContext_mCannotProceed_marshal_fn,
               _0RL_CosNaming_mNamingContext_mCannotProceed_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::CannotProceed* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mCannotProceed,
               _0RL_CosNaming_mNamingContext_mCannotProceed_marshal_fn,
               _0RL_CosNaming_mNamingContext_mCannotProceed_destructor_fn,
               (CosNaming::NamingContext::CannotProceed*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::NamingContext::CannotProceed*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mNamingContext_mCannotProceed,
                    _0RL_CosNaming_mNamingContext_mCannotProceed_unmarshal_fn,
                    _0RL_CosNaming_mNamingContext_mCannotProceed_marshal_fn,
                    _0RL_CosNaming_mNamingContext_mCannotProceed_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::NamingContext::CannotProceed*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNaming_mNamingContext_mCannotProceed(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNaming::NamingContext::CannotProceed & _ex = (const CosNaming::NamingContext::CannotProceed &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mCannotProceed (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNaming::NamingContext::CannotProceed* _ex = (const CosNaming::NamingContext::CannotProceed*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mCannotProceed {
public:
  _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mCannotProceed() {
    CosNaming::NamingContext::CannotProceed::insertToAnyFn = _0RL_insertToAny__cCosNaming_mNamingContext_mCannotProceed;
    CosNaming::NamingContext::CannotProceed::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mCannotProceed;
  }
};
static _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mCannotProceed _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mCannotProceed_;


static void _0RL_CosNaming_mNamingContext_mInvalidName_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNaming::NamingContext::InvalidName* _p = (const CosNaming::NamingContext::InvalidName*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNaming_mNamingContext_mInvalidName_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNaming::NamingContext::InvalidName* _p = new CosNaming::NamingContext::InvalidName;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mNamingContext_mInvalidName_destructor_fn(void* _v)
{
  CosNaming::NamingContext::InvalidName* _p = (CosNaming::NamingContext::InvalidName*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::InvalidName& _s)
{
  CosNaming::NamingContext::InvalidName* _p = new CosNaming::NamingContext::InvalidName(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mInvalidName,
               _0RL_CosNaming_mNamingContext_mInvalidName_marshal_fn,
               _0RL_CosNaming_mNamingContext_mInvalidName_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::InvalidName* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mInvalidName,
               _0RL_CosNaming_mNamingContext_mInvalidName_marshal_fn,
               _0RL_CosNaming_mNamingContext_mInvalidName_destructor_fn,
               (CosNaming::NamingContext::InvalidName*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::NamingContext::InvalidName*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mNamingContext_mInvalidName,
                    _0RL_CosNaming_mNamingContext_mInvalidName_unmarshal_fn,
                    _0RL_CosNaming_mNamingContext_mInvalidName_marshal_fn,
                    _0RL_CosNaming_mNamingContext_mInvalidName_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::NamingContext::InvalidName*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNaming_mNamingContext_mInvalidName(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNaming::NamingContext::InvalidName & _ex = (const CosNaming::NamingContext::InvalidName &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mInvalidName (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNaming::NamingContext::InvalidName* _ex = (const CosNaming::NamingContext::InvalidName*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mInvalidName {
public:
  _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mInvalidName() {
    CosNaming::NamingContext::InvalidName::insertToAnyFn = _0RL_insertToAny__cCosNaming_mNamingContext_mInvalidName;
    CosNaming::NamingContext::InvalidName::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mInvalidName;
  }
};
static _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mInvalidName _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mInvalidName_;


static void _0RL_CosNaming_mNamingContext_mAlreadyBound_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNaming::NamingContext::AlreadyBound* _p = (const CosNaming::NamingContext::AlreadyBound*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNaming_mNamingContext_mAlreadyBound_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNaming::NamingContext::AlreadyBound* _p = new CosNaming::NamingContext::AlreadyBound;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mNamingContext_mAlreadyBound_destructor_fn(void* _v)
{
  CosNaming::NamingContext::AlreadyBound* _p = (CosNaming::NamingContext::AlreadyBound*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::AlreadyBound& _s)
{
  CosNaming::NamingContext::AlreadyBound* _p = new CosNaming::NamingContext::AlreadyBound(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mAlreadyBound,
               _0RL_CosNaming_mNamingContext_mAlreadyBound_marshal_fn,
               _0RL_CosNaming_mNamingContext_mAlreadyBound_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::AlreadyBound* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mAlreadyBound,
               _0RL_CosNaming_mNamingContext_mAlreadyBound_marshal_fn,
               _0RL_CosNaming_mNamingContext_mAlreadyBound_destructor_fn,
               (CosNaming::NamingContext::AlreadyBound*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::NamingContext::AlreadyBound*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mNamingContext_mAlreadyBound,
                    _0RL_CosNaming_mNamingContext_mAlreadyBound_unmarshal_fn,
                    _0RL_CosNaming_mNamingContext_mAlreadyBound_marshal_fn,
                    _0RL_CosNaming_mNamingContext_mAlreadyBound_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::NamingContext::AlreadyBound*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNaming_mNamingContext_mAlreadyBound(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNaming::NamingContext::AlreadyBound & _ex = (const CosNaming::NamingContext::AlreadyBound &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mAlreadyBound (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNaming::NamingContext::AlreadyBound* _ex = (const CosNaming::NamingContext::AlreadyBound*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mAlreadyBound {
public:
  _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mAlreadyBound() {
    CosNaming::NamingContext::AlreadyBound::insertToAnyFn = _0RL_insertToAny__cCosNaming_mNamingContext_mAlreadyBound;
    CosNaming::NamingContext::AlreadyBound::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mAlreadyBound;
  }
};
static _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mAlreadyBound _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mAlreadyBound_;


static void _0RL_CosNaming_mNamingContext_mNotEmpty_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNaming::NamingContext::NotEmpty* _p = (const CosNaming::NamingContext::NotEmpty*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNaming_mNamingContext_mNotEmpty_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNaming::NamingContext::NotEmpty* _p = new CosNaming::NamingContext::NotEmpty;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mNamingContext_mNotEmpty_destructor_fn(void* _v)
{
  CosNaming::NamingContext::NotEmpty* _p = (CosNaming::NamingContext::NotEmpty*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::NotEmpty& _s)
{
  CosNaming::NamingContext::NotEmpty* _p = new CosNaming::NamingContext::NotEmpty(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mNotEmpty,
               _0RL_CosNaming_mNamingContext_mNotEmpty_marshal_fn,
               _0RL_CosNaming_mNamingContext_mNotEmpty_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContext::NotEmpty* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContext_mNotEmpty,
               _0RL_CosNaming_mNamingContext_mNotEmpty_marshal_fn,
               _0RL_CosNaming_mNamingContext_mNotEmpty_destructor_fn,
               (CosNaming::NamingContext::NotEmpty*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::NamingContext::NotEmpty*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mNamingContext_mNotEmpty,
                    _0RL_CosNaming_mNamingContext_mNotEmpty_unmarshal_fn,
                    _0RL_CosNaming_mNamingContext_mNotEmpty_marshal_fn,
                    _0RL_CosNaming_mNamingContext_mNotEmpty_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::NamingContext::NotEmpty*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNaming_mNamingContext_mNotEmpty(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNaming::NamingContext::NotEmpty & _ex = (const CosNaming::NamingContext::NotEmpty &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mNotEmpty (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNaming::NamingContext::NotEmpty* _ex = (const CosNaming::NamingContext::NotEmpty*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotEmpty {
public:
  _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotEmpty() {
    CosNaming::NamingContext::NotEmpty::insertToAnyFn = _0RL_insertToAny__cCosNaming_mNamingContext_mNotEmpty;
    CosNaming::NamingContext::NotEmpty::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNaming_mNamingContext_mNotEmpty;
  }
};
static _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotEmpty _0RL_insertToAny_Singleton__cCosNaming_mNamingContext_mNotEmpty_;

static void _0RL_CosNaming_mNamingContext_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_CosNaming_mNamingContext_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(CosNaming::NamingContext::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_CosNaming_mNamingContext_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, CosNaming::NamingContext_ptr _o)
{
  CosNaming::NamingContext_ptr _no = CosNaming::NamingContext::_duplicate(_o);
  _a.PR_insert(CosNaming::_tc_NamingContext,
               _0RL_CosNaming_mNamingContext_marshal_fn,
               _0RL_CosNaming_mNamingContext_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, CosNaming::NamingContext_ptr* _op)
{
  _a.PR_insert(CosNaming::_tc_NamingContext,
               _0RL_CosNaming_mNamingContext_marshal_fn,
               _0RL_CosNaming_mNamingContext_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = CosNaming::NamingContext::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::NamingContext_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(CosNaming::_tc_NamingContext,
                    _0RL_CosNaming_mNamingContext_unmarshal_fn,
                    _0RL_CosNaming_mNamingContext_marshal_fn,
                    _0RL_CosNaming_mNamingContext_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (CosNaming::NamingContext_ptr)_r->_ptrToObjRef(CosNaming::NamingContext::_PD_repoId);
    else
      _o = CosNaming::NamingContext::_nil();
    return 1;
  }
  return 0;
}

static void _0RL_CosNaming_mBindingIterator_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_CosNaming_mBindingIterator_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(CosNaming::BindingIterator::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_CosNaming_mBindingIterator_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, CosNaming::BindingIterator_ptr _o)
{
  CosNaming::BindingIterator_ptr _no = CosNaming::BindingIterator::_duplicate(_o);
  _a.PR_insert(CosNaming::_tc_BindingIterator,
               _0RL_CosNaming_mBindingIterator_marshal_fn,
               _0RL_CosNaming_mBindingIterator_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, CosNaming::BindingIterator_ptr* _op)
{
  _a.PR_insert(CosNaming::_tc_BindingIterator,
               _0RL_CosNaming_mBindingIterator_marshal_fn,
               _0RL_CosNaming_mBindingIterator_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = CosNaming::BindingIterator::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::BindingIterator_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(CosNaming::_tc_BindingIterator,
                    _0RL_CosNaming_mBindingIterator_unmarshal_fn,
                    _0RL_CosNaming_mBindingIterator_marshal_fn,
                    _0RL_CosNaming_mBindingIterator_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (CosNaming::BindingIterator_ptr)_r->_ptrToObjRef(CosNaming::BindingIterator::_PD_repoId);
    else
      _o = CosNaming::BindingIterator::_nil();
    return 1;
  }
  return 0;
}


static void _0RL_CosNaming_mNamingContextExt_mInvalidAddress_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNaming::NamingContextExt::InvalidAddress* _p = (const CosNaming::NamingContextExt::InvalidAddress*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNaming_mNamingContextExt_mInvalidAddress_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNaming::NamingContextExt::InvalidAddress* _p = new CosNaming::NamingContextExt::InvalidAddress;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNaming_mNamingContextExt_mInvalidAddress_destructor_fn(void* _v)
{
  CosNaming::NamingContextExt::InvalidAddress* _p = (CosNaming::NamingContextExt::InvalidAddress*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContextExt::InvalidAddress& _s)
{
  CosNaming::NamingContextExt::InvalidAddress* _p = new CosNaming::NamingContextExt::InvalidAddress(_s);
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContextExt_mInvalidAddress,
               _0RL_CosNaming_mNamingContextExt_mInvalidAddress_marshal_fn,
               _0RL_CosNaming_mNamingContextExt_mInvalidAddress_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNaming::NamingContextExt::InvalidAddress* _sp)
{
  _a.PR_insert(_0RL_tc_CosNaming_mNamingContextExt_mInvalidAddress,
               _0RL_CosNaming_mNamingContextExt_mInvalidAddress_marshal_fn,
               _0RL_CosNaming_mNamingContextExt_mInvalidAddress_destructor_fn,
               (CosNaming::NamingContextExt::InvalidAddress*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNaming::NamingContextExt::InvalidAddress*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNaming_mNamingContextExt_mInvalidAddress,
                    _0RL_CosNaming_mNamingContextExt_mInvalidAddress_unmarshal_fn,
                    _0RL_CosNaming_mNamingContextExt_mInvalidAddress_marshal_fn,
                    _0RL_CosNaming_mNamingContextExt_mInvalidAddress_destructor_fn,
                    _v)) {
    _sp = (const CosNaming::NamingContextExt::InvalidAddress*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNaming_mNamingContextExt_mInvalidAddress(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNaming::NamingContextExt::InvalidAddress & _ex = (const CosNaming::NamingContextExt::InvalidAddress &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNaming_mNamingContextExt_mInvalidAddress (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNaming::NamingContextExt::InvalidAddress* _ex = (const CosNaming::NamingContextExt::InvalidAddress*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNaming_mNamingContextExt_mInvalidAddress {
public:
  _0RL_insertToAny_Singleton__cCosNaming_mNamingContextExt_mInvalidAddress() {
    CosNaming::NamingContextExt::InvalidAddress::insertToAnyFn = _0RL_insertToAny__cCosNaming_mNamingContextExt_mInvalidAddress;
    CosNaming::NamingContextExt::InvalidAddress::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNaming_mNamingContextExt_mInvalidAddress;
  }
};
static _0RL_insertToAny_Singleton__cCosNaming_mNamingContextExt_mInvalidAddress _0RL_insertToAny_Singleton__cCosNaming_mNamingContextExt_mInvalidAddress_;

static void _0RL_CosNaming_mNamingContextExt_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_CosNaming_mNamingContextExt_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(CosNaming::NamingContextExt::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_CosNaming_mNamingContextExt_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, CosNaming::NamingContextExt_ptr _o)
{
  CosNaming::NamingContextExt_ptr _no = CosNaming::NamingContextExt::_duplicate(_o);
  _a.PR_insert(CosNaming::_tc_NamingContextExt,
               _0RL_CosNaming_mNamingContextExt_marshal_fn,
               _0RL_CosNaming_mNamingContextExt_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, CosNaming::NamingContextExt_ptr* _op)
{
  _a.PR_insert(CosNaming::_tc_NamingContextExt,
               _0RL_CosNaming_mNamingContextExt_marshal_fn,
               _0RL_CosNaming_mNamingContextExt_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = CosNaming::NamingContextExt::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNaming::NamingContextExt_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(CosNaming::_tc_NamingContextExt,
                    _0RL_CosNaming_mNamingContextExt_unmarshal_fn,
                    _0RL_CosNaming_mNamingContextExt_marshal_fn,
                    _0RL_CosNaming_mNamingContextExt_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (CosNaming::NamingContextExt_ptr)_r->_ptrToObjRef(CosNaming::NamingContextExt::_PD_repoId);
    else
      _o = CosNaming::NamingContextExt::_nil();
    return 1;
  }
  return 0;
}

