// This file is generated by omniidl (C++ backend)- omniORB_4_1. Do not edit.
//
// Copyright (C) :      2004,2005,2006,2007,2008,2009,2010,2011,2012
//						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/>.
//

#ifndef __tango_hh__
#define __tango_hh__

#ifndef __CORBA_H_EXTERNAL_GUARD__
#include <omniORB4/CORBA.h>
#endif

#ifndef  USE_stub_in_nt_dll
# define USE_stub_in_nt_dll_NOT_DEFINED_tango
#endif
#ifndef  USE_core_stub_in_nt_dll
# define USE_core_stub_in_nt_dll_NOT_DEFINED_tango
#endif
#ifndef  USE_dyn_stub_in_nt_dll
# define USE_dyn_stub_in_nt_dll_NOT_DEFINED_tango
#endif






#ifdef USE_stub_in_nt_dll
# ifndef USE_core_stub_in_nt_dll
#  define USE_core_stub_in_nt_dll
# endif
# ifndef USE_dyn_stub_in_nt_dll
#  define USE_dyn_stub_in_nt_dll
# endif
#endif

#ifdef _core_attr
# error "A local CPP macro _core_attr has already been defined."
#else
# ifdef  USE_core_stub_in_nt_dll
#  define _core_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _core_attr
# endif
#endif

#ifdef _dyn_attr
# error "A local CPP macro _dyn_attr has already been defined."
#else
# ifdef  USE_dyn_stub_in_nt_dll
#  define _dyn_attr _OMNIORB_NTDLL_IMPORT
# else
#  define _dyn_attr
# endif
#endif





_CORBA_MODULE Tango

_CORBA_MODULE_BEG

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevBoolean;

  typedef ::CORBA::Boolean DevBoolean;
  typedef ::CORBA::Boolean_out DevBoolean_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevDouble;

  typedef ::CORBA::Double DevDouble;
  typedef ::CORBA::Double_out DevDouble_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevFloat;

  typedef ::CORBA::Float DevFloat;
  typedef ::CORBA::Float_out DevFloat_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevShort;

  typedef ::CORBA::Short DevShort;
  typedef ::CORBA::Short_out DevShort_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevLong;

  typedef ::CORBA::Long DevLong;
  typedef ::CORBA::Long_out DevLong_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevLong64;

  typedef ::CORBA::LongLong DevLong64;
  typedef ::CORBA::LongLong_out DevLong64_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevString;

  typedef char* DevString;
  typedef ::CORBA::String_var DevString_var;
  typedef ::CORBA::String_out DevString_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevUChar;
  typedef ::CORBA::Octet DevUChar;
  typedef ::CORBA::Octet_out DevUChar_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevUShort;

  typedef ::CORBA::UShort DevUShort;
  typedef ::CORBA::UShort_out DevUShort_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevULong;

  typedef ::CORBA::ULong DevULong;
  typedef ::CORBA::ULong_out DevULong_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevULong64;

  typedef ::CORBA::ULongLong DevULong64;
  typedef ::CORBA::ULongLong_out DevULong64_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarBooleanArray;

  class DevVarBooleanArray_var;

  class DevVarBooleanArray : public _CORBA_Unbounded_Sequence_Boolean {
  public:
    typedef DevVarBooleanArray_var _var_type;
    inline DevVarBooleanArray() {}
    inline DevVarBooleanArray(const DevVarBooleanArray& _s)
      : _CORBA_Unbounded_Sequence_Boolean(_s) {}

    inline DevVarBooleanArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_Boolean(_max) {}
    inline DevVarBooleanArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Boolean* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_Boolean(_max, _len, _val, _rel) {}



    inline DevVarBooleanArray& operator = (const DevVarBooleanArray& _s) {
      _CORBA_Unbounded_Sequence_Boolean::operator=(_s);
      return *this;
    }
  };

  class DevVarBooleanArray_out;

  class DevVarBooleanArray_var {
  public:
    inline DevVarBooleanArray_var() : _pd_seq(0) {}
    inline DevVarBooleanArray_var(DevVarBooleanArray* _s) : _pd_seq(_s) {}
    inline DevVarBooleanArray_var(const DevVarBooleanArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarBooleanArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarBooleanArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarBooleanArray_var& operator = (DevVarBooleanArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarBooleanArray_var& operator = (const DevVarBooleanArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarBooleanArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::Boolean& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarBooleanArray* operator -> () { return _pd_seq; }
    inline const DevVarBooleanArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarBooleanArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarBooleanArray& () const { return *_pd_seq; }
    inline operator DevVarBooleanArray& () { return *_pd_seq; }
#endif

    inline const DevVarBooleanArray& in() const { return *_pd_seq; }
    inline DevVarBooleanArray&       inout()    { return *_pd_seq; }
    inline DevVarBooleanArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarBooleanArray* _retn() { DevVarBooleanArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarBooleanArray_out;

  private:
    DevVarBooleanArray* _pd_seq;
  };

  class DevVarBooleanArray_out {
  public:
    inline DevVarBooleanArray_out(DevVarBooleanArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarBooleanArray_out(DevVarBooleanArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarBooleanArray*) 0; }
    inline DevVarBooleanArray_out(const DevVarBooleanArray_out& _s) : _data(_s._data) {}
    inline DevVarBooleanArray_out& operator = (const DevVarBooleanArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarBooleanArray_out& operator = (DevVarBooleanArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarBooleanArray*&()  { return _data; }
    inline DevVarBooleanArray*& ptr()       { return _data; }
    inline DevVarBooleanArray* operator->() { return _data; }

    inline ::CORBA::Boolean& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarBooleanArray*& _data;

  private:
    DevVarBooleanArray_out();
    DevVarBooleanArray_out& operator=(const DevVarBooleanArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarDoubleArray;

  class DevVarDoubleArray_var;

  class DevVarDoubleArray : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 >  {
  public:
    typedef DevVarDoubleArray_var _var_type;
    inline DevVarDoubleArray() {}
    inline DevVarDoubleArray(const DevVarDoubleArray& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_s) {}

    inline DevVarDoubleArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max) {}
    inline DevVarDoubleArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Double* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > (_max, _len, _val, _rel) {}



    inline DevVarDoubleArray& operator = (const DevVarDoubleArray& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Double, 8, 8 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarDoubleArray_out;

  class DevVarDoubleArray_var {
  public:
    inline DevVarDoubleArray_var() : _pd_seq(0) {}
    inline DevVarDoubleArray_var(DevVarDoubleArray* _s) : _pd_seq(_s) {}
    inline DevVarDoubleArray_var(const DevVarDoubleArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarDoubleArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarDoubleArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarDoubleArray_var& operator = (DevVarDoubleArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarDoubleArray_var& operator = (const DevVarDoubleArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarDoubleArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::Double& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarDoubleArray* operator -> () { return _pd_seq; }
    inline const DevVarDoubleArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarDoubleArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarDoubleArray& () const { return *_pd_seq; }
    inline operator DevVarDoubleArray& () { return *_pd_seq; }
#endif

    inline const DevVarDoubleArray& in() const { return *_pd_seq; }
    inline DevVarDoubleArray&       inout()    { return *_pd_seq; }
    inline DevVarDoubleArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarDoubleArray* _retn() { DevVarDoubleArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarDoubleArray_out;

  private:
    DevVarDoubleArray* _pd_seq;
  };

  class DevVarDoubleArray_out {
  public:
    inline DevVarDoubleArray_out(DevVarDoubleArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarDoubleArray_out(DevVarDoubleArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarDoubleArray*) 0; }
    inline DevVarDoubleArray_out(const DevVarDoubleArray_out& _s) : _data(_s._data) {}
    inline DevVarDoubleArray_out& operator = (const DevVarDoubleArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarDoubleArray_out& operator = (DevVarDoubleArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarDoubleArray*&()  { return _data; }
    inline DevVarDoubleArray*& ptr()       { return _data; }
    inline DevVarDoubleArray* operator->() { return _data; }

    inline ::CORBA::Double& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarDoubleArray*& _data;

  private:
    DevVarDoubleArray_out();
    DevVarDoubleArray_out& operator=(const DevVarDoubleArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarFloatArray;

  class DevVarFloatArray_var;

  class DevVarFloatArray : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 >  {
  public:
    typedef DevVarFloatArray_var _var_type;
    inline DevVarFloatArray() {}
    inline DevVarFloatArray(const DevVarFloatArray& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_s) {}

    inline DevVarFloatArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_max) {}
    inline DevVarFloatArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Float* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > (_max, _len, _val, _rel) {}



    inline DevVarFloatArray& operator = (const DevVarFloatArray& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Float, 4, 4 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarFloatArray_out;

  class DevVarFloatArray_var {
  public:
    inline DevVarFloatArray_var() : _pd_seq(0) {}
    inline DevVarFloatArray_var(DevVarFloatArray* _s) : _pd_seq(_s) {}
    inline DevVarFloatArray_var(const DevVarFloatArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarFloatArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarFloatArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarFloatArray_var& operator = (DevVarFloatArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarFloatArray_var& operator = (const DevVarFloatArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarFloatArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::Float& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarFloatArray* operator -> () { return _pd_seq; }
    inline const DevVarFloatArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarFloatArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarFloatArray& () const { return *_pd_seq; }
    inline operator DevVarFloatArray& () { return *_pd_seq; }
#endif

    inline const DevVarFloatArray& in() const { return *_pd_seq; }
    inline DevVarFloatArray&       inout()    { return *_pd_seq; }
    inline DevVarFloatArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarFloatArray* _retn() { DevVarFloatArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarFloatArray_out;

  private:
    DevVarFloatArray* _pd_seq;
  };

  class DevVarFloatArray_out {
  public:
    inline DevVarFloatArray_out(DevVarFloatArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarFloatArray_out(DevVarFloatArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarFloatArray*) 0; }
    inline DevVarFloatArray_out(const DevVarFloatArray_out& _s) : _data(_s._data) {}
    inline DevVarFloatArray_out& operator = (const DevVarFloatArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarFloatArray_out& operator = (DevVarFloatArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarFloatArray*&()  { return _data; }
    inline DevVarFloatArray*& ptr()       { return _data; }
    inline DevVarFloatArray* operator->() { return _data; }

    inline ::CORBA::Float& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarFloatArray*& _data;

  private:
    DevVarFloatArray_out();
    DevVarFloatArray_out& operator=(const DevVarFloatArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarShortArray;

  class DevVarShortArray_var;

  class DevVarShortArray : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 >  {
  public:
    typedef DevVarShortArray_var _var_type;
    inline DevVarShortArray() {}
    inline DevVarShortArray(const DevVarShortArray& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > (_s) {}

    inline DevVarShortArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > (_max) {}
    inline DevVarShortArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Short* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > (_max, _len, _val, _rel) {}



    inline DevVarShortArray& operator = (const DevVarShortArray& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Short, 2, 2 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarShortArray_out;

  class DevVarShortArray_var {
  public:
    inline DevVarShortArray_var() : _pd_seq(0) {}
    inline DevVarShortArray_var(DevVarShortArray* _s) : _pd_seq(_s) {}
    inline DevVarShortArray_var(const DevVarShortArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarShortArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarShortArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarShortArray_var& operator = (DevVarShortArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarShortArray_var& operator = (const DevVarShortArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarShortArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::Short& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarShortArray* operator -> () { return _pd_seq; }
    inline const DevVarShortArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarShortArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarShortArray& () const { return *_pd_seq; }
    inline operator DevVarShortArray& () { return *_pd_seq; }
#endif

    inline const DevVarShortArray& in() const { return *_pd_seq; }
    inline DevVarShortArray&       inout()    { return *_pd_seq; }
    inline DevVarShortArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarShortArray* _retn() { DevVarShortArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarShortArray_out;

  private:
    DevVarShortArray* _pd_seq;
  };

  class DevVarShortArray_out {
  public:
    inline DevVarShortArray_out(DevVarShortArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarShortArray_out(DevVarShortArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarShortArray*) 0; }
    inline DevVarShortArray_out(const DevVarShortArray_out& _s) : _data(_s._data) {}
    inline DevVarShortArray_out& operator = (const DevVarShortArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarShortArray_out& operator = (DevVarShortArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarShortArray*&()  { return _data; }
    inline DevVarShortArray*& ptr()       { return _data; }
    inline DevVarShortArray* operator->() { return _data; }

    inline ::CORBA::Short& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarShortArray*& _data;

  private:
    DevVarShortArray_out();
    DevVarShortArray_out& operator=(const DevVarShortArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarLongArray;

  class DevVarLongArray_var;

  class DevVarLongArray : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 >  {
  public:
    typedef DevVarLongArray_var _var_type;
    inline DevVarLongArray() {}
    inline DevVarLongArray(const DevVarLongArray& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_s) {}

    inline DevVarLongArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max) {}
    inline DevVarLongArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Long* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > (_max, _len, _val, _rel) {}



    inline DevVarLongArray& operator = (const DevVarLongArray& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::Long, 4, 4 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarLongArray_out;

  class DevVarLongArray_var {
  public:
    inline DevVarLongArray_var() : _pd_seq(0) {}
    inline DevVarLongArray_var(DevVarLongArray* _s) : _pd_seq(_s) {}
    inline DevVarLongArray_var(const DevVarLongArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarLongArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarLongArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarLongArray_var& operator = (DevVarLongArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarLongArray_var& operator = (const DevVarLongArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarLongArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::Long& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarLongArray* operator -> () { return _pd_seq; }
    inline const DevVarLongArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarLongArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarLongArray& () const { return *_pd_seq; }
    inline operator DevVarLongArray& () { return *_pd_seq; }
#endif

    inline const DevVarLongArray& in() const { return *_pd_seq; }
    inline DevVarLongArray&       inout()    { return *_pd_seq; }
    inline DevVarLongArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarLongArray* _retn() { DevVarLongArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarLongArray_out;

  private:
    DevVarLongArray* _pd_seq;
  };

  class DevVarLongArray_out {
  public:
    inline DevVarLongArray_out(DevVarLongArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarLongArray_out(DevVarLongArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarLongArray*) 0; }
    inline DevVarLongArray_out(const DevVarLongArray_out& _s) : _data(_s._data) {}
    inline DevVarLongArray_out& operator = (const DevVarLongArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarLongArray_out& operator = (DevVarLongArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarLongArray*&()  { return _data; }
    inline DevVarLongArray*& ptr()       { return _data; }
    inline DevVarLongArray* operator->() { return _data; }

    inline ::CORBA::Long& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarLongArray*& _data;

  private:
    DevVarLongArray_out();
    DevVarLongArray_out& operator=(const DevVarLongArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarLong64Array;

  class DevVarLong64Array_var;

  class DevVarLong64Array : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 >  {
  public:
    typedef DevVarLong64Array_var _var_type;
    inline DevVarLong64Array() {}
    inline DevVarLong64Array(const DevVarLong64Array& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_s) {}

    inline DevVarLong64Array(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_max) {}
    inline DevVarLong64Array(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::LongLong* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > (_max, _len, _val, _rel) {}



    inline DevVarLong64Array& operator = (const DevVarLong64Array& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::LongLong, 8, 8 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarLong64Array_out;

  class DevVarLong64Array_var {
  public:
    inline DevVarLong64Array_var() : _pd_seq(0) {}
    inline DevVarLong64Array_var(DevVarLong64Array* _s) : _pd_seq(_s) {}
    inline DevVarLong64Array_var(const DevVarLong64Array_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarLong64Array(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarLong64Array_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarLong64Array_var& operator = (DevVarLong64Array* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarLong64Array_var& operator = (const DevVarLong64Array_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarLong64Array;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::LongLong& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarLong64Array* operator -> () { return _pd_seq; }
    inline const DevVarLong64Array* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarLong64Array& () const { return *_pd_seq; }
#else
    inline operator const DevVarLong64Array& () const { return *_pd_seq; }
    inline operator DevVarLong64Array& () { return *_pd_seq; }
#endif

    inline const DevVarLong64Array& in() const { return *_pd_seq; }
    inline DevVarLong64Array&       inout()    { return *_pd_seq; }
    inline DevVarLong64Array*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarLong64Array* _retn() { DevVarLong64Array* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarLong64Array_out;

  private:
    DevVarLong64Array* _pd_seq;
  };

  class DevVarLong64Array_out {
  public:
    inline DevVarLong64Array_out(DevVarLong64Array*& _s) : _data(_s) { _data = 0; }
    inline DevVarLong64Array_out(DevVarLong64Array_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarLong64Array*) 0; }
    inline DevVarLong64Array_out(const DevVarLong64Array_out& _s) : _data(_s._data) {}
    inline DevVarLong64Array_out& operator = (const DevVarLong64Array_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarLong64Array_out& operator = (DevVarLong64Array* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarLong64Array*&()  { return _data; }
    inline DevVarLong64Array*& ptr()       { return _data; }
    inline DevVarLong64Array* operator->() { return _data; }

    inline ::CORBA::LongLong& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarLong64Array*& _data;

  private:
    DevVarLong64Array_out();
    DevVarLong64Array_out& operator=(const DevVarLong64Array_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarCharArray;

  class DevVarCharArray_var;

  class DevVarCharArray : public _CORBA_Unbounded_Sequence_Octet {
  public:
    typedef DevVarCharArray_var _var_type;
    inline DevVarCharArray() {}
    inline DevVarCharArray(const DevVarCharArray& _s)
      : _CORBA_Unbounded_Sequence_Octet(_s) {}

    inline DevVarCharArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_Octet(_max) {}
    inline DevVarCharArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::Octet* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_Octet(_max, _len, _val, _rel) {}



    inline DevVarCharArray& operator = (const DevVarCharArray& _s) {
      _CORBA_Unbounded_Sequence_Octet::operator=(_s);
      return *this;
    }
  };

  class DevVarCharArray_out;

  class DevVarCharArray_var {
  public:
    inline DevVarCharArray_var() : _pd_seq(0) {}
    inline DevVarCharArray_var(DevVarCharArray* _s) : _pd_seq(_s) {}
    inline DevVarCharArray_var(const DevVarCharArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarCharArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarCharArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarCharArray_var& operator = (DevVarCharArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarCharArray_var& operator = (const DevVarCharArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarCharArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::Octet& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarCharArray* operator -> () { return _pd_seq; }
    inline const DevVarCharArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarCharArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarCharArray& () const { return *_pd_seq; }
    inline operator DevVarCharArray& () { return *_pd_seq; }
#endif

    inline const DevVarCharArray& in() const { return *_pd_seq; }
    inline DevVarCharArray&       inout()    { return *_pd_seq; }
    inline DevVarCharArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarCharArray* _retn() { DevVarCharArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarCharArray_out;

  private:
    DevVarCharArray* _pd_seq;
  };

  class DevVarCharArray_out {
  public:
    inline DevVarCharArray_out(DevVarCharArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarCharArray_out(DevVarCharArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarCharArray*) 0; }
    inline DevVarCharArray_out(const DevVarCharArray_out& _s) : _data(_s._data) {}
    inline DevVarCharArray_out& operator = (const DevVarCharArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarCharArray_out& operator = (DevVarCharArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarCharArray*&()  { return _data; }
    inline DevVarCharArray*& ptr()       { return _data; }
    inline DevVarCharArray* operator->() { return _data; }

    inline ::CORBA::Octet& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarCharArray*& _data;

  private:
    DevVarCharArray_out();
    DevVarCharArray_out& operator=(const DevVarCharArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarStringArray;

  class DevVarStringArray_var;

  class DevVarStringArray : public _CORBA_Unbounded_Sequence_String {
  public:
    typedef DevVarStringArray_var _var_type;
    inline DevVarStringArray() {}
    inline DevVarStringArray(const DevVarStringArray& _s)
      : _CORBA_Unbounded_Sequence_String(_s) {}

    inline DevVarStringArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_String(_max) {}
    inline DevVarStringArray(_CORBA_ULong _max, _CORBA_ULong _len, char** _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_String(_max, _len, _val, _rel) {}



    inline DevVarStringArray& operator = (const DevVarStringArray& _s) {
      _CORBA_Unbounded_Sequence_String::operator=(_s);
      return *this;
    }
  };

  class DevVarStringArray_out;

  class DevVarStringArray_var {
  public:
    inline DevVarStringArray_var() : _pd_seq(0) {}
    inline DevVarStringArray_var(DevVarStringArray* _s) : _pd_seq(_s) {}
    inline DevVarStringArray_var(const DevVarStringArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarStringArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarStringArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarStringArray_var& operator = (DevVarStringArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarStringArray_var& operator = (const DevVarStringArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarStringArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline _CORBA_String_element operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarStringArray* operator -> () { return _pd_seq; }
    inline const DevVarStringArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarStringArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarStringArray& () const { return *_pd_seq; }
    inline operator DevVarStringArray& () { return *_pd_seq; }
#endif

    inline const DevVarStringArray& in() const { return *_pd_seq; }
    inline DevVarStringArray&       inout()    { return *_pd_seq; }
    inline DevVarStringArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarStringArray* _retn() { DevVarStringArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarStringArray_out;

  private:
    DevVarStringArray* _pd_seq;
  };

  class DevVarStringArray_out {
  public:
    inline DevVarStringArray_out(DevVarStringArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarStringArray_out(DevVarStringArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarStringArray*) 0; }
    inline DevVarStringArray_out(const DevVarStringArray_out& _s) : _data(_s._data) {}
    inline DevVarStringArray_out& operator = (const DevVarStringArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarStringArray_out& operator = (DevVarStringArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarStringArray*&()  { return _data; }
    inline DevVarStringArray*& ptr()       { return _data; }
    inline DevVarStringArray* operator->() { return _data; }

    inline _CORBA_String_element operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarStringArray*& _data;

  private:
    DevVarStringArray_out();
    DevVarStringArray_out& operator=(const DevVarStringArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarUShortArray;

  class DevVarUShortArray_var;

  class DevVarUShortArray : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 >  {
  public:
    typedef DevVarUShortArray_var _var_type;
    inline DevVarUShortArray() {}
    inline DevVarUShortArray(const DevVarUShortArray& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > (_s) {}

    inline DevVarUShortArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > (_max) {}
    inline DevVarUShortArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::UShort* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > (_max, _len, _val, _rel) {}



    inline DevVarUShortArray& operator = (const DevVarUShortArray& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::UShort, 2, 2 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarUShortArray_out;

  class DevVarUShortArray_var {
  public:
    inline DevVarUShortArray_var() : _pd_seq(0) {}
    inline DevVarUShortArray_var(DevVarUShortArray* _s) : _pd_seq(_s) {}
    inline DevVarUShortArray_var(const DevVarUShortArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarUShortArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarUShortArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarUShortArray_var& operator = (DevVarUShortArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarUShortArray_var& operator = (const DevVarUShortArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarUShortArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::UShort& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarUShortArray* operator -> () { return _pd_seq; }
    inline const DevVarUShortArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarUShortArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarUShortArray& () const { return *_pd_seq; }
    inline operator DevVarUShortArray& () { return *_pd_seq; }
#endif

    inline const DevVarUShortArray& in() const { return *_pd_seq; }
    inline DevVarUShortArray&       inout()    { return *_pd_seq; }
    inline DevVarUShortArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarUShortArray* _retn() { DevVarUShortArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarUShortArray_out;

  private:
    DevVarUShortArray* _pd_seq;
  };

  class DevVarUShortArray_out {
  public:
    inline DevVarUShortArray_out(DevVarUShortArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarUShortArray_out(DevVarUShortArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarUShortArray*) 0; }
    inline DevVarUShortArray_out(const DevVarUShortArray_out& _s) : _data(_s._data) {}
    inline DevVarUShortArray_out& operator = (const DevVarUShortArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarUShortArray_out& operator = (DevVarUShortArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarUShortArray*&()  { return _data; }
    inline DevVarUShortArray*& ptr()       { return _data; }
    inline DevVarUShortArray* operator->() { return _data; }

    inline ::CORBA::UShort& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarUShortArray*& _data;

  private:
    DevVarUShortArray_out();
    DevVarUShortArray_out& operator=(const DevVarUShortArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarULongArray;

  class DevVarULongArray_var;

  class DevVarULongArray : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 >  {
  public:
    typedef DevVarULongArray_var _var_type;
    inline DevVarULongArray() {}
    inline DevVarULongArray(const DevVarULongArray& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > (_s) {}

    inline DevVarULongArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > (_max) {}
    inline DevVarULongArray(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::ULong* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > (_max, _len, _val, _rel) {}



    inline DevVarULongArray& operator = (const DevVarULongArray& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULong, 4, 4 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarULongArray_out;

  class DevVarULongArray_var {
  public:
    inline DevVarULongArray_var() : _pd_seq(0) {}
    inline DevVarULongArray_var(DevVarULongArray* _s) : _pd_seq(_s) {}
    inline DevVarULongArray_var(const DevVarULongArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarULongArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarULongArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarULongArray_var& operator = (DevVarULongArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarULongArray_var& operator = (const DevVarULongArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarULongArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::ULong& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarULongArray* operator -> () { return _pd_seq; }
    inline const DevVarULongArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarULongArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarULongArray& () const { return *_pd_seq; }
    inline operator DevVarULongArray& () { return *_pd_seq; }
#endif

    inline const DevVarULongArray& in() const { return *_pd_seq; }
    inline DevVarULongArray&       inout()    { return *_pd_seq; }
    inline DevVarULongArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarULongArray* _retn() { DevVarULongArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarULongArray_out;

  private:
    DevVarULongArray* _pd_seq;
  };

  class DevVarULongArray_out {
  public:
    inline DevVarULongArray_out(DevVarULongArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarULongArray_out(DevVarULongArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarULongArray*) 0; }
    inline DevVarULongArray_out(const DevVarULongArray_out& _s) : _data(_s._data) {}
    inline DevVarULongArray_out& operator = (const DevVarULongArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarULongArray_out& operator = (DevVarULongArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarULongArray*&()  { return _data; }
    inline DevVarULongArray*& ptr()       { return _data; }
    inline DevVarULongArray* operator->() { return _data; }

    inline ::CORBA::ULong& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarULongArray*& _data;

  private:
    DevVarULongArray_out();
    DevVarULongArray_out& operator=(const DevVarULongArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarULong64Array;

  class DevVarULong64Array_var;

  class DevVarULong64Array : public _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 >  {
  public:
    typedef DevVarULong64Array_var _var_type;
    inline DevVarULong64Array() {}
    inline DevVarULong64Array(const DevVarULong64Array& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > (_s) {}

    inline DevVarULong64Array(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > (_max) {}
    inline DevVarULong64Array(_CORBA_ULong _max, _CORBA_ULong _len, ::CORBA::ULongLong* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > (_max, _len, _val, _rel) {}



    inline DevVarULong64Array& operator = (const DevVarULong64Array& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< ::CORBA::ULongLong, 8, 8 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarULong64Array_out;

  class DevVarULong64Array_var {
  public:
    inline DevVarULong64Array_var() : _pd_seq(0) {}
    inline DevVarULong64Array_var(DevVarULong64Array* _s) : _pd_seq(_s) {}
    inline DevVarULong64Array_var(const DevVarULong64Array_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarULong64Array(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarULong64Array_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarULong64Array_var& operator = (DevVarULong64Array* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarULong64Array_var& operator = (const DevVarULong64Array_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarULong64Array;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline ::CORBA::ULongLong& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarULong64Array* operator -> () { return _pd_seq; }
    inline const DevVarULong64Array* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarULong64Array& () const { return *_pd_seq; }
#else
    inline operator const DevVarULong64Array& () const { return *_pd_seq; }
    inline operator DevVarULong64Array& () { return *_pd_seq; }
#endif

    inline const DevVarULong64Array& in() const { return *_pd_seq; }
    inline DevVarULong64Array&       inout()    { return *_pd_seq; }
    inline DevVarULong64Array*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarULong64Array* _retn() { DevVarULong64Array* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarULong64Array_out;

  private:
    DevVarULong64Array* _pd_seq;
  };

  class DevVarULong64Array_out {
  public:
    inline DevVarULong64Array_out(DevVarULong64Array*& _s) : _data(_s) { _data = 0; }
    inline DevVarULong64Array_out(DevVarULong64Array_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarULong64Array*) 0; }
    inline DevVarULong64Array_out(const DevVarULong64Array_out& _s) : _data(_s._data) {}
    inline DevVarULong64Array_out& operator = (const DevVarULong64Array_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarULong64Array_out& operator = (DevVarULong64Array* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarULong64Array*&()  { return _data; }
    inline DevVarULong64Array*& ptr()       { return _data; }
    inline DevVarULong64Array* operator->() { return _data; }

    inline ::CORBA::ULongLong& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarULong64Array*& _data;

  private:
    DevVarULong64Array_out();
    DevVarULong64Array_out& operator=(const DevVarULong64Array_var&);
  };

  struct DevVarLongStringArray {
    typedef _CORBA_ConstrType_Variable_Var<DevVarLongStringArray> _var_type;


    DevVarLongArray lvalue;

    DevVarStringArray svalue;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevVarLongStringArray::_var_type DevVarLongStringArray_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevVarLongStringArray,DevVarLongStringArray_var > DevVarLongStringArray_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarLongStringArray;

  struct DevVarDoubleStringArray {
    typedef _CORBA_ConstrType_Variable_Var<DevVarDoubleStringArray> _var_type;


    DevVarDoubleArray dvalue;

    DevVarStringArray svalue;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevVarDoubleStringArray::_var_type DevVarDoubleStringArray_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevVarDoubleStringArray,DevVarDoubleStringArray_var > DevVarDoubleStringArray_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarDoubleStringArray;

  struct DevEncoded {
    typedef _CORBA_ConstrType_Variable_Var<DevEncoded> _var_type;


    ::CORBA::String_member encoded_format;

    DevVarCharArray encoded_data;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevEncoded::_var_type DevEncoded_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevEncoded,DevEncoded_var > DevEncoded_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevEncoded;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarEncodedArray;

  class DevVarEncodedArray_var;

  class DevVarEncodedArray : public _CORBA_Unbounded_Sequence< DevEncoded >  {
  public:
    typedef DevVarEncodedArray_var _var_type;
    inline DevVarEncodedArray() {}
    inline DevVarEncodedArray(const DevVarEncodedArray& _s)
      : _CORBA_Unbounded_Sequence< DevEncoded > (_s) {}

    inline DevVarEncodedArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevEncoded > (_max) {}
    inline DevVarEncodedArray(_CORBA_ULong _max, _CORBA_ULong _len, DevEncoded* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevEncoded > (_max, _len, _val, _rel) {}



    inline DevVarEncodedArray& operator = (const DevVarEncodedArray& _s) {
      _CORBA_Unbounded_Sequence< DevEncoded > ::operator=(_s);
      return *this;
    }
  };

  class DevVarEncodedArray_out;

  class DevVarEncodedArray_var {
  public:
    inline DevVarEncodedArray_var() : _pd_seq(0) {}
    inline DevVarEncodedArray_var(DevVarEncodedArray* _s) : _pd_seq(_s) {}
    inline DevVarEncodedArray_var(const DevVarEncodedArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarEncodedArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarEncodedArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarEncodedArray_var& operator = (DevVarEncodedArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarEncodedArray_var& operator = (const DevVarEncodedArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarEncodedArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevEncoded& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarEncodedArray* operator -> () { return _pd_seq; }
    inline const DevVarEncodedArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarEncodedArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarEncodedArray& () const { return *_pd_seq; }
    inline operator DevVarEncodedArray& () { return *_pd_seq; }
#endif

    inline const DevVarEncodedArray& in() const { return *_pd_seq; }
    inline DevVarEncodedArray&       inout()    { return *_pd_seq; }
    inline DevVarEncodedArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarEncodedArray* _retn() { DevVarEncodedArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarEncodedArray_out;

  private:
    DevVarEncodedArray* _pd_seq;
  };

  class DevVarEncodedArray_out {
  public:
    inline DevVarEncodedArray_out(DevVarEncodedArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarEncodedArray_out(DevVarEncodedArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarEncodedArray*) 0; }
    inline DevVarEncodedArray_out(const DevVarEncodedArray_out& _s) : _data(_s._data) {}
    inline DevVarEncodedArray_out& operator = (const DevVarEncodedArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarEncodedArray_out& operator = (DevVarEncodedArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarEncodedArray*&()  { return _data; }
    inline DevVarEncodedArray*& ptr()       { return _data; }
    inline DevVarEncodedArray* operator->() { return _data; }

    inline DevEncoded& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarEncodedArray*& _data;

  private:
    DevVarEncodedArray_out();
    DevVarEncodedArray_out& operator=(const DevVarEncodedArray_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_JavaUUID;

  typedef ::CORBA::ULongLong JavaUUID[2];
  typedef ::CORBA::ULongLong JavaUUID_slice;

  _CORBA_MODULE_INLINE JavaUUID_slice* JavaUUID_alloc() {
    return new JavaUUID_slice[2];
  }

  _CORBA_MODULE_INLINE JavaUUID_slice* JavaUUID_dup(const JavaUUID_slice* _s) {
    if (!_s) return 0;
    JavaUUID_slice* _data = JavaUUID_alloc();
    if (_data) {
      for (_CORBA_ULong _0i0 = 0; _0i0 < 2; _0i0++){

        _data[_0i0] = _s[_0i0];

      }

    }
    return _data;
  }

  _CORBA_MODULE_INLINE void JavaUUID_copy(JavaUUID_slice* _to, const JavaUUID_slice* _from){
    for (_CORBA_ULong _0i0 = 0; _0i0 < 2; _0i0++){

      _to[_0i0] = _from[_0i0];

    }

  }

  _CORBA_MODULE_INLINE void JavaUUID_free(JavaUUID_slice* _s) {
    delete [] _s;
  }

  class JavaUUID_copyHelper {
  public:
    static inline JavaUUID_slice* alloc() { return ::Tango::JavaUUID_alloc(); }
    static inline JavaUUID_slice* dup(const JavaUUID_slice* p) { return ::Tango::JavaUUID_dup(p); }
    static inline void free(JavaUUID_slice* p) { ::Tango::JavaUUID_free(p); }
  };

  typedef _CORBA_Array_Fix_Var<JavaUUID_copyHelper,JavaUUID_slice> JavaUUID_var;
  typedef _CORBA_Array_Fix_Forany<JavaUUID_copyHelper,JavaUUID_slice> JavaUUID_forany;

  typedef JavaUUID_slice* JavaUUID_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_CppClntIdent;

  typedef ::CORBA::ULong CppClntIdent;
  typedef ::CORBA::ULong_out CppClntIdent_out;

  struct JavaClntIdent {
    typedef _CORBA_ConstrType_Variable_Var<JavaClntIdent> _var_type;


    ::CORBA::String_member MainClass;

    JavaUUID uuid;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef JavaClntIdent::_var_type JavaClntIdent_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< JavaClntIdent,JavaClntIdent_var > JavaClntIdent_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_JavaClntIdent;

  enum LockerLanguage { CPP, JAVA /*, __max_LockerLanguage=0xffffffff */ };
  typedef LockerLanguage& LockerLanguage_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_LockerLanguage;

  class ClntIdent {
  public:

    typedef _CORBA_ConstrType_Variable_Var<ClntIdent> _var_type;



    ClntIdent(): _pd__initialised(0) {

    }

    ClntIdent(const ClntIdent& _value) {
      _pd__initialised = _value._pd__initialised;
      switch(_value._pd__d) {
        case CPP: cpp_clnt(_value._pd_cpp_clnt); break;

        case JAVA: java_clnt(_value._pd_java_clnt); break;

          default: break;


      }
      _pd__d = _value._pd__d;

    }

    ~ClntIdent() {}

    ClntIdent& operator=(const ClntIdent& _value) {
      _pd__initialised = _value._pd__initialised;
      switch(_value._pd__d) {
        case CPP: cpp_clnt(_value._pd_cpp_clnt); break;

        case JAVA: java_clnt(_value._pd_java_clnt); break;

          default: break;


      }
      _pd__d = _value._pd__d;

      return *this;
    }

    LockerLanguage _d() const { return _pd__d;}
    void _d(LockerLanguage _value){
      // illegal to set discriminator before making a member active
      if (!_pd__initialised)
        OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);

      if (_value == _pd__d) return; // no change

      switch (_pd__d){
        case CPP: goto fail;
        case JAVA: goto fail;
        default: goto fail;

      };


      fail:
      OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);



    }



    CppClntIdent cpp_clnt () const { return _pd_cpp_clnt; }
    void cpp_clnt (CppClntIdent  _value) {
      _pd__initialised = 1;
      _pd__d = CPP;
      _pd__default = 0;
      _pd_cpp_clnt = _value;
    }

    const JavaClntIdent &java_clnt () const { return _pd_java_clnt; }
    JavaClntIdent &java_clnt () { return _pd_java_clnt; }
    void java_clnt (const JavaClntIdent& _value) {
      _pd__initialised = 1;
      _pd__d = JAVA;
      _pd__default = 0;
      _pd_java_clnt = _value;
    }



    void operator>>= (cdrStream&) const;
    void operator<<= (cdrStream&);

  private:
    LockerLanguage _pd__d;
    _CORBA_Boolean _pd__default;
    _CORBA_Boolean _pd__initialised;

    union {
      CppClntIdent _pd_cpp_clnt;


    };


    JavaClntIdent _pd_java_clnt;


  };

  typedef ClntIdent::_var_type ClntIdent_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ClntIdent,ClntIdent_var > ClntIdent_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ClntIdent;

  enum AttrQuality { ATTR_VALID, ATTR_INVALID, ATTR_ALARM, ATTR_CHANGING, ATTR_WARNING /*, __max_AttrQuality=0xffffffff */ };
  typedef AttrQuality& AttrQuality_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttrQuality;

  enum AttrWriteType { READ, READ_WITH_WRITE, WRITE, READ_WRITE /*, __max_AttrWriteType=0xffffffff */ };
  typedef AttrWriteType& AttrWriteType_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttrWriteType;

  enum AttrDataFormat { SCALAR, SPECTRUM, IMAGE, FMT_UNKNOWN /*, __max_AttrDataFormat=0xffffffff */ };
  typedef AttrDataFormat& AttrDataFormat_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttrDataFormat;

  enum DevSource { DEV, CACHE, CACHE_DEV /*, __max_DevSource=0xffffffff */ };
  typedef DevSource& DevSource_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevSource;

  enum ErrSeverity { WARN, ERR, PANIC /*, __max_ErrSeverity=0xffffffff */ };
  typedef ErrSeverity& ErrSeverity_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ErrSeverity;

  enum DevState { ON, OFF, CLOSE, OPEN, INSERT, EXTRACT, MOVING, STANDBY, FAULT, INIT, RUNNING, ALARM, DISABLE, UNKNOWN /*, __max_DevState=0xffffffff */ };
  typedef DevState& DevState_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevState;

  enum DispLevel { OPERATOR, EXPERT /*, __max_DispLevel=0xffffffff */ };
  typedef DispLevel& DispLevel_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DispLevel;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevVarStateArray;

  // Need to declare <<= for elem type, as GCC expands templates early
#if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
   friend inline void operator >>= (DevState, cdrStream&);
   friend inline void operator <<= (DevState&, cdrStream&);
#endif

  class DevVarStateArray_var;

  class DevVarStateArray : public _CORBA_Unbounded_Sequence_w_FixSizeElement< DevState, 4, 4 >  {
  public:
    typedef DevVarStateArray_var _var_type;
    inline DevVarStateArray() {}
    inline DevVarStateArray(const DevVarStateArray& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< DevState, 4, 4 > (_s) {}

    inline DevVarStateArray(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< DevState, 4, 4 > (_max) {}
    inline DevVarStateArray(_CORBA_ULong _max, _CORBA_ULong _len, DevState* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< DevState, 4, 4 > (_max, _len, _val, _rel) {}



    inline DevVarStateArray& operator = (const DevVarStateArray& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< DevState, 4, 4 > ::operator=(_s);
      return *this;
    }
  };

  class DevVarStateArray_out;

  class DevVarStateArray_var {
  public:
    inline DevVarStateArray_var() : _pd_seq(0) {}
    inline DevVarStateArray_var(DevVarStateArray* _s) : _pd_seq(_s) {}
    inline DevVarStateArray_var(const DevVarStateArray_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevVarStateArray(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevVarStateArray_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevVarStateArray_var& operator = (DevVarStateArray* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevVarStateArray_var& operator = (const DevVarStateArray_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevVarStateArray;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevState& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevVarStateArray* operator -> () { return _pd_seq; }
    inline const DevVarStateArray* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevVarStateArray& () const { return *_pd_seq; }
#else
    inline operator const DevVarStateArray& () const { return *_pd_seq; }
    inline operator DevVarStateArray& () { return *_pd_seq; }
#endif

    inline const DevVarStateArray& in() const { return *_pd_seq; }
    inline DevVarStateArray&       inout()    { return *_pd_seq; }
    inline DevVarStateArray*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevVarStateArray* _retn() { DevVarStateArray* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevVarStateArray_out;

  private:
    DevVarStateArray* _pd_seq;
  };

  class DevVarStateArray_out {
  public:
    inline DevVarStateArray_out(DevVarStateArray*& _s) : _data(_s) { _data = 0; }
    inline DevVarStateArray_out(DevVarStateArray_var& _s)
      : _data(_s._pd_seq) { _s = (DevVarStateArray*) 0; }
    inline DevVarStateArray_out(const DevVarStateArray_out& _s) : _data(_s._data) {}
    inline DevVarStateArray_out& operator = (const DevVarStateArray_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevVarStateArray_out& operator = (DevVarStateArray* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevVarStateArray*&()  { return _data; }
    inline DevVarStateArray*& ptr()       { return _data; }
    inline DevVarStateArray* operator->() { return _data; }

    inline DevState& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevVarStateArray*& _data;

  private:
    DevVarStateArray_out();
    DevVarStateArray_out& operator=(const DevVarStateArray_var&);
  };

  struct TimeVal {
    typedef _CORBA_ConstrType_Fix_Var<TimeVal> _var_type;


    ::CORBA::Long tv_sec;

    ::CORBA::Long tv_usec;

    ::CORBA::Long tv_nsec;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef TimeVal::_var_type TimeVal_var;

  typedef TimeVal& TimeVal_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TimeVal;

  struct DevCmdInfo {
    typedef _CORBA_ConstrType_Variable_Var<DevCmdInfo> _var_type;


    ::CORBA::String_member cmd_name;

    ::CORBA::Long cmd_tag;

    ::CORBA::Long in_type;

    ::CORBA::Long out_type;

    ::CORBA::String_member in_type_desc;

    ::CORBA::String_member out_type_desc;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevCmdInfo::_var_type DevCmdInfo_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevCmdInfo,DevCmdInfo_var > DevCmdInfo_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevCmdInfo;

  struct DevCmdInfo_2 {
    typedef _CORBA_ConstrType_Variable_Var<DevCmdInfo_2> _var_type;


    ::CORBA::String_member cmd_name;

    DispLevel level;

    ::CORBA::Long cmd_tag;

    ::CORBA::Long in_type;

    ::CORBA::Long out_type;

    ::CORBA::String_member in_type_desc;

    ::CORBA::String_member out_type_desc;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevCmdInfo_2::_var_type DevCmdInfo_2_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevCmdInfo_2,DevCmdInfo_2_var > DevCmdInfo_2_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevCmdInfo_2;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevCmdInfoList;

  class DevCmdInfoList_var;

  class DevCmdInfoList : public _CORBA_Unbounded_Sequence< DevCmdInfo >  {
  public:
    typedef DevCmdInfoList_var _var_type;
    inline DevCmdInfoList() {}
    inline DevCmdInfoList(const DevCmdInfoList& _s)
      : _CORBA_Unbounded_Sequence< DevCmdInfo > (_s) {}

    inline DevCmdInfoList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevCmdInfo > (_max) {}
    inline DevCmdInfoList(_CORBA_ULong _max, _CORBA_ULong _len, DevCmdInfo* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevCmdInfo > (_max, _len, _val, _rel) {}



    inline DevCmdInfoList& operator = (const DevCmdInfoList& _s) {
      _CORBA_Unbounded_Sequence< DevCmdInfo > ::operator=(_s);
      return *this;
    }
  };

  class DevCmdInfoList_out;

  class DevCmdInfoList_var {
  public:
    inline DevCmdInfoList_var() : _pd_seq(0) {}
    inline DevCmdInfoList_var(DevCmdInfoList* _s) : _pd_seq(_s) {}
    inline DevCmdInfoList_var(const DevCmdInfoList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevCmdInfoList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevCmdInfoList_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevCmdInfoList_var& operator = (DevCmdInfoList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevCmdInfoList_var& operator = (const DevCmdInfoList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevCmdInfoList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevCmdInfo& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevCmdInfoList* operator -> () { return _pd_seq; }
    inline const DevCmdInfoList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevCmdInfoList& () const { return *_pd_seq; }
#else
    inline operator const DevCmdInfoList& () const { return *_pd_seq; }
    inline operator DevCmdInfoList& () { return *_pd_seq; }
#endif

    inline const DevCmdInfoList& in() const { return *_pd_seq; }
    inline DevCmdInfoList&       inout()    { return *_pd_seq; }
    inline DevCmdInfoList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevCmdInfoList* _retn() { DevCmdInfoList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevCmdInfoList_out;

  private:
    DevCmdInfoList* _pd_seq;
  };

  class DevCmdInfoList_out {
  public:
    inline DevCmdInfoList_out(DevCmdInfoList*& _s) : _data(_s) { _data = 0; }
    inline DevCmdInfoList_out(DevCmdInfoList_var& _s)
      : _data(_s._pd_seq) { _s = (DevCmdInfoList*) 0; }
    inline DevCmdInfoList_out(const DevCmdInfoList_out& _s) : _data(_s._data) {}
    inline DevCmdInfoList_out& operator = (const DevCmdInfoList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevCmdInfoList_out& operator = (DevCmdInfoList* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevCmdInfoList*&()  { return _data; }
    inline DevCmdInfoList*& ptr()       { return _data; }
    inline DevCmdInfoList* operator->() { return _data; }

    inline DevCmdInfo& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevCmdInfoList*& _data;

  private:
    DevCmdInfoList_out();
    DevCmdInfoList_out& operator=(const DevCmdInfoList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevCmdInfoList_2;

  class DevCmdInfoList_2_var;

  class DevCmdInfoList_2 : public _CORBA_Unbounded_Sequence< DevCmdInfo_2 >  {
  public:
    typedef DevCmdInfoList_2_var _var_type;
    inline DevCmdInfoList_2() {}
    inline DevCmdInfoList_2(const DevCmdInfoList_2& _s)
      : _CORBA_Unbounded_Sequence< DevCmdInfo_2 > (_s) {}

    inline DevCmdInfoList_2(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevCmdInfo_2 > (_max) {}
    inline DevCmdInfoList_2(_CORBA_ULong _max, _CORBA_ULong _len, DevCmdInfo_2* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevCmdInfo_2 > (_max, _len, _val, _rel) {}



    inline DevCmdInfoList_2& operator = (const DevCmdInfoList_2& _s) {
      _CORBA_Unbounded_Sequence< DevCmdInfo_2 > ::operator=(_s);
      return *this;
    }
  };

  class DevCmdInfoList_2_out;

  class DevCmdInfoList_2_var {
  public:
    inline DevCmdInfoList_2_var() : _pd_seq(0) {}
    inline DevCmdInfoList_2_var(DevCmdInfoList_2* _s) : _pd_seq(_s) {}
    inline DevCmdInfoList_2_var(const DevCmdInfoList_2_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevCmdInfoList_2(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevCmdInfoList_2_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevCmdInfoList_2_var& operator = (DevCmdInfoList_2* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevCmdInfoList_2_var& operator = (const DevCmdInfoList_2_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevCmdInfoList_2;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevCmdInfo_2& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevCmdInfoList_2* operator -> () { return _pd_seq; }
    inline const DevCmdInfoList_2* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevCmdInfoList_2& () const { return *_pd_seq; }
#else
    inline operator const DevCmdInfoList_2& () const { return *_pd_seq; }
    inline operator DevCmdInfoList_2& () { return *_pd_seq; }
#endif

    inline const DevCmdInfoList_2& in() const { return *_pd_seq; }
    inline DevCmdInfoList_2&       inout()    { return *_pd_seq; }
    inline DevCmdInfoList_2*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevCmdInfoList_2* _retn() { DevCmdInfoList_2* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevCmdInfoList_2_out;

  private:
    DevCmdInfoList_2* _pd_seq;
  };

  class DevCmdInfoList_2_out {
  public:
    inline DevCmdInfoList_2_out(DevCmdInfoList_2*& _s) : _data(_s) { _data = 0; }
    inline DevCmdInfoList_2_out(DevCmdInfoList_2_var& _s)
      : _data(_s._pd_seq) { _s = (DevCmdInfoList_2*) 0; }
    inline DevCmdInfoList_2_out(const DevCmdInfoList_2_out& _s) : _data(_s._data) {}
    inline DevCmdInfoList_2_out& operator = (const DevCmdInfoList_2_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevCmdInfoList_2_out& operator = (DevCmdInfoList_2* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevCmdInfoList_2*&()  { return _data; }
    inline DevCmdInfoList_2*& ptr()       { return _data; }
    inline DevCmdInfoList_2* operator->() { return _data; }

    inline DevCmdInfo_2& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevCmdInfoList_2*& _data;

  private:
    DevCmdInfoList_2_out();
    DevCmdInfoList_2_out& operator=(const DevCmdInfoList_2_var&);
  };

  struct DevError {
    typedef _CORBA_ConstrType_Variable_Var<DevError> _var_type;


    ::CORBA::String_member reason;

    ErrSeverity severity;

    ::CORBA::String_member desc;

    ::CORBA::String_member origin;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevError::_var_type DevError_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevError,DevError_var > DevError_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevError;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevErrorList;

  class DevErrorList_var;

  class DevErrorList : public _CORBA_Unbounded_Sequence< DevError >  {
  public:
    typedef DevErrorList_var _var_type;
    inline DevErrorList() {}
    inline DevErrorList(const DevErrorList& _s)
      : _CORBA_Unbounded_Sequence< DevError > (_s) {}

    inline DevErrorList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevError > (_max) {}
    inline DevErrorList(_CORBA_ULong _max, _CORBA_ULong _len, DevError* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevError > (_max, _len, _val, _rel) {}



    inline DevErrorList& operator = (const DevErrorList& _s) {
      _CORBA_Unbounded_Sequence< DevError > ::operator=(_s);
      return *this;
    }
  };

  class DevErrorList_out;

  class DevErrorList_var {
  public:
    inline DevErrorList_var() : _pd_seq(0) {}
    inline DevErrorList_var(DevErrorList* _s) : _pd_seq(_s) {}
    inline DevErrorList_var(const DevErrorList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevErrorList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevErrorList_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevErrorList_var& operator = (DevErrorList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevErrorList_var& operator = (const DevErrorList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevErrorList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevError& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevErrorList* operator -> () { return _pd_seq; }
    inline const DevErrorList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevErrorList& () const { return *_pd_seq; }
#else
    inline operator const DevErrorList& () const { return *_pd_seq; }
    inline operator DevErrorList& () { return *_pd_seq; }
#endif

    inline const DevErrorList& in() const { return *_pd_seq; }
    inline DevErrorList&       inout()    { return *_pd_seq; }
    inline DevErrorList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevErrorList* _retn() { DevErrorList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevErrorList_out;

  private:
    DevErrorList* _pd_seq;
  };

  class DevErrorList_out {
  public:
    inline DevErrorList_out(DevErrorList*& _s) : _data(_s) { _data = 0; }
    inline DevErrorList_out(DevErrorList_var& _s)
      : _data(_s._pd_seq) { _s = (DevErrorList*) 0; }
    inline DevErrorList_out(const DevErrorList_out& _s) : _data(_s._data) {}
    inline DevErrorList_out& operator = (const DevErrorList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevErrorList_out& operator = (DevErrorList* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevErrorList*&()  { return _data; }
    inline DevErrorList*& ptr()       { return _data; }
    inline DevErrorList* operator->() { return _data; }

    inline DevError& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevErrorList*& _data;

  private:
    DevErrorList_out();
    DevErrorList_out& operator=(const DevErrorList_var&);
  };

  struct NamedDevError {
    typedef _CORBA_ConstrType_Variable_Var<NamedDevError> _var_type;


    ::CORBA::String_member name;

    ::CORBA::Long index_in_call;

    DevErrorList err_list;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef NamedDevError::_var_type NamedDevError_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< NamedDevError,NamedDevError_var > NamedDevError_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NamedDevError;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_NamedDevErrorList;

  class NamedDevErrorList_var;

  class NamedDevErrorList : public _CORBA_Unbounded_Sequence< NamedDevError >  {
  public:
    typedef NamedDevErrorList_var _var_type;
    inline NamedDevErrorList() {}
    inline NamedDevErrorList(const NamedDevErrorList& _s)
      : _CORBA_Unbounded_Sequence< NamedDevError > (_s) {}

    inline NamedDevErrorList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< NamedDevError > (_max) {}
    inline NamedDevErrorList(_CORBA_ULong _max, _CORBA_ULong _len, NamedDevError* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< NamedDevError > (_max, _len, _val, _rel) {}



    inline NamedDevErrorList& operator = (const NamedDevErrorList& _s) {
      _CORBA_Unbounded_Sequence< NamedDevError > ::operator=(_s);
      return *this;
    }
  };

  class NamedDevErrorList_out;

  class NamedDevErrorList_var {
  public:
    inline NamedDevErrorList_var() : _pd_seq(0) {}
    inline NamedDevErrorList_var(NamedDevErrorList* _s) : _pd_seq(_s) {}
    inline NamedDevErrorList_var(const NamedDevErrorList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new NamedDevErrorList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~NamedDevErrorList_var() { if( _pd_seq )  delete _pd_seq; }

    inline NamedDevErrorList_var& operator = (NamedDevErrorList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline NamedDevErrorList_var& operator = (const NamedDevErrorList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new NamedDevErrorList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline NamedDevError& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline NamedDevErrorList* operator -> () { return _pd_seq; }
    inline const NamedDevErrorList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator NamedDevErrorList& () const { return *_pd_seq; }
#else
    inline operator const NamedDevErrorList& () const { return *_pd_seq; }
    inline operator NamedDevErrorList& () { return *_pd_seq; }
#endif

    inline const NamedDevErrorList& in() const { return *_pd_seq; }
    inline NamedDevErrorList&       inout()    { return *_pd_seq; }
    inline NamedDevErrorList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline NamedDevErrorList* _retn() { NamedDevErrorList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class NamedDevErrorList_out;

  private:
    NamedDevErrorList* _pd_seq;
  };

  class NamedDevErrorList_out {
  public:
    inline NamedDevErrorList_out(NamedDevErrorList*& _s) : _data(_s) { _data = 0; }
    inline NamedDevErrorList_out(NamedDevErrorList_var& _s)
      : _data(_s._pd_seq) { _s = (NamedDevErrorList*) 0; }
    inline NamedDevErrorList_out(const NamedDevErrorList_out& _s) : _data(_s._data) {}
    inline NamedDevErrorList_out& operator = (const NamedDevErrorList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline NamedDevErrorList_out& operator = (NamedDevErrorList* _s) {
      _data = _s;
      return *this;
    }
    inline operator NamedDevErrorList*&()  { return _data; }
    inline NamedDevErrorList*& ptr()       { return _data; }
    inline NamedDevErrorList* operator->() { return _data; }

    inline NamedDevError& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    NamedDevErrorList*& _data;

  private:
    NamedDevErrorList_out();
    NamedDevErrorList_out& operator=(const NamedDevErrorList_var&);
  };

  class DevFailed : public ::CORBA::UserException {
  public:

    DevErrorList errors;



    inline DevFailed() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    DevFailed(const DevFailed&);
    DevFailed(const DevErrorList i_errors);
    DevFailed& operator=(const DevFailed&);
    virtual ~DevFailed();
    virtual void _raise() const;
    static DevFailed* _downcast(::CORBA::Exception*);
    static const DevFailed* _downcast(const ::CORBA::Exception*);
    static inline DevFailed* _narrow(::CORBA::Exception* _e) {
      return _downcast(_e);
    }

    void operator>>=(cdrStream&) const ;
    void operator<<=(cdrStream&) ;

    static _core_attr insertExceptionToAny    insertToAnyFn;
    static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

    virtual ::CORBA::Exception* _NP_duplicate() const;

    static _core_attr const char* _PD_repoId;
    static _core_attr const char* _PD_typeId;

  private:
    virtual const char* _NP_typeId() const;
    virtual const char* _NP_repoId(int*) const;
    virtual void _NP_marshal(cdrStream&) const;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevFailed;

  class MultiDevFailed : public ::CORBA::UserException {
  public:

    NamedDevErrorList errors;



    inline MultiDevFailed() {
      pd_insertToAnyFn    = insertToAnyFn;
      pd_insertToAnyFnNCP = insertToAnyFnNCP;
    }
    MultiDevFailed(const MultiDevFailed&);
    MultiDevFailed(const NamedDevErrorList i_errors);
    MultiDevFailed& operator=(const MultiDevFailed&);
    virtual ~MultiDevFailed();
    virtual void _raise() const;
    static MultiDevFailed* _downcast(::CORBA::Exception*);
    static const MultiDevFailed* _downcast(const ::CORBA::Exception*);
    static inline MultiDevFailed* _narrow(::CORBA::Exception* _e) {
      return _downcast(_e);
    }

    void operator>>=(cdrStream&) const ;
    void operator<<=(cdrStream&) ;

    static _core_attr insertExceptionToAny    insertToAnyFn;
    static _core_attr insertExceptionToAnyNCP insertToAnyFnNCP;

    virtual ::CORBA::Exception* _NP_duplicate() const;

    static _core_attr const char* _PD_repoId;
    static _core_attr const char* _PD_typeId;

  private:
    virtual const char* _NP_typeId() const;
    virtual const char* _NP_repoId(int*) const;
    virtual void _NP_marshal(cdrStream&) const;
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_MultiDevFailed;

  struct AttributeConfig {
    typedef _CORBA_ConstrType_Variable_Var<AttributeConfig> _var_type;


    ::CORBA::String_member name;

    AttrWriteType writable;

    AttrDataFormat data_format;

    ::CORBA::Long data_type;

    ::CORBA::Long max_dim_x;

    ::CORBA::Long max_dim_y;

    ::CORBA::String_member description;

    ::CORBA::String_member label;

    ::CORBA::String_member unit;

    ::CORBA::String_member standard_unit;

    ::CORBA::String_member display_unit;

    ::CORBA::String_member format;

    ::CORBA::String_member min_value;

    ::CORBA::String_member max_value;

    ::CORBA::String_member min_alarm;

    ::CORBA::String_member max_alarm;

    ::CORBA::String_member writable_attr_name;

    DevVarStringArray extensions;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeConfig::_var_type AttributeConfig_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttributeConfig,AttributeConfig_var > AttributeConfig_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeConfig;

  struct AttributeConfig_2 {
    typedef _CORBA_ConstrType_Variable_Var<AttributeConfig_2> _var_type;


    ::CORBA::String_member name;

    AttrWriteType writable;

    AttrDataFormat data_format;

    ::CORBA::Long data_type;

    ::CORBA::Long max_dim_x;

    ::CORBA::Long max_dim_y;

    ::CORBA::String_member description;

    ::CORBA::String_member label;

    ::CORBA::String_member unit;

    ::CORBA::String_member standard_unit;

    ::CORBA::String_member display_unit;

    ::CORBA::String_member format;

    ::CORBA::String_member min_value;

    ::CORBA::String_member max_value;

    ::CORBA::String_member min_alarm;

    ::CORBA::String_member max_alarm;

    ::CORBA::String_member writable_attr_name;

    DispLevel level;

    DevVarStringArray extensions;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeConfig_2::_var_type AttributeConfig_2_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttributeConfig_2,AttributeConfig_2_var > AttributeConfig_2_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeConfig_2;

  struct AttributeValue {
    typedef _CORBA_ConstrType_Variable_Var<AttributeValue> _var_type;


    ::CORBA::Any value;

    AttrQuality quality;

    TimeVal time;

    ::CORBA::String_member name;

    ::CORBA::Long dim_x;

    ::CORBA::Long dim_y;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeValue::_var_type AttributeValue_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttributeValue,AttributeValue_var > AttributeValue_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeValue;

  struct AttributeDim {
    typedef _CORBA_ConstrType_Fix_Var<AttributeDim> _var_type;


    ::CORBA::Long dim_x;

    ::CORBA::Long dim_y;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeDim::_var_type AttributeDim_var;

  typedef AttributeDim& AttributeDim_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeDim;

  struct AttributeValue_3 {
    typedef _CORBA_ConstrType_Variable_Var<AttributeValue_3> _var_type;


    ::CORBA::Any value;

    AttrQuality quality;

    TimeVal time;

    ::CORBA::String_member name;

    AttributeDim r_dim;

    AttributeDim w_dim;

    DevErrorList err_list;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeValue_3::_var_type AttributeValue_3_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttributeValue_3,AttributeValue_3_var > AttributeValue_3_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeValue_3;

  enum AttributeDataType { 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 /*, __max_AttributeDataType=0xffffffff */ };
  typedef AttributeDataType& AttributeDataType_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeDataType;

  class AttrValUnion {
  public:

    typedef _CORBA_ConstrType_Variable_Var<AttrValUnion> _var_type;



    AttrValUnion(): _pd__initialised(0) {

    }

    AttrValUnion(const AttrValUnion& _value) {
      _pd__initialised = _value._pd__initialised;
      switch(_value._pd__d) {
        case ATT_BOOL: bool_att_value(_value._pd_bool_att_value); break;

        case ATT_SHORT: short_att_value(_value._pd_short_att_value); break;

        case ATT_LONG: long_att_value(_value._pd_long_att_value); break;

        case ATT_LONG64: long64_att_value(_value._pd_long64_att_value); break;

        case ATT_FLOAT: float_att_value(_value._pd_float_att_value); break;

        case ATT_DOUBLE: double_att_value(_value._pd_double_att_value); break;

        case ATT_UCHAR: uchar_att_value(_value._pd_uchar_att_value); break;

        case ATT_USHORT: ushort_att_value(_value._pd_ushort_att_value); break;

        case ATT_ULONG: ulong_att_value(_value._pd_ulong_att_value); break;

        case ATT_ULONG64: ulong64_att_value(_value._pd_ulong64_att_value); break;

        case ATT_STRING: string_att_value(_value._pd_string_att_value); break;

        case ATT_STATE: state_att_value(_value._pd_state_att_value); break;

        case DEVICE_STATE: dev_state_att(_value._pd_dev_state_att); break;

        case ATT_ENCODED: encoded_att_value(_value._pd_encoded_att_value); break;

        case NO_DATA: union_no_data(_value._pd_union_no_data); break;

          default: break;


      }
      _pd__d = _value._pd__d;

    }

    ~AttrValUnion() {}

    AttrValUnion& operator=(const AttrValUnion& _value) {
      _pd__initialised = _value._pd__initialised;
      switch(_value._pd__d) {
        case ATT_BOOL: bool_att_value(_value._pd_bool_att_value); break;

        case ATT_SHORT: short_att_value(_value._pd_short_att_value); break;

        case ATT_LONG: long_att_value(_value._pd_long_att_value); break;

        case ATT_LONG64: long64_att_value(_value._pd_long64_att_value); break;

        case ATT_FLOAT: float_att_value(_value._pd_float_att_value); break;

        case ATT_DOUBLE: double_att_value(_value._pd_double_att_value); break;

        case ATT_UCHAR: uchar_att_value(_value._pd_uchar_att_value); break;

        case ATT_USHORT: ushort_att_value(_value._pd_ushort_att_value); break;

        case ATT_ULONG: ulong_att_value(_value._pd_ulong_att_value); break;

        case ATT_ULONG64: ulong64_att_value(_value._pd_ulong64_att_value); break;

        case ATT_STRING: string_att_value(_value._pd_string_att_value); break;

        case ATT_STATE: state_att_value(_value._pd_state_att_value); break;

        case DEVICE_STATE: dev_state_att(_value._pd_dev_state_att); break;

        case ATT_ENCODED: encoded_att_value(_value._pd_encoded_att_value); break;

        case NO_DATA: union_no_data(_value._pd_union_no_data); break;

          default: break;


      }
      _pd__d = _value._pd__d;

      return *this;
    }

    AttributeDataType _d() const { return _pd__d;}
    void _d(AttributeDataType _value){
      // illegal to set discriminator before making a member active
      if (!_pd__initialised)
        OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);

      if (_value == _pd__d) return; // no change

      switch (_pd__d){
        case ATT_BOOL: goto fail;
        case ATT_SHORT: goto fail;
        case ATT_LONG: goto fail;
        case ATT_LONG64: goto fail;
        case ATT_FLOAT: goto fail;
        case ATT_DOUBLE: goto fail;
        case ATT_UCHAR: goto fail;
        case ATT_USHORT: goto fail;
        case ATT_ULONG: goto fail;
        case ATT_ULONG64: goto fail;
        case ATT_STRING: goto fail;
        case ATT_STATE: goto fail;
        case DEVICE_STATE: goto fail;
        case ATT_ENCODED: goto fail;
        case NO_DATA: goto fail;
        default: goto fail;

      };


      fail:
      OMNIORB_THROW(BAD_PARAM,_OMNI_NS(BAD_PARAM_InvalidUnionDiscValue),::CORBA::COMPLETED_NO);



    }



    const DevVarBooleanArray &bool_att_value () const { return _pd_bool_att_value; }
    DevVarBooleanArray &bool_att_value () { return _pd_bool_att_value; }
    void bool_att_value (const DevVarBooleanArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_BOOL;
      _pd__default = 0;
      _pd_bool_att_value = _value;
    }

    const DevVarShortArray &short_att_value () const { return _pd_short_att_value; }
    DevVarShortArray &short_att_value () { return _pd_short_att_value; }
    void short_att_value (const DevVarShortArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_SHORT;
      _pd__default = 0;
      _pd_short_att_value = _value;
    }

    const DevVarLongArray &long_att_value () const { return _pd_long_att_value; }
    DevVarLongArray &long_att_value () { return _pd_long_att_value; }
    void long_att_value (const DevVarLongArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_LONG;
      _pd__default = 0;
      _pd_long_att_value = _value;
    }

    const DevVarLong64Array &long64_att_value () const { return _pd_long64_att_value; }
    DevVarLong64Array &long64_att_value () { return _pd_long64_att_value; }
    void long64_att_value (const DevVarLong64Array& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_LONG64;
      _pd__default = 0;
      _pd_long64_att_value = _value;
    }

    const DevVarFloatArray &float_att_value () const { return _pd_float_att_value; }
    DevVarFloatArray &float_att_value () { return _pd_float_att_value; }
    void float_att_value (const DevVarFloatArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_FLOAT;
      _pd__default = 0;
      _pd_float_att_value = _value;
    }

    const DevVarDoubleArray &double_att_value () const { return _pd_double_att_value; }
    DevVarDoubleArray &double_att_value () { return _pd_double_att_value; }
    void double_att_value (const DevVarDoubleArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_DOUBLE;
      _pd__default = 0;
      _pd_double_att_value = _value;
    }

    const DevVarCharArray &uchar_att_value () const { return _pd_uchar_att_value; }
    DevVarCharArray &uchar_att_value () { return _pd_uchar_att_value; }
    void uchar_att_value (const DevVarCharArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_UCHAR;
      _pd__default = 0;
      _pd_uchar_att_value = _value;
    }

    const DevVarUShortArray &ushort_att_value () const { return _pd_ushort_att_value; }
    DevVarUShortArray &ushort_att_value () { return _pd_ushort_att_value; }
    void ushort_att_value (const DevVarUShortArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_USHORT;
      _pd__default = 0;
      _pd_ushort_att_value = _value;
    }

    const DevVarULongArray &ulong_att_value () const { return _pd_ulong_att_value; }
    DevVarULongArray &ulong_att_value () { return _pd_ulong_att_value; }
    void ulong_att_value (const DevVarULongArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_ULONG;
      _pd__default = 0;
      _pd_ulong_att_value = _value;
    }

    const DevVarULong64Array &ulong64_att_value () const { return _pd_ulong64_att_value; }
    DevVarULong64Array &ulong64_att_value () { return _pd_ulong64_att_value; }
    void ulong64_att_value (const DevVarULong64Array& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_ULONG64;
      _pd__default = 0;
      _pd_ulong64_att_value = _value;
    }

    const DevVarStringArray &string_att_value () const { return _pd_string_att_value; }
    DevVarStringArray &string_att_value () { return _pd_string_att_value; }
    void string_att_value (const DevVarStringArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_STRING;
      _pd__default = 0;
      _pd_string_att_value = _value;
    }

    const DevVarStateArray &state_att_value () const { return _pd_state_att_value; }
    DevVarStateArray &state_att_value () { return _pd_state_att_value; }
    void state_att_value (const DevVarStateArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_STATE;
      _pd__default = 0;
      _pd_state_att_value = _value;
    }

    DevState dev_state_att () const { return _pd_dev_state_att; }
    void dev_state_att (DevState  _value) {
      _pd__initialised = 1;
      _pd__d = DEVICE_STATE;
      _pd__default = 0;
      _pd_dev_state_att = _value;
    }

    const DevVarEncodedArray &encoded_att_value () const { return _pd_encoded_att_value; }
    DevVarEncodedArray &encoded_att_value () { return _pd_encoded_att_value; }
    void encoded_att_value (const DevVarEncodedArray& _value) {
      _pd__initialised = 1;
      _pd__d = ATT_ENCODED;
      _pd__default = 0;
      _pd_encoded_att_value = _value;
    }

    DevBoolean union_no_data () const { return _pd_union_no_data; }
    void union_no_data (DevBoolean  _value) {
      _pd__initialised = 1;
      _pd__d = NO_DATA;
      _pd__default = 0;
      _pd_union_no_data = _value;
    }



    void operator>>= (cdrStream&) const;
    void operator<<= (cdrStream&);

  private:
    AttributeDataType _pd__d;
    _CORBA_Boolean _pd__default;
    _CORBA_Boolean _pd__initialised;

    union {
      DevState _pd_dev_state_att;

      DevBoolean _pd_union_no_data;


    };


    DevVarBooleanArray _pd_bool_att_value;

    DevVarShortArray _pd_short_att_value;

    DevVarLongArray _pd_long_att_value;

    DevVarLong64Array _pd_long64_att_value;

    DevVarFloatArray _pd_float_att_value;

    DevVarDoubleArray _pd_double_att_value;

    DevVarCharArray _pd_uchar_att_value;

    DevVarUShortArray _pd_ushort_att_value;

    DevVarULongArray _pd_ulong_att_value;

    DevVarULong64Array _pd_ulong64_att_value;

    DevVarStringArray _pd_string_att_value;

    DevVarStateArray _pd_state_att_value;

    DevVarEncodedArray _pd_encoded_att_value;


  };

  typedef AttrValUnion::_var_type AttrValUnion_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttrValUnion,AttrValUnion_var > AttrValUnion_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttrValUnion;

  struct AttributeValue_4 {
    typedef _CORBA_ConstrType_Variable_Var<AttributeValue_4> _var_type;

// Added by ET for LockedAttributeValue_4 class
virtual ~AttributeValue_4() {if (mut_ptr != NULL)mut_ptr->unlock();}
AttributeValue_4() {mut_ptr=NULL;}
void set_attr_mutex(omni_mutex *ptr) {mut_ptr=ptr;}
void rel_attr_mutex() {if (mut_ptr != NULL){mut_ptr->unlock();mut_ptr=NULL;}}

    AttrValUnion value;

    AttrQuality quality;

    AttrDataFormat data_format;

    TimeVal time;

    ::CORBA::String_member name;

    AttributeDim r_dim;

    AttributeDim w_dim;

    DevErrorList err_list;

// Added by ET for LockedAttributeValue_4 class
omni_mutex *mut_ptr;

    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeValue_4::_var_type AttributeValue_4_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttributeValue_4,AttributeValue_4_var > AttributeValue_4_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeValue_4;

  struct ChangeEventProp {
    typedef _CORBA_ConstrType_Variable_Var<ChangeEventProp> _var_type;


    ::CORBA::String_member rel_change;

    ::CORBA::String_member abs_change;

    DevVarStringArray extensions;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef ChangeEventProp::_var_type ChangeEventProp_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ChangeEventProp,ChangeEventProp_var > ChangeEventProp_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ChangeEventProp;

  struct PeriodicEventProp {
    typedef _CORBA_ConstrType_Variable_Var<PeriodicEventProp> _var_type;


    ::CORBA::String_member period;

    DevVarStringArray extensions;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef PeriodicEventProp::_var_type PeriodicEventProp_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< PeriodicEventProp,PeriodicEventProp_var > PeriodicEventProp_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_PeriodicEventProp;

  struct ArchiveEventProp {
    typedef _CORBA_ConstrType_Variable_Var<ArchiveEventProp> _var_type;


    ::CORBA::String_member rel_change;

    ::CORBA::String_member abs_change;

    ::CORBA::String_member period;

    DevVarStringArray extensions;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef ArchiveEventProp::_var_type ArchiveEventProp_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ArchiveEventProp,ArchiveEventProp_var > ArchiveEventProp_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ArchiveEventProp;

  struct EventProperties {
    typedef _CORBA_ConstrType_Variable_Var<EventProperties> _var_type;


    ChangeEventProp ch_event;

    PeriodicEventProp per_event;

    ArchiveEventProp arch_event;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef EventProperties::_var_type EventProperties_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< EventProperties,EventProperties_var > EventProperties_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_EventProperties;

  struct AttributeAlarm {
    typedef _CORBA_ConstrType_Variable_Var<AttributeAlarm> _var_type;


    ::CORBA::String_member min_alarm;

    ::CORBA::String_member max_alarm;

    ::CORBA::String_member min_warning;

    ::CORBA::String_member max_warning;

    ::CORBA::String_member delta_t;

    ::CORBA::String_member delta_val;

    DevVarStringArray extensions;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeAlarm::_var_type AttributeAlarm_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttributeAlarm,AttributeAlarm_var > AttributeAlarm_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeAlarm;

  struct AttributeConfig_3 {
    typedef _CORBA_ConstrType_Variable_Var<AttributeConfig_3> _var_type;


    ::CORBA::String_member name;

    AttrWriteType writable;

    AttrDataFormat data_format;

    ::CORBA::Long data_type;

    ::CORBA::Long max_dim_x;

    ::CORBA::Long max_dim_y;

    ::CORBA::String_member description;

    ::CORBA::String_member label;

    ::CORBA::String_member unit;

    ::CORBA::String_member standard_unit;

    ::CORBA::String_member display_unit;

    ::CORBA::String_member format;

    ::CORBA::String_member min_value;

    ::CORBA::String_member max_value;

    ::CORBA::String_member writable_attr_name;

    DispLevel level;

    AttributeAlarm att_alarm;

    EventProperties event_prop;

    DevVarStringArray extensions;

    DevVarStringArray sys_extensions;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttributeConfig_3::_var_type AttributeConfig_3_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttributeConfig_3,AttributeConfig_3_var > AttributeConfig_3_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeConfig_3;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeConfigList;

  class AttributeConfigList_var;

  class AttributeConfigList : public _CORBA_Unbounded_Sequence< AttributeConfig >  {
  public:
    typedef AttributeConfigList_var _var_type;
    inline AttributeConfigList() {}
    inline AttributeConfigList(const AttributeConfigList& _s)
      : _CORBA_Unbounded_Sequence< AttributeConfig > (_s) {}

    inline AttributeConfigList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< AttributeConfig > (_max) {}
    inline AttributeConfigList(_CORBA_ULong _max, _CORBA_ULong _len, AttributeConfig* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< AttributeConfig > (_max, _len, _val, _rel) {}



    inline AttributeConfigList& operator = (const AttributeConfigList& _s) {
      _CORBA_Unbounded_Sequence< AttributeConfig > ::operator=(_s);
      return *this;
    }
  };

  class AttributeConfigList_out;

  class AttributeConfigList_var {
  public:
    inline AttributeConfigList_var() : _pd_seq(0) {}
    inline AttributeConfigList_var(AttributeConfigList* _s) : _pd_seq(_s) {}
    inline AttributeConfigList_var(const AttributeConfigList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttributeConfigList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttributeConfigList_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttributeConfigList_var& operator = (AttributeConfigList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttributeConfigList_var& operator = (const AttributeConfigList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttributeConfigList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttributeConfig& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttributeConfigList* operator -> () { return _pd_seq; }
    inline const AttributeConfigList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttributeConfigList& () const { return *_pd_seq; }
#else
    inline operator const AttributeConfigList& () const { return *_pd_seq; }
    inline operator AttributeConfigList& () { return *_pd_seq; }
#endif

    inline const AttributeConfigList& in() const { return *_pd_seq; }
    inline AttributeConfigList&       inout()    { return *_pd_seq; }
    inline AttributeConfigList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttributeConfigList* _retn() { AttributeConfigList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttributeConfigList_out;

  private:
    AttributeConfigList* _pd_seq;
  };

  class AttributeConfigList_out {
  public:
    inline AttributeConfigList_out(AttributeConfigList*& _s) : _data(_s) { _data = 0; }
    inline AttributeConfigList_out(AttributeConfigList_var& _s)
      : _data(_s._pd_seq) { _s = (AttributeConfigList*) 0; }
    inline AttributeConfigList_out(const AttributeConfigList_out& _s) : _data(_s._data) {}
    inline AttributeConfigList_out& operator = (const AttributeConfigList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttributeConfigList_out& operator = (AttributeConfigList* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttributeConfigList*&()  { return _data; }
    inline AttributeConfigList*& ptr()       { return _data; }
    inline AttributeConfigList* operator->() { return _data; }

    inline AttributeConfig& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttributeConfigList*& _data;

  private:
    AttributeConfigList_out();
    AttributeConfigList_out& operator=(const AttributeConfigList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeConfigList_2;

  class AttributeConfigList_2_var;

  class AttributeConfigList_2 : public _CORBA_Unbounded_Sequence< AttributeConfig_2 >  {
  public:
    typedef AttributeConfigList_2_var _var_type;
    inline AttributeConfigList_2() {}
    inline AttributeConfigList_2(const AttributeConfigList_2& _s)
      : _CORBA_Unbounded_Sequence< AttributeConfig_2 > (_s) {}

    inline AttributeConfigList_2(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< AttributeConfig_2 > (_max) {}
    inline AttributeConfigList_2(_CORBA_ULong _max, _CORBA_ULong _len, AttributeConfig_2* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< AttributeConfig_2 > (_max, _len, _val, _rel) {}



    inline AttributeConfigList_2& operator = (const AttributeConfigList_2& _s) {
      _CORBA_Unbounded_Sequence< AttributeConfig_2 > ::operator=(_s);
      return *this;
    }
  };

  class AttributeConfigList_2_out;

  class AttributeConfigList_2_var {
  public:
    inline AttributeConfigList_2_var() : _pd_seq(0) {}
    inline AttributeConfigList_2_var(AttributeConfigList_2* _s) : _pd_seq(_s) {}
    inline AttributeConfigList_2_var(const AttributeConfigList_2_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttributeConfigList_2(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttributeConfigList_2_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttributeConfigList_2_var& operator = (AttributeConfigList_2* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttributeConfigList_2_var& operator = (const AttributeConfigList_2_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttributeConfigList_2;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttributeConfig_2& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttributeConfigList_2* operator -> () { return _pd_seq; }
    inline const AttributeConfigList_2* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttributeConfigList_2& () const { return *_pd_seq; }
#else
    inline operator const AttributeConfigList_2& () const { return *_pd_seq; }
    inline operator AttributeConfigList_2& () { return *_pd_seq; }
#endif

    inline const AttributeConfigList_2& in() const { return *_pd_seq; }
    inline AttributeConfigList_2&       inout()    { return *_pd_seq; }
    inline AttributeConfigList_2*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttributeConfigList_2* _retn() { AttributeConfigList_2* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttributeConfigList_2_out;

  private:
    AttributeConfigList_2* _pd_seq;
  };

  class AttributeConfigList_2_out {
  public:
    inline AttributeConfigList_2_out(AttributeConfigList_2*& _s) : _data(_s) { _data = 0; }
    inline AttributeConfigList_2_out(AttributeConfigList_2_var& _s)
      : _data(_s._pd_seq) { _s = (AttributeConfigList_2*) 0; }
    inline AttributeConfigList_2_out(const AttributeConfigList_2_out& _s) : _data(_s._data) {}
    inline AttributeConfigList_2_out& operator = (const AttributeConfigList_2_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttributeConfigList_2_out& operator = (AttributeConfigList_2* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttributeConfigList_2*&()  { return _data; }
    inline AttributeConfigList_2*& ptr()       { return _data; }
    inline AttributeConfigList_2* operator->() { return _data; }

    inline AttributeConfig_2& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttributeConfigList_2*& _data;

  private:
    AttributeConfigList_2_out();
    AttributeConfigList_2_out& operator=(const AttributeConfigList_2_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeConfigList_3;

  class AttributeConfigList_3_var;

  class AttributeConfigList_3 : public _CORBA_Unbounded_Sequence< AttributeConfig_3 >  {
  public:
    typedef AttributeConfigList_3_var _var_type;
    inline AttributeConfigList_3() {}
    inline AttributeConfigList_3(const AttributeConfigList_3& _s)
      : _CORBA_Unbounded_Sequence< AttributeConfig_3 > (_s) {}

    inline AttributeConfigList_3(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< AttributeConfig_3 > (_max) {}
    inline AttributeConfigList_3(_CORBA_ULong _max, _CORBA_ULong _len, AttributeConfig_3* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< AttributeConfig_3 > (_max, _len, _val, _rel) {}



    inline AttributeConfigList_3& operator = (const AttributeConfigList_3& _s) {
      _CORBA_Unbounded_Sequence< AttributeConfig_3 > ::operator=(_s);
      return *this;
    }
  };

  class AttributeConfigList_3_out;

  class AttributeConfigList_3_var {
  public:
    inline AttributeConfigList_3_var() : _pd_seq(0) {}
    inline AttributeConfigList_3_var(AttributeConfigList_3* _s) : _pd_seq(_s) {}
    inline AttributeConfigList_3_var(const AttributeConfigList_3_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttributeConfigList_3(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttributeConfigList_3_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttributeConfigList_3_var& operator = (AttributeConfigList_3* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttributeConfigList_3_var& operator = (const AttributeConfigList_3_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttributeConfigList_3;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttributeConfig_3& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttributeConfigList_3* operator -> () { return _pd_seq; }
    inline const AttributeConfigList_3* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttributeConfigList_3& () const { return *_pd_seq; }
#else
    inline operator const AttributeConfigList_3& () const { return *_pd_seq; }
    inline operator AttributeConfigList_3& () { return *_pd_seq; }
#endif

    inline const AttributeConfigList_3& in() const { return *_pd_seq; }
    inline AttributeConfigList_3&       inout()    { return *_pd_seq; }
    inline AttributeConfigList_3*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttributeConfigList_3* _retn() { AttributeConfigList_3* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttributeConfigList_3_out;

  private:
    AttributeConfigList_3* _pd_seq;
  };

  class AttributeConfigList_3_out {
  public:
    inline AttributeConfigList_3_out(AttributeConfigList_3*& _s) : _data(_s) { _data = 0; }
    inline AttributeConfigList_3_out(AttributeConfigList_3_var& _s)
      : _data(_s._pd_seq) { _s = (AttributeConfigList_3*) 0; }
    inline AttributeConfigList_3_out(const AttributeConfigList_3_out& _s) : _data(_s._data) {}
    inline AttributeConfigList_3_out& operator = (const AttributeConfigList_3_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttributeConfigList_3_out& operator = (AttributeConfigList_3* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttributeConfigList_3*&()  { return _data; }
    inline AttributeConfigList_3*& ptr()       { return _data; }
    inline AttributeConfigList_3* operator->() { return _data; }

    inline AttributeConfig_3& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttributeConfigList_3*& _data;

  private:
    AttributeConfigList_3_out();
    AttributeConfigList_3_out& operator=(const AttributeConfigList_3_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeValueList;

  class AttributeValueList_var;

  class AttributeValueList : public _CORBA_Unbounded_Sequence< AttributeValue >  {
  public:
    typedef AttributeValueList_var _var_type;
    inline AttributeValueList() {}
    inline AttributeValueList(const AttributeValueList& _s)
      : _CORBA_Unbounded_Sequence< AttributeValue > (_s) {}

    inline AttributeValueList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< AttributeValue > (_max) {}
    inline AttributeValueList(_CORBA_ULong _max, _CORBA_ULong _len, AttributeValue* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< AttributeValue > (_max, _len, _val, _rel) {}



    inline AttributeValueList& operator = (const AttributeValueList& _s) {
      _CORBA_Unbounded_Sequence< AttributeValue > ::operator=(_s);
      return *this;
    }
  };

  class AttributeValueList_out;

  class AttributeValueList_var {
  public:
    inline AttributeValueList_var() : _pd_seq(0) {}
    inline AttributeValueList_var(AttributeValueList* _s) : _pd_seq(_s) {}
    inline AttributeValueList_var(const AttributeValueList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttributeValueList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttributeValueList_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttributeValueList_var& operator = (AttributeValueList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttributeValueList_var& operator = (const AttributeValueList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttributeValueList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttributeValue& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttributeValueList* operator -> () { return _pd_seq; }
    inline const AttributeValueList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttributeValueList& () const { return *_pd_seq; }
#else
    inline operator const AttributeValueList& () const { return *_pd_seq; }
    inline operator AttributeValueList& () { return *_pd_seq; }
#endif

    inline const AttributeValueList& in() const { return *_pd_seq; }
    inline AttributeValueList&       inout()    { return *_pd_seq; }
    inline AttributeValueList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttributeValueList* _retn() { AttributeValueList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttributeValueList_out;

  private:
    AttributeValueList* _pd_seq;
  };

  class AttributeValueList_out {
  public:
    inline AttributeValueList_out(AttributeValueList*& _s) : _data(_s) { _data = 0; }
    inline AttributeValueList_out(AttributeValueList_var& _s)
      : _data(_s._pd_seq) { _s = (AttributeValueList*) 0; }
    inline AttributeValueList_out(const AttributeValueList_out& _s) : _data(_s._data) {}
    inline AttributeValueList_out& operator = (const AttributeValueList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttributeValueList_out& operator = (AttributeValueList* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttributeValueList*&()  { return _data; }
    inline AttributeValueList*& ptr()       { return _data; }
    inline AttributeValueList* operator->() { return _data; }

    inline AttributeValue& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttributeValueList*& _data;

  private:
    AttributeValueList_out();
    AttributeValueList_out& operator=(const AttributeValueList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeValueList_3;

  class AttributeValueList_3_var;

  class AttributeValueList_3 : public _CORBA_Unbounded_Sequence< AttributeValue_3 >  {
  public:
    typedef AttributeValueList_3_var _var_type;
    inline AttributeValueList_3() {}
    inline AttributeValueList_3(const AttributeValueList_3& _s)
      : _CORBA_Unbounded_Sequence< AttributeValue_3 > (_s) {}

    inline AttributeValueList_3(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< AttributeValue_3 > (_max) {}
    inline AttributeValueList_3(_CORBA_ULong _max, _CORBA_ULong _len, AttributeValue_3* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< AttributeValue_3 > (_max, _len, _val, _rel) {}



    inline AttributeValueList_3& operator = (const AttributeValueList_3& _s) {
      _CORBA_Unbounded_Sequence< AttributeValue_3 > ::operator=(_s);
      return *this;
    }
  };

  class AttributeValueList_3_out;

  class AttributeValueList_3_var {
  public:
    inline AttributeValueList_3_var() : _pd_seq(0) {}
    inline AttributeValueList_3_var(AttributeValueList_3* _s) : _pd_seq(_s) {}
    inline AttributeValueList_3_var(const AttributeValueList_3_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttributeValueList_3(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttributeValueList_3_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttributeValueList_3_var& operator = (AttributeValueList_3* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttributeValueList_3_var& operator = (const AttributeValueList_3_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttributeValueList_3;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttributeValue_3& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttributeValueList_3* operator -> () { return _pd_seq; }
    inline const AttributeValueList_3* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttributeValueList_3& () const { return *_pd_seq; }
#else
    inline operator const AttributeValueList_3& () const { return *_pd_seq; }
    inline operator AttributeValueList_3& () { return *_pd_seq; }
#endif

    inline const AttributeValueList_3& in() const { return *_pd_seq; }
    inline AttributeValueList_3&       inout()    { return *_pd_seq; }
    inline AttributeValueList_3*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttributeValueList_3* _retn() { AttributeValueList_3* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttributeValueList_3_out;

  private:
    AttributeValueList_3* _pd_seq;
  };

  class AttributeValueList_3_out {
  public:
    inline AttributeValueList_3_out(AttributeValueList_3*& _s) : _data(_s) { _data = 0; }
    inline AttributeValueList_3_out(AttributeValueList_3_var& _s)
      : _data(_s._pd_seq) { _s = (AttributeValueList_3*) 0; }
    inline AttributeValueList_3_out(const AttributeValueList_3_out& _s) : _data(_s._data) {}
    inline AttributeValueList_3_out& operator = (const AttributeValueList_3_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttributeValueList_3_out& operator = (AttributeValueList_3* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttributeValueList_3*&()  { return _data; }
    inline AttributeValueList_3*& ptr()       { return _data; }
    inline AttributeValueList_3* operator->() { return _data; }

    inline AttributeValue_3& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttributeValueList_3*& _data;

  private:
    AttributeValueList_3_out();
    AttributeValueList_3_out& operator=(const AttributeValueList_3_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeValueList_4;

  class AttributeValueList_4_var;

  class AttributeValueList_4 : public _CORBA_Unbounded_Sequence< AttributeValue_4 >  {
  public:
    typedef AttributeValueList_4_var _var_type;
    inline AttributeValueList_4() {}
    inline AttributeValueList_4(const AttributeValueList_4& _s)
      : _CORBA_Unbounded_Sequence< AttributeValue_4 > (_s) {}

    inline AttributeValueList_4(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< AttributeValue_4 > (_max) {}
    inline AttributeValueList_4(_CORBA_ULong _max, _CORBA_ULong _len, AttributeValue_4* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< AttributeValue_4 > (_max, _len, _val, _rel) {}



    inline AttributeValueList_4& operator = (const AttributeValueList_4& _s) {
      _CORBA_Unbounded_Sequence< AttributeValue_4 > ::operator=(_s);
      return *this;
    }
  };

  class AttributeValueList_4_out;

  class AttributeValueList_4_var {
  public:
    inline AttributeValueList_4_var() : _pd_seq(0) {}
    inline AttributeValueList_4_var(AttributeValueList_4* _s) : _pd_seq(_s) {}
    inline AttributeValueList_4_var(const AttributeValueList_4_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttributeValueList_4(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttributeValueList_4_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttributeValueList_4_var& operator = (AttributeValueList_4* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttributeValueList_4_var& operator = (const AttributeValueList_4_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttributeValueList_4;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttributeValue_4& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttributeValueList_4* operator -> () { return _pd_seq; }
    inline const AttributeValueList_4* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttributeValueList_4& () const { return *_pd_seq; }
#else
    inline operator const AttributeValueList_4& () const { return *_pd_seq; }
    inline operator AttributeValueList_4& () { return *_pd_seq; }
#endif

    inline const AttributeValueList_4& in() const { return *_pd_seq; }
    inline AttributeValueList_4&       inout()    { return *_pd_seq; }
    inline AttributeValueList_4*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttributeValueList_4* _retn() { AttributeValueList_4* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttributeValueList_4_out;

  private:
    AttributeValueList_4* _pd_seq;
  };

  class AttributeValueList_4_out {
  public:
    inline AttributeValueList_4_out(AttributeValueList_4*& _s) : _data(_s) { _data = 0; }
    inline AttributeValueList_4_out(AttributeValueList_4_var& _s)
      : _data(_s._pd_seq) { _s = (AttributeValueList_4*) 0; }
    inline AttributeValueList_4_out(const AttributeValueList_4_out& _s) : _data(_s._data) {}
    inline AttributeValueList_4_out& operator = (const AttributeValueList_4_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttributeValueList_4_out& operator = (AttributeValueList_4* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttributeValueList_4*&()  { return _data; }
    inline AttributeValueList_4*& ptr()       { return _data; }
    inline AttributeValueList_4* operator->() { return _data; }

    inline AttributeValue_4& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttributeValueList_4*& _data;

  private:
    AttributeValueList_4_out();
    AttributeValueList_4_out& operator=(const AttributeValueList_4_var&);
  };

  struct AttDataReady {
    typedef _CORBA_ConstrType_Variable_Var<AttDataReady> _var_type;


    ::CORBA::String_member name;

    ::CORBA::Long data_type;

    ::CORBA::Long ctr;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef AttDataReady::_var_type AttDataReady_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< AttDataReady,AttDataReady_var > AttDataReady_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttDataReady;

  struct DevInfo {
    typedef _CORBA_ConstrType_Variable_Var<DevInfo> _var_type;


    ::CORBA::String_member dev_class;

    ::CORBA::String_member server_id;

    ::CORBA::String_member server_host;

    ::CORBA::Long server_version;

    ::CORBA::String_member doc_url;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevInfo::_var_type DevInfo_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevInfo,DevInfo_var > DevInfo_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevInfo;

  struct DevInfo_3 {
    typedef _CORBA_ConstrType_Variable_Var<DevInfo_3> _var_type;


    ::CORBA::String_member dev_class;

    ::CORBA::String_member server_id;

    ::CORBA::String_member server_host;

    ::CORBA::Long server_version;

    ::CORBA::String_member doc_url;

    ::CORBA::String_member dev_type;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevInfo_3::_var_type DevInfo_3_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevInfo_3,DevInfo_3_var > DevInfo_3_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevInfo_3;

  struct DevCmdHistory {
    typedef _CORBA_ConstrType_Variable_Var<DevCmdHistory> _var_type;


    TimeVal time;

    ::CORBA::Boolean cmd_failed;

    ::CORBA::Any value;

    DevErrorList errors;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevCmdHistory::_var_type DevCmdHistory_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevCmdHistory,DevCmdHistory_var > DevCmdHistory_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevCmdHistory;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevCmdHistoryList;

  class DevCmdHistoryList_var;

  class DevCmdHistoryList : public _CORBA_Unbounded_Sequence< DevCmdHistory >  {
  public:
    typedef DevCmdHistoryList_var _var_type;
    inline DevCmdHistoryList() {}
    inline DevCmdHistoryList(const DevCmdHistoryList& _s)
      : _CORBA_Unbounded_Sequence< DevCmdHistory > (_s) {}

    inline DevCmdHistoryList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevCmdHistory > (_max) {}
    inline DevCmdHistoryList(_CORBA_ULong _max, _CORBA_ULong _len, DevCmdHistory* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevCmdHistory > (_max, _len, _val, _rel) {}



    inline DevCmdHistoryList& operator = (const DevCmdHistoryList& _s) {
      _CORBA_Unbounded_Sequence< DevCmdHistory > ::operator=(_s);
      return *this;
    }
  };

  class DevCmdHistoryList_out;

  class DevCmdHistoryList_var {
  public:
    inline DevCmdHistoryList_var() : _pd_seq(0) {}
    inline DevCmdHistoryList_var(DevCmdHistoryList* _s) : _pd_seq(_s) {}
    inline DevCmdHistoryList_var(const DevCmdHistoryList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevCmdHistoryList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevCmdHistoryList_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevCmdHistoryList_var& operator = (DevCmdHistoryList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevCmdHistoryList_var& operator = (const DevCmdHistoryList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevCmdHistoryList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevCmdHistory& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevCmdHistoryList* operator -> () { return _pd_seq; }
    inline const DevCmdHistoryList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevCmdHistoryList& () const { return *_pd_seq; }
#else
    inline operator const DevCmdHistoryList& () const { return *_pd_seq; }
    inline operator DevCmdHistoryList& () { return *_pd_seq; }
#endif

    inline const DevCmdHistoryList& in() const { return *_pd_seq; }
    inline DevCmdHistoryList&       inout()    { return *_pd_seq; }
    inline DevCmdHistoryList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevCmdHistoryList* _retn() { DevCmdHistoryList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevCmdHistoryList_out;

  private:
    DevCmdHistoryList* _pd_seq;
  };

  class DevCmdHistoryList_out {
  public:
    inline DevCmdHistoryList_out(DevCmdHistoryList*& _s) : _data(_s) { _data = 0; }
    inline DevCmdHistoryList_out(DevCmdHistoryList_var& _s)
      : _data(_s._pd_seq) { _s = (DevCmdHistoryList*) 0; }
    inline DevCmdHistoryList_out(const DevCmdHistoryList_out& _s) : _data(_s._data) {}
    inline DevCmdHistoryList_out& operator = (const DevCmdHistoryList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevCmdHistoryList_out& operator = (DevCmdHistoryList* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevCmdHistoryList*&()  { return _data; }
    inline DevCmdHistoryList*& ptr()       { return _data; }
    inline DevCmdHistoryList* operator->() { return _data; }

    inline DevCmdHistory& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevCmdHistoryList*& _data;

  private:
    DevCmdHistoryList_out();
    DevCmdHistoryList_out& operator=(const DevCmdHistoryList_var&);
  };

  struct DevAttrHistory {
    typedef _CORBA_ConstrType_Variable_Var<DevAttrHistory> _var_type;


    ::CORBA::Boolean attr_failed;

    AttributeValue value;

    DevErrorList errors;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevAttrHistory::_var_type DevAttrHistory_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevAttrHistory,DevAttrHistory_var > DevAttrHistory_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevAttrHistory;

  struct DevAttrHistory_3 {
    typedef _CORBA_ConstrType_Variable_Var<DevAttrHistory_3> _var_type;


    ::CORBA::Boolean attr_failed;

    AttributeValue_3 value;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevAttrHistory_3::_var_type DevAttrHistory_3_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevAttrHistory_3,DevAttrHistory_3_var > DevAttrHistory_3_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevAttrHistory_3;

  struct EltInArray {
    typedef _CORBA_ConstrType_Fix_Var<EltInArray> _var_type;


    ::CORBA::Long start;

    ::CORBA::Long nb_elt;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef EltInArray::_var_type EltInArray_var;

  typedef EltInArray& EltInArray_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_EltInArray;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_EltInArrayList;

  class EltInArrayList_var;

  class EltInArrayList : public _CORBA_Unbounded_Sequence< EltInArray >  {
  public:
    typedef EltInArrayList_var _var_type;
    inline EltInArrayList() {}
    inline EltInArrayList(const EltInArrayList& _s)
      : _CORBA_Unbounded_Sequence< EltInArray > (_s) {}

    inline EltInArrayList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< EltInArray > (_max) {}
    inline EltInArrayList(_CORBA_ULong _max, _CORBA_ULong _len, EltInArray* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< EltInArray > (_max, _len, _val, _rel) {}



    inline EltInArrayList& operator = (const EltInArrayList& _s) {
      _CORBA_Unbounded_Sequence< EltInArray > ::operator=(_s);
      return *this;
    }
  };

  class EltInArrayList_out;

  class EltInArrayList_var {
  public:
    inline EltInArrayList_var() : _pd_seq(0) {}
    inline EltInArrayList_var(EltInArrayList* _s) : _pd_seq(_s) {}
    inline EltInArrayList_var(const EltInArrayList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new EltInArrayList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~EltInArrayList_var() { if( _pd_seq )  delete _pd_seq; }

    inline EltInArrayList_var& operator = (EltInArrayList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline EltInArrayList_var& operator = (const EltInArrayList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new EltInArrayList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline EltInArray& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline EltInArrayList* operator -> () { return _pd_seq; }
    inline const EltInArrayList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator EltInArrayList& () const { return *_pd_seq; }
#else
    inline operator const EltInArrayList& () const { return *_pd_seq; }
    inline operator EltInArrayList& () { return *_pd_seq; }
#endif

    inline const EltInArrayList& in() const { return *_pd_seq; }
    inline EltInArrayList&       inout()    { return *_pd_seq; }
    inline EltInArrayList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline EltInArrayList* _retn() { EltInArrayList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class EltInArrayList_out;

  private:
    EltInArrayList* _pd_seq;
  };

  class EltInArrayList_out {
  public:
    inline EltInArrayList_out(EltInArrayList*& _s) : _data(_s) { _data = 0; }
    inline EltInArrayList_out(EltInArrayList_var& _s)
      : _data(_s._pd_seq) { _s = (EltInArrayList*) 0; }
    inline EltInArrayList_out(const EltInArrayList_out& _s) : _data(_s._data) {}
    inline EltInArrayList_out& operator = (const EltInArrayList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline EltInArrayList_out& operator = (EltInArrayList* _s) {
      _data = _s;
      return *this;
    }
    inline operator EltInArrayList*&()  { return _data; }
    inline EltInArrayList*& ptr()       { return _data; }
    inline EltInArrayList* operator->() { return _data; }

    inline EltInArray& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    EltInArrayList*& _data;

  private:
    EltInArrayList_out();
    EltInArrayList_out& operator=(const EltInArrayList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_TimeValList;

  class TimeValList_var;

  class TimeValList : public _CORBA_Unbounded_Sequence< TimeVal >  {
  public:
    typedef TimeValList_var _var_type;
    inline TimeValList() {}
    inline TimeValList(const TimeValList& _s)
      : _CORBA_Unbounded_Sequence< TimeVal > (_s) {}

    inline TimeValList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< TimeVal > (_max) {}
    inline TimeValList(_CORBA_ULong _max, _CORBA_ULong _len, TimeVal* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< TimeVal > (_max, _len, _val, _rel) {}



    inline TimeValList& operator = (const TimeValList& _s) {
      _CORBA_Unbounded_Sequence< TimeVal > ::operator=(_s);
      return *this;
    }
  };

  class TimeValList_out;

  class TimeValList_var {
  public:
    inline TimeValList_var() : _pd_seq(0) {}
    inline TimeValList_var(TimeValList* _s) : _pd_seq(_s) {}
    inline TimeValList_var(const TimeValList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new TimeValList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~TimeValList_var() { if( _pd_seq )  delete _pd_seq; }

    inline TimeValList_var& operator = (TimeValList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline TimeValList_var& operator = (const TimeValList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new TimeValList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline TimeVal& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline TimeValList* operator -> () { return _pd_seq; }
    inline const TimeValList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator TimeValList& () const { return *_pd_seq; }
#else
    inline operator const TimeValList& () const { return *_pd_seq; }
    inline operator TimeValList& () { return *_pd_seq; }
#endif

    inline const TimeValList& in() const { return *_pd_seq; }
    inline TimeValList&       inout()    { return *_pd_seq; }
    inline TimeValList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline TimeValList* _retn() { TimeValList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class TimeValList_out;

  private:
    TimeValList* _pd_seq;
  };

  class TimeValList_out {
  public:
    inline TimeValList_out(TimeValList*& _s) : _data(_s) { _data = 0; }
    inline TimeValList_out(TimeValList_var& _s)
      : _data(_s._pd_seq) { _s = (TimeValList*) 0; }
    inline TimeValList_out(const TimeValList_out& _s) : _data(_s._data) {}
    inline TimeValList_out& operator = (const TimeValList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline TimeValList_out& operator = (TimeValList* _s) {
      _data = _s;
      return *this;
    }
    inline operator TimeValList*&()  { return _data; }
    inline TimeValList*& ptr()       { return _data; }
    inline TimeValList* operator->() { return _data; }

    inline TimeVal& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    TimeValList*& _data;

  private:
    TimeValList_out();
    TimeValList_out& operator=(const TimeValList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttrQualityList;

  // Need to declare <<= for elem type, as GCC expands templates early
#if defined(__GNUG__) && __GNUG__ == 2 && __GNUC_MINOR__ == 7
   friend inline void operator >>= (AttrQuality, cdrStream&);
   friend inline void operator <<= (AttrQuality&, cdrStream&);
#endif

  class AttrQualityList_var;

  class AttrQualityList : public _CORBA_Unbounded_Sequence_w_FixSizeElement< AttrQuality, 4, 4 >  {
  public:
    typedef AttrQualityList_var _var_type;
    inline AttrQualityList() {}
    inline AttrQualityList(const AttrQualityList& _s)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< AttrQuality, 4, 4 > (_s) {}

    inline AttrQualityList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< AttrQuality, 4, 4 > (_max) {}
    inline AttrQualityList(_CORBA_ULong _max, _CORBA_ULong _len, AttrQuality* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence_w_FixSizeElement< AttrQuality, 4, 4 > (_max, _len, _val, _rel) {}



    inline AttrQualityList& operator = (const AttrQualityList& _s) {
      _CORBA_Unbounded_Sequence_w_FixSizeElement< AttrQuality, 4, 4 > ::operator=(_s);
      return *this;
    }
  };

  class AttrQualityList_out;

  class AttrQualityList_var {
  public:
    inline AttrQualityList_var() : _pd_seq(0) {}
    inline AttrQualityList_var(AttrQualityList* _s) : _pd_seq(_s) {}
    inline AttrQualityList_var(const AttrQualityList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttrQualityList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttrQualityList_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttrQualityList_var& operator = (AttrQualityList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttrQualityList_var& operator = (const AttrQualityList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttrQualityList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttrQuality& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttrQualityList* operator -> () { return _pd_seq; }
    inline const AttrQualityList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttrQualityList& () const { return *_pd_seq; }
#else
    inline operator const AttrQualityList& () const { return *_pd_seq; }
    inline operator AttrQualityList& () { return *_pd_seq; }
#endif

    inline const AttrQualityList& in() const { return *_pd_seq; }
    inline AttrQualityList&       inout()    { return *_pd_seq; }
    inline AttrQualityList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttrQualityList* _retn() { AttrQualityList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttrQualityList_out;

  private:
    AttrQualityList* _pd_seq;
  };

  class AttrQualityList_out {
  public:
    inline AttrQualityList_out(AttrQualityList*& _s) : _data(_s) { _data = 0; }
    inline AttrQualityList_out(AttrQualityList_var& _s)
      : _data(_s._pd_seq) { _s = (AttrQualityList*) 0; }
    inline AttrQualityList_out(const AttrQualityList_out& _s) : _data(_s._data) {}
    inline AttrQualityList_out& operator = (const AttrQualityList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttrQualityList_out& operator = (AttrQualityList* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttrQualityList*&()  { return _data; }
    inline AttrQualityList*& ptr()       { return _data; }
    inline AttrQualityList* operator->() { return _data; }

    inline AttrQuality& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttrQualityList*& _data;

  private:
    AttrQualityList_out();
    AttrQualityList_out& operator=(const AttrQualityList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_AttributeDimList;

  class AttributeDimList_var;

  class AttributeDimList : public _CORBA_Unbounded_Sequence< AttributeDim >  {
  public:
    typedef AttributeDimList_var _var_type;
    inline AttributeDimList() {}
    inline AttributeDimList(const AttributeDimList& _s)
      : _CORBA_Unbounded_Sequence< AttributeDim > (_s) {}

    inline AttributeDimList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< AttributeDim > (_max) {}
    inline AttributeDimList(_CORBA_ULong _max, _CORBA_ULong _len, AttributeDim* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< AttributeDim > (_max, _len, _val, _rel) {}



    inline AttributeDimList& operator = (const AttributeDimList& _s) {
      _CORBA_Unbounded_Sequence< AttributeDim > ::operator=(_s);
      return *this;
    }
  };

  class AttributeDimList_out;

  class AttributeDimList_var {
  public:
    inline AttributeDimList_var() : _pd_seq(0) {}
    inline AttributeDimList_var(AttributeDimList* _s) : _pd_seq(_s) {}
    inline AttributeDimList_var(const AttributeDimList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new AttributeDimList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~AttributeDimList_var() { if( _pd_seq )  delete _pd_seq; }

    inline AttributeDimList_var& operator = (AttributeDimList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline AttributeDimList_var& operator = (const AttributeDimList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new AttributeDimList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline AttributeDim& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline AttributeDimList* operator -> () { return _pd_seq; }
    inline const AttributeDimList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator AttributeDimList& () const { return *_pd_seq; }
#else
    inline operator const AttributeDimList& () const { return *_pd_seq; }
    inline operator AttributeDimList& () { return *_pd_seq; }
#endif

    inline const AttributeDimList& in() const { return *_pd_seq; }
    inline AttributeDimList&       inout()    { return *_pd_seq; }
    inline AttributeDimList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline AttributeDimList* _retn() { AttributeDimList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class AttributeDimList_out;

  private:
    AttributeDimList* _pd_seq;
  };

  class AttributeDimList_out {
  public:
    inline AttributeDimList_out(AttributeDimList*& _s) : _data(_s) { _data = 0; }
    inline AttributeDimList_out(AttributeDimList_var& _s)
      : _data(_s._pd_seq) { _s = (AttributeDimList*) 0; }
    inline AttributeDimList_out(const AttributeDimList_out& _s) : _data(_s._data) {}
    inline AttributeDimList_out& operator = (const AttributeDimList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline AttributeDimList_out& operator = (AttributeDimList* _s) {
      _data = _s;
      return *this;
    }
    inline operator AttributeDimList*&()  { return _data; }
    inline AttributeDimList*& ptr()       { return _data; }
    inline AttributeDimList* operator->() { return _data; }

    inline AttributeDim& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    AttributeDimList*& _data;

  private:
    AttributeDimList_out();
    AttributeDimList_out& operator=(const AttributeDimList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevErrorListList;

  class DevErrorListList_var;

  class DevErrorListList : public _CORBA_Unbounded_Sequence< DevErrorList >  {
  public:
    typedef DevErrorListList_var _var_type;
    inline DevErrorListList() {}
    inline DevErrorListList(const DevErrorListList& _s)
      : _CORBA_Unbounded_Sequence< DevErrorList > (_s) {}

    inline DevErrorListList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevErrorList > (_max) {}
    inline DevErrorListList(_CORBA_ULong _max, _CORBA_ULong _len, DevErrorList* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevErrorList > (_max, _len, _val, _rel) {}



    inline DevErrorListList& operator = (const DevErrorListList& _s) {
      _CORBA_Unbounded_Sequence< DevErrorList > ::operator=(_s);
      return *this;
    }
  };

  class DevErrorListList_out;

  class DevErrorListList_var {
  public:
    inline DevErrorListList_var() : _pd_seq(0) {}
    inline DevErrorListList_var(DevErrorListList* _s) : _pd_seq(_s) {}
    inline DevErrorListList_var(const DevErrorListList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevErrorListList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevErrorListList_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevErrorListList_var& operator = (DevErrorListList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevErrorListList_var& operator = (const DevErrorListList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevErrorListList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevErrorList& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevErrorListList* operator -> () { return _pd_seq; }
    inline const DevErrorListList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevErrorListList& () const { return *_pd_seq; }
#else
    inline operator const DevErrorListList& () const { return *_pd_seq; }
    inline operator DevErrorListList& () { return *_pd_seq; }
#endif

    inline const DevErrorListList& in() const { return *_pd_seq; }
    inline DevErrorListList&       inout()    { return *_pd_seq; }
    inline DevErrorListList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevErrorListList* _retn() { DevErrorListList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevErrorListList_out;

  private:
    DevErrorListList* _pd_seq;
  };

  class DevErrorListList_out {
  public:
    inline DevErrorListList_out(DevErrorListList*& _s) : _data(_s) { _data = 0; }
    inline DevErrorListList_out(DevErrorListList_var& _s)
      : _data(_s._pd_seq) { _s = (DevErrorListList*) 0; }
    inline DevErrorListList_out(const DevErrorListList_out& _s) : _data(_s._data) {}
    inline DevErrorListList_out& operator = (const DevErrorListList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevErrorListList_out& operator = (DevErrorListList* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevErrorListList*&()  { return _data; }
    inline DevErrorListList*& ptr()       { return _data; }
    inline DevErrorListList* operator->() { return _data; }

    inline DevErrorList& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevErrorListList*& _data;

  private:
    DevErrorListList_out();
    DevErrorListList_out& operator=(const DevErrorListList_var&);
  };

  struct DevAttrHistory_4 {
    typedef _CORBA_ConstrType_Variable_Var<DevAttrHistory_4> _var_type;


    ::CORBA::String_member name;

    TimeValList dates;

    ::CORBA::Any value;

    AttrQualityList quals;

    EltInArrayList quals_array;

    AttributeDimList r_dims;

    EltInArrayList r_dims_array;

    AttributeDimList w_dims;

    EltInArrayList w_dims_array;

    DevErrorListList errors;

    EltInArrayList errors_array;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevAttrHistory_4::_var_type DevAttrHistory_4_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevAttrHistory_4,DevAttrHistory_4_var > DevAttrHistory_4_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevAttrHistory_4;

  struct DevCmdHistory_4 {
    typedef _CORBA_ConstrType_Variable_Var<DevCmdHistory_4> _var_type;


    TimeValList dates;

    ::CORBA::Any value;

    AttributeDimList dims;

    EltInArrayList dims_array;

    DevErrorListList errors;

    EltInArrayList errors_array;

    ::CORBA::Long cmd_type;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef DevCmdHistory_4::_var_type DevCmdHistory_4_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< DevCmdHistory_4,DevCmdHistory_4_var > DevCmdHistory_4_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevCmdHistory_4;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevAttrHistoryList;

  class DevAttrHistoryList_var;

  class DevAttrHistoryList : public _CORBA_Unbounded_Sequence< DevAttrHistory >  {
  public:
    typedef DevAttrHistoryList_var _var_type;
    inline DevAttrHistoryList() {}
    inline DevAttrHistoryList(const DevAttrHistoryList& _s)
      : _CORBA_Unbounded_Sequence< DevAttrHistory > (_s) {}

    inline DevAttrHistoryList(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevAttrHistory > (_max) {}
    inline DevAttrHistoryList(_CORBA_ULong _max, _CORBA_ULong _len, DevAttrHistory* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevAttrHistory > (_max, _len, _val, _rel) {}



    inline DevAttrHistoryList& operator = (const DevAttrHistoryList& _s) {
      _CORBA_Unbounded_Sequence< DevAttrHistory > ::operator=(_s);
      return *this;
    }
  };

  class DevAttrHistoryList_out;

  class DevAttrHistoryList_var {
  public:
    inline DevAttrHistoryList_var() : _pd_seq(0) {}
    inline DevAttrHistoryList_var(DevAttrHistoryList* _s) : _pd_seq(_s) {}
    inline DevAttrHistoryList_var(const DevAttrHistoryList_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevAttrHistoryList(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevAttrHistoryList_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevAttrHistoryList_var& operator = (DevAttrHistoryList* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevAttrHistoryList_var& operator = (const DevAttrHistoryList_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevAttrHistoryList;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevAttrHistory& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevAttrHistoryList* operator -> () { return _pd_seq; }
    inline const DevAttrHistoryList* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevAttrHistoryList& () const { return *_pd_seq; }
#else
    inline operator const DevAttrHistoryList& () const { return *_pd_seq; }
    inline operator DevAttrHistoryList& () { return *_pd_seq; }
#endif

    inline const DevAttrHistoryList& in() const { return *_pd_seq; }
    inline DevAttrHistoryList&       inout()    { return *_pd_seq; }
    inline DevAttrHistoryList*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevAttrHistoryList* _retn() { DevAttrHistoryList* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevAttrHistoryList_out;

  private:
    DevAttrHistoryList* _pd_seq;
  };

  class DevAttrHistoryList_out {
  public:
    inline DevAttrHistoryList_out(DevAttrHistoryList*& _s) : _data(_s) { _data = 0; }
    inline DevAttrHistoryList_out(DevAttrHistoryList_var& _s)
      : _data(_s._pd_seq) { _s = (DevAttrHistoryList*) 0; }
    inline DevAttrHistoryList_out(const DevAttrHistoryList_out& _s) : _data(_s._data) {}
    inline DevAttrHistoryList_out& operator = (const DevAttrHistoryList_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevAttrHistoryList_out& operator = (DevAttrHistoryList* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevAttrHistoryList*&()  { return _data; }
    inline DevAttrHistoryList*& ptr()       { return _data; }
    inline DevAttrHistoryList* operator->() { return _data; }

    inline DevAttrHistory& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevAttrHistoryList*& _data;

  private:
    DevAttrHistoryList_out();
    DevAttrHistoryList_out& operator=(const DevAttrHistoryList_var&);
  };

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_DevAttrHistoryList_3;

  class DevAttrHistoryList_3_var;

  class DevAttrHistoryList_3 : public _CORBA_Unbounded_Sequence< DevAttrHistory_3 >  {
  public:
    typedef DevAttrHistoryList_3_var _var_type;
    inline DevAttrHistoryList_3() {}
    inline DevAttrHistoryList_3(const DevAttrHistoryList_3& _s)
      : _CORBA_Unbounded_Sequence< DevAttrHistory_3 > (_s) {}

    inline DevAttrHistoryList_3(_CORBA_ULong _max)
      : _CORBA_Unbounded_Sequence< DevAttrHistory_3 > (_max) {}
    inline DevAttrHistoryList_3(_CORBA_ULong _max, _CORBA_ULong _len, DevAttrHistory_3* _val, _CORBA_Boolean _rel=0)
      : _CORBA_Unbounded_Sequence< DevAttrHistory_3 > (_max, _len, _val, _rel) {}



    inline DevAttrHistoryList_3& operator = (const DevAttrHistoryList_3& _s) {
      _CORBA_Unbounded_Sequence< DevAttrHistory_3 > ::operator=(_s);
      return *this;
    }
  };

  class DevAttrHistoryList_3_out;

  class DevAttrHistoryList_3_var {
  public:
    inline DevAttrHistoryList_3_var() : _pd_seq(0) {}
    inline DevAttrHistoryList_3_var(DevAttrHistoryList_3* _s) : _pd_seq(_s) {}
    inline DevAttrHistoryList_3_var(const DevAttrHistoryList_3_var& _s) {
      if( _s._pd_seq )  _pd_seq = new DevAttrHistoryList_3(*_s._pd_seq);
      else              _pd_seq = 0;
    }
    inline ~DevAttrHistoryList_3_var() { if( _pd_seq )  delete _pd_seq; }

    inline DevAttrHistoryList_3_var& operator = (DevAttrHistoryList_3* _s) {
      if( _pd_seq )  delete _pd_seq;
      _pd_seq = _s;
      return *this;
    }
    inline DevAttrHistoryList_3_var& operator = (const DevAttrHistoryList_3_var& _s) {
      if( _s._pd_seq ) {
        if( !_pd_seq )  _pd_seq = new DevAttrHistoryList_3;
        *_pd_seq = *_s._pd_seq;
      } else if( _pd_seq ) {
        delete _pd_seq;
        _pd_seq = 0;
      }
      return *this;
    }
    inline DevAttrHistory_3& operator [] (_CORBA_ULong _s) {
      return (*_pd_seq)[_s];
    }



    inline DevAttrHistoryList_3* operator -> () { return _pd_seq; }
    inline const DevAttrHistoryList_3* operator -> () const { return _pd_seq; }
#if defined(__GNUG__)
    inline operator DevAttrHistoryList_3& () const { return *_pd_seq; }
#else
    inline operator const DevAttrHistoryList_3& () const { return *_pd_seq; }
    inline operator DevAttrHistoryList_3& () { return *_pd_seq; }
#endif

    inline const DevAttrHistoryList_3& in() const { return *_pd_seq; }
    inline DevAttrHistoryList_3&       inout()    { return *_pd_seq; }
    inline DevAttrHistoryList_3*&      out() {
      if( _pd_seq ) { delete _pd_seq; _pd_seq = 0; }
      return _pd_seq;
    }
    inline DevAttrHistoryList_3* _retn() { DevAttrHistoryList_3* tmp = _pd_seq; _pd_seq = 0; return tmp; }

    friend class DevAttrHistoryList_3_out;

  private:
    DevAttrHistoryList_3* _pd_seq;
  };

  class DevAttrHistoryList_3_out {
  public:
    inline DevAttrHistoryList_3_out(DevAttrHistoryList_3*& _s) : _data(_s) { _data = 0; }
    inline DevAttrHistoryList_3_out(DevAttrHistoryList_3_var& _s)
      : _data(_s._pd_seq) { _s = (DevAttrHistoryList_3*) 0; }
    inline DevAttrHistoryList_3_out(const DevAttrHistoryList_3_out& _s) : _data(_s._data) {}
    inline DevAttrHistoryList_3_out& operator = (const DevAttrHistoryList_3_out& _s) {
      _data = _s._data;
      return *this;
    }
    inline DevAttrHistoryList_3_out& operator = (DevAttrHistoryList_3* _s) {
      _data = _s;
      return *this;
    }
    inline operator DevAttrHistoryList_3*&()  { return _data; }
    inline DevAttrHistoryList_3*& ptr()       { return _data; }
    inline DevAttrHistoryList_3* operator->() { return _data; }

    inline DevAttrHistory_3& operator [] (_CORBA_ULong _i) {
      return (*_data)[_i];
    }



    DevAttrHistoryList_3*& _data;

  private:
    DevAttrHistoryList_3_out();
    DevAttrHistoryList_3_out& operator=(const DevAttrHistoryList_3_var&);
  };

  struct ZmqCallInfo {
    typedef _CORBA_ConstrType_Variable_Var<ZmqCallInfo> _var_type;


    ::CORBA::Long version;

    ::CORBA::ULong ctr;

    ::CORBA::String_member method_name;

    DevVarCharArray oid;

    ::CORBA::Boolean call_is_except;



    void operator>>= (cdrStream &) const;
    void operator<<= (cdrStream &);
  };

  typedef ZmqCallInfo::_var_type ZmqCallInfo_var;

  typedef _CORBA_ConstrType_Variable_OUT_arg< ZmqCallInfo,ZmqCallInfo_var > ZmqCallInfo_out;

  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_ZmqCallInfo;

#ifndef __Tango_mDevice__
#define __Tango_mDevice__

  class Device;
  class _objref_Device;
  class _impl_Device;

  typedef _objref_Device* Device_ptr;
  typedef Device_ptr DeviceRef;

  class Device_Helper {
  public:
    typedef Device_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Device, Device_Helper> Device_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Device,Device_Helper > Device_out;

#endif

  // interface Device
  class Device {
  public:
    // Declarations for this interface type.
    typedef Device_ptr _ptr_type;
    typedef Device_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);

    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.

  };

  class _objref_Device :
    public virtual ::CORBA::Object,
    public virtual omniObjRef
  {
  public:
    ::CORBA::Any* command_inout(const char* command, const ::CORBA::Any& argin);
    AttributeConfigList* get_attribute_config(const ::Tango::DevVarStringArray& names);
    void set_attribute_config(const ::Tango::AttributeConfigList& new_conf);
    AttributeValueList* read_attributes(const ::Tango::DevVarStringArray& names);
    void write_attributes(const ::Tango::AttributeValueList& values);
    void ping();
    DevVarStringArray* black_box(::CORBA::Long n);
    DevInfo* info();
    DevCmdInfoList* command_list_query();
    DevCmdInfo* command_query(const char* command);
    char* name();
    char* description();
    DevState state();
    char* status();
    char* adm_name();

    inline _objref_Device()  { _PR_setobj(0); }  // nil
    _objref_Device(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Device();


  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Device(const _objref_Device&);
    _objref_Device& operator = (const _objref_Device&);
    // not implemented

    friend class Device;
  };

  class _pof_Device : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Device() : _OMNI_NS(proxyObjectFactory)(Device::_PD_repoId) {}
    virtual ~_pof_Device();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Device :
    public virtual omniServant
  {
  public:
    virtual ~_impl_Device();

    virtual ::CORBA::Any* command_inout(const char* command, const ::CORBA::Any& argin) = 0;
    virtual AttributeConfigList* get_attribute_config(const ::Tango::DevVarStringArray& names) = 0;
    virtual void set_attribute_config(const ::Tango::AttributeConfigList& new_conf) = 0;
    virtual AttributeValueList* read_attributes(const ::Tango::DevVarStringArray& names) = 0;
    virtual void write_attributes(const ::Tango::AttributeValueList& values) = 0;
    virtual void ping() = 0;
    virtual DevVarStringArray* black_box(::CORBA::Long n) = 0;
    virtual DevInfo* info() = 0;
    virtual DevCmdInfoList* command_list_query() = 0;
    virtual DevCmdInfo* command_query(const char* command) = 0;
    virtual char* name() = 0;
    virtual char* description() = 0;
    virtual DevState state() = 0;
    virtual char* status() = 0;
    virtual char* adm_name() = 0;

  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();

  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Device;

#ifndef __Tango_mDevice__2__
#define __Tango_mDevice__2__

  class Device_2;
  class _objref_Device_2;
  class _impl_Device_2;

  typedef _objref_Device_2* Device_2_ptr;
  typedef Device_2_ptr Device_2Ref;

  class Device_2_Helper {
  public:
    typedef Device_2_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Device_2, Device_2_Helper> Device_2_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Device_2,Device_2_Helper > Device_2_out;

#endif

  // interface Device_2
  class Device_2 {
  public:
    // Declarations for this interface type.
    typedef Device_2_ptr _ptr_type;
    typedef Device_2_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);

    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.

  };

  class _objref_Device_2 :
    public virtual _objref_Device
  {
  public:
    ::CORBA::Any* command_inout_2(const char* command, const ::CORBA::Any& argin, ::Tango::DevSource source);
    AttributeValueList* read_attributes_2(const ::Tango::DevVarStringArray& names, ::Tango::DevSource source);
    AttributeConfigList_2* get_attribute_config_2(const ::Tango::DevVarStringArray& names);
    DevCmdInfoList_2* command_list_query_2();
    DevCmdInfo_2* command_query_2(const char* command);
    DevCmdHistoryList* command_inout_history_2(const char* command, ::CORBA::Long n);
    DevAttrHistoryList* read_attribute_history_2(const char* name, ::CORBA::Long n);

    inline _objref_Device_2()  { _PR_setobj(0); }  // nil
    _objref_Device_2(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Device_2();


  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Device_2(const _objref_Device_2&);
    _objref_Device_2& operator = (const _objref_Device_2&);
    // not implemented

    friend class Device_2;
  };

  class _pof_Device_2 : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Device_2() : _OMNI_NS(proxyObjectFactory)(Device_2::_PD_repoId) {}
    virtual ~_pof_Device_2();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Device_2 :
    public virtual _impl_Device
  {
  public:
    virtual ~_impl_Device_2();

    virtual ::CORBA::Any* command_inout_2(const char* command, const ::CORBA::Any& argin, ::Tango::DevSource source) = 0;
    virtual AttributeValueList* read_attributes_2(const ::Tango::DevVarStringArray& names, ::Tango::DevSource source) = 0;
    virtual AttributeConfigList_2* get_attribute_config_2(const ::Tango::DevVarStringArray& names) = 0;
    virtual DevCmdInfoList_2* command_list_query_2() = 0;
    virtual DevCmdInfo_2* command_query_2(const char* command) = 0;
    virtual DevCmdHistoryList* command_inout_history_2(const char* command, ::CORBA::Long n) = 0;
    virtual DevAttrHistoryList* read_attribute_history_2(const char* name, ::CORBA::Long n) = 0;

  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();

  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Device_2;

#ifndef __Tango_mDevice__3__
#define __Tango_mDevice__3__

  class Device_3;
  class _objref_Device_3;
  class _impl_Device_3;

  typedef _objref_Device_3* Device_3_ptr;
  typedef Device_3_ptr Device_3Ref;

  class Device_3_Helper {
  public:
    typedef Device_3_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Device_3, Device_3_Helper> Device_3_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Device_3,Device_3_Helper > Device_3_out;

#endif

  // interface Device_3
  class Device_3 {
  public:
    // Declarations for this interface type.
    typedef Device_3_ptr _ptr_type;
    typedef Device_3_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);

    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.

  };

  class _objref_Device_3 :
    public virtual _objref_Device_2
  {
  public:
    AttributeValueList_3* read_attributes_3(const ::Tango::DevVarStringArray& names, ::Tango::DevSource source);
    void write_attributes_3(const ::Tango::AttributeValueList& values);
    DevAttrHistoryList_3* read_attribute_history_3(const char* name, ::CORBA::Long n);
    DevInfo_3* info_3();
    AttributeConfigList_3* get_attribute_config_3(const ::Tango::DevVarStringArray& names);
    void set_attribute_config_3(const ::Tango::AttributeConfigList_3& new_conf);

    inline _objref_Device_3()  { _PR_setobj(0); }  // nil
    _objref_Device_3(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Device_3();


  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Device_3(const _objref_Device_3&);
    _objref_Device_3& operator = (const _objref_Device_3&);
    // not implemented

    friend class Device_3;
  };

  class _pof_Device_3 : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Device_3() : _OMNI_NS(proxyObjectFactory)(Device_3::_PD_repoId) {}
    virtual ~_pof_Device_3();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Device_3 :
    public virtual _impl_Device_2
  {
  public:
    virtual ~_impl_Device_3();

    virtual AttributeValueList_3* read_attributes_3(const ::Tango::DevVarStringArray& names, ::Tango::DevSource source) = 0;
    virtual void write_attributes_3(const ::Tango::AttributeValueList& values) = 0;
    virtual DevAttrHistoryList_3* read_attribute_history_3(const char* name, ::CORBA::Long n) = 0;
    virtual DevInfo_3* info_3() = 0;
    virtual AttributeConfigList_3* get_attribute_config_3(const ::Tango::DevVarStringArray& names) = 0;
    virtual void set_attribute_config_3(const ::Tango::AttributeConfigList_3& new_conf) = 0;

  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();

  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Device_3;

#ifndef __Tango_mDevice__4__
#define __Tango_mDevice__4__

  class Device_4;
  class _objref_Device_4;
  class _impl_Device_4;

  typedef _objref_Device_4* Device_4_ptr;
  typedef Device_4_ptr Device_4Ref;

  class Device_4_Helper {
  public:
    typedef Device_4_ptr _ptr_type;

    static _ptr_type _nil();
    static _CORBA_Boolean is_nil(_ptr_type);
    static void release(_ptr_type);
    static void duplicate(_ptr_type);
    static void marshalObjRef(_ptr_type, cdrStream&);
    static _ptr_type unmarshalObjRef(cdrStream&);
  };

  typedef _CORBA_ObjRef_Var<_objref_Device_4, Device_4_Helper> Device_4_var;
  typedef _CORBA_ObjRef_OUT_arg<_objref_Device_4,Device_4_Helper > Device_4_out;

#endif

  // interface Device_4
  class Device_4 {
  public:
    // Declarations for this interface type.
    typedef Device_4_ptr _ptr_type;
    typedef Device_4_var _var_type;

    static _ptr_type _duplicate(_ptr_type);
    static _ptr_type _narrow(::CORBA::Object_ptr);
    static _ptr_type _unchecked_narrow(::CORBA::Object_ptr);

    static _ptr_type _nil();

    static inline void _marshalObjRef(_ptr_type, cdrStream&);

    static inline _ptr_type _unmarshalObjRef(cdrStream& s) {
      omniObjRef* o = omniObjRef::_unMarshal(_PD_repoId,s);
      if (o)
        return (_ptr_type) o->_ptrToObjRef(_PD_repoId);
      else
        return _nil();
    }

    static _core_attr const char* _PD_repoId;

    // Other IDL defined within this scope.

  };

  class _objref_Device_4 :
    public virtual _objref_Device_3
  {
  public:
    DevAttrHistory_4* read_attribute_history_4(const char* name, ::CORBA::Long n);
    DevCmdHistory_4* command_inout_history_4(const char* command, ::CORBA::Long n);
    ::CORBA::Any* command_inout_4(const char* command, const ::CORBA::Any& argin, ::Tango::DevSource source, const ::Tango::ClntIdent& cl_ident);
    AttributeValueList_4* read_attributes_4(const ::Tango::DevVarStringArray& names, ::Tango::DevSource source, const ::Tango::ClntIdent& cl_ident);
    void write_attributes_4(const ::Tango::AttributeValueList_4& values, const ::Tango::ClntIdent& cl_ident);
    void set_attribute_config_4(const ::Tango::AttributeConfigList_3& new_conf, const ::Tango::ClntIdent& cl_ident);
    AttributeValueList_4* write_read_attributes_4(const ::Tango::AttributeValueList_4& values, const ::Tango::ClntIdent& cl_ident);

    inline _objref_Device_4()  { _PR_setobj(0); }  // nil
    _objref_Device_4(omniIOR*, omniIdentity*);

  protected:
    virtual ~_objref_Device_4();


  private:
    virtual void* _ptrToObjRef(const char*);

    _objref_Device_4(const _objref_Device_4&);
    _objref_Device_4& operator = (const _objref_Device_4&);
    // not implemented

    friend class Device_4;
  };

  class _pof_Device_4 : public _OMNI_NS(proxyObjectFactory) {
  public:
    inline _pof_Device_4() : _OMNI_NS(proxyObjectFactory)(Device_4::_PD_repoId) {}
    virtual ~_pof_Device_4();

    virtual omniObjRef* newObjRef(omniIOR*,omniIdentity*);
    virtual _CORBA_Boolean is_a(const char*) const;
  };

  class _impl_Device_4 :
    public virtual _impl_Device_3
  {
  public:
    virtual ~_impl_Device_4();

    virtual DevAttrHistory_4* read_attribute_history_4(const char* name, ::CORBA::Long n) = 0;
    virtual DevCmdHistory_4* command_inout_history_4(const char* command, ::CORBA::Long n) = 0;
    virtual ::CORBA::Any* command_inout_4(const char* command, const ::CORBA::Any& argin, ::Tango::DevSource source, const ::Tango::ClntIdent& cl_ident) = 0;
    virtual AttributeValueList_4* read_attributes_4(const ::Tango::DevVarStringArray& names, ::Tango::DevSource source, const ::Tango::ClntIdent& cl_ident) = 0;
    virtual void write_attributes_4(const ::Tango::AttributeValueList_4& values, const ::Tango::ClntIdent& cl_ident) = 0;
    virtual void set_attribute_config_4(const ::Tango::AttributeConfigList_3& new_conf, const ::Tango::ClntIdent& cl_ident) = 0;
    virtual AttributeValueList_4* write_read_attributes_4(const ::Tango::AttributeValueList_4& values, const ::Tango::ClntIdent& cl_ident) = 0;

  public:  // Really protected, workaround for xlC
    virtual _CORBA_Boolean _dispatch(omniCallHandle&);

  private:
    virtual void* _ptrToInterface(const char*);
    virtual const char* _mostDerivedRepoId();

  };


  _CORBA_MODULE_VAR _dyn_attr const ::CORBA::TypeCode_ptr _tc_Device_4;

_CORBA_MODULE_END



_CORBA_MODULE POA_Tango
_CORBA_MODULE_BEG

  class Device :
    public virtual Tango::_impl_Device,
    public virtual ::PortableServer::ServantBase
  {
  public:
    virtual ~Device();

    inline ::Tango::Device_ptr _this() {
      return (::Tango::Device_ptr) _do_this(::Tango::Device::_PD_repoId);
    }
  };

  class Device_2 :
    public virtual Tango::_impl_Device_2,
    public virtual Device
  {
  public:
    virtual ~Device_2();

    inline ::Tango::Device_2_ptr _this() {
      return (::Tango::Device_2_ptr) _do_this(::Tango::Device_2::_PD_repoId);
    }
  };

  class Device_3 :
    public virtual Tango::_impl_Device_3,
    public virtual Device_2
  {
  public:
    virtual ~Device_3();

    inline ::Tango::Device_3_ptr _this() {
      return (::Tango::Device_3_ptr) _do_this(::Tango::Device_3::_PD_repoId);
    }
  };

  class Device_4 :
    public virtual Tango::_impl_Device_4,
    public virtual Device_3
  {
  public:
    virtual ~Device_4();

    inline ::Tango::Device_4_ptr _this() {
      return (::Tango::Device_4_ptr) _do_this(::Tango::Device_4::_PD_repoId);
    }
  };

_CORBA_MODULE_END



_CORBA_MODULE OBV_Tango
_CORBA_MODULE_BEG

_CORBA_MODULE_END





#undef _core_attr
#undef _dyn_attr

void operator<<=(::CORBA::Any& _a, const Tango::DevVarBooleanArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarBooleanArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarBooleanArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarBooleanArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarDoubleArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarDoubleArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarDoubleArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarDoubleArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarFloatArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarFloatArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarFloatArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarFloatArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarShortArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarShortArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarShortArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarShortArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarLongArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarLongArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarLongArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarLongArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarLong64Array& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarLong64Array* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarLong64Array*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarLong64Array*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarCharArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarCharArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarCharArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarCharArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarStringArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarStringArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarStringArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarStringArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarUShortArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarUShortArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarUShortArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarUShortArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarULongArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarULongArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarULongArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarULongArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarULong64Array& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarULong64Array* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarULong64Array*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarULong64Array*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevVarLongStringArray& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevVarLongStringArray* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarLongStringArray*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarLongStringArray*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevVarDoubleStringArray& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevVarDoubleStringArray* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarDoubleStringArray*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarDoubleStringArray*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevEncoded& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevEncoded* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevEncoded*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevEncoded*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarEncodedArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarEncodedArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarEncodedArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarEncodedArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::JavaUUID_forany& _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::JavaUUID_forany& _s);

extern void operator<<=(::CORBA::Any& _a, const Tango::JavaClntIdent& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::JavaClntIdent* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::JavaClntIdent*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::JavaClntIdent*& _sp);

inline void operator >>=(Tango::LockerLanguage _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::LockerLanguage& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::JAVA) {
    _e = (Tango::LockerLanguage) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::LockerLanguage _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::LockerLanguage& _s);

void operator<<=(::CORBA::Any& _a, const Tango::ClntIdent& _s);
void operator<<=(::CORBA::Any& _a, Tango::ClntIdent* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::ClntIdent*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::ClntIdent*& _sp);

inline void operator >>=(Tango::AttrQuality _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::AttrQuality& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::ATTR_WARNING) {
    _e = (Tango::AttrQuality) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::AttrQuality _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrQuality& _s);

inline void operator >>=(Tango::AttrWriteType _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::AttrWriteType& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::READ_WRITE) {
    _e = (Tango::AttrWriteType) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::AttrWriteType _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrWriteType& _s);

inline void operator >>=(Tango::AttrDataFormat _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::AttrDataFormat& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::FMT_UNKNOWN) {
    _e = (Tango::AttrDataFormat) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::AttrDataFormat _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrDataFormat& _s);

inline void operator >>=(Tango::DevSource _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::DevSource& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::CACHE_DEV) {
    _e = (Tango::DevSource) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::DevSource _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevSource& _s);

inline void operator >>=(Tango::ErrSeverity _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::ErrSeverity& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::PANIC) {
    _e = (Tango::ErrSeverity) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::ErrSeverity _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::ErrSeverity& _s);

inline void operator >>=(Tango::DevState _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::DevState& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::UNKNOWN) {
    _e = (Tango::DevState) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::DevState _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevState& _s);

inline void operator >>=(Tango::DispLevel _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::DispLevel& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::EXPERT) {
    _e = (Tango::DispLevel) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::DispLevel _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DispLevel& _s);

void operator<<=(::CORBA::Any& _a, const Tango::DevVarStateArray& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevVarStateArray* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevVarStateArray*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevVarStateArray*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::TimeVal& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::TimeVal* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::TimeVal*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::TimeVal*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfo& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfo* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfo*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfo*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfo_2& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfo_2* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfo_2*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfo_2*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfoList& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfoList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfoList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfoList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdInfoList_2& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevCmdInfoList_2* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdInfoList_2*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdInfoList_2*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevError& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevError* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevError*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevError*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevErrorList& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevErrorList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevErrorList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevErrorList*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::NamedDevError& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::NamedDevError* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::NamedDevError*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::NamedDevError*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::NamedDevErrorList& _s);
void operator<<=(::CORBA::Any& _a, Tango::NamedDevErrorList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::NamedDevErrorList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::NamedDevErrorList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevFailed& _s);
void operator<<=(::CORBA::Any& _a, const Tango::DevFailed* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevFailed*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::MultiDevFailed& _s);
void operator<<=(::CORBA::Any& _a, const Tango::MultiDevFailed* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::MultiDevFailed*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfig& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeConfig* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfig*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfig*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfig_2& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeConfig_2* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfig_2*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfig_2*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeValue& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeValue* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValue*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValue*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeDim& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeDim* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeDim*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeDim*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeValue_3& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeValue_3* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValue_3*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValue_3*& _sp);

inline void operator >>=(Tango::AttributeDataType _e, cdrStream& s) {
  ::operator>>=((::CORBA::ULong)_e, s);
}

inline void operator <<= (Tango::AttributeDataType& _e, cdrStream& s) {
  ::CORBA::ULong _0RL_e;
  ::operator<<=(_0RL_e,s);
  if (_0RL_e <= Tango::NO_DATA) {
    _e = (Tango::AttributeDataType) _0RL_e;
  }
  else {
    OMNIORB_THROW(MARSHAL,_OMNI_NS(MARSHAL_InvalidEnumValue),
                  (::CORBA::CompletionStatus)s.completion());
  }
}

void operator<<=(::CORBA::Any& _a, Tango::AttributeDataType _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeDataType& _s);

void operator<<=(::CORBA::Any& _a, const Tango::AttrValUnion& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttrValUnion* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttrValUnion*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrValUnion*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeValue_4& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeValue_4* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValue_4*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValue_4*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::ChangeEventProp& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::ChangeEventProp* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::ChangeEventProp*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::ChangeEventProp*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::PeriodicEventProp& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::PeriodicEventProp* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::PeriodicEventProp*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::PeriodicEventProp*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::ArchiveEventProp& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::ArchiveEventProp* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::ArchiveEventProp*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::ArchiveEventProp*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::EventProperties& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::EventProperties* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::EventProperties*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::EventProperties*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeAlarm& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeAlarm* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeAlarm*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeAlarm*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfig_3& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttributeConfig_3* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfig_3*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfig_3*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfigList& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfigList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfigList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfigList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfigList_2& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfigList_2* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfigList_2*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfigList_2*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttributeConfigList_3& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttributeConfigList_3* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeConfigList_3*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeConfigList_3*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValueList& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttributeValueList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValueList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValueList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValueList_3& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttributeValueList_3* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValueList_3*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValueList_3*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttributeValueList_4& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttributeValueList_4* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeValueList_4*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeValueList_4*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::AttDataReady& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::AttDataReady* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttDataReady*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttDataReady*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevInfo& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevInfo* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevInfo*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevInfo*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevInfo_3& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevInfo_3* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevInfo_3*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevInfo_3*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevCmdHistory& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevCmdHistory* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdHistory*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdHistory*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevCmdHistoryList& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevCmdHistoryList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdHistoryList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdHistoryList*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistory& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistory* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistory*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistory*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistory_3& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistory_3* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistory_3*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistory_3*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::EltInArray& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::EltInArray* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::EltInArray*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::EltInArray*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::EltInArrayList& _s);
void operator<<=(::CORBA::Any& _a, Tango::EltInArrayList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::EltInArrayList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::EltInArrayList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::TimeValList& _s);
void operator<<=(::CORBA::Any& _a, Tango::TimeValList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::TimeValList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::TimeValList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttrQualityList& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttrQualityList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttrQualityList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttrQualityList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::AttributeDimList& _s);
void operator<<=(::CORBA::Any& _a, Tango::AttributeDimList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::AttributeDimList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::AttributeDimList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevErrorListList& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevErrorListList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevErrorListList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevErrorListList*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistory_4& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistory_4* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistory_4*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistory_4*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::DevCmdHistory_4& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::DevCmdHistory_4* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevCmdHistory_4*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevCmdHistory_4*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistoryList& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistoryList* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistoryList*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistoryList*& _sp);

void operator<<=(::CORBA::Any& _a, const Tango::DevAttrHistoryList_3& _s);
void operator<<=(::CORBA::Any& _a, Tango::DevAttrHistoryList_3* _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::DevAttrHistoryList_3*& _sp);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::DevAttrHistoryList_3*& _sp);

extern void operator<<=(::CORBA::Any& _a, const Tango::ZmqCallInfo& _s);
extern void operator<<=(::CORBA::Any& _a, Tango::ZmqCallInfo* _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::ZmqCallInfo*& _sp);
extern _CORBA_Boolean operator>>=(const ::CORBA::Any& _a, const Tango::ZmqCallInfo*& _sp);

void operator<<=(::CORBA::Any& _a, Tango::Device_ptr _s);
void operator<<=(::CORBA::Any& _a, Tango::Device_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_ptr& _s);

void operator<<=(::CORBA::Any& _a, Tango::Device_2_ptr _s);
void operator<<=(::CORBA::Any& _a, Tango::Device_2_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_2_ptr& _s);

void operator<<=(::CORBA::Any& _a, Tango::Device_3_ptr _s);
void operator<<=(::CORBA::Any& _a, Tango::Device_3_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_3_ptr& _s);

void operator<<=(::CORBA::Any& _a, Tango::Device_4_ptr _s);
void operator<<=(::CORBA::Any& _a, Tango::Device_4_ptr* _s);
_CORBA_Boolean operator>>=(const ::CORBA::Any& _a, Tango::Device_4_ptr& _s);



inline void
Tango::Device::_marshalObjRef(::Tango::Device_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Tango::Device_2::_marshalObjRef(::Tango::Device_2_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Tango::Device_3::_marshalObjRef(::Tango::Device_3_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}


inline void
Tango::Device_4::_marshalObjRef(::Tango::Device_4_ptr obj, cdrStream& s) {
  omniObjRef::_marshal(obj->_PR_getobj(),s);
}




#ifdef   USE_stub_in_nt_dll_NOT_DEFINED_tango
# undef  USE_stub_in_nt_dll
# undef  USE_stub_in_nt_dll_NOT_DEFINED_tango
#endif
#ifdef   USE_core_stub_in_nt_dll_NOT_DEFINED_tango
# undef  USE_core_stub_in_nt_dll
# undef  USE_core_stub_in_nt_dll_NOT_DEFINED_tango
#endif
#ifdef   USE_dyn_stub_in_nt_dll_NOT_DEFINED_tango
# undef  USE_dyn_stub_in_nt_dll
# undef  USE_dyn_stub_in_nt_dll_NOT_DEFINED_tango
#endif

#endif  // __tango_hh__

