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

#include "CosNotification.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_CosNotification_mIstring = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/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 CosNotification { 
  const ::CORBA::TypeCode_ptr _tc_Istring = _0RL_tc_CosNotification_mIstring;
} 
#else
const ::CORBA::TypeCode_ptr CosNotification::_tc_Istring = _0RL_tc_CosNotification_mIstring;
#endif

static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mPropertyName = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/PropertyName:1.0", "PropertyName", _0RL_tc_CosNotification_mIstring, &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mPropertyValue = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/PropertyValue:1.0", "PropertyValue", CORBA::TypeCode::PR_any_tc(), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_CosNotification_mProperty[] = {
  {"name", _0RL_tc_CosNotification_mPropertyName},
  {"value", _0RL_tc_CosNotification_mPropertyValue}
};

#ifdef _0RL_tc_CosNotification_mProperty
#  undef _0RL_tc_CosNotification_mProperty
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mProperty = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/Property:1.0", "Property", _0RL_structmember_CosNotification_mProperty, 2, &_0RL_tcTrack);

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






static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mPropertySeq = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/PropertySeq:1.0", "PropertySeq", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_CosNotification_mProperty, &_0RL_tcTrack), &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mOptionalHeaderFields = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/OptionalHeaderFields:1.0", "OptionalHeaderFields", _0RL_tc_CosNotification_mPropertySeq, &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mFilterableEventBody = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/FilterableEventBody:1.0", "FilterableEventBody", _0RL_tc_CosNotification_mPropertySeq, &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mQoSProperties = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/QoSProperties:1.0", "QoSProperties", _0RL_tc_CosNotification_mPropertySeq, &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mAdminProperties = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/AdminProperties:1.0", "AdminProperties", _0RL_tc_CosNotification_mPropertySeq, &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_CosNotification_mEventType[] = {
  {"domain_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"type_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}
};

#ifdef _0RL_tc_CosNotification_mEventType
#  undef _0RL_tc_CosNotification_mEventType
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mEventType = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/EventType:1.0", "EventType", _0RL_structmember_CosNotification_mEventType, 2, &_0RL_tcTrack);

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






static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mEventTypeSeq = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/EventTypeSeq:1.0", "EventTypeSeq", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_CosNotification_mEventType, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_CosNotification_mPropertyRange[] = {
  {"low_val", _0RL_tc_CosNotification_mPropertyValue},
  {"high_val", _0RL_tc_CosNotification_mPropertyValue}
};

#ifdef _0RL_tc_CosNotification_mPropertyRange
#  undef _0RL_tc_CosNotification_mPropertyRange
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mPropertyRange = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/PropertyRange:1.0", "PropertyRange", _0RL_structmember_CosNotification_mPropertyRange, 2, &_0RL_tcTrack);

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



static CORBA::PR_structMember _0RL_structmember_CosNotification_mNamedPropertyRange[] = {
  {"name", _0RL_tc_CosNotification_mPropertyName},
  {"range", _0RL_tc_CosNotification_mPropertyRange}
};

#ifdef _0RL_tc_CosNotification_mNamedPropertyRange
#  undef _0RL_tc_CosNotification_mNamedPropertyRange
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mNamedPropertyRange = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/NamedPropertyRange:1.0", "NamedPropertyRange", _0RL_structmember_CosNotification_mNamedPropertyRange, 2, &_0RL_tcTrack);


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










static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mNamedPropertyRangeSeq = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/NamedPropertyRangeSeq:1.0", "NamedPropertyRangeSeq", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_CosNotification_mNamedPropertyRange, &_0RL_tcTrack), &_0RL_tcTrack);


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

static const char* _0RL_enumMember_CosNotification_mQoSError__code[] = { "UNSUPPORTED_PROPERTY", "UNAVAILABLE_PROPERTY", "UNSUPPORTED_VALUE", "UNAVAILABLE_VALUE", "BAD_PROPERTY", "BAD_TYPE", "BAD_VALUE" };
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mQoSError__code = CORBA::TypeCode::PR_enum_tc("IDL:omg.org/CosNotification/QoSError_code:1.0", "QoSError_code", _0RL_enumMember_CosNotification_mQoSError__code, 7, &_0RL_tcTrack);
#if defined(OMNI_HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace CosNotification { 
  const ::CORBA::TypeCode_ptr _tc_QoSError_code = _0RL_tc_CosNotification_mQoSError__code;
} 
#else
const ::CORBA::TypeCode_ptr CosNotification::_tc_QoSError_code = _0RL_tc_CosNotification_mQoSError__code;
#endif


static CORBA::PR_structMember _0RL_structmember_CosNotification_mPropertyError[] = {
  {"code", _0RL_tc_CosNotification_mQoSError__code},
  {"name", _0RL_tc_CosNotification_mPropertyName},
  {"available_range", _0RL_tc_CosNotification_mPropertyRange}
};

#ifdef _0RL_tc_CosNotification_mPropertyError
#  undef _0RL_tc_CosNotification_mPropertyError
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mPropertyError = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/PropertyError:1.0", "PropertyError", _0RL_structmember_CosNotification_mPropertyError, 3, &_0RL_tcTrack);


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










static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mPropertyErrorSeq = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/PropertyErrorSeq:1.0", "PropertyErrorSeq", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_CosNotification_mPropertyError, &_0RL_tcTrack), &_0RL_tcTrack);


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



static CORBA::PR_structMember _0RL_structmember_CosNotification_mUnsupportedQoS[] = {
  {"qos_err", _0RL_tc_CosNotification_mPropertyErrorSeq}
};

static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mUnsupportedQoS = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNotification/UnsupportedQoS:1.0", "UnsupportedQoS", _0RL_structmember_CosNotification_mUnsupportedQoS, 1, &_0RL_tcTrack);


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




static CORBA::PR_structMember _0RL_structmember_CosNotification_mUnsupportedAdmin[] = {
  {"admin_err", _0RL_tc_CosNotification_mPropertyErrorSeq}
};

static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mUnsupportedAdmin = CORBA::TypeCode::PR_exception_tc("IDL:omg.org/CosNotification/UnsupportedAdmin:1.0", "UnsupportedAdmin", _0RL_structmember_CosNotification_mUnsupportedAdmin, 1, &_0RL_tcTrack);


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



static CORBA::PR_structMember _0RL_structmember_CosNotification_mFixedEventHeader[] = {
  {"event_type", _0RL_tc_CosNotification_mEventType},
  {"event_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}
};

#ifdef _0RL_tc_CosNotification_mFixedEventHeader
#  undef _0RL_tc_CosNotification_mFixedEventHeader
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mFixedEventHeader = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/FixedEventHeader:1.0", "FixedEventHeader", _0RL_structmember_CosNotification_mFixedEventHeader, 2, &_0RL_tcTrack);


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





static CORBA::PR_structMember _0RL_structmember_CosNotification_mEventHeader[] = {
  {"fixed_header", _0RL_tc_CosNotification_mFixedEventHeader},
  {"variable_header", _0RL_tc_CosNotification_mOptionalHeaderFields}
};

#ifdef _0RL_tc_CosNotification_mEventHeader
#  undef _0RL_tc_CosNotification_mEventHeader
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mEventHeader = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/EventHeader:1.0", "EventHeader", _0RL_structmember_CosNotification_mEventHeader, 2, &_0RL_tcTrack);




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







static CORBA::PR_structMember _0RL_structmember_CosNotification_mStructuredEvent[] = {
  {"header", _0RL_tc_CosNotification_mEventHeader},
  {"filterable_data", _0RL_tc_CosNotification_mFilterableEventBody},
  {"remainder_of_body", CORBA::TypeCode::PR_any_tc()}
};

#ifdef _0RL_tc_CosNotification_mStructuredEvent
#  undef _0RL_tc_CosNotification_mStructuredEvent
#endif
static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mStructuredEvent = CORBA::TypeCode::PR_struct_tc("IDL:omg.org/CosNotification/StructuredEvent:1.0", "StructuredEvent", _0RL_structmember_CosNotification_mStructuredEvent, 3, &_0RL_tcTrack);






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


























static CORBA::TypeCode_ptr _0RL_tc_CosNotification_mEventBatch = CORBA::TypeCode::PR_alias_tc("IDL:omg.org/CosNotification/EventBatch:1.0", "EventBatch", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_CosNotification_mStructuredEvent, &_0RL_tcTrack), &_0RL_tcTrack);


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

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

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

static void _0RL_CosNotification_mProperty_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::Property* _p = (CosNotification::Property*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mProperty_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::Property* _p = new CosNotification::Property;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mProperty_destructor_fn(void* _v)
{
  CosNotification::Property* _p = (CosNotification::Property*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::Property& _s)
{
  CosNotification::Property* _p = new CosNotification::Property(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mProperty,
               _0RL_CosNotification_mProperty_marshal_fn,
               _0RL_CosNotification_mProperty_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::Property* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mProperty,
               _0RL_CosNotification_mProperty_marshal_fn,
               _0RL_CosNotification_mProperty_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::Property*& _sp)
{
  return _a >>= (const CosNotification::Property*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::Property*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mProperty,
                    _0RL_CosNotification_mProperty_unmarshal_fn,
                    _0RL_CosNotification_mProperty_marshal_fn,
                    _0RL_CosNotification_mProperty_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::Property*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mPropertySeq_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::PropertySeq* _p = (CosNotification::PropertySeq*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mPropertySeq_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::PropertySeq* _p = new CosNotification::PropertySeq;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mPropertySeq_destructor_fn(void* _v)
{
  CosNotification::PropertySeq* _p = (CosNotification::PropertySeq*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::PropertySeq& _s)
{
  CosNotification::PropertySeq* _p = new CosNotification::PropertySeq(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mPropertySeq,
               _0RL_CosNotification_mPropertySeq_marshal_fn,
               _0RL_CosNotification_mPropertySeq_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::PropertySeq* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mPropertySeq,
               _0RL_CosNotification_mPropertySeq_marshal_fn,
               _0RL_CosNotification_mPropertySeq_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::PropertySeq*& _sp)
{
  return _a >>= (const CosNotification::PropertySeq*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::PropertySeq*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mPropertySeq,
                    _0RL_CosNotification_mPropertySeq_unmarshal_fn,
                    _0RL_CosNotification_mPropertySeq_marshal_fn,
                    _0RL_CosNotification_mPropertySeq_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::PropertySeq*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mEventType_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::EventType* _p = (CosNotification::EventType*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mEventType_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::EventType* _p = new CosNotification::EventType;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mEventType_destructor_fn(void* _v)
{
  CosNotification::EventType* _p = (CosNotification::EventType*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::EventType& _s)
{
  CosNotification::EventType* _p = new CosNotification::EventType(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mEventType,
               _0RL_CosNotification_mEventType_marshal_fn,
               _0RL_CosNotification_mEventType_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::EventType* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mEventType,
               _0RL_CosNotification_mEventType_marshal_fn,
               _0RL_CosNotification_mEventType_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::EventType*& _sp)
{
  return _a >>= (const CosNotification::EventType*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::EventType*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mEventType,
                    _0RL_CosNotification_mEventType_unmarshal_fn,
                    _0RL_CosNotification_mEventType_marshal_fn,
                    _0RL_CosNotification_mEventType_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::EventType*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mEventTypeSeq_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::EventTypeSeq* _p = (CosNotification::EventTypeSeq*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mEventTypeSeq_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::EventTypeSeq* _p = new CosNotification::EventTypeSeq;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mEventTypeSeq_destructor_fn(void* _v)
{
  CosNotification::EventTypeSeq* _p = (CosNotification::EventTypeSeq*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::EventTypeSeq& _s)
{
  CosNotification::EventTypeSeq* _p = new CosNotification::EventTypeSeq(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mEventTypeSeq,
               _0RL_CosNotification_mEventTypeSeq_marshal_fn,
               _0RL_CosNotification_mEventTypeSeq_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::EventTypeSeq* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mEventTypeSeq,
               _0RL_CosNotification_mEventTypeSeq_marshal_fn,
               _0RL_CosNotification_mEventTypeSeq_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::EventTypeSeq*& _sp)
{
  return _a >>= (const CosNotification::EventTypeSeq*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::EventTypeSeq*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mEventTypeSeq,
                    _0RL_CosNotification_mEventTypeSeq_unmarshal_fn,
                    _0RL_CosNotification_mEventTypeSeq_marshal_fn,
                    _0RL_CosNotification_mEventTypeSeq_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::EventTypeSeq*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mPropertyRange_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::PropertyRange* _p = (CosNotification::PropertyRange*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mPropertyRange_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::PropertyRange* _p = new CosNotification::PropertyRange;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mPropertyRange_destructor_fn(void* _v)
{
  CosNotification::PropertyRange* _p = (CosNotification::PropertyRange*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::PropertyRange& _s)
{
  CosNotification::PropertyRange* _p = new CosNotification::PropertyRange(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mPropertyRange,
               _0RL_CosNotification_mPropertyRange_marshal_fn,
               _0RL_CosNotification_mPropertyRange_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::PropertyRange* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mPropertyRange,
               _0RL_CosNotification_mPropertyRange_marshal_fn,
               _0RL_CosNotification_mPropertyRange_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::PropertyRange*& _sp)
{
  return _a >>= (const CosNotification::PropertyRange*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::PropertyRange*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mPropertyRange,
                    _0RL_CosNotification_mPropertyRange_unmarshal_fn,
                    _0RL_CosNotification_mPropertyRange_marshal_fn,
                    _0RL_CosNotification_mPropertyRange_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::PropertyRange*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mNamedPropertyRange_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::NamedPropertyRange* _p = (CosNotification::NamedPropertyRange*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mNamedPropertyRange_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::NamedPropertyRange* _p = new CosNotification::NamedPropertyRange;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mNamedPropertyRange_destructor_fn(void* _v)
{
  CosNotification::NamedPropertyRange* _p = (CosNotification::NamedPropertyRange*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::NamedPropertyRange& _s)
{
  CosNotification::NamedPropertyRange* _p = new CosNotification::NamedPropertyRange(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mNamedPropertyRange,
               _0RL_CosNotification_mNamedPropertyRange_marshal_fn,
               _0RL_CosNotification_mNamedPropertyRange_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::NamedPropertyRange* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mNamedPropertyRange,
               _0RL_CosNotification_mNamedPropertyRange_marshal_fn,
               _0RL_CosNotification_mNamedPropertyRange_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::NamedPropertyRange*& _sp)
{
  return _a >>= (const CosNotification::NamedPropertyRange*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::NamedPropertyRange*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mNamedPropertyRange,
                    _0RL_CosNotification_mNamedPropertyRange_unmarshal_fn,
                    _0RL_CosNotification_mNamedPropertyRange_marshal_fn,
                    _0RL_CosNotification_mNamedPropertyRange_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::NamedPropertyRange*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mNamedPropertyRangeSeq_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::NamedPropertyRangeSeq* _p = (CosNotification::NamedPropertyRangeSeq*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mNamedPropertyRangeSeq_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::NamedPropertyRangeSeq* _p = new CosNotification::NamedPropertyRangeSeq;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mNamedPropertyRangeSeq_destructor_fn(void* _v)
{
  CosNotification::NamedPropertyRangeSeq* _p = (CosNotification::NamedPropertyRangeSeq*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::NamedPropertyRangeSeq& _s)
{
  CosNotification::NamedPropertyRangeSeq* _p = new CosNotification::NamedPropertyRangeSeq(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mNamedPropertyRangeSeq,
               _0RL_CosNotification_mNamedPropertyRangeSeq_marshal_fn,
               _0RL_CosNotification_mNamedPropertyRangeSeq_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::NamedPropertyRangeSeq* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mNamedPropertyRangeSeq,
               _0RL_CosNotification_mNamedPropertyRangeSeq_marshal_fn,
               _0RL_CosNotification_mNamedPropertyRangeSeq_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::NamedPropertyRangeSeq*& _sp)
{
  return _a >>= (const CosNotification::NamedPropertyRangeSeq*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::NamedPropertyRangeSeq*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mNamedPropertyRangeSeq,
                    _0RL_CosNotification_mNamedPropertyRangeSeq_unmarshal_fn,
                    _0RL_CosNotification_mNamedPropertyRangeSeq_marshal_fn,
                    _0RL_CosNotification_mNamedPropertyRangeSeq_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::NamedPropertyRangeSeq*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mQoSError__code_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::QoSError_code* _p = (CosNotification::QoSError_code*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mQoSError__code_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::QoSError_code* _p = (CosNotification::QoSError_code*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, CosNotification::QoSError_code _s)
{
  _a.PR_insert(_0RL_tc_CosNotification_mQoSError__code,
               _0RL_CosNotification_mQoSError__code_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::QoSError_code& _s)
{
  return _a.PR_extract(_0RL_tc_CosNotification_mQoSError__code,
                       _0RL_CosNotification_mQoSError__code_unmarshal_fn,
                       &_s);
}

static void _0RL_CosNotification_mPropertyError_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::PropertyError* _p = (CosNotification::PropertyError*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mPropertyError_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::PropertyError* _p = new CosNotification::PropertyError;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mPropertyError_destructor_fn(void* _v)
{
  CosNotification::PropertyError* _p = (CosNotification::PropertyError*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::PropertyError& _s)
{
  CosNotification::PropertyError* _p = new CosNotification::PropertyError(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mPropertyError,
               _0RL_CosNotification_mPropertyError_marshal_fn,
               _0RL_CosNotification_mPropertyError_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::PropertyError* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mPropertyError,
               _0RL_CosNotification_mPropertyError_marshal_fn,
               _0RL_CosNotification_mPropertyError_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::PropertyError*& _sp)
{
  return _a >>= (const CosNotification::PropertyError*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::PropertyError*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mPropertyError,
                    _0RL_CosNotification_mPropertyError_unmarshal_fn,
                    _0RL_CosNotification_mPropertyError_marshal_fn,
                    _0RL_CosNotification_mPropertyError_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::PropertyError*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mPropertyErrorSeq_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::PropertyErrorSeq* _p = (CosNotification::PropertyErrorSeq*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mPropertyErrorSeq_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::PropertyErrorSeq* _p = new CosNotification::PropertyErrorSeq;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mPropertyErrorSeq_destructor_fn(void* _v)
{
  CosNotification::PropertyErrorSeq* _p = (CosNotification::PropertyErrorSeq*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::PropertyErrorSeq& _s)
{
  CosNotification::PropertyErrorSeq* _p = new CosNotification::PropertyErrorSeq(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mPropertyErrorSeq,
               _0RL_CosNotification_mPropertyErrorSeq_marshal_fn,
               _0RL_CosNotification_mPropertyErrorSeq_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::PropertyErrorSeq* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mPropertyErrorSeq,
               _0RL_CosNotification_mPropertyErrorSeq_marshal_fn,
               _0RL_CosNotification_mPropertyErrorSeq_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::PropertyErrorSeq*& _sp)
{
  return _a >>= (const CosNotification::PropertyErrorSeq*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::PropertyErrorSeq*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mPropertyErrorSeq,
                    _0RL_CosNotification_mPropertyErrorSeq_unmarshal_fn,
                    _0RL_CosNotification_mPropertyErrorSeq_marshal_fn,
                    _0RL_CosNotification_mPropertyErrorSeq_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::PropertyErrorSeq*)_v;
    return 1;
  }
  return 0;
}


static void _0RL_CosNotification_mUnsupportedQoS_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNotification::UnsupportedQoS* _p = (const CosNotification::UnsupportedQoS*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNotification_mUnsupportedQoS_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNotification::UnsupportedQoS* _p = new CosNotification::UnsupportedQoS;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mUnsupportedQoS_destructor_fn(void* _v)
{
  CosNotification::UnsupportedQoS* _p = (CosNotification::UnsupportedQoS*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::UnsupportedQoS& _s)
{
  CosNotification::UnsupportedQoS* _p = new CosNotification::UnsupportedQoS(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mUnsupportedQoS,
               _0RL_CosNotification_mUnsupportedQoS_marshal_fn,
               _0RL_CosNotification_mUnsupportedQoS_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNotification::UnsupportedQoS* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mUnsupportedQoS,
               _0RL_CosNotification_mUnsupportedQoS_marshal_fn,
               _0RL_CosNotification_mUnsupportedQoS_destructor_fn,
               (CosNotification::UnsupportedQoS*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::UnsupportedQoS*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mUnsupportedQoS,
                    _0RL_CosNotification_mUnsupportedQoS_unmarshal_fn,
                    _0RL_CosNotification_mUnsupportedQoS_marshal_fn,
                    _0RL_CosNotification_mUnsupportedQoS_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::UnsupportedQoS*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNotification_mUnsupportedQoS(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNotification::UnsupportedQoS & _ex = (const CosNotification::UnsupportedQoS &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNotification_mUnsupportedQoS (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNotification::UnsupportedQoS* _ex = (const CosNotification::UnsupportedQoS*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedQoS {
public:
  _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedQoS() {
    CosNotification::UnsupportedQoS::insertToAnyFn = _0RL_insertToAny__cCosNotification_mUnsupportedQoS;
    CosNotification::UnsupportedQoS::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNotification_mUnsupportedQoS;
  }
};
static _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedQoS _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedQoS_;


static void _0RL_CosNotification_mUnsupportedAdmin_marshal_fn(cdrStream& _s, void* _v)
{
  const CosNotification::UnsupportedAdmin* _p = (const CosNotification::UnsupportedAdmin*)_v;
  ::CORBA::Any::PR_marshalExceptionRepoId(_s, _p->_rep_id());
  *_p >>= _s;
}
static void _0RL_CosNotification_mUnsupportedAdmin_unmarshal_fn(cdrStream& _s, void*& _v)
{
  ::CORBA::Any::PR_unmarshalExceptionRepoId(_s);
  CosNotification::UnsupportedAdmin* _p = new CosNotification::UnsupportedAdmin;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mUnsupportedAdmin_destructor_fn(void* _v)
{
  CosNotification::UnsupportedAdmin* _p = (CosNotification::UnsupportedAdmin*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::UnsupportedAdmin& _s)
{
  CosNotification::UnsupportedAdmin* _p = new CosNotification::UnsupportedAdmin(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mUnsupportedAdmin,
               _0RL_CosNotification_mUnsupportedAdmin_marshal_fn,
               _0RL_CosNotification_mUnsupportedAdmin_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const CosNotification::UnsupportedAdmin* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mUnsupportedAdmin,
               _0RL_CosNotification_mUnsupportedAdmin_marshal_fn,
               _0RL_CosNotification_mUnsupportedAdmin_destructor_fn,
               (CosNotification::UnsupportedAdmin*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::UnsupportedAdmin*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mUnsupportedAdmin,
                    _0RL_CosNotification_mUnsupportedAdmin_unmarshal_fn,
                    _0RL_CosNotification_mUnsupportedAdmin_marshal_fn,
                    _0RL_CosNotification_mUnsupportedAdmin_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::UnsupportedAdmin*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cCosNotification_mUnsupportedAdmin(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const CosNotification::UnsupportedAdmin & _ex = (const CosNotification::UnsupportedAdmin &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cCosNotification_mUnsupportedAdmin (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const CosNotification::UnsupportedAdmin* _ex = (const CosNotification::UnsupportedAdmin*) _e;
  operator<<=(_a,_ex);
}

class _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedAdmin {
public:
  _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedAdmin() {
    CosNotification::UnsupportedAdmin::insertToAnyFn = _0RL_insertToAny__cCosNotification_mUnsupportedAdmin;
    CosNotification::UnsupportedAdmin::insertToAnyFnNCP = _0RL_insertToAnyNCP__cCosNotification_mUnsupportedAdmin;
  }
};
static _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedAdmin _0RL_insertToAny_Singleton__cCosNotification_mUnsupportedAdmin_;

static void _0RL_CosNotification_mFixedEventHeader_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::FixedEventHeader* _p = (CosNotification::FixedEventHeader*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mFixedEventHeader_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::FixedEventHeader* _p = new CosNotification::FixedEventHeader;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mFixedEventHeader_destructor_fn(void* _v)
{
  CosNotification::FixedEventHeader* _p = (CosNotification::FixedEventHeader*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::FixedEventHeader& _s)
{
  CosNotification::FixedEventHeader* _p = new CosNotification::FixedEventHeader(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mFixedEventHeader,
               _0RL_CosNotification_mFixedEventHeader_marshal_fn,
               _0RL_CosNotification_mFixedEventHeader_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::FixedEventHeader* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mFixedEventHeader,
               _0RL_CosNotification_mFixedEventHeader_marshal_fn,
               _0RL_CosNotification_mFixedEventHeader_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::FixedEventHeader*& _sp)
{
  return _a >>= (const CosNotification::FixedEventHeader*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::FixedEventHeader*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mFixedEventHeader,
                    _0RL_CosNotification_mFixedEventHeader_unmarshal_fn,
                    _0RL_CosNotification_mFixedEventHeader_marshal_fn,
                    _0RL_CosNotification_mFixedEventHeader_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::FixedEventHeader*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mEventHeader_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::EventHeader* _p = (CosNotification::EventHeader*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mEventHeader_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::EventHeader* _p = new CosNotification::EventHeader;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mEventHeader_destructor_fn(void* _v)
{
  CosNotification::EventHeader* _p = (CosNotification::EventHeader*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::EventHeader& _s)
{
  CosNotification::EventHeader* _p = new CosNotification::EventHeader(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mEventHeader,
               _0RL_CosNotification_mEventHeader_marshal_fn,
               _0RL_CosNotification_mEventHeader_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::EventHeader* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mEventHeader,
               _0RL_CosNotification_mEventHeader_marshal_fn,
               _0RL_CosNotification_mEventHeader_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::EventHeader*& _sp)
{
  return _a >>= (const CosNotification::EventHeader*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::EventHeader*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mEventHeader,
                    _0RL_CosNotification_mEventHeader_unmarshal_fn,
                    _0RL_CosNotification_mEventHeader_marshal_fn,
                    _0RL_CosNotification_mEventHeader_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::EventHeader*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mStructuredEvent_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::StructuredEvent* _p = (CosNotification::StructuredEvent*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mStructuredEvent_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::StructuredEvent* _p = new CosNotification::StructuredEvent;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mStructuredEvent_destructor_fn(void* _v)
{
  CosNotification::StructuredEvent* _p = (CosNotification::StructuredEvent*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::StructuredEvent& _s)
{
  CosNotification::StructuredEvent* _p = new CosNotification::StructuredEvent(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mStructuredEvent,
               _0RL_CosNotification_mStructuredEvent_marshal_fn,
               _0RL_CosNotification_mStructuredEvent_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::StructuredEvent* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mStructuredEvent,
               _0RL_CosNotification_mStructuredEvent_marshal_fn,
               _0RL_CosNotification_mStructuredEvent_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::StructuredEvent*& _sp)
{
  return _a >>= (const CosNotification::StructuredEvent*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::StructuredEvent*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mStructuredEvent,
                    _0RL_CosNotification_mStructuredEvent_unmarshal_fn,
                    _0RL_CosNotification_mStructuredEvent_marshal_fn,
                    _0RL_CosNotification_mStructuredEvent_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::StructuredEvent*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mEventBatch_marshal_fn(cdrStream& _s, void* _v)
{
  CosNotification::EventBatch* _p = (CosNotification::EventBatch*)_v;
  *_p >>= _s;
}
static void _0RL_CosNotification_mEventBatch_unmarshal_fn(cdrStream& _s, void*& _v)
{
  CosNotification::EventBatch* _p = new CosNotification::EventBatch;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_CosNotification_mEventBatch_destructor_fn(void* _v)
{
  CosNotification::EventBatch* _p = (CosNotification::EventBatch*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const CosNotification::EventBatch& _s)
{
  CosNotification::EventBatch* _p = new CosNotification::EventBatch(_s);
  _a.PR_insert(_0RL_tc_CosNotification_mEventBatch,
               _0RL_CosNotification_mEventBatch_marshal_fn,
               _0RL_CosNotification_mEventBatch_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, CosNotification::EventBatch* _sp)
{
  _a.PR_insert(_0RL_tc_CosNotification_mEventBatch,
               _0RL_CosNotification_mEventBatch_marshal_fn,
               _0RL_CosNotification_mEventBatch_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::EventBatch*& _sp)
{
  return _a >>= (const CosNotification::EventBatch*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const CosNotification::EventBatch*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_CosNotification_mEventBatch,
                    _0RL_CosNotification_mEventBatch_unmarshal_fn,
                    _0RL_CosNotification_mEventBatch_marshal_fn,
                    _0RL_CosNotification_mEventBatch_destructor_fn,
                    _v)) {
    _sp = (const CosNotification::EventBatch*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mQoSAdmin_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_CosNotification_mQoSAdmin_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(CosNotification::QoSAdmin::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_CosNotification_mQoSAdmin_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, CosNotification::QoSAdmin_ptr _o)
{
  CosNotification::QoSAdmin_ptr _no = CosNotification::QoSAdmin::_duplicate(_o);
  _a.PR_insert(CosNotification::_tc_QoSAdmin,
               _0RL_CosNotification_mQoSAdmin_marshal_fn,
               _0RL_CosNotification_mQoSAdmin_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, CosNotification::QoSAdmin_ptr* _op)
{
  _a.PR_insert(CosNotification::_tc_QoSAdmin,
               _0RL_CosNotification_mQoSAdmin_marshal_fn,
               _0RL_CosNotification_mQoSAdmin_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = CosNotification::QoSAdmin::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::QoSAdmin_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(CosNotification::_tc_QoSAdmin,
                    _0RL_CosNotification_mQoSAdmin_unmarshal_fn,
                    _0RL_CosNotification_mQoSAdmin_marshal_fn,
                    _0RL_CosNotification_mQoSAdmin_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (CosNotification::QoSAdmin_ptr)_r->_ptrToObjRef(CosNotification::QoSAdmin::_PD_repoId);
    else
      _o = CosNotification::QoSAdmin::_nil();
    return 1;
  }
  return 0;
}

static void _0RL_CosNotification_mAdminPropertiesAdmin_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_CosNotification_mAdminPropertiesAdmin_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(CosNotification::AdminPropertiesAdmin::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_CosNotification_mAdminPropertiesAdmin_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, CosNotification::AdminPropertiesAdmin_ptr _o)
{
  CosNotification::AdminPropertiesAdmin_ptr _no = CosNotification::AdminPropertiesAdmin::_duplicate(_o);
  _a.PR_insert(CosNotification::_tc_AdminPropertiesAdmin,
               _0RL_CosNotification_mAdminPropertiesAdmin_marshal_fn,
               _0RL_CosNotification_mAdminPropertiesAdmin_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, CosNotification::AdminPropertiesAdmin_ptr* _op)
{
  _a.PR_insert(CosNotification::_tc_AdminPropertiesAdmin,
               _0RL_CosNotification_mAdminPropertiesAdmin_marshal_fn,
               _0RL_CosNotification_mAdminPropertiesAdmin_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = CosNotification::AdminPropertiesAdmin::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, CosNotification::AdminPropertiesAdmin_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(CosNotification::_tc_AdminPropertiesAdmin,
                    _0RL_CosNotification_mAdminPropertiesAdmin_unmarshal_fn,
                    _0RL_CosNotification_mAdminPropertiesAdmin_marshal_fn,
                    _0RL_CosNotification_mAdminPropertiesAdmin_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (CosNotification::AdminPropertiesAdmin_ptr)_r->_ptrToObjRef(CosNotification::AdminPropertiesAdmin::_PD_repoId);
    else
      _o = CosNotification::AdminPropertiesAdmin::_nil();
    return 1;
  }
  return 0;
}

