Logo Search packages:      
Sourcecode: tango version File versions  Download package

tangoDynSK.cpp

// This file is generated by omniidl (C++ backend) - omniORB_4_1. Do not edit.
//
// Copyright (C) :      2004,2005,2006,2007,2008,2009,2010,2011
//                                  European Synchrotron Radiation Facility
//                      BP 220, Grenoble 38043
//                      FRANCE
//
// This file is part of Tango.
//
// Tango is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// Tango is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with Tango.  If not, see <http://www.gnu.org/licenses/>.
//

#include "tango.h"

OMNI_USING_NAMESPACE(omni)

static const char* _0RL_dyn_library_version = omniORB_4_1_dyn;

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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevBoolean = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevBoolean:1.0", "DevBoolean", CORBA::TypeCode::PR_boolean_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevDouble = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevDouble:1.0", "DevDouble", CORBA::TypeCode::PR_double_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevFloat = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevFloat:1.0", "DevFloat", CORBA::TypeCode::PR_float_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevShort = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevShort:1.0", "DevShort", CORBA::TypeCode::PR_short_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevLong = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevLong:1.0", "DevLong", CORBA::TypeCode::PR_long_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevLong64 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevLong64:1.0", "DevLong64", CORBA::TypeCode::PR_longlong_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevString = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevString:1.0", "DevString", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevUChar = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevUChar:1.0", "DevUChar", CORBA::TypeCode::PR_octet_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevUShort = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevUShort:1.0", "DevUShort", CORBA::TypeCode::PR_ushort_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevULong = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevULong:1.0", "DevULong", CORBA::TypeCode::PR_ulong_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevULong64 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevULong64:1.0", "DevULong64", CORBA::TypeCode::PR_ulonglong_tc(), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarBooleanArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarBooleanArray:1.0", "DevVarBooleanArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_boolean_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarDoubleArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarDoubleArray:1.0", "DevVarDoubleArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_double_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarFloatArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarFloatArray:1.0", "DevVarFloatArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_float_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarShortArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarShortArray:1.0", "DevVarShortArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_short_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarLongArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarLongArray:1.0", "DevVarLongArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_long_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarLong64Array = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarLong64Array:1.0", "DevVarLong64Array", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_longlong_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarCharArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarCharArray:1.0", "DevVarCharArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_octet_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarStringArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarStringArray:1.0", "DevVarStringArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarUShortArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarUShortArray:1.0", "DevVarUShortArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_ushort_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarULongArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarULongArray:1.0", "DevVarULongArray", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_ulong_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarULong64Array = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarULong64Array:1.0", "DevVarULong64Array", CORBA::TypeCode::PR_sequence_tc(0, CORBA::TypeCode::PR_ulonglong_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_Tango_mDevVarLongStringArray[] = {
  {"lvalue", _0RL_tc_Tango_mDevVarLongArray},
  {"svalue", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mDevVarLongStringArray
#  undef _0RL_tc_Tango_mDevVarLongStringArray
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarLongStringArray = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevVarLongStringArray:1.0", "DevVarLongStringArray", _0RL_structmember_Tango_mDevVarLongStringArray, 2, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mDevVarDoubleStringArray[] = {
  {"dvalue", _0RL_tc_Tango_mDevVarDoubleArray},
  {"svalue", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mDevVarDoubleStringArray
#  undef _0RL_tc_Tango_mDevVarDoubleStringArray
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarDoubleStringArray = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevVarDoubleStringArray:1.0", "DevVarDoubleStringArray", _0RL_structmember_Tango_mDevVarDoubleStringArray, 2, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mDevEncoded[] = {
  {"encoded_format", _0RL_tc_Tango_mDevString},
  {"encoded_data", _0RL_tc_Tango_mDevVarCharArray}
};

#ifdef _0RL_tc_Tango_mDevEncoded
#  undef _0RL_tc_Tango_mDevEncoded
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevEncoded = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevEncoded:1.0", "DevEncoded", _0RL_structmember_Tango_mDevEncoded, 2, &_0RL_tcTrack);

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






static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarEncodedArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarEncodedArray:1.0", "DevVarEncodedArray", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevEncoded, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mJavaUUID = CORBA::TypeCode::PR_alias_tc("IDL:Tango/JavaUUID:1.0", "JavaUUID", CORBA::TypeCode::PR_array_tc(2, CORBA::TypeCode::PR_ulonglong_tc(), &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mCppClntIdent = CORBA::TypeCode::PR_alias_tc("IDL:Tango/CppClntIdent:1.0", "CppClntIdent", CORBA::TypeCode::PR_ulong_tc(), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_Tango_mJavaClntIdent[] = {
  {"MainClass", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"uuid", _0RL_tc_Tango_mJavaUUID}
};

#ifdef _0RL_tc_Tango_mJavaClntIdent
#  undef _0RL_tc_Tango_mJavaClntIdent
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mJavaClntIdent = CORBA::TypeCode::PR_struct_tc("IDL:Tango/JavaClntIdent:1.0", "JavaClntIdent", _0RL_structmember_Tango_mJavaClntIdent, 2, &_0RL_tcTrack);

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


static const char* _0RL_enumMember_Tango_mLockerLanguage[] = { "CPP", "JAVA" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mLockerLanguage = CORBA::TypeCode::PR_enum_tc("IDL:Tango/LockerLanguage:1.0", "LockerLanguage", _0RL_enumMember_Tango_mLockerLanguage, 2, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_LockerLanguage = _0RL_tc_Tango_mLockerLanguage;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_LockerLanguage = _0RL_tc_Tango_mLockerLanguage;
#endif


static CORBA::PR_unionMember _0RL_unionMember_Tango_mClntIdent[] = {
  {"cpp_clnt", _0RL_tc_Tango_mCppClntIdent, Tango::CPP},
  {"java_clnt", _0RL_tc_Tango_mJavaClntIdent, Tango::JAVA}
};
#ifdef _0RL_tc_Tango_mClntIdent
#  undef _0RL_tc_Tango_mClntIdent
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mClntIdent = CORBA::TypeCode::PR_union_tc("IDL:Tango/ClntIdent:1.0", "ClntIdent", _0RL_tc_Tango_mLockerLanguage, _0RL_unionMember_Tango_mClntIdent, 2, -1, &_0RL_tcTrack);

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


static const char* _0RL_enumMember_Tango_mAttrQuality[] = { "ATTR_VALID", "ATTR_INVALID", "ATTR_ALARM", "ATTR_CHANGING", "ATTR_WARNING" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttrQuality = CORBA::TypeCode::PR_enum_tc("IDL:Tango/AttrQuality:1.0", "AttrQuality", _0RL_enumMember_Tango_mAttrQuality, 5, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_AttrQuality = _0RL_tc_Tango_mAttrQuality;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_AttrQuality = _0RL_tc_Tango_mAttrQuality;
#endif

static const char* _0RL_enumMember_Tango_mAttrWriteType[] = { "READ", "READ_WITH_WRITE", "WRITE", "READ_WRITE" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttrWriteType = CORBA::TypeCode::PR_enum_tc("IDL:Tango/AttrWriteType:1.0", "AttrWriteType", _0RL_enumMember_Tango_mAttrWriteType, 4, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_AttrWriteType = _0RL_tc_Tango_mAttrWriteType;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_AttrWriteType = _0RL_tc_Tango_mAttrWriteType;
#endif

static const char* _0RL_enumMember_Tango_mAttrDataFormat[] = { "SCALAR", "SPECTRUM", "IMAGE", "FMT_UNKNOWN" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttrDataFormat = CORBA::TypeCode::PR_enum_tc("IDL:Tango/AttrDataFormat:1.0", "AttrDataFormat", _0RL_enumMember_Tango_mAttrDataFormat, 4, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_AttrDataFormat = _0RL_tc_Tango_mAttrDataFormat;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_AttrDataFormat = _0RL_tc_Tango_mAttrDataFormat;
#endif

static const char* _0RL_enumMember_Tango_mDevSource[] = { "DEV", "CACHE", "CACHE_DEV" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevSource = CORBA::TypeCode::PR_enum_tc("IDL:Tango/DevSource:1.0", "DevSource", _0RL_enumMember_Tango_mDevSource, 3, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_DevSource = _0RL_tc_Tango_mDevSource;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_DevSource = _0RL_tc_Tango_mDevSource;
#endif

static const char* _0RL_enumMember_Tango_mErrSeverity[] = { "WARN", "ERR", "PANIC" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mErrSeverity = CORBA::TypeCode::PR_enum_tc("IDL:Tango/ErrSeverity:1.0", "ErrSeverity", _0RL_enumMember_Tango_mErrSeverity, 3, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_ErrSeverity = _0RL_tc_Tango_mErrSeverity;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_ErrSeverity = _0RL_tc_Tango_mErrSeverity;
#endif

static const char* _0RL_enumMember_Tango_mDevState[] = { "ON", "OFF", "CLOSE", "OPEN", "INSERT", "EXTRACT", "MOVING", "STANDBY", "FAULT", "INIT", "RUNNING", "ALARM", "DISABLE", "UNKNOWN" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevState = CORBA::TypeCode::PR_enum_tc("IDL:Tango/DevState:1.0", "DevState", _0RL_enumMember_Tango_mDevState, 14, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_DevState = _0RL_tc_Tango_mDevState;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_DevState = _0RL_tc_Tango_mDevState;
#endif

static const char* _0RL_enumMember_Tango_mDispLevel[] = { "OPERATOR", "EXPERT" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDispLevel = CORBA::TypeCode::PR_enum_tc("IDL:Tango/DispLevel:1.0", "DispLevel", _0RL_enumMember_Tango_mDispLevel, 2, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_DispLevel = _0RL_tc_Tango_mDispLevel;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_DispLevel = _0RL_tc_Tango_mDispLevel;
#endif

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevVarStateArray = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevVarStateArray:1.0", "DevVarStateArray", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevState, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_Tango_mTimeVal[] = {
  {"tv_sec", CORBA::TypeCode::PR_long_tc()},
  {"tv_usec", CORBA::TypeCode::PR_long_tc()},
  {"tv_nsec", CORBA::TypeCode::PR_long_tc()}
};

#ifdef _0RL_tc_Tango_mTimeVal
#  undef _0RL_tc_Tango_mTimeVal
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mTimeVal = CORBA::TypeCode::PR_struct_tc("IDL:Tango/TimeVal:1.0", "TimeVal", _0RL_structmember_Tango_mTimeVal, 3, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mDevCmdInfo[] = {
  {"cmd_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"cmd_tag", CORBA::TypeCode::PR_long_tc()},
  {"in_type", CORBA::TypeCode::PR_long_tc()},
  {"out_type", CORBA::TypeCode::PR_long_tc()},
  {"in_type_desc", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"out_type_desc", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}
};

#ifdef _0RL_tc_Tango_mDevCmdInfo
#  undef _0RL_tc_Tango_mDevCmdInfo
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevCmdInfo = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevCmdInfo:1.0", "DevCmdInfo", _0RL_structmember_Tango_mDevCmdInfo, 6, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mDevCmdInfo__2[] = {
  {"cmd_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"level", _0RL_tc_Tango_mDispLevel},
  {"cmd_tag", CORBA::TypeCode::PR_long_tc()},
  {"in_type", CORBA::TypeCode::PR_long_tc()},
  {"out_type", CORBA::TypeCode::PR_long_tc()},
  {"in_type_desc", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"out_type_desc", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}
};

#ifdef _0RL_tc_Tango_mDevCmdInfo__2
#  undef _0RL_tc_Tango_mDevCmdInfo__2
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevCmdInfo__2 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevCmdInfo_2:1.0", "DevCmdInfo_2", _0RL_structmember_Tango_mDevCmdInfo__2, 7, &_0RL_tcTrack);

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






static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevCmdInfoList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevCmdInfoList:1.0", "DevCmdInfoList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevCmdInfo, &_0RL_tcTrack), &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevCmdInfoList__2 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevCmdInfoList_2:1.0", "DevCmdInfoList_2", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevCmdInfo__2, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_Tango_mDevError[] = {
  {"reason", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"severity", _0RL_tc_Tango_mErrSeverity},
  {"desc", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"origin", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}
};

#ifdef _0RL_tc_Tango_mDevError
#  undef _0RL_tc_Tango_mDevError
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevError = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevError:1.0", "DevError", _0RL_structmember_Tango_mDevError, 4, &_0RL_tcTrack);

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






static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevErrorList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevErrorList:1.0", "DevErrorList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevError, &_0RL_tcTrack), &_0RL_tcTrack);


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


static CORBA::PR_structMember _0RL_structmember_Tango_mNamedDevError[] = {
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"index_in_call", CORBA::TypeCode::PR_long_tc()},
  {"err_list", _0RL_tc_Tango_mDevErrorList}
};

#ifdef _0RL_tc_Tango_mNamedDevError
#  undef _0RL_tc_Tango_mNamedDevError
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mNamedDevError = CORBA::TypeCode::PR_struct_tc("IDL:Tango/NamedDevError:1.0", "NamedDevError", _0RL_structmember_Tango_mNamedDevError, 3, &_0RL_tcTrack);


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










static CORBA::TypeCode_ptr _0RL_tc_Tango_mNamedDevErrorList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/NamedDevErrorList:1.0", "NamedDevErrorList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mNamedDevError, &_0RL_tcTrack), &_0RL_tcTrack);


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


static CORBA::PR_structMember _0RL_structmember_Tango_mDevFailed[] = {
  {"errors", _0RL_tc_Tango_mDevErrorList}
};

static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevFailed = CORBA::TypeCode::PR_exception_tc("IDL:Tango/DevFailed:1.0", "DevFailed", _0RL_structmember_Tango_mDevFailed, 1, &_0RL_tcTrack);

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




static CORBA::PR_structMember _0RL_structmember_Tango_mMultiDevFailed[] = {
  {"errors", _0RL_tc_Tango_mNamedDevErrorList}
};

static CORBA::TypeCode_ptr _0RL_tc_Tango_mMultiDevFailed = CORBA::TypeCode::PR_exception_tc("IDL:Tango/MultiDevFailed:1.0", "MultiDevFailed", _0RL_structmember_Tango_mMultiDevFailed, 1, &_0RL_tcTrack);


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


static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeConfig[] = {
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"writable", _0RL_tc_Tango_mAttrWriteType},
  {"data_format", _0RL_tc_Tango_mAttrDataFormat},
  {"data_type", CORBA::TypeCode::PR_long_tc()},
  {"max_dim_x", CORBA::TypeCode::PR_long_tc()},
  {"max_dim_y", CORBA::TypeCode::PR_long_tc()},
  {"description", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"label", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"standard_unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"display_unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"format", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"min_value", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"max_value", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"min_alarm", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"max_alarm", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"writable_attr_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"extensions", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mAttributeConfig
#  undef _0RL_tc_Tango_mAttributeConfig
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeConfig = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeConfig:1.0", "AttributeConfig", _0RL_structmember_Tango_mAttributeConfig, 18, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeConfig__2[] = {
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"writable", _0RL_tc_Tango_mAttrWriteType},
  {"data_format", _0RL_tc_Tango_mAttrDataFormat},
  {"data_type", CORBA::TypeCode::PR_long_tc()},
  {"max_dim_x", CORBA::TypeCode::PR_long_tc()},
  {"max_dim_y", CORBA::TypeCode::PR_long_tc()},
  {"description", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"label", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"standard_unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"display_unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"format", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"min_value", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"max_value", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"min_alarm", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"max_alarm", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"writable_attr_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"level", _0RL_tc_Tango_mDispLevel},
  {"extensions", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mAttributeConfig__2
#  undef _0RL_tc_Tango_mAttributeConfig__2
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeConfig__2 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeConfig_2:1.0", "AttributeConfig_2", _0RL_structmember_Tango_mAttributeConfig__2, 19, &_0RL_tcTrack);

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



static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeValue[] = {
  {"value", CORBA::TypeCode::PR_any_tc()},
  {"quality", _0RL_tc_Tango_mAttrQuality},
  {"time", _0RL_tc_Tango_mTimeVal},
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"dim_x", CORBA::TypeCode::PR_long_tc()},
  {"dim_y", CORBA::TypeCode::PR_long_tc()}
};

#ifdef _0RL_tc_Tango_mAttributeValue
#  undef _0RL_tc_Tango_mAttributeValue
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeValue = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeValue:1.0", "AttributeValue", _0RL_structmember_Tango_mAttributeValue, 6, &_0RL_tcTrack);


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


static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeDim[] = {
  {"dim_x", CORBA::TypeCode::PR_long_tc()},
  {"dim_y", CORBA::TypeCode::PR_long_tc()}
};

#ifdef _0RL_tc_Tango_mAttributeDim
#  undef _0RL_tc_Tango_mAttributeDim
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeDim = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeDim:1.0", "AttributeDim", _0RL_structmember_Tango_mAttributeDim, 2, &_0RL_tcTrack);

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






static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeValue__3[] = {
  {"value", CORBA::TypeCode::PR_any_tc()},
  {"quality", _0RL_tc_Tango_mAttrQuality},
  {"time", _0RL_tc_Tango_mTimeVal},
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"r_dim", _0RL_tc_Tango_mAttributeDim},
  {"w_dim", _0RL_tc_Tango_mAttributeDim},
  {"err_list", _0RL_tc_Tango_mDevErrorList}
};

#ifdef _0RL_tc_Tango_mAttributeValue__3
#  undef _0RL_tc_Tango_mAttributeValue__3
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeValue__3 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeValue_3:1.0", "AttributeValue_3", _0RL_structmember_Tango_mAttributeValue__3, 7, &_0RL_tcTrack);





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


static const char* _0RL_enumMember_Tango_mAttributeDataType[] = { "ATT_BOOL", "ATT_SHORT", "ATT_LONG", "ATT_LONG64", "ATT_FLOAT", "ATT_DOUBLE", "ATT_UCHAR", "ATT_USHORT", "ATT_ULONG", "ATT_ULONG64", "ATT_STRING", "ATT_STATE", "DEVICE_STATE", "ATT_ENCODED", "NO_DATA" };
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeDataType = CORBA::TypeCode::PR_enum_tc("IDL:Tango/AttributeDataType:1.0", "AttributeDataType", _0RL_enumMember_Tango_mAttributeDataType, 15, &_0RL_tcTrack);
#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_AttributeDataType = _0RL_tc_Tango_mAttributeDataType;
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_AttributeDataType = _0RL_tc_Tango_mAttributeDataType;
#endif


static CORBA::PR_unionMember _0RL_unionMember_Tango_mAttrValUnion[] = {
  {"bool_att_value", _0RL_tc_Tango_mDevVarBooleanArray, Tango::ATT_BOOL},
  {"short_att_value", _0RL_tc_Tango_mDevVarShortArray, Tango::ATT_SHORT},
  {"long_att_value", _0RL_tc_Tango_mDevVarLongArray, Tango::ATT_LONG},
  {"long64_att_value", _0RL_tc_Tango_mDevVarLong64Array, Tango::ATT_LONG64},
  {"float_att_value", _0RL_tc_Tango_mDevVarFloatArray, Tango::ATT_FLOAT},
  {"double_att_value", _0RL_tc_Tango_mDevVarDoubleArray, Tango::ATT_DOUBLE},
  {"uchar_att_value", _0RL_tc_Tango_mDevVarCharArray, Tango::ATT_UCHAR},
  {"ushort_att_value", _0RL_tc_Tango_mDevVarUShortArray, Tango::ATT_USHORT},
  {"ulong_att_value", _0RL_tc_Tango_mDevVarULongArray, Tango::ATT_ULONG},
  {"ulong64_att_value", _0RL_tc_Tango_mDevVarULong64Array, Tango::ATT_ULONG64},
  {"string_att_value", _0RL_tc_Tango_mDevVarStringArray, Tango::ATT_STRING},
  {"state_att_value", _0RL_tc_Tango_mDevVarStateArray, Tango::ATT_STATE},
  {"dev_state_att", _0RL_tc_Tango_mDevState, Tango::DEVICE_STATE},
  {"encoded_att_value", _0RL_tc_Tango_mDevVarEncodedArray, Tango::ATT_ENCODED},
  {"union_no_data", _0RL_tc_Tango_mDevBoolean, Tango::NO_DATA}
};
#ifdef _0RL_tc_Tango_mAttrValUnion
#  undef _0RL_tc_Tango_mAttrValUnion
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttrValUnion = CORBA::TypeCode::PR_union_tc("IDL:Tango/AttrValUnion:1.0", "AttrValUnion", _0RL_tc_Tango_mAttributeDataType, _0RL_unionMember_Tango_mAttrValUnion, 15, -1, &_0RL_tcTrack);

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






static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeValue__4[] = {
  {"value", _0RL_tc_Tango_mAttrValUnion},
  {"quality", _0RL_tc_Tango_mAttrQuality},
  {"data_format", _0RL_tc_Tango_mAttrDataFormat},
  {"time", _0RL_tc_Tango_mTimeVal},
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"r_dim", _0RL_tc_Tango_mAttributeDim},
  {"w_dim", _0RL_tc_Tango_mAttributeDim},
  {"err_list", _0RL_tc_Tango_mDevErrorList}
};

#ifdef _0RL_tc_Tango_mAttributeValue__4
#  undef _0RL_tc_Tango_mAttributeValue__4
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeValue__4 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeValue_4:1.0", "AttributeValue_4", _0RL_structmember_Tango_mAttributeValue__4, 8, &_0RL_tcTrack);





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


static CORBA::PR_structMember _0RL_structmember_Tango_mChangeEventProp[] = {
  {"rel_change", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"abs_change", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"extensions", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mChangeEventProp
#  undef _0RL_tc_Tango_mChangeEventProp
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mChangeEventProp = CORBA::TypeCode::PR_struct_tc("IDL:Tango/ChangeEventProp:1.0", "ChangeEventProp", _0RL_structmember_Tango_mChangeEventProp, 3, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mPeriodicEventProp[] = {
  {"period", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"extensions", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mPeriodicEventProp
#  undef _0RL_tc_Tango_mPeriodicEventProp
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mPeriodicEventProp = CORBA::TypeCode::PR_struct_tc("IDL:Tango/PeriodicEventProp:1.0", "PeriodicEventProp", _0RL_structmember_Tango_mPeriodicEventProp, 2, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mArchiveEventProp[] = {
  {"rel_change", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"abs_change", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"period", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"extensions", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mArchiveEventProp
#  undef _0RL_tc_Tango_mArchiveEventProp
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mArchiveEventProp = CORBA::TypeCode::PR_struct_tc("IDL:Tango/ArchiveEventProp:1.0", "ArchiveEventProp", _0RL_structmember_Tango_mArchiveEventProp, 4, &_0RL_tcTrack);

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





static CORBA::PR_structMember _0RL_structmember_Tango_mEventProperties[] = {
  {"ch_event", _0RL_tc_Tango_mChangeEventProp},
  {"per_event", _0RL_tc_Tango_mPeriodicEventProp},
  {"arch_event", _0RL_tc_Tango_mArchiveEventProp}
};

#ifdef _0RL_tc_Tango_mEventProperties
#  undef _0RL_tc_Tango_mEventProperties
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mEventProperties = CORBA::TypeCode::PR_struct_tc("IDL:Tango/EventProperties:1.0", "EventProperties", _0RL_structmember_Tango_mEventProperties, 3, &_0RL_tcTrack);




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


static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeAlarm[] = {
  {"min_alarm", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"max_alarm", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"min_warning", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"max_warning", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"delta_t", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"delta_val", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"extensions", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mAttributeAlarm
#  undef _0RL_tc_Tango_mAttributeAlarm
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeAlarm = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeAlarm:1.0", "AttributeAlarm", _0RL_structmember_Tango_mAttributeAlarm, 7, &_0RL_tcTrack);

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







static CORBA::PR_structMember _0RL_structmember_Tango_mAttributeConfig__3[] = {
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"writable", _0RL_tc_Tango_mAttrWriteType},
  {"data_format", _0RL_tc_Tango_mAttrDataFormat},
  {"data_type", CORBA::TypeCode::PR_long_tc()},
  {"max_dim_x", CORBA::TypeCode::PR_long_tc()},
  {"max_dim_y", CORBA::TypeCode::PR_long_tc()},
  {"description", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"label", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"standard_unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"display_unit", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"format", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"min_value", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"max_value", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"writable_attr_name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"level", _0RL_tc_Tango_mDispLevel},
  {"att_alarm", _0RL_tc_Tango_mAttributeAlarm},
  {"event_prop", _0RL_tc_Tango_mEventProperties},
  {"extensions", _0RL_tc_Tango_mDevVarStringArray},
  {"sys_extensions", _0RL_tc_Tango_mDevVarStringArray}
};

#ifdef _0RL_tc_Tango_mAttributeConfig__3
#  undef _0RL_tc_Tango_mAttributeConfig__3
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeConfig__3 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttributeConfig_3:1.0", "AttributeConfig_3", _0RL_structmember_Tango_mAttributeConfig__3, 20, &_0RL_tcTrack);






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






static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeConfigList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttributeConfigList:1.0", "AttributeConfigList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttributeConfig, &_0RL_tcTrack), &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeConfigList__2 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttributeConfigList_2:1.0", "AttributeConfigList_2", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttributeConfig__2, &_0RL_tcTrack), &_0RL_tcTrack);


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

























static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeConfigList__3 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttributeConfigList_3:1.0", "AttributeConfigList_3", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttributeConfig__3, &_0RL_tcTrack), &_0RL_tcTrack);


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









static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeValueList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttributeValueList:1.0", "AttributeValueList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttributeValue, &_0RL_tcTrack), &_0RL_tcTrack);


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





















static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeValueList__3 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttributeValueList_3:1.0", "AttributeValueList_3", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttributeValue__3, &_0RL_tcTrack), &_0RL_tcTrack);


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





















static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeValueList__4 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttributeValueList_4:1.0", "AttributeValueList_4", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttributeValue__4, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::PR_structMember _0RL_structmember_Tango_mAttDataReady[] = {
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"data_type", CORBA::TypeCode::PR_long_tc()},
  {"ctr", CORBA::TypeCode::PR_long_tc()}
};

#ifdef _0RL_tc_Tango_mAttDataReady
#  undef _0RL_tc_Tango_mAttDataReady
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttDataReady = CORBA::TypeCode::PR_struct_tc("IDL:Tango/AttDataReady:1.0", "AttDataReady", _0RL_structmember_Tango_mAttDataReady, 3, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mDevInfo[] = {
  {"dev_class", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"server_id", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"server_host", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"server_version", CORBA::TypeCode::PR_long_tc()},
  {"doc_url", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}
};

#ifdef _0RL_tc_Tango_mDevInfo
#  undef _0RL_tc_Tango_mDevInfo
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevInfo = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevInfo:1.0", "DevInfo", _0RL_structmember_Tango_mDevInfo, 5, &_0RL_tcTrack);

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


static CORBA::PR_structMember _0RL_structmember_Tango_mDevInfo__3[] = {
  {"dev_class", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"server_id", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"server_host", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"server_version", CORBA::TypeCode::PR_long_tc()},
  {"doc_url", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"dev_type", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)}
};

#ifdef _0RL_tc_Tango_mDevInfo__3
#  undef _0RL_tc_Tango_mDevInfo__3
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevInfo__3 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevInfo_3:1.0", "DevInfo_3", _0RL_structmember_Tango_mDevInfo__3, 6, &_0RL_tcTrack);

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




static CORBA::PR_structMember _0RL_structmember_Tango_mDevCmdHistory[] = {
  {"time", _0RL_tc_Tango_mTimeVal},
  {"cmd_failed", CORBA::TypeCode::PR_boolean_tc()},
  {"value", CORBA::TypeCode::PR_any_tc()},
  {"errors", _0RL_tc_Tango_mDevErrorList}
};

#ifdef _0RL_tc_Tango_mDevCmdHistory
#  undef _0RL_tc_Tango_mDevCmdHistory
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevCmdHistory = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevCmdHistory:1.0", "DevCmdHistory", _0RL_structmember_Tango_mDevCmdHistory, 4, &_0RL_tcTrack);



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














static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevCmdHistoryList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevCmdHistoryList:1.0", "DevCmdHistoryList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevCmdHistory, &_0RL_tcTrack), &_0RL_tcTrack);


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




static CORBA::PR_structMember _0RL_structmember_Tango_mDevAttrHistory[] = {
  {"attr_failed", CORBA::TypeCode::PR_boolean_tc()},
  {"value", _0RL_tc_Tango_mAttributeValue},
  {"errors", _0RL_tc_Tango_mDevErrorList}
};

#ifdef _0RL_tc_Tango_mDevAttrHistory
#  undef _0RL_tc_Tango_mDevAttrHistory
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevAttrHistory = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevAttrHistory:1.0", "DevAttrHistory", _0RL_structmember_Tango_mDevAttrHistory, 3, &_0RL_tcTrack);




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







static CORBA::PR_structMember _0RL_structmember_Tango_mDevAttrHistory__3[] = {
  {"attr_failed", CORBA::TypeCode::PR_boolean_tc()},
  {"value", _0RL_tc_Tango_mAttributeValue__3}
};

#ifdef _0RL_tc_Tango_mDevAttrHistory__3
#  undef _0RL_tc_Tango_mDevAttrHistory__3
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevAttrHistory__3 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevAttrHistory_3:1.0", "DevAttrHistory_3", _0RL_structmember_Tango_mDevAttrHistory__3, 2, &_0RL_tcTrack);






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


static CORBA::PR_structMember _0RL_structmember_Tango_mEltInArray[] = {
  {"start", CORBA::TypeCode::PR_long_tc()},
  {"nb_elt", CORBA::TypeCode::PR_long_tc()}
};

#ifdef _0RL_tc_Tango_mEltInArray
#  undef _0RL_tc_Tango_mEltInArray
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mEltInArray = CORBA::TypeCode::PR_struct_tc("IDL:Tango/EltInArray:1.0", "EltInArray", _0RL_structmember_Tango_mEltInArray, 2, &_0RL_tcTrack);

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






static CORBA::TypeCode_ptr _0RL_tc_Tango_mEltInArrayList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/EltInArrayList:1.0", "EltInArrayList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mEltInArray, &_0RL_tcTrack), &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_Tango_mTimeValList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/TimeValList:1.0", "TimeValList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mTimeVal, &_0RL_tcTrack), &_0RL_tcTrack);


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

static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttrQualityList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttrQualityList:1.0", "AttrQualityList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttrQuality, &_0RL_tcTrack), &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_Tango_mAttributeDimList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/AttributeDimList:1.0", "AttributeDimList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mAttributeDim, &_0RL_tcTrack), &_0RL_tcTrack);


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





static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevErrorListList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevErrorListList:1.0", "DevErrorListList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevErrorList, &_0RL_tcTrack), &_0RL_tcTrack);


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









static CORBA::PR_structMember _0RL_structmember_Tango_mDevAttrHistory__4[] = {
  {"name", CORBA::TypeCode::PR_string_tc(0, &_0RL_tcTrack)},
  {"dates", _0RL_tc_Tango_mTimeValList},
  {"value", CORBA::TypeCode::PR_any_tc()},
  {"quals", _0RL_tc_Tango_mAttrQualityList},
  {"quals_array", _0RL_tc_Tango_mEltInArrayList},
  {"r_dims", _0RL_tc_Tango_mAttributeDimList},
  {"r_dims_array", _0RL_tc_Tango_mEltInArrayList},
  {"w_dims", _0RL_tc_Tango_mAttributeDimList},
  {"w_dims_array", _0RL_tc_Tango_mEltInArrayList},
  {"errors", _0RL_tc_Tango_mDevErrorListList},
  {"errors_array", _0RL_tc_Tango_mEltInArrayList}
};

#ifdef _0RL_tc_Tango_mDevAttrHistory__4
#  undef _0RL_tc_Tango_mDevAttrHistory__4
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevAttrHistory__4 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevAttrHistory_4:1.0", "DevAttrHistory_4", _0RL_structmember_Tango_mDevAttrHistory__4, 11, &_0RL_tcTrack);









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







static CORBA::PR_structMember _0RL_structmember_Tango_mDevCmdHistory__4[] = {
  {"dates", _0RL_tc_Tango_mTimeValList},
  {"value", CORBA::TypeCode::PR_any_tc()},
  {"dims", _0RL_tc_Tango_mAttributeDimList},
  {"dims_array", _0RL_tc_Tango_mEltInArrayList},
  {"errors", _0RL_tc_Tango_mDevErrorListList},
  {"errors_array", _0RL_tc_Tango_mEltInArrayList},
  {"cmd_type", CORBA::TypeCode::PR_long_tc()}
};

#ifdef _0RL_tc_Tango_mDevCmdHistory__4
#  undef _0RL_tc_Tango_mDevCmdHistory__4
#endif
static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevCmdHistory__4 = CORBA::TypeCode::PR_struct_tc("IDL:Tango/DevCmdHistory_4:1.0", "DevCmdHistory_4", _0RL_structmember_Tango_mDevCmdHistory__4, 7, &_0RL_tcTrack);






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


















static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevAttrHistoryList = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevAttrHistoryList:1.0", "DevAttrHistoryList", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevAttrHistory, &_0RL_tcTrack), &_0RL_tcTrack);


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

























static CORBA::TypeCode_ptr _0RL_tc_Tango_mDevAttrHistoryList__3 = CORBA::TypeCode::PR_alias_tc("IDL:Tango/DevAttrHistoryList_3:1.0", "DevAttrHistoryList_3", CORBA::TypeCode::PR_sequence_tc(0, _0RL_tc_Tango_mDevAttrHistory__3, &_0RL_tcTrack), &_0RL_tcTrack);


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

#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_Device = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device:1.0", "Device", &_0RL_tcTrack);
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_Device = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device:1.0", "Device", &_0RL_tcTrack);
#endif

#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_Device_2 = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device_2:1.0", "Device_2", &_0RL_tcTrack);
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_Device_2 = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device_2:1.0", "Device_2", &_0RL_tcTrack);
#endif

#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_Device_3 = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device_3:1.0", "Device_3", &_0RL_tcTrack);
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_Device_3 = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device_3:1.0", "Device_3", &_0RL_tcTrack);
#endif

#if defined(HAS_Cplusplus_Namespace) && defined(_MSC_VER)
// MSVC++ does not give the constant external linkage otherwise.
namespace Tango { 
  const ::CORBA::TypeCode_ptr _tc_Device_4 = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device_4:1.0", "Device_4", &_0RL_tcTrack);
} 
#else
const ::CORBA::TypeCode_ptr Tango::_tc_Device_4 = CORBA::TypeCode::PR_interface_tc("IDL:Tango/Device_4:1.0", "Device_4", &_0RL_tcTrack);
#endif

static void _0RL_Tango_mDevVarBooleanArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarBooleanArray* _p = (Tango::DevVarBooleanArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarBooleanArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarBooleanArray* _p = new Tango::DevVarBooleanArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarBooleanArray_destructor_fn(void* _v)
{
  Tango::DevVarBooleanArray* _p = (Tango::DevVarBooleanArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarBooleanArray& _s)
{
  Tango::DevVarBooleanArray* _p = new Tango::DevVarBooleanArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarBooleanArray,
               _0RL_Tango_mDevVarBooleanArray_marshal_fn,
               _0RL_Tango_mDevVarBooleanArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarBooleanArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarBooleanArray,
               _0RL_Tango_mDevVarBooleanArray_marshal_fn,
               _0RL_Tango_mDevVarBooleanArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarBooleanArray*& _sp)
{
  return _a >>= (const Tango::DevVarBooleanArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarBooleanArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarBooleanArray,
                    _0RL_Tango_mDevVarBooleanArray_unmarshal_fn,
                    _0RL_Tango_mDevVarBooleanArray_marshal_fn,
                    _0RL_Tango_mDevVarBooleanArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarBooleanArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarDoubleArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarDoubleArray* _p = (Tango::DevVarDoubleArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarDoubleArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarDoubleArray* _p = new Tango::DevVarDoubleArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarDoubleArray_destructor_fn(void* _v)
{
  Tango::DevVarDoubleArray* _p = (Tango::DevVarDoubleArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarDoubleArray& _s)
{
  Tango::DevVarDoubleArray* _p = new Tango::DevVarDoubleArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarDoubleArray,
               _0RL_Tango_mDevVarDoubleArray_marshal_fn,
               _0RL_Tango_mDevVarDoubleArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarDoubleArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarDoubleArray,
               _0RL_Tango_mDevVarDoubleArray_marshal_fn,
               _0RL_Tango_mDevVarDoubleArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarDoubleArray*& _sp)
{
  return _a >>= (const Tango::DevVarDoubleArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarDoubleArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarDoubleArray,
                    _0RL_Tango_mDevVarDoubleArray_unmarshal_fn,
                    _0RL_Tango_mDevVarDoubleArray_marshal_fn,
                    _0RL_Tango_mDevVarDoubleArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarDoubleArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarFloatArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarFloatArray* _p = (Tango::DevVarFloatArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarFloatArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarFloatArray* _p = new Tango::DevVarFloatArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarFloatArray_destructor_fn(void* _v)
{
  Tango::DevVarFloatArray* _p = (Tango::DevVarFloatArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarFloatArray& _s)
{
  Tango::DevVarFloatArray* _p = new Tango::DevVarFloatArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarFloatArray,
               _0RL_Tango_mDevVarFloatArray_marshal_fn,
               _0RL_Tango_mDevVarFloatArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarFloatArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarFloatArray,
               _0RL_Tango_mDevVarFloatArray_marshal_fn,
               _0RL_Tango_mDevVarFloatArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarFloatArray*& _sp)
{
  return _a >>= (const Tango::DevVarFloatArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarFloatArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarFloatArray,
                    _0RL_Tango_mDevVarFloatArray_unmarshal_fn,
                    _0RL_Tango_mDevVarFloatArray_marshal_fn,
                    _0RL_Tango_mDevVarFloatArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarFloatArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarShortArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarShortArray* _p = (Tango::DevVarShortArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarShortArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarShortArray* _p = new Tango::DevVarShortArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarShortArray_destructor_fn(void* _v)
{
  Tango::DevVarShortArray* _p = (Tango::DevVarShortArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarShortArray& _s)
{
  Tango::DevVarShortArray* _p = new Tango::DevVarShortArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarShortArray,
               _0RL_Tango_mDevVarShortArray_marshal_fn,
               _0RL_Tango_mDevVarShortArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarShortArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarShortArray,
               _0RL_Tango_mDevVarShortArray_marshal_fn,
               _0RL_Tango_mDevVarShortArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarShortArray*& _sp)
{
  return _a >>= (const Tango::DevVarShortArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarShortArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarShortArray,
                    _0RL_Tango_mDevVarShortArray_unmarshal_fn,
                    _0RL_Tango_mDevVarShortArray_marshal_fn,
                    _0RL_Tango_mDevVarShortArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarShortArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarLongArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarLongArray* _p = (Tango::DevVarLongArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarLongArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarLongArray* _p = new Tango::DevVarLongArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarLongArray_destructor_fn(void* _v)
{
  Tango::DevVarLongArray* _p = (Tango::DevVarLongArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarLongArray& _s)
{
  Tango::DevVarLongArray* _p = new Tango::DevVarLongArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarLongArray,
               _0RL_Tango_mDevVarLongArray_marshal_fn,
               _0RL_Tango_mDevVarLongArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarLongArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarLongArray,
               _0RL_Tango_mDevVarLongArray_marshal_fn,
               _0RL_Tango_mDevVarLongArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarLongArray*& _sp)
{
  return _a >>= (const Tango::DevVarLongArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarLongArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarLongArray,
                    _0RL_Tango_mDevVarLongArray_unmarshal_fn,
                    _0RL_Tango_mDevVarLongArray_marshal_fn,
                    _0RL_Tango_mDevVarLongArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarLongArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarLong64Array_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarLong64Array* _p = (Tango::DevVarLong64Array*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarLong64Array_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarLong64Array* _p = new Tango::DevVarLong64Array;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarLong64Array_destructor_fn(void* _v)
{
  Tango::DevVarLong64Array* _p = (Tango::DevVarLong64Array*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarLong64Array& _s)
{
  Tango::DevVarLong64Array* _p = new Tango::DevVarLong64Array(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarLong64Array,
               _0RL_Tango_mDevVarLong64Array_marshal_fn,
               _0RL_Tango_mDevVarLong64Array_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarLong64Array* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarLong64Array,
               _0RL_Tango_mDevVarLong64Array_marshal_fn,
               _0RL_Tango_mDevVarLong64Array_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarLong64Array*& _sp)
{
  return _a >>= (const Tango::DevVarLong64Array*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarLong64Array*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarLong64Array,
                    _0RL_Tango_mDevVarLong64Array_unmarshal_fn,
                    _0RL_Tango_mDevVarLong64Array_marshal_fn,
                    _0RL_Tango_mDevVarLong64Array_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarLong64Array*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarCharArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarCharArray* _p = (Tango::DevVarCharArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarCharArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarCharArray* _p = new Tango::DevVarCharArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarCharArray_destructor_fn(void* _v)
{
  Tango::DevVarCharArray* _p = (Tango::DevVarCharArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarCharArray& _s)
{
  Tango::DevVarCharArray* _p = new Tango::DevVarCharArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarCharArray,
               _0RL_Tango_mDevVarCharArray_marshal_fn,
               _0RL_Tango_mDevVarCharArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarCharArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarCharArray,
               _0RL_Tango_mDevVarCharArray_marshal_fn,
               _0RL_Tango_mDevVarCharArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarCharArray*& _sp)
{
  return _a >>= (const Tango::DevVarCharArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarCharArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarCharArray,
                    _0RL_Tango_mDevVarCharArray_unmarshal_fn,
                    _0RL_Tango_mDevVarCharArray_marshal_fn,
                    _0RL_Tango_mDevVarCharArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarCharArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarStringArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarStringArray* _p = (Tango::DevVarStringArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarStringArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarStringArray* _p = new Tango::DevVarStringArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarStringArray_destructor_fn(void* _v)
{
  Tango::DevVarStringArray* _p = (Tango::DevVarStringArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarStringArray& _s)
{
  Tango::DevVarStringArray* _p = new Tango::DevVarStringArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarStringArray,
               _0RL_Tango_mDevVarStringArray_marshal_fn,
               _0RL_Tango_mDevVarStringArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarStringArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarStringArray,
               _0RL_Tango_mDevVarStringArray_marshal_fn,
               _0RL_Tango_mDevVarStringArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarStringArray*& _sp)
{
  return _a >>= (const Tango::DevVarStringArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarStringArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarStringArray,
                    _0RL_Tango_mDevVarStringArray_unmarshal_fn,
                    _0RL_Tango_mDevVarStringArray_marshal_fn,
                    _0RL_Tango_mDevVarStringArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarStringArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarUShortArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarUShortArray* _p = (Tango::DevVarUShortArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarUShortArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarUShortArray* _p = new Tango::DevVarUShortArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarUShortArray_destructor_fn(void* _v)
{
  Tango::DevVarUShortArray* _p = (Tango::DevVarUShortArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarUShortArray& _s)
{
  Tango::DevVarUShortArray* _p = new Tango::DevVarUShortArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarUShortArray,
               _0RL_Tango_mDevVarUShortArray_marshal_fn,
               _0RL_Tango_mDevVarUShortArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarUShortArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarUShortArray,
               _0RL_Tango_mDevVarUShortArray_marshal_fn,
               _0RL_Tango_mDevVarUShortArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarUShortArray*& _sp)
{
  return _a >>= (const Tango::DevVarUShortArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarUShortArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarUShortArray,
                    _0RL_Tango_mDevVarUShortArray_unmarshal_fn,
                    _0RL_Tango_mDevVarUShortArray_marshal_fn,
                    _0RL_Tango_mDevVarUShortArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarUShortArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarULongArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarULongArray* _p = (Tango::DevVarULongArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarULongArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarULongArray* _p = new Tango::DevVarULongArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarULongArray_destructor_fn(void* _v)
{
  Tango::DevVarULongArray* _p = (Tango::DevVarULongArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarULongArray& _s)
{
  Tango::DevVarULongArray* _p = new Tango::DevVarULongArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarULongArray,
               _0RL_Tango_mDevVarULongArray_marshal_fn,
               _0RL_Tango_mDevVarULongArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarULongArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarULongArray,
               _0RL_Tango_mDevVarULongArray_marshal_fn,
               _0RL_Tango_mDevVarULongArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarULongArray*& _sp)
{
  return _a >>= (const Tango::DevVarULongArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarULongArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarULongArray,
                    _0RL_Tango_mDevVarULongArray_unmarshal_fn,
                    _0RL_Tango_mDevVarULongArray_marshal_fn,
                    _0RL_Tango_mDevVarULongArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarULongArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarULong64Array_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarULong64Array* _p = (Tango::DevVarULong64Array*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarULong64Array_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarULong64Array* _p = new Tango::DevVarULong64Array;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarULong64Array_destructor_fn(void* _v)
{
  Tango::DevVarULong64Array* _p = (Tango::DevVarULong64Array*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarULong64Array& _s)
{
  Tango::DevVarULong64Array* _p = new Tango::DevVarULong64Array(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarULong64Array,
               _0RL_Tango_mDevVarULong64Array_marshal_fn,
               _0RL_Tango_mDevVarULong64Array_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarULong64Array* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarULong64Array,
               _0RL_Tango_mDevVarULong64Array_marshal_fn,
               _0RL_Tango_mDevVarULong64Array_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarULong64Array*& _sp)
{
  return _a >>= (const Tango::DevVarULong64Array*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarULong64Array*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarULong64Array,
                    _0RL_Tango_mDevVarULong64Array_unmarshal_fn,
                    _0RL_Tango_mDevVarULong64Array_marshal_fn,
                    _0RL_Tango_mDevVarULong64Array_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarULong64Array*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarLongStringArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarLongStringArray* _p = (Tango::DevVarLongStringArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarLongStringArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarLongStringArray* _p = new Tango::DevVarLongStringArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarLongStringArray_destructor_fn(void* _v)
{
  Tango::DevVarLongStringArray* _p = (Tango::DevVarLongStringArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarLongStringArray& _s)
{
  Tango::DevVarLongStringArray* _p = new Tango::DevVarLongStringArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarLongStringArray,
               _0RL_Tango_mDevVarLongStringArray_marshal_fn,
               _0RL_Tango_mDevVarLongStringArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarLongStringArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarLongStringArray,
               _0RL_Tango_mDevVarLongStringArray_marshal_fn,
               _0RL_Tango_mDevVarLongStringArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarLongStringArray*& _sp)
{
  return _a >>= (const Tango::DevVarLongStringArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarLongStringArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarLongStringArray,
                    _0RL_Tango_mDevVarLongStringArray_unmarshal_fn,
                    _0RL_Tango_mDevVarLongStringArray_marshal_fn,
                    _0RL_Tango_mDevVarLongStringArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarLongStringArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarDoubleStringArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarDoubleStringArray* _p = (Tango::DevVarDoubleStringArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarDoubleStringArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarDoubleStringArray* _p = new Tango::DevVarDoubleStringArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarDoubleStringArray_destructor_fn(void* _v)
{
  Tango::DevVarDoubleStringArray* _p = (Tango::DevVarDoubleStringArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarDoubleStringArray& _s)
{
  Tango::DevVarDoubleStringArray* _p = new Tango::DevVarDoubleStringArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarDoubleStringArray,
               _0RL_Tango_mDevVarDoubleStringArray_marshal_fn,
               _0RL_Tango_mDevVarDoubleStringArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarDoubleStringArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarDoubleStringArray,
               _0RL_Tango_mDevVarDoubleStringArray_marshal_fn,
               _0RL_Tango_mDevVarDoubleStringArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarDoubleStringArray*& _sp)
{
  return _a >>= (const Tango::DevVarDoubleStringArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarDoubleStringArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarDoubleStringArray,
                    _0RL_Tango_mDevVarDoubleStringArray_unmarshal_fn,
                    _0RL_Tango_mDevVarDoubleStringArray_marshal_fn,
                    _0RL_Tango_mDevVarDoubleStringArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarDoubleStringArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevEncoded_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevEncoded* _p = (Tango::DevEncoded*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevEncoded_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevEncoded* _p = new Tango::DevEncoded;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevEncoded_destructor_fn(void* _v)
{
  Tango::DevEncoded* _p = (Tango::DevEncoded*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevEncoded& _s)
{
  Tango::DevEncoded* _p = new Tango::DevEncoded(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevEncoded,
               _0RL_Tango_mDevEncoded_marshal_fn,
               _0RL_Tango_mDevEncoded_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevEncoded* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevEncoded,
               _0RL_Tango_mDevEncoded_marshal_fn,
               _0RL_Tango_mDevEncoded_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevEncoded*& _sp)
{
  return _a >>= (const Tango::DevEncoded*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevEncoded*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevEncoded,
                    _0RL_Tango_mDevEncoded_unmarshal_fn,
                    _0RL_Tango_mDevEncoded_marshal_fn,
                    _0RL_Tango_mDevEncoded_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevEncoded*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevVarEncodedArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarEncodedArray* _p = (Tango::DevVarEncodedArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarEncodedArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarEncodedArray* _p = new Tango::DevVarEncodedArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarEncodedArray_destructor_fn(void* _v)
{
  Tango::DevVarEncodedArray* _p = (Tango::DevVarEncodedArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarEncodedArray& _s)
{
  Tango::DevVarEncodedArray* _p = new Tango::DevVarEncodedArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarEncodedArray,
               _0RL_Tango_mDevVarEncodedArray_marshal_fn,
               _0RL_Tango_mDevVarEncodedArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarEncodedArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarEncodedArray,
               _0RL_Tango_mDevVarEncodedArray_marshal_fn,
               _0RL_Tango_mDevVarEncodedArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarEncodedArray*& _sp)
{
  return _a >>= (const Tango::DevVarEncodedArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarEncodedArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarEncodedArray,
                    _0RL_Tango_mDevVarEncodedArray_unmarshal_fn,
                    _0RL_Tango_mDevVarEncodedArray_marshal_fn,
                    _0RL_Tango_mDevVarEncodedArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarEncodedArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mJavaUUID_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::JavaUUID_slice* _a = (Tango::JavaUUID_slice*)_v;
  if (! _s.marshal_byte_swap()) {
    _s.put_octet_array((_CORBA_Octet*)(_a),16,omni::ALIGN_8);
  }
  else 
  {
    _s.declareArrayLength(omni::ALIGN_8, 16);
    for (_CORBA_ULong _0i0 = 0; _0i0 < 2; _0i0++){
      _a[_0i0] >>= _s;
    }
  }

}
static void _0RL_Tango_mJavaUUID_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::JavaUUID_slice* _a = Tango::JavaUUID_alloc();
  _s.unmarshalArrayULongLong((_CORBA_ULongLong*)(_a), 2);

  _v = _a;
}
static void _0RL_Tango_mJavaUUID_destructor_fn(void* _v)
{
  Tango::JavaUUID_slice* _a = (Tango::JavaUUID_slice*)_v;
  Tango::JavaUUID_free(_a);
}

void operator<<=(::CORBA::Any& _a, const Tango::JavaUUID_forany& _s)
{
  Tango::JavaUUID_slice* _v;
  if (!_s.NP_nocopy())
    _v = Tango::JavaUUID_dup(_s);
  else
    _v = _s.NP_getSlice();

  _a.PR_insert(_0RL_tc_Tango_mJavaUUID,
               _0RL_Tango_mJavaUUID_marshal_fn,
               _0RL_Tango_mJavaUUID_destructor_fn,
               _v);
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::JavaUUID_forany& _s)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mJavaUUID,
                    _0RL_Tango_mJavaUUID_unmarshal_fn,
                    _0RL_Tango_mJavaUUID_marshal_fn,
                    _0RL_Tango_mJavaUUID_destructor_fn,
                    _v)) {
    _s = (Tango::JavaUUID_slice*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mJavaClntIdent_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::JavaClntIdent* _p = (Tango::JavaClntIdent*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mJavaClntIdent_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::JavaClntIdent* _p = new Tango::JavaClntIdent;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mJavaClntIdent_destructor_fn(void* _v)
{
  Tango::JavaClntIdent* _p = (Tango::JavaClntIdent*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::JavaClntIdent& _s)
{
  Tango::JavaClntIdent* _p = new Tango::JavaClntIdent(_s);
  _a.PR_insert(_0RL_tc_Tango_mJavaClntIdent,
               _0RL_Tango_mJavaClntIdent_marshal_fn,
               _0RL_Tango_mJavaClntIdent_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::JavaClntIdent* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mJavaClntIdent,
               _0RL_Tango_mJavaClntIdent_marshal_fn,
               _0RL_Tango_mJavaClntIdent_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::JavaClntIdent*& _sp)
{
  return _a >>= (const Tango::JavaClntIdent*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::JavaClntIdent*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mJavaClntIdent,
                    _0RL_Tango_mJavaClntIdent_unmarshal_fn,
                    _0RL_Tango_mJavaClntIdent_marshal_fn,
                    _0RL_Tango_mJavaClntIdent_destructor_fn,
                    _v)) {
    _sp = (const Tango::JavaClntIdent*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mLockerLanguage_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::LockerLanguage* _p = (Tango::LockerLanguage*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mLockerLanguage_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::LockerLanguage* _p = (Tango::LockerLanguage*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::LockerLanguage _s)
{
  _a.PR_insert(_0RL_tc_Tango_mLockerLanguage,
               _0RL_Tango_mLockerLanguage_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::LockerLanguage& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mLockerLanguage,
                       _0RL_Tango_mLockerLanguage_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mClntIdent_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::ClntIdent* _p = (Tango::ClntIdent*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mClntIdent_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::ClntIdent* _p = new Tango::ClntIdent;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mClntIdent_destructor_fn(void* _v)
{
  Tango::ClntIdent* _p = (Tango::ClntIdent*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::ClntIdent& _s)
{
  Tango::ClntIdent* _p = new Tango::ClntIdent(_s);
  _a.PR_insert(_0RL_tc_Tango_mClntIdent,
               _0RL_Tango_mClntIdent_marshal_fn,
               _0RL_Tango_mClntIdent_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::ClntIdent* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mClntIdent,
               _0RL_Tango_mClntIdent_marshal_fn,
               _0RL_Tango_mClntIdent_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::ClntIdent*& _sp)
{
  return _a >>= (const Tango::ClntIdent*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::ClntIdent*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mClntIdent,
                    _0RL_Tango_mClntIdent_unmarshal_fn,
                    _0RL_Tango_mClntIdent_marshal_fn,
                    _0RL_Tango_mClntIdent_destructor_fn,
                    _v)) {
    _sp = (const Tango::ClntIdent*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttrQuality_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttrQuality* _p = (Tango::AttrQuality*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttrQuality_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttrQuality* _p = (Tango::AttrQuality*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::AttrQuality _s)
{
  _a.PR_insert(_0RL_tc_Tango_mAttrQuality,
               _0RL_Tango_mAttrQuality_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrQuality& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mAttrQuality,
                       _0RL_Tango_mAttrQuality_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mAttrWriteType_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttrWriteType* _p = (Tango::AttrWriteType*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttrWriteType_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttrWriteType* _p = (Tango::AttrWriteType*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::AttrWriteType _s)
{
  _a.PR_insert(_0RL_tc_Tango_mAttrWriteType,
               _0RL_Tango_mAttrWriteType_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrWriteType& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mAttrWriteType,
                       _0RL_Tango_mAttrWriteType_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mAttrDataFormat_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttrDataFormat* _p = (Tango::AttrDataFormat*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttrDataFormat_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttrDataFormat* _p = (Tango::AttrDataFormat*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::AttrDataFormat _s)
{
  _a.PR_insert(_0RL_tc_Tango_mAttrDataFormat,
               _0RL_Tango_mAttrDataFormat_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrDataFormat& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mAttrDataFormat,
                       _0RL_Tango_mAttrDataFormat_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mDevSource_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevSource* _p = (Tango::DevSource*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevSource_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevSource* _p = (Tango::DevSource*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::DevSource _s)
{
  _a.PR_insert(_0RL_tc_Tango_mDevSource,
               _0RL_Tango_mDevSource_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevSource& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mDevSource,
                       _0RL_Tango_mDevSource_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mErrSeverity_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::ErrSeverity* _p = (Tango::ErrSeverity*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mErrSeverity_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::ErrSeverity* _p = (Tango::ErrSeverity*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::ErrSeverity _s)
{
  _a.PR_insert(_0RL_tc_Tango_mErrSeverity,
               _0RL_Tango_mErrSeverity_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::ErrSeverity& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mErrSeverity,
                       _0RL_Tango_mErrSeverity_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mDevState_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevState* _p = (Tango::DevState*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevState_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevState* _p = (Tango::DevState*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::DevState _s)
{
  _a.PR_insert(_0RL_tc_Tango_mDevState,
               _0RL_Tango_mDevState_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevState& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mDevState,
                       _0RL_Tango_mDevState_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mDispLevel_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DispLevel* _p = (Tango::DispLevel*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDispLevel_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DispLevel* _p = (Tango::DispLevel*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::DispLevel _s)
{
  _a.PR_insert(_0RL_tc_Tango_mDispLevel,
               _0RL_Tango_mDispLevel_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DispLevel& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mDispLevel,
                       _0RL_Tango_mDispLevel_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mDevVarStateArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevVarStateArray* _p = (Tango::DevVarStateArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevVarStateArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevVarStateArray* _p = new Tango::DevVarStateArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevVarStateArray_destructor_fn(void* _v)
{
  Tango::DevVarStateArray* _p = (Tango::DevVarStateArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevVarStateArray& _s)
{
  Tango::DevVarStateArray* _p = new Tango::DevVarStateArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevVarStateArray,
               _0RL_Tango_mDevVarStateArray_marshal_fn,
               _0RL_Tango_mDevVarStateArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevVarStateArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevVarStateArray,
               _0RL_Tango_mDevVarStateArray_marshal_fn,
               _0RL_Tango_mDevVarStateArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarStateArray*& _sp)
{
  return _a >>= (const Tango::DevVarStateArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarStateArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevVarStateArray,
                    _0RL_Tango_mDevVarStateArray_unmarshal_fn,
                    _0RL_Tango_mDevVarStateArray_marshal_fn,
                    _0RL_Tango_mDevVarStateArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevVarStateArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mTimeVal_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::TimeVal* _p = (Tango::TimeVal*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mTimeVal_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::TimeVal* _p = new Tango::TimeVal;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mTimeVal_destructor_fn(void* _v)
{
  Tango::TimeVal* _p = (Tango::TimeVal*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::TimeVal& _s)
{
  Tango::TimeVal* _p = new Tango::TimeVal(_s);
  _a.PR_insert(_0RL_tc_Tango_mTimeVal,
               _0RL_Tango_mTimeVal_marshal_fn,
               _0RL_Tango_mTimeVal_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::TimeVal* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mTimeVal,
               _0RL_Tango_mTimeVal_marshal_fn,
               _0RL_Tango_mTimeVal_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::TimeVal*& _sp)
{
  return _a >>= (const Tango::TimeVal*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::TimeVal*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mTimeVal,
                    _0RL_Tango_mTimeVal_unmarshal_fn,
                    _0RL_Tango_mTimeVal_marshal_fn,
                    _0RL_Tango_mTimeVal_destructor_fn,
                    _v)) {
    _sp = (const Tango::TimeVal*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevCmdInfo_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevCmdInfo* _p = (Tango::DevCmdInfo*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevCmdInfo_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevCmdInfo* _p = new Tango::DevCmdInfo;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevCmdInfo_destructor_fn(void* _v)
{
  Tango::DevCmdInfo* _p = (Tango::DevCmdInfo*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfo& _s)
{
  Tango::DevCmdInfo* _p = new Tango::DevCmdInfo(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfo,
               _0RL_Tango_mDevCmdInfo_marshal_fn,
               _0RL_Tango_mDevCmdInfo_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfo* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfo,
               _0RL_Tango_mDevCmdInfo_marshal_fn,
               _0RL_Tango_mDevCmdInfo_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfo*& _sp)
{
  return _a >>= (const Tango::DevCmdInfo*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfo*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevCmdInfo,
                    _0RL_Tango_mDevCmdInfo_unmarshal_fn,
                    _0RL_Tango_mDevCmdInfo_marshal_fn,
                    _0RL_Tango_mDevCmdInfo_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevCmdInfo*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevCmdInfo__2_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevCmdInfo_2* _p = (Tango::DevCmdInfo_2*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevCmdInfo__2_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevCmdInfo_2* _p = new Tango::DevCmdInfo_2;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevCmdInfo__2_destructor_fn(void* _v)
{
  Tango::DevCmdInfo_2* _p = (Tango::DevCmdInfo_2*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfo_2& _s)
{
  Tango::DevCmdInfo_2* _p = new Tango::DevCmdInfo_2(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfo__2,
               _0RL_Tango_mDevCmdInfo__2_marshal_fn,
               _0RL_Tango_mDevCmdInfo__2_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfo_2* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfo__2,
               _0RL_Tango_mDevCmdInfo__2_marshal_fn,
               _0RL_Tango_mDevCmdInfo__2_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfo_2*& _sp)
{
  return _a >>= (const Tango::DevCmdInfo_2*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfo_2*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevCmdInfo__2,
                    _0RL_Tango_mDevCmdInfo__2_unmarshal_fn,
                    _0RL_Tango_mDevCmdInfo__2_marshal_fn,
                    _0RL_Tango_mDevCmdInfo__2_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevCmdInfo_2*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevCmdInfoList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevCmdInfoList* _p = (Tango::DevCmdInfoList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevCmdInfoList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevCmdInfoList* _p = new Tango::DevCmdInfoList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevCmdInfoList_destructor_fn(void* _v)
{
  Tango::DevCmdInfoList* _p = (Tango::DevCmdInfoList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfoList& _s)
{
  Tango::DevCmdInfoList* _p = new Tango::DevCmdInfoList(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfoList,
               _0RL_Tango_mDevCmdInfoList_marshal_fn,
               _0RL_Tango_mDevCmdInfoList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfoList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfoList,
               _0RL_Tango_mDevCmdInfoList_marshal_fn,
               _0RL_Tango_mDevCmdInfoList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfoList*& _sp)
{
  return _a >>= (const Tango::DevCmdInfoList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfoList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevCmdInfoList,
                    _0RL_Tango_mDevCmdInfoList_unmarshal_fn,
                    _0RL_Tango_mDevCmdInfoList_marshal_fn,
                    _0RL_Tango_mDevCmdInfoList_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevCmdInfoList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevCmdInfoList__2_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevCmdInfoList_2* _p = (Tango::DevCmdInfoList_2*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevCmdInfoList__2_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevCmdInfoList_2* _p = new Tango::DevCmdInfoList_2;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevCmdInfoList__2_destructor_fn(void* _v)
{
  Tango::DevCmdInfoList_2* _p = (Tango::DevCmdInfoList_2*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfoList_2& _s)
{
  Tango::DevCmdInfoList_2* _p = new Tango::DevCmdInfoList_2(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfoList__2,
               _0RL_Tango_mDevCmdInfoList__2_marshal_fn,
               _0RL_Tango_mDevCmdInfoList__2_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfoList_2* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevCmdInfoList__2,
               _0RL_Tango_mDevCmdInfoList__2_marshal_fn,
               _0RL_Tango_mDevCmdInfoList__2_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfoList_2*& _sp)
{
  return _a >>= (const Tango::DevCmdInfoList_2*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfoList_2*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevCmdInfoList__2,
                    _0RL_Tango_mDevCmdInfoList__2_unmarshal_fn,
                    _0RL_Tango_mDevCmdInfoList__2_marshal_fn,
                    _0RL_Tango_mDevCmdInfoList__2_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevCmdInfoList_2*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevError_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevError* _p = (Tango::DevError*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevError_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevError* _p = new Tango::DevError;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevError_destructor_fn(void* _v)
{
  Tango::DevError* _p = (Tango::DevError*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevError& _s)
{
  Tango::DevError* _p = new Tango::DevError(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevError,
               _0RL_Tango_mDevError_marshal_fn,
               _0RL_Tango_mDevError_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevError* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevError,
               _0RL_Tango_mDevError_marshal_fn,
               _0RL_Tango_mDevError_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevError*& _sp)
{
  return _a >>= (const Tango::DevError*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevError*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevError,
                    _0RL_Tango_mDevError_unmarshal_fn,
                    _0RL_Tango_mDevError_marshal_fn,
                    _0RL_Tango_mDevError_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevError*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevErrorList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevErrorList* _p = (Tango::DevErrorList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevErrorList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevErrorList* _p = new Tango::DevErrorList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevErrorList_destructor_fn(void* _v)
{
  Tango::DevErrorList* _p = (Tango::DevErrorList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevErrorList& _s)
{
  Tango::DevErrorList* _p = new Tango::DevErrorList(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevErrorList,
               _0RL_Tango_mDevErrorList_marshal_fn,
               _0RL_Tango_mDevErrorList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevErrorList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevErrorList,
               _0RL_Tango_mDevErrorList_marshal_fn,
               _0RL_Tango_mDevErrorList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevErrorList*& _sp)
{
  return _a >>= (const Tango::DevErrorList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevErrorList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevErrorList,
                    _0RL_Tango_mDevErrorList_unmarshal_fn,
                    _0RL_Tango_mDevErrorList_marshal_fn,
                    _0RL_Tango_mDevErrorList_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevErrorList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mNamedDevError_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::NamedDevError* _p = (Tango::NamedDevError*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mNamedDevError_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::NamedDevError* _p = new Tango::NamedDevError;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mNamedDevError_destructor_fn(void* _v)
{
  Tango::NamedDevError* _p = (Tango::NamedDevError*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::NamedDevError& _s)
{
  Tango::NamedDevError* _p = new Tango::NamedDevError(_s);
  _a.PR_insert(_0RL_tc_Tango_mNamedDevError,
               _0RL_Tango_mNamedDevError_marshal_fn,
               _0RL_Tango_mNamedDevError_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::NamedDevError* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mNamedDevError,
               _0RL_Tango_mNamedDevError_marshal_fn,
               _0RL_Tango_mNamedDevError_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::NamedDevError*& _sp)
{
  return _a >>= (const Tango::NamedDevError*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::NamedDevError*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mNamedDevError,
                    _0RL_Tango_mNamedDevError_unmarshal_fn,
                    _0RL_Tango_mNamedDevError_marshal_fn,
                    _0RL_Tango_mNamedDevError_destructor_fn,
                    _v)) {
    _sp = (const Tango::NamedDevError*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mNamedDevErrorList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::NamedDevErrorList* _p = (Tango::NamedDevErrorList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mNamedDevErrorList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::NamedDevErrorList* _p = new Tango::NamedDevErrorList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mNamedDevErrorList_destructor_fn(void* _v)
{
  Tango::NamedDevErrorList* _p = (Tango::NamedDevErrorList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::NamedDevErrorList& _s)
{
  Tango::NamedDevErrorList* _p = new Tango::NamedDevErrorList(_s);
  _a.PR_insert(_0RL_tc_Tango_mNamedDevErrorList,
               _0RL_Tango_mNamedDevErrorList_marshal_fn,
               _0RL_Tango_mNamedDevErrorList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::NamedDevErrorList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mNamedDevErrorList,
               _0RL_Tango_mNamedDevErrorList_marshal_fn,
               _0RL_Tango_mNamedDevErrorList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::NamedDevErrorList*& _sp)
{
  return _a >>= (const Tango::NamedDevErrorList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::NamedDevErrorList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mNamedDevErrorList,
                    _0RL_Tango_mNamedDevErrorList_unmarshal_fn,
                    _0RL_Tango_mNamedDevErrorList_marshal_fn,
                    _0RL_Tango_mNamedDevErrorList_destructor_fn,
                    _v)) {
    _sp = (const Tango::NamedDevErrorList*)_v;
    return 1;
  }
  return 0;
}


static void _0RL_Tango_mDevFailed_marshal_fn(cdrStream& _s, void* _v)
{
  const Tango::DevFailed* _p = (const Tango::DevFailed*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevFailed_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevFailed* _p = new Tango::DevFailed;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevFailed_destructor_fn(void* _v)
{
  Tango::DevFailed* _p = (Tango::DevFailed*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevFailed& _s)
{
  Tango::DevFailed* _p = new Tango::DevFailed(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevFailed,
               _0RL_Tango_mDevFailed_marshal_fn,
               _0RL_Tango_mDevFailed_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const Tango::DevFailed* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevFailed,
               _0RL_Tango_mDevFailed_marshal_fn,
               _0RL_Tango_mDevFailed_destructor_fn,
               (Tango::DevFailed*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevFailed*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevFailed,
                    _0RL_Tango_mDevFailed_unmarshal_fn,
                    _0RL_Tango_mDevFailed_marshal_fn,
                    _0RL_Tango_mDevFailed_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevFailed*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cTango_mDevFailed(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const Tango::DevFailed & _ex = (const Tango::DevFailed &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cTango_mDevFailed (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const Tango::DevFailed* _ex = (const Tango::DevFailed*) _e;
  operator<<=(_a,_ex);
}

03441 class _0RL_insertToAny_Singleton__cTango_mDevFailed {
public:
  _0RL_insertToAny_Singleton__cTango_mDevFailed() {
    Tango::DevFailed::insertToAnyFn = _0RL_insertToAny__cTango_mDevFailed;
    Tango::DevFailed::insertToAnyFnNCP = _0RL_insertToAnyNCP__cTango_mDevFailed;
  }
};
static _0RL_insertToAny_Singleton__cTango_mDevFailed _0RL_insertToAny_Singleton__cTango_mDevFailed_;


static void _0RL_Tango_mMultiDevFailed_marshal_fn(cdrStream& _s, void* _v)
{
  const Tango::MultiDevFailed* _p = (const Tango::MultiDevFailed*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mMultiDevFailed_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::MultiDevFailed* _p = new Tango::MultiDevFailed;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mMultiDevFailed_destructor_fn(void* _v)
{
  Tango::MultiDevFailed* _p = (Tango::MultiDevFailed*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::MultiDevFailed& _s)
{
  Tango::MultiDevFailed* _p = new Tango::MultiDevFailed(_s);
  _a.PR_insert(_0RL_tc_Tango_mMultiDevFailed,
               _0RL_Tango_mMultiDevFailed_marshal_fn,
               _0RL_Tango_mMultiDevFailed_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, const Tango::MultiDevFailed* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mMultiDevFailed,
               _0RL_Tango_mMultiDevFailed_marshal_fn,
               _0RL_Tango_mMultiDevFailed_destructor_fn,
               (Tango::MultiDevFailed*)_sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::MultiDevFailed*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mMultiDevFailed,
                    _0RL_Tango_mMultiDevFailed_unmarshal_fn,
                    _0RL_Tango_mMultiDevFailed_marshal_fn,
                    _0RL_Tango_mMultiDevFailed_destructor_fn,
                    _v)) {
    _sp = (const Tango::MultiDevFailed*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_insertToAny__cTango_mMultiDevFailed(::CORBA::Any& _a, const ::CORBA::Exception& _e) {
  const Tango::MultiDevFailed & _ex = (const Tango::MultiDevFailed &) _e;
  operator<<=(_a,_ex);
}

static void _0RL_insertToAnyNCP__cTango_mMultiDevFailed (::CORBA::Any& _a, const ::CORBA::Exception* _e) {
  const Tango::MultiDevFailed* _ex = (const Tango::MultiDevFailed*) _e;
  operator<<=(_a,_ex);
}

03508 class _0RL_insertToAny_Singleton__cTango_mMultiDevFailed {
public:
  _0RL_insertToAny_Singleton__cTango_mMultiDevFailed() {
    Tango::MultiDevFailed::insertToAnyFn = _0RL_insertToAny__cTango_mMultiDevFailed;
    Tango::MultiDevFailed::insertToAnyFnNCP = _0RL_insertToAnyNCP__cTango_mMultiDevFailed;
  }
};
static _0RL_insertToAny_Singleton__cTango_mMultiDevFailed _0RL_insertToAny_Singleton__cTango_mMultiDevFailed_;

static void _0RL_Tango_mAttributeConfig_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeConfig* _p = (Tango::AttributeConfig*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeConfig_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeConfig* _p = new Tango::AttributeConfig;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeConfig_destructor_fn(void* _v)
{
  Tango::AttributeConfig* _p = (Tango::AttributeConfig*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfig& _s)
{
  Tango::AttributeConfig* _p = new Tango::AttributeConfig(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfig,
               _0RL_Tango_mAttributeConfig_marshal_fn,
               _0RL_Tango_mAttributeConfig_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfig* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfig,
               _0RL_Tango_mAttributeConfig_marshal_fn,
               _0RL_Tango_mAttributeConfig_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfig*& _sp)
{
  return _a >>= (const Tango::AttributeConfig*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfig*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeConfig,
                    _0RL_Tango_mAttributeConfig_unmarshal_fn,
                    _0RL_Tango_mAttributeConfig_marshal_fn,
                    _0RL_Tango_mAttributeConfig_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeConfig*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeConfig__2_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeConfig_2* _p = (Tango::AttributeConfig_2*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeConfig__2_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeConfig_2* _p = new Tango::AttributeConfig_2;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeConfig__2_destructor_fn(void* _v)
{
  Tango::AttributeConfig_2* _p = (Tango::AttributeConfig_2*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfig_2& _s)
{
  Tango::AttributeConfig_2* _p = new Tango::AttributeConfig_2(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfig__2,
               _0RL_Tango_mAttributeConfig__2_marshal_fn,
               _0RL_Tango_mAttributeConfig__2_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfig_2* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfig__2,
               _0RL_Tango_mAttributeConfig__2_marshal_fn,
               _0RL_Tango_mAttributeConfig__2_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfig_2*& _sp)
{
  return _a >>= (const Tango::AttributeConfig_2*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfig_2*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeConfig__2,
                    _0RL_Tango_mAttributeConfig__2_unmarshal_fn,
                    _0RL_Tango_mAttributeConfig__2_marshal_fn,
                    _0RL_Tango_mAttributeConfig__2_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeConfig_2*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeValue_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeValue* _p = (Tango::AttributeValue*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeValue_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeValue* _p = new Tango::AttributeValue;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeValue_destructor_fn(void* _v)
{
  Tango::AttributeValue* _p = (Tango::AttributeValue*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValue& _s)
{
  Tango::AttributeValue* _p = new Tango::AttributeValue(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeValue,
               _0RL_Tango_mAttributeValue_marshal_fn,
               _0RL_Tango_mAttributeValue_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeValue* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeValue,
               _0RL_Tango_mAttributeValue_marshal_fn,
               _0RL_Tango_mAttributeValue_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValue*& _sp)
{
  return _a >>= (const Tango::AttributeValue*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValue*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeValue,
                    _0RL_Tango_mAttributeValue_unmarshal_fn,
                    _0RL_Tango_mAttributeValue_marshal_fn,
                    _0RL_Tango_mAttributeValue_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeValue*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeDim_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeDim* _p = (Tango::AttributeDim*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeDim_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeDim* _p = new Tango::AttributeDim;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeDim_destructor_fn(void* _v)
{
  Tango::AttributeDim* _p = (Tango::AttributeDim*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeDim& _s)
{
  Tango::AttributeDim* _p = new Tango::AttributeDim(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeDim,
               _0RL_Tango_mAttributeDim_marshal_fn,
               _0RL_Tango_mAttributeDim_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeDim* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeDim,
               _0RL_Tango_mAttributeDim_marshal_fn,
               _0RL_Tango_mAttributeDim_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeDim*& _sp)
{
  return _a >>= (const Tango::AttributeDim*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeDim*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeDim,
                    _0RL_Tango_mAttributeDim_unmarshal_fn,
                    _0RL_Tango_mAttributeDim_marshal_fn,
                    _0RL_Tango_mAttributeDim_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeDim*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeValue__3_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeValue_3* _p = (Tango::AttributeValue_3*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeValue__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeValue_3* _p = new Tango::AttributeValue_3;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeValue__3_destructor_fn(void* _v)
{
  Tango::AttributeValue_3* _p = (Tango::AttributeValue_3*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValue_3& _s)
{
  Tango::AttributeValue_3* _p = new Tango::AttributeValue_3(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeValue__3,
               _0RL_Tango_mAttributeValue__3_marshal_fn,
               _0RL_Tango_mAttributeValue__3_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeValue_3* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeValue__3,
               _0RL_Tango_mAttributeValue__3_marshal_fn,
               _0RL_Tango_mAttributeValue__3_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValue_3*& _sp)
{
  return _a >>= (const Tango::AttributeValue_3*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValue_3*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeValue__3,
                    _0RL_Tango_mAttributeValue__3_unmarshal_fn,
                    _0RL_Tango_mAttributeValue__3_marshal_fn,
                    _0RL_Tango_mAttributeValue__3_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeValue_3*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeDataType_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeDataType* _p = (Tango::AttributeDataType*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeDataType_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeDataType* _p = (Tango::AttributeDataType*)_v;
  *_p <<= _s;
}

void operator<<=(::CORBA::Any& _a, Tango::AttributeDataType _s)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeDataType,
               _0RL_Tango_mAttributeDataType_marshal_fn,
               &_s);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeDataType& _s)
{
  return _a.PR_extract(_0RL_tc_Tango_mAttributeDataType,
                       _0RL_Tango_mAttributeDataType_unmarshal_fn,
                       &_s);
}

static void _0RL_Tango_mAttrValUnion_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttrValUnion* _p = (Tango::AttrValUnion*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttrValUnion_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttrValUnion* _p = new Tango::AttrValUnion;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttrValUnion_destructor_fn(void* _v)
{
  Tango::AttrValUnion* _p = (Tango::AttrValUnion*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttrValUnion& _s)
{
  Tango::AttrValUnion* _p = new Tango::AttrValUnion(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttrValUnion,
               _0RL_Tango_mAttrValUnion_marshal_fn,
               _0RL_Tango_mAttrValUnion_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttrValUnion* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttrValUnion,
               _0RL_Tango_mAttrValUnion_marshal_fn,
               _0RL_Tango_mAttrValUnion_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrValUnion*& _sp)
{
  return _a >>= (const Tango::AttrValUnion*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttrValUnion*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttrValUnion,
                    _0RL_Tango_mAttrValUnion_unmarshal_fn,
                    _0RL_Tango_mAttrValUnion_marshal_fn,
                    _0RL_Tango_mAttrValUnion_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttrValUnion*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeValue__4_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeValue_4* _p = (Tango::AttributeValue_4*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeValue__4_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeValue_4* _p = new Tango::AttributeValue_4;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeValue__4_destructor_fn(void* _v)
{
  Tango::AttributeValue_4* _p = (Tango::AttributeValue_4*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValue_4& _s)
{
  Tango::AttributeValue_4* _p = new Tango::AttributeValue_4(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeValue__4,
               _0RL_Tango_mAttributeValue__4_marshal_fn,
               _0RL_Tango_mAttributeValue__4_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeValue_4* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeValue__4,
               _0RL_Tango_mAttributeValue__4_marshal_fn,
               _0RL_Tango_mAttributeValue__4_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValue_4*& _sp)
{
  return _a >>= (const Tango::AttributeValue_4*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValue_4*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeValue__4,
                    _0RL_Tango_mAttributeValue__4_unmarshal_fn,
                    _0RL_Tango_mAttributeValue__4_marshal_fn,
                    _0RL_Tango_mAttributeValue__4_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeValue_4*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mChangeEventProp_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::ChangeEventProp* _p = (Tango::ChangeEventProp*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mChangeEventProp_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::ChangeEventProp* _p = new Tango::ChangeEventProp;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mChangeEventProp_destructor_fn(void* _v)
{
  Tango::ChangeEventProp* _p = (Tango::ChangeEventProp*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::ChangeEventProp& _s)
{
  Tango::ChangeEventProp* _p = new Tango::ChangeEventProp(_s);
  _a.PR_insert(_0RL_tc_Tango_mChangeEventProp,
               _0RL_Tango_mChangeEventProp_marshal_fn,
               _0RL_Tango_mChangeEventProp_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::ChangeEventProp* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mChangeEventProp,
               _0RL_Tango_mChangeEventProp_marshal_fn,
               _0RL_Tango_mChangeEventProp_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::ChangeEventProp*& _sp)
{
  return _a >>= (const Tango::ChangeEventProp*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::ChangeEventProp*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mChangeEventProp,
                    _0RL_Tango_mChangeEventProp_unmarshal_fn,
                    _0RL_Tango_mChangeEventProp_marshal_fn,
                    _0RL_Tango_mChangeEventProp_destructor_fn,
                    _v)) {
    _sp = (const Tango::ChangeEventProp*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mPeriodicEventProp_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::PeriodicEventProp* _p = (Tango::PeriodicEventProp*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mPeriodicEventProp_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::PeriodicEventProp* _p = new Tango::PeriodicEventProp;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mPeriodicEventProp_destructor_fn(void* _v)
{
  Tango::PeriodicEventProp* _p = (Tango::PeriodicEventProp*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::PeriodicEventProp& _s)
{
  Tango::PeriodicEventProp* _p = new Tango::PeriodicEventProp(_s);
  _a.PR_insert(_0RL_tc_Tango_mPeriodicEventProp,
               _0RL_Tango_mPeriodicEventProp_marshal_fn,
               _0RL_Tango_mPeriodicEventProp_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::PeriodicEventProp* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mPeriodicEventProp,
               _0RL_Tango_mPeriodicEventProp_marshal_fn,
               _0RL_Tango_mPeriodicEventProp_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::PeriodicEventProp*& _sp)
{
  return _a >>= (const Tango::PeriodicEventProp*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::PeriodicEventProp*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mPeriodicEventProp,
                    _0RL_Tango_mPeriodicEventProp_unmarshal_fn,
                    _0RL_Tango_mPeriodicEventProp_marshal_fn,
                    _0RL_Tango_mPeriodicEventProp_destructor_fn,
                    _v)) {
    _sp = (const Tango::PeriodicEventProp*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mArchiveEventProp_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::ArchiveEventProp* _p = (Tango::ArchiveEventProp*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mArchiveEventProp_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::ArchiveEventProp* _p = new Tango::ArchiveEventProp;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mArchiveEventProp_destructor_fn(void* _v)
{
  Tango::ArchiveEventProp* _p = (Tango::ArchiveEventProp*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::ArchiveEventProp& _s)
{
  Tango::ArchiveEventProp* _p = new Tango::ArchiveEventProp(_s);
  _a.PR_insert(_0RL_tc_Tango_mArchiveEventProp,
               _0RL_Tango_mArchiveEventProp_marshal_fn,
               _0RL_Tango_mArchiveEventProp_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::ArchiveEventProp* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mArchiveEventProp,
               _0RL_Tango_mArchiveEventProp_marshal_fn,
               _0RL_Tango_mArchiveEventProp_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::ArchiveEventProp*& _sp)
{
  return _a >>= (const Tango::ArchiveEventProp*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::ArchiveEventProp*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mArchiveEventProp,
                    _0RL_Tango_mArchiveEventProp_unmarshal_fn,
                    _0RL_Tango_mArchiveEventProp_marshal_fn,
                    _0RL_Tango_mArchiveEventProp_destructor_fn,
                    _v)) {
    _sp = (const Tango::ArchiveEventProp*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mEventProperties_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::EventProperties* _p = (Tango::EventProperties*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mEventProperties_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::EventProperties* _p = new Tango::EventProperties;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mEventProperties_destructor_fn(void* _v)
{
  Tango::EventProperties* _p = (Tango::EventProperties*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::EventProperties& _s)
{
  Tango::EventProperties* _p = new Tango::EventProperties(_s);
  _a.PR_insert(_0RL_tc_Tango_mEventProperties,
               _0RL_Tango_mEventProperties_marshal_fn,
               _0RL_Tango_mEventProperties_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::EventProperties* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mEventProperties,
               _0RL_Tango_mEventProperties_marshal_fn,
               _0RL_Tango_mEventProperties_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::EventProperties*& _sp)
{
  return _a >>= (const Tango::EventProperties*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::EventProperties*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mEventProperties,
                    _0RL_Tango_mEventProperties_unmarshal_fn,
                    _0RL_Tango_mEventProperties_marshal_fn,
                    _0RL_Tango_mEventProperties_destructor_fn,
                    _v)) {
    _sp = (const Tango::EventProperties*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeAlarm_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeAlarm* _p = (Tango::AttributeAlarm*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeAlarm_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeAlarm* _p = new Tango::AttributeAlarm;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeAlarm_destructor_fn(void* _v)
{
  Tango::AttributeAlarm* _p = (Tango::AttributeAlarm*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeAlarm& _s)
{
  Tango::AttributeAlarm* _p = new Tango::AttributeAlarm(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeAlarm,
               _0RL_Tango_mAttributeAlarm_marshal_fn,
               _0RL_Tango_mAttributeAlarm_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeAlarm* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeAlarm,
               _0RL_Tango_mAttributeAlarm_marshal_fn,
               _0RL_Tango_mAttributeAlarm_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeAlarm*& _sp)
{
  return _a >>= (const Tango::AttributeAlarm*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeAlarm*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeAlarm,
                    _0RL_Tango_mAttributeAlarm_unmarshal_fn,
                    _0RL_Tango_mAttributeAlarm_marshal_fn,
                    _0RL_Tango_mAttributeAlarm_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeAlarm*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeConfig__3_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeConfig_3* _p = (Tango::AttributeConfig_3*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeConfig__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeConfig_3* _p = new Tango::AttributeConfig_3;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeConfig__3_destructor_fn(void* _v)
{
  Tango::AttributeConfig_3* _p = (Tango::AttributeConfig_3*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfig_3& _s)
{
  Tango::AttributeConfig_3* _p = new Tango::AttributeConfig_3(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfig__3,
               _0RL_Tango_mAttributeConfig__3_marshal_fn,
               _0RL_Tango_mAttributeConfig__3_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfig_3* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfig__3,
               _0RL_Tango_mAttributeConfig__3_marshal_fn,
               _0RL_Tango_mAttributeConfig__3_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfig_3*& _sp)
{
  return _a >>= (const Tango::AttributeConfig_3*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfig_3*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeConfig__3,
                    _0RL_Tango_mAttributeConfig__3_unmarshal_fn,
                    _0RL_Tango_mAttributeConfig__3_marshal_fn,
                    _0RL_Tango_mAttributeConfig__3_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeConfig_3*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeConfigList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeConfigList* _p = (Tango::AttributeConfigList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeConfigList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeConfigList* _p = new Tango::AttributeConfigList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeConfigList_destructor_fn(void* _v)
{
  Tango::AttributeConfigList* _p = (Tango::AttributeConfigList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfigList& _s)
{
  Tango::AttributeConfigList* _p = new Tango::AttributeConfigList(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfigList,
               _0RL_Tango_mAttributeConfigList_marshal_fn,
               _0RL_Tango_mAttributeConfigList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfigList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfigList,
               _0RL_Tango_mAttributeConfigList_marshal_fn,
               _0RL_Tango_mAttributeConfigList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfigList*& _sp)
{
  return _a >>= (const Tango::AttributeConfigList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfigList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeConfigList,
                    _0RL_Tango_mAttributeConfigList_unmarshal_fn,
                    _0RL_Tango_mAttributeConfigList_marshal_fn,
                    _0RL_Tango_mAttributeConfigList_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeConfigList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeConfigList__2_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeConfigList_2* _p = (Tango::AttributeConfigList_2*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeConfigList__2_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeConfigList_2* _p = new Tango::AttributeConfigList_2;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeConfigList__2_destructor_fn(void* _v)
{
  Tango::AttributeConfigList_2* _p = (Tango::AttributeConfigList_2*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfigList_2& _s)
{
  Tango::AttributeConfigList_2* _p = new Tango::AttributeConfigList_2(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfigList__2,
               _0RL_Tango_mAttributeConfigList__2_marshal_fn,
               _0RL_Tango_mAttributeConfigList__2_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfigList_2* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfigList__2,
               _0RL_Tango_mAttributeConfigList__2_marshal_fn,
               _0RL_Tango_mAttributeConfigList__2_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfigList_2*& _sp)
{
  return _a >>= (const Tango::AttributeConfigList_2*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfigList_2*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeConfigList__2,
                    _0RL_Tango_mAttributeConfigList__2_unmarshal_fn,
                    _0RL_Tango_mAttributeConfigList__2_marshal_fn,
                    _0RL_Tango_mAttributeConfigList__2_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeConfigList_2*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeConfigList__3_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeConfigList_3* _p = (Tango::AttributeConfigList_3*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeConfigList__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeConfigList_3* _p = new Tango::AttributeConfigList_3;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeConfigList__3_destructor_fn(void* _v)
{
  Tango::AttributeConfigList_3* _p = (Tango::AttributeConfigList_3*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfigList_3& _s)
{
  Tango::AttributeConfigList_3* _p = new Tango::AttributeConfigList_3(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfigList__3,
               _0RL_Tango_mAttributeConfigList__3_marshal_fn,
               _0RL_Tango_mAttributeConfigList__3_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfigList_3* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeConfigList__3,
               _0RL_Tango_mAttributeConfigList__3_marshal_fn,
               _0RL_Tango_mAttributeConfigList__3_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfigList_3*& _sp)
{
  return _a >>= (const Tango::AttributeConfigList_3*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfigList_3*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeConfigList__3,
                    _0RL_Tango_mAttributeConfigList__3_unmarshal_fn,
                    _0RL_Tango_mAttributeConfigList__3_marshal_fn,
                    _0RL_Tango_mAttributeConfigList__3_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeConfigList_3*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeValueList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeValueList* _p = (Tango::AttributeValueList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeValueList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeValueList* _p = new Tango::AttributeValueList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeValueList_destructor_fn(void* _v)
{
  Tango::AttributeValueList* _p = (Tango::AttributeValueList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValueList& _s)
{
  Tango::AttributeValueList* _p = new Tango::AttributeValueList(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeValueList,
               _0RL_Tango_mAttributeValueList_marshal_fn,
               _0RL_Tango_mAttributeValueList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeValueList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeValueList,
               _0RL_Tango_mAttributeValueList_marshal_fn,
               _0RL_Tango_mAttributeValueList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValueList*& _sp)
{
  return _a >>= (const Tango::AttributeValueList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValueList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeValueList,
                    _0RL_Tango_mAttributeValueList_unmarshal_fn,
                    _0RL_Tango_mAttributeValueList_marshal_fn,
                    _0RL_Tango_mAttributeValueList_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeValueList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeValueList__3_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeValueList_3* _p = (Tango::AttributeValueList_3*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeValueList__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeValueList_3* _p = new Tango::AttributeValueList_3;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeValueList__3_destructor_fn(void* _v)
{
  Tango::AttributeValueList_3* _p = (Tango::AttributeValueList_3*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValueList_3& _s)
{
  Tango::AttributeValueList_3* _p = new Tango::AttributeValueList_3(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeValueList__3,
               _0RL_Tango_mAttributeValueList__3_marshal_fn,
               _0RL_Tango_mAttributeValueList__3_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeValueList_3* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeValueList__3,
               _0RL_Tango_mAttributeValueList__3_marshal_fn,
               _0RL_Tango_mAttributeValueList__3_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValueList_3*& _sp)
{
  return _a >>= (const Tango::AttributeValueList_3*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValueList_3*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeValueList__3,
                    _0RL_Tango_mAttributeValueList__3_unmarshal_fn,
                    _0RL_Tango_mAttributeValueList__3_marshal_fn,
                    _0RL_Tango_mAttributeValueList__3_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeValueList_3*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeValueList__4_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeValueList_4* _p = (Tango::AttributeValueList_4*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeValueList__4_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeValueList_4* _p = new Tango::AttributeValueList_4;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeValueList__4_destructor_fn(void* _v)
{
  Tango::AttributeValueList_4* _p = (Tango::AttributeValueList_4*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValueList_4& _s)
{
  Tango::AttributeValueList_4* _p = new Tango::AttributeValueList_4(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeValueList__4,
               _0RL_Tango_mAttributeValueList__4_marshal_fn,
               _0RL_Tango_mAttributeValueList__4_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeValueList_4* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeValueList__4,
               _0RL_Tango_mAttributeValueList__4_marshal_fn,
               _0RL_Tango_mAttributeValueList__4_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValueList_4*& _sp)
{
  return _a >>= (const Tango::AttributeValueList_4*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValueList_4*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeValueList__4,
                    _0RL_Tango_mAttributeValueList__4_unmarshal_fn,
                    _0RL_Tango_mAttributeValueList__4_marshal_fn,
                    _0RL_Tango_mAttributeValueList__4_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeValueList_4*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttDataReady_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttDataReady* _p = (Tango::AttDataReady*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttDataReady_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttDataReady* _p = new Tango::AttDataReady;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttDataReady_destructor_fn(void* _v)
{
  Tango::AttDataReady* _p = (Tango::AttDataReady*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttDataReady& _s)
{
  Tango::AttDataReady* _p = new Tango::AttDataReady(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttDataReady,
               _0RL_Tango_mAttDataReady_marshal_fn,
               _0RL_Tango_mAttDataReady_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttDataReady* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttDataReady,
               _0RL_Tango_mAttDataReady_marshal_fn,
               _0RL_Tango_mAttDataReady_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttDataReady*& _sp)
{
  return _a >>= (const Tango::AttDataReady*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttDataReady*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttDataReady,
                    _0RL_Tango_mAttDataReady_unmarshal_fn,
                    _0RL_Tango_mAttDataReady_marshal_fn,
                    _0RL_Tango_mAttDataReady_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttDataReady*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevInfo_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevInfo* _p = (Tango::DevInfo*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevInfo_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevInfo* _p = new Tango::DevInfo;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevInfo_destructor_fn(void* _v)
{
  Tango::DevInfo* _p = (Tango::DevInfo*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevInfo& _s)
{
  Tango::DevInfo* _p = new Tango::DevInfo(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevInfo,
               _0RL_Tango_mDevInfo_marshal_fn,
               _0RL_Tango_mDevInfo_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevInfo* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevInfo,
               _0RL_Tango_mDevInfo_marshal_fn,
               _0RL_Tango_mDevInfo_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevInfo*& _sp)
{
  return _a >>= (const Tango::DevInfo*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevInfo*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevInfo,
                    _0RL_Tango_mDevInfo_unmarshal_fn,
                    _0RL_Tango_mDevInfo_marshal_fn,
                    _0RL_Tango_mDevInfo_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevInfo*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevInfo__3_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevInfo_3* _p = (Tango::DevInfo_3*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevInfo__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevInfo_3* _p = new Tango::DevInfo_3;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevInfo__3_destructor_fn(void* _v)
{
  Tango::DevInfo_3* _p = (Tango::DevInfo_3*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevInfo_3& _s)
{
  Tango::DevInfo_3* _p = new Tango::DevInfo_3(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevInfo__3,
               _0RL_Tango_mDevInfo__3_marshal_fn,
               _0RL_Tango_mDevInfo__3_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevInfo_3* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevInfo__3,
               _0RL_Tango_mDevInfo__3_marshal_fn,
               _0RL_Tango_mDevInfo__3_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevInfo_3*& _sp)
{
  return _a >>= (const Tango::DevInfo_3*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevInfo_3*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevInfo__3,
                    _0RL_Tango_mDevInfo__3_unmarshal_fn,
                    _0RL_Tango_mDevInfo__3_marshal_fn,
                    _0RL_Tango_mDevInfo__3_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevInfo_3*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevCmdHistory_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevCmdHistory* _p = (Tango::DevCmdHistory*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevCmdHistory_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevCmdHistory* _p = new Tango::DevCmdHistory;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevCmdHistory_destructor_fn(void* _v)
{
  Tango::DevCmdHistory* _p = (Tango::DevCmdHistory*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdHistory& _s)
{
  Tango::DevCmdHistory* _p = new Tango::DevCmdHistory(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevCmdHistory,
               _0RL_Tango_mDevCmdHistory_marshal_fn,
               _0RL_Tango_mDevCmdHistory_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevCmdHistory* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevCmdHistory,
               _0RL_Tango_mDevCmdHistory_marshal_fn,
               _0RL_Tango_mDevCmdHistory_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdHistory*& _sp)
{
  return _a >>= (const Tango::DevCmdHistory*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdHistory*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevCmdHistory,
                    _0RL_Tango_mDevCmdHistory_unmarshal_fn,
                    _0RL_Tango_mDevCmdHistory_marshal_fn,
                    _0RL_Tango_mDevCmdHistory_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevCmdHistory*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevCmdHistoryList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevCmdHistoryList* _p = (Tango::DevCmdHistoryList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevCmdHistoryList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevCmdHistoryList* _p = new Tango::DevCmdHistoryList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevCmdHistoryList_destructor_fn(void* _v)
{
  Tango::DevCmdHistoryList* _p = (Tango::DevCmdHistoryList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdHistoryList& _s)
{
  Tango::DevCmdHistoryList* _p = new Tango::DevCmdHistoryList(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevCmdHistoryList,
               _0RL_Tango_mDevCmdHistoryList_marshal_fn,
               _0RL_Tango_mDevCmdHistoryList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevCmdHistoryList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevCmdHistoryList,
               _0RL_Tango_mDevCmdHistoryList_marshal_fn,
               _0RL_Tango_mDevCmdHistoryList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdHistoryList*& _sp)
{
  return _a >>= (const Tango::DevCmdHistoryList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdHistoryList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevCmdHistoryList,
                    _0RL_Tango_mDevCmdHistoryList_unmarshal_fn,
                    _0RL_Tango_mDevCmdHistoryList_marshal_fn,
                    _0RL_Tango_mDevCmdHistoryList_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevCmdHistoryList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevAttrHistory_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevAttrHistory* _p = (Tango::DevAttrHistory*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevAttrHistory_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevAttrHistory* _p = new Tango::DevAttrHistory;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevAttrHistory_destructor_fn(void* _v)
{
  Tango::DevAttrHistory* _p = (Tango::DevAttrHistory*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistory& _s)
{
  Tango::DevAttrHistory* _p = new Tango::DevAttrHistory(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistory,
               _0RL_Tango_mDevAttrHistory_marshal_fn,
               _0RL_Tango_mDevAttrHistory_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistory* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistory,
               _0RL_Tango_mDevAttrHistory_marshal_fn,
               _0RL_Tango_mDevAttrHistory_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistory*& _sp)
{
  return _a >>= (const Tango::DevAttrHistory*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistory*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevAttrHistory,
                    _0RL_Tango_mDevAttrHistory_unmarshal_fn,
                    _0RL_Tango_mDevAttrHistory_marshal_fn,
                    _0RL_Tango_mDevAttrHistory_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevAttrHistory*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevAttrHistory__3_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevAttrHistory_3* _p = (Tango::DevAttrHistory_3*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevAttrHistory__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevAttrHistory_3* _p = new Tango::DevAttrHistory_3;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevAttrHistory__3_destructor_fn(void* _v)
{
  Tango::DevAttrHistory_3* _p = (Tango::DevAttrHistory_3*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistory_3& _s)
{
  Tango::DevAttrHistory_3* _p = new Tango::DevAttrHistory_3(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistory__3,
               _0RL_Tango_mDevAttrHistory__3_marshal_fn,
               _0RL_Tango_mDevAttrHistory__3_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistory_3* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistory__3,
               _0RL_Tango_mDevAttrHistory__3_marshal_fn,
               _0RL_Tango_mDevAttrHistory__3_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistory_3*& _sp)
{
  return _a >>= (const Tango::DevAttrHistory_3*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistory_3*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevAttrHistory__3,
                    _0RL_Tango_mDevAttrHistory__3_unmarshal_fn,
                    _0RL_Tango_mDevAttrHistory__3_marshal_fn,
                    _0RL_Tango_mDevAttrHistory__3_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevAttrHistory_3*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mEltInArray_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::EltInArray* _p = (Tango::EltInArray*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mEltInArray_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::EltInArray* _p = new Tango::EltInArray;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mEltInArray_destructor_fn(void* _v)
{
  Tango::EltInArray* _p = (Tango::EltInArray*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::EltInArray& _s)
{
  Tango::EltInArray* _p = new Tango::EltInArray(_s);
  _a.PR_insert(_0RL_tc_Tango_mEltInArray,
               _0RL_Tango_mEltInArray_marshal_fn,
               _0RL_Tango_mEltInArray_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::EltInArray* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mEltInArray,
               _0RL_Tango_mEltInArray_marshal_fn,
               _0RL_Tango_mEltInArray_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::EltInArray*& _sp)
{
  return _a >>= (const Tango::EltInArray*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::EltInArray*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mEltInArray,
                    _0RL_Tango_mEltInArray_unmarshal_fn,
                    _0RL_Tango_mEltInArray_marshal_fn,
                    _0RL_Tango_mEltInArray_destructor_fn,
                    _v)) {
    _sp = (const Tango::EltInArray*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mEltInArrayList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::EltInArrayList* _p = (Tango::EltInArrayList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mEltInArrayList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::EltInArrayList* _p = new Tango::EltInArrayList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mEltInArrayList_destructor_fn(void* _v)
{
  Tango::EltInArrayList* _p = (Tango::EltInArrayList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::EltInArrayList& _s)
{
  Tango::EltInArrayList* _p = new Tango::EltInArrayList(_s);
  _a.PR_insert(_0RL_tc_Tango_mEltInArrayList,
               _0RL_Tango_mEltInArrayList_marshal_fn,
               _0RL_Tango_mEltInArrayList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::EltInArrayList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mEltInArrayList,
               _0RL_Tango_mEltInArrayList_marshal_fn,
               _0RL_Tango_mEltInArrayList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::EltInArrayList*& _sp)
{
  return _a >>= (const Tango::EltInArrayList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::EltInArrayList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mEltInArrayList,
                    _0RL_Tango_mEltInArrayList_unmarshal_fn,
                    _0RL_Tango_mEltInArrayList_marshal_fn,
                    _0RL_Tango_mEltInArrayList_destructor_fn,
                    _v)) {
    _sp = (const Tango::EltInArrayList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mTimeValList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::TimeValList* _p = (Tango::TimeValList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mTimeValList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::TimeValList* _p = new Tango::TimeValList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mTimeValList_destructor_fn(void* _v)
{
  Tango::TimeValList* _p = (Tango::TimeValList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::TimeValList& _s)
{
  Tango::TimeValList* _p = new Tango::TimeValList(_s);
  _a.PR_insert(_0RL_tc_Tango_mTimeValList,
               _0RL_Tango_mTimeValList_marshal_fn,
               _0RL_Tango_mTimeValList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::TimeValList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mTimeValList,
               _0RL_Tango_mTimeValList_marshal_fn,
               _0RL_Tango_mTimeValList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::TimeValList*& _sp)
{
  return _a >>= (const Tango::TimeValList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::TimeValList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mTimeValList,
                    _0RL_Tango_mTimeValList_unmarshal_fn,
                    _0RL_Tango_mTimeValList_marshal_fn,
                    _0RL_Tango_mTimeValList_destructor_fn,
                    _v)) {
    _sp = (const Tango::TimeValList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttrQualityList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttrQualityList* _p = (Tango::AttrQualityList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttrQualityList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttrQualityList* _p = new Tango::AttrQualityList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttrQualityList_destructor_fn(void* _v)
{
  Tango::AttrQualityList* _p = (Tango::AttrQualityList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttrQualityList& _s)
{
  Tango::AttrQualityList* _p = new Tango::AttrQualityList(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttrQualityList,
               _0RL_Tango_mAttrQualityList_marshal_fn,
               _0RL_Tango_mAttrQualityList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttrQualityList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttrQualityList,
               _0RL_Tango_mAttrQualityList_marshal_fn,
               _0RL_Tango_mAttrQualityList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrQualityList*& _sp)
{
  return _a >>= (const Tango::AttrQualityList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttrQualityList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttrQualityList,
                    _0RL_Tango_mAttrQualityList_unmarshal_fn,
                    _0RL_Tango_mAttrQualityList_marshal_fn,
                    _0RL_Tango_mAttrQualityList_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttrQualityList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mAttributeDimList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::AttributeDimList* _p = (Tango::AttributeDimList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mAttributeDimList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::AttributeDimList* _p = new Tango::AttributeDimList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mAttributeDimList_destructor_fn(void* _v)
{
  Tango::AttributeDimList* _p = (Tango::AttributeDimList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::AttributeDimList& _s)
{
  Tango::AttributeDimList* _p = new Tango::AttributeDimList(_s);
  _a.PR_insert(_0RL_tc_Tango_mAttributeDimList,
               _0RL_Tango_mAttributeDimList_marshal_fn,
               _0RL_Tango_mAttributeDimList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::AttributeDimList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mAttributeDimList,
               _0RL_Tango_mAttributeDimList_marshal_fn,
               _0RL_Tango_mAttributeDimList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeDimList*& _sp)
{
  return _a >>= (const Tango::AttributeDimList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeDimList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mAttributeDimList,
                    _0RL_Tango_mAttributeDimList_unmarshal_fn,
                    _0RL_Tango_mAttributeDimList_marshal_fn,
                    _0RL_Tango_mAttributeDimList_destructor_fn,
                    _v)) {
    _sp = (const Tango::AttributeDimList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevErrorListList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevErrorListList* _p = (Tango::DevErrorListList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevErrorListList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevErrorListList* _p = new Tango::DevErrorListList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevErrorListList_destructor_fn(void* _v)
{
  Tango::DevErrorListList* _p = (Tango::DevErrorListList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevErrorListList& _s)
{
  Tango::DevErrorListList* _p = new Tango::DevErrorListList(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevErrorListList,
               _0RL_Tango_mDevErrorListList_marshal_fn,
               _0RL_Tango_mDevErrorListList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevErrorListList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevErrorListList,
               _0RL_Tango_mDevErrorListList_marshal_fn,
               _0RL_Tango_mDevErrorListList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevErrorListList*& _sp)
{
  return _a >>= (const Tango::DevErrorListList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevErrorListList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevErrorListList,
                    _0RL_Tango_mDevErrorListList_unmarshal_fn,
                    _0RL_Tango_mDevErrorListList_marshal_fn,
                    _0RL_Tango_mDevErrorListList_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevErrorListList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevAttrHistory__4_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevAttrHistory_4* _p = (Tango::DevAttrHistory_4*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevAttrHistory__4_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevAttrHistory_4* _p = new Tango::DevAttrHistory_4;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevAttrHistory__4_destructor_fn(void* _v)
{
  Tango::DevAttrHistory_4* _p = (Tango::DevAttrHistory_4*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistory_4& _s)
{
  Tango::DevAttrHistory_4* _p = new Tango::DevAttrHistory_4(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistory__4,
               _0RL_Tango_mDevAttrHistory__4_marshal_fn,
               _0RL_Tango_mDevAttrHistory__4_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistory_4* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistory__4,
               _0RL_Tango_mDevAttrHistory__4_marshal_fn,
               _0RL_Tango_mDevAttrHistory__4_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistory_4*& _sp)
{
  return _a >>= (const Tango::DevAttrHistory_4*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistory_4*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevAttrHistory__4,
                    _0RL_Tango_mDevAttrHistory__4_unmarshal_fn,
                    _0RL_Tango_mDevAttrHistory__4_marshal_fn,
                    _0RL_Tango_mDevAttrHistory__4_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevAttrHistory_4*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevCmdHistory__4_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevCmdHistory_4* _p = (Tango::DevCmdHistory_4*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevCmdHistory__4_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevCmdHistory_4* _p = new Tango::DevCmdHistory_4;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevCmdHistory__4_destructor_fn(void* _v)
{
  Tango::DevCmdHistory_4* _p = (Tango::DevCmdHistory_4*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdHistory_4& _s)
{
  Tango::DevCmdHistory_4* _p = new Tango::DevCmdHistory_4(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevCmdHistory__4,
               _0RL_Tango_mDevCmdHistory__4_marshal_fn,
               _0RL_Tango_mDevCmdHistory__4_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevCmdHistory_4* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevCmdHistory__4,
               _0RL_Tango_mDevCmdHistory__4_marshal_fn,
               _0RL_Tango_mDevCmdHistory__4_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdHistory_4*& _sp)
{
  return _a >>= (const Tango::DevCmdHistory_4*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdHistory_4*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevCmdHistory__4,
                    _0RL_Tango_mDevCmdHistory__4_unmarshal_fn,
                    _0RL_Tango_mDevCmdHistory__4_marshal_fn,
                    _0RL_Tango_mDevCmdHistory__4_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevCmdHistory_4*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevAttrHistoryList_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevAttrHistoryList* _p = (Tango::DevAttrHistoryList*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevAttrHistoryList_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevAttrHistoryList* _p = new Tango::DevAttrHistoryList;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevAttrHistoryList_destructor_fn(void* _v)
{
  Tango::DevAttrHistoryList* _p = (Tango::DevAttrHistoryList*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistoryList& _s)
{
  Tango::DevAttrHistoryList* _p = new Tango::DevAttrHistoryList(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistoryList,
               _0RL_Tango_mDevAttrHistoryList_marshal_fn,
               _0RL_Tango_mDevAttrHistoryList_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistoryList* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistoryList,
               _0RL_Tango_mDevAttrHistoryList_marshal_fn,
               _0RL_Tango_mDevAttrHistoryList_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistoryList*& _sp)
{
  return _a >>= (const Tango::DevAttrHistoryList*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistoryList*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevAttrHistoryList,
                    _0RL_Tango_mDevAttrHistoryList_unmarshal_fn,
                    _0RL_Tango_mDevAttrHistoryList_marshal_fn,
                    _0RL_Tango_mDevAttrHistoryList_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevAttrHistoryList*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevAttrHistoryList__3_marshal_fn(cdrStream& _s, void* _v)
{
  Tango::DevAttrHistoryList_3* _p = (Tango::DevAttrHistoryList_3*)_v;
  *_p >>= _s;
}
static void _0RL_Tango_mDevAttrHistoryList__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  Tango::DevAttrHistoryList_3* _p = new Tango::DevAttrHistoryList_3;
  *_p <<= _s;
  _v = _p;
}
static void _0RL_Tango_mDevAttrHistoryList__3_destructor_fn(void* _v)
{
  Tango::DevAttrHistoryList_3* _p = (Tango::DevAttrHistoryList_3*)_v;
  delete _p;
}

void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistoryList_3& _s)
{
  Tango::DevAttrHistoryList_3* _p = new Tango::DevAttrHistoryList_3(_s);
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistoryList__3,
               _0RL_Tango_mDevAttrHistoryList__3_marshal_fn,
               _0RL_Tango_mDevAttrHistoryList__3_destructor_fn,
               _p);
}
void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistoryList_3* _sp)
{
  _a.PR_insert(_0RL_tc_Tango_mDevAttrHistoryList__3,
               _0RL_Tango_mDevAttrHistoryList__3_marshal_fn,
               _0RL_Tango_mDevAttrHistoryList__3_destructor_fn,
               _sp);
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistoryList_3*& _sp)
{
  return _a >>= (const Tango::DevAttrHistoryList_3*&) _sp;
}
::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistoryList_3*& _sp)
{
  void* _v;
  if (_a.PR_extract(_0RL_tc_Tango_mDevAttrHistoryList__3,
                    _0RL_Tango_mDevAttrHistoryList__3_unmarshal_fn,
                    _0RL_Tango_mDevAttrHistoryList__3_marshal_fn,
                    _0RL_Tango_mDevAttrHistoryList__3_destructor_fn,
                    _v)) {
    _sp = (const Tango::DevAttrHistoryList_3*)_v;
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevice_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_Tango_mDevice_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(Tango::Device::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_Tango_mDevice_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, Tango::Device_ptr _o)
{
  Tango::Device_ptr _no = Tango::Device::_duplicate(_o);
  _a.PR_insert(Tango::_tc_Device,
               _0RL_Tango_mDevice_marshal_fn,
               _0RL_Tango_mDevice_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, Tango::Device_ptr* _op)
{
  _a.PR_insert(Tango::_tc_Device,
               _0RL_Tango_mDevice_marshal_fn,
               _0RL_Tango_mDevice_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = Tango::Device::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(Tango::_tc_Device,
                    _0RL_Tango_mDevice_unmarshal_fn,
                    _0RL_Tango_mDevice_marshal_fn,
                    _0RL_Tango_mDevice_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (Tango::Device_ptr)_r->_ptrToObjRef(Tango::Device::_PD_repoId);
    else
      _o = Tango::Device::_nil();
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevice__2_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_Tango_mDevice__2_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(Tango::Device_2::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_Tango_mDevice__2_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, Tango::Device_2_ptr _o)
{
  Tango::Device_2_ptr _no = Tango::Device_2::_duplicate(_o);
  _a.PR_insert(Tango::_tc_Device_2,
               _0RL_Tango_mDevice__2_marshal_fn,
               _0RL_Tango_mDevice__2_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, Tango::Device_2_ptr* _op)
{
  _a.PR_insert(Tango::_tc_Device_2,
               _0RL_Tango_mDevice__2_marshal_fn,
               _0RL_Tango_mDevice__2_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = Tango::Device_2::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_2_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(Tango::_tc_Device_2,
                    _0RL_Tango_mDevice__2_unmarshal_fn,
                    _0RL_Tango_mDevice__2_marshal_fn,
                    _0RL_Tango_mDevice__2_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (Tango::Device_2_ptr)_r->_ptrToObjRef(Tango::Device_2::_PD_repoId);
    else
      _o = Tango::Device_2::_nil();
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevice__3_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_Tango_mDevice__3_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(Tango::Device_3::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_Tango_mDevice__3_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, Tango::Device_3_ptr _o)
{
  Tango::Device_3_ptr _no = Tango::Device_3::_duplicate(_o);
  _a.PR_insert(Tango::_tc_Device_3,
               _0RL_Tango_mDevice__3_marshal_fn,
               _0RL_Tango_mDevice__3_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, Tango::Device_3_ptr* _op)
{
  _a.PR_insert(Tango::_tc_Device_3,
               _0RL_Tango_mDevice__3_marshal_fn,
               _0RL_Tango_mDevice__3_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = Tango::Device_3::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_3_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(Tango::_tc_Device_3,
                    _0RL_Tango_mDevice__3_unmarshal_fn,
                    _0RL_Tango_mDevice__3_marshal_fn,
                    _0RL_Tango_mDevice__3_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (Tango::Device_3_ptr)_r->_ptrToObjRef(Tango::Device_3::_PD_repoId);
    else
      _o = Tango::Device_3::_nil();
    return 1;
  }
  return 0;
}

static void _0RL_Tango_mDevice__4_marshal_fn(cdrStream& _s, void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  omniObjRef::_marshal(_o, _s);
}
static void _0RL_Tango_mDevice__4_unmarshal_fn(cdrStream& _s, void*& _v)
{
  omniObjRef* _o = omniObjRef::_unMarshal(Tango::Device_4::_PD_repoId, _s);
  _v = _o;
}
static void _0RL_Tango_mDevice__4_destructor_fn(void* _v)
{
  omniObjRef* _o = (omniObjRef*)_v;
  if (_o)
    omni::releaseObjRef(_o);
}

void operator<<=(::CORBA::Any& _a, Tango::Device_4_ptr _o)
{
  Tango::Device_4_ptr _no = Tango::Device_4::_duplicate(_o);
  _a.PR_insert(Tango::_tc_Device_4,
               _0RL_Tango_mDevice__4_marshal_fn,
               _0RL_Tango_mDevice__4_destructor_fn,
               _no->_PR_getobj());
}
void operator<<=(::CORBA::Any& _a, Tango::Device_4_ptr* _op)
{
  _a.PR_insert(Tango::_tc_Device_4,
               _0RL_Tango_mDevice__4_marshal_fn,
               _0RL_Tango_mDevice__4_destructor_fn,
               (*_op)->_PR_getobj());
  *_op = Tango::Device_4::_nil();
}

::CORBA::Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_4_ptr& _o)
{
  void* _v;
  if (_a.PR_extract(Tango::_tc_Device_4,
                    _0RL_Tango_mDevice__4_unmarshal_fn,
                    _0RL_Tango_mDevice__4_marshal_fn,
                    _0RL_Tango_mDevice__4_destructor_fn,
                    _v)) {
    omniObjRef* _r = (omniObjRef*)_v;
    if (_r)
      _o = (Tango::Device_4_ptr)_r->_ptrToObjRef(Tango::Device_4::_PD_repoId);
    else
      _o = Tango::Device_4::_nil();
    return 1;
  }
  return 0;
}


Generated by  Doxygen 1.6.0   Back to index