// -*- C++ -*-
/**
 * Code generated by the The ACE ORB (TAO) IDL Compiler v2.4.3
 * TAO and the TAO IDL Compiler have been developed by:
 *       Center for Distributed Object Computing
 *       Washington University
 *       St. Louis, MO
 *       USA
 *       http://www.cs.wustl.edu/~schmidt/doc-center.html
 * and
 *       Distributed Object Computing Laboratory
 *       University of California at Irvine
 *       Irvine, CA
 *       USA
 * and
 *       Institute for Software Integrated Systems
 *       Vanderbilt University
 *       Nashville, TN
 *       USA
 *       http://www.isis.vanderbilt.edu/
 *
 * Information about TAO is available at:
 *     http://www.dre.vanderbilt.edu/~schmidt/TAO.html
 **/

// TAO_IDL - Generated from
// be/be_codegen.cpp:373


#include "TmcdbGuiErrTypeC.h"
#include "tao/AnyTypeCode/Null_RefCount_Policy.h"
#include "tao/AnyTypeCode/TypeCode_Constants.h"
#include "tao/AnyTypeCode/Alias_TypeCode_Static.h"
#include "tao/AnyTypeCode/Struct_TypeCode_Static.h"
#include "tao/AnyTypeCode/TypeCode_Struct_Field.h"
#include "tao/CDR.h"
#include "tao/SystemException.h"
#include "tao/CDR.h"
#include "tao/AnyTypeCode/Any_Dual_Impl_T.h"
#include "ace/OS_NS_string.h"

#if !defined (__ACE_INLINE__)
#include "TmcdbGuiErrTypeC.inl"
#endif /* !defined INLINE */

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbGuiErrTypeEx::TmcdbGuiErrTypeEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbGuiErrTypeEx:1.0",
        "TmcdbGuiErrTypeEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbGuiErrTypeEx::TmcdbGuiErrTypeEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbGuiErrTypeEx:1.0",
        "TmcdbGuiErrTypeEx")
{
}

TmcdbGuiErrType::TmcdbGuiErrTypeEx::~TmcdbGuiErrTypeEx (void)
{
}

TmcdbGuiErrType::TmcdbGuiErrTypeEx::TmcdbGuiErrTypeEx (const ::TmcdbGuiErrType::TmcdbGuiErrTypeEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbGuiErrTypeEx&
TmcdbGuiErrType::TmcdbGuiErrTypeEx::operator= (const ::TmcdbGuiErrType::TmcdbGuiErrTypeEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbGuiErrTypeEx *_tao_tmp_pointer =
    static_cast<TmcdbGuiErrTypeEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbGuiErrTypeEx *
TmcdbGuiErrType::TmcdbGuiErrTypeEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbGuiErrTypeEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbGuiErrTypeEx *
TmcdbGuiErrType::TmcdbGuiErrTypeEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbGuiErrTypeEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbGuiErrTypeEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbGuiErrTypeEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbGuiErrTypeEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbGuiErrTypeEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbGuiErrTypeEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbGuiErrTypeEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbGuiErrTypeEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbGuiErrTypeEx:1.0",
  "TmcdbGuiErrTypeEx",
  _tao_fields_TmcdbGuiErrType_TmcdbGuiErrTypeEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbGuiErrTypeEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbGuiErrTypeEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbErrorEx::TmcdbErrorEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbErrorEx:1.0",
        "TmcdbErrorEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbErrorEx::TmcdbErrorEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbErrorEx:1.0",
        "TmcdbErrorEx")
{
}

TmcdbGuiErrType::TmcdbErrorEx::~TmcdbErrorEx (void)
{
}

TmcdbGuiErrType::TmcdbErrorEx::TmcdbErrorEx (const ::TmcdbGuiErrType::TmcdbErrorEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbErrorEx&
TmcdbGuiErrType::TmcdbErrorEx::operator= (const ::TmcdbGuiErrType::TmcdbErrorEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbErrorEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbErrorEx *_tao_tmp_pointer =
    static_cast<TmcdbErrorEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbErrorEx *
TmcdbGuiErrType::TmcdbErrorEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbErrorEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbErrorEx *
TmcdbGuiErrType::TmcdbErrorEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbErrorEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbErrorEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbErrorEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbErrorEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbErrorEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbErrorEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbErrorEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbErrorEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbErrorEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbErrorEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbErrorEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbErrorEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbErrorEx:1.0",
  "TmcdbErrorEx",
  _tao_fields_TmcdbGuiErrType_TmcdbErrorEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbErrorEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbErrorEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbNoSuchRowEx::TmcdbNoSuchRowEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbNoSuchRowEx:1.0",
        "TmcdbNoSuchRowEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbNoSuchRowEx::TmcdbNoSuchRowEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbNoSuchRowEx:1.0",
        "TmcdbNoSuchRowEx")
{
}

TmcdbGuiErrType::TmcdbNoSuchRowEx::~TmcdbNoSuchRowEx (void)
{
}

TmcdbGuiErrType::TmcdbNoSuchRowEx::TmcdbNoSuchRowEx (const ::TmcdbGuiErrType::TmcdbNoSuchRowEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbNoSuchRowEx&
TmcdbGuiErrType::TmcdbNoSuchRowEx::operator= (const ::TmcdbGuiErrType::TmcdbNoSuchRowEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbNoSuchRowEx *_tao_tmp_pointer =
    static_cast<TmcdbNoSuchRowEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbNoSuchRowEx *
TmcdbGuiErrType::TmcdbNoSuchRowEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbNoSuchRowEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbNoSuchRowEx *
TmcdbGuiErrType::TmcdbNoSuchRowEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbNoSuchRowEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbNoSuchRowEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbNoSuchRowEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbNoSuchRowEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbNoSuchRowEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbNoSuchRowEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbNoSuchRowEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbNoSuchRowEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbNoSuchRowEx:1.0",
  "TmcdbNoSuchRowEx",
  _tao_fields_TmcdbGuiErrType_TmcdbNoSuchRowEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbNoSuchRowEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbNoSuchRowEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::TmcdbRowAlreadyExistsEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbRowAlreadyExistsEx:1.0",
        "TmcdbRowAlreadyExistsEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::TmcdbRowAlreadyExistsEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbRowAlreadyExistsEx:1.0",
        "TmcdbRowAlreadyExistsEx")
{
}

TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::~TmcdbRowAlreadyExistsEx (void)
{
}

TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::TmcdbRowAlreadyExistsEx (const ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbRowAlreadyExistsEx&
TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::operator= (const ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbRowAlreadyExistsEx *_tao_tmp_pointer =
    static_cast<TmcdbRowAlreadyExistsEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbRowAlreadyExistsEx *
TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbRowAlreadyExistsEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbRowAlreadyExistsEx *
TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbRowAlreadyExistsEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbRowAlreadyExistsEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbRowAlreadyExistsEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbRowAlreadyExistsEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbRowAlreadyExistsEx:1.0",
  "TmcdbRowAlreadyExistsEx",
  _tao_fields_TmcdbGuiErrType_TmcdbRowAlreadyExistsEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbRowAlreadyExistsEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbRowAlreadyExistsEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbConnectionFailureEx::TmcdbConnectionFailureEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbConnectionFailureEx:1.0",
        "TmcdbConnectionFailureEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbConnectionFailureEx::TmcdbConnectionFailureEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbConnectionFailureEx:1.0",
        "TmcdbConnectionFailureEx")
{
}

TmcdbGuiErrType::TmcdbConnectionFailureEx::~TmcdbConnectionFailureEx (void)
{
}

TmcdbGuiErrType::TmcdbConnectionFailureEx::TmcdbConnectionFailureEx (const ::TmcdbGuiErrType::TmcdbConnectionFailureEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbConnectionFailureEx&
TmcdbGuiErrType::TmcdbConnectionFailureEx::operator= (const ::TmcdbGuiErrType::TmcdbConnectionFailureEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbConnectionFailureEx *_tao_tmp_pointer =
    static_cast<TmcdbConnectionFailureEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbConnectionFailureEx *
TmcdbGuiErrType::TmcdbConnectionFailureEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbConnectionFailureEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbConnectionFailureEx *
TmcdbGuiErrType::TmcdbConnectionFailureEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbConnectionFailureEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbConnectionFailureEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbConnectionFailureEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbConnectionFailureEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbConnectionFailureEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbConnectionFailureEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbConnectionFailureEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbConnectionFailureEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbConnectionFailureEx:1.0",
  "TmcdbConnectionFailureEx",
  _tao_fields_TmcdbGuiErrType_TmcdbConnectionFailureEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbConnectionFailureEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbConnectionFailureEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbInitializationFailureEx::TmcdbInitializationFailureEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbInitializationFailureEx:1.0",
        "TmcdbInitializationFailureEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbInitializationFailureEx::TmcdbInitializationFailureEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbInitializationFailureEx:1.0",
        "TmcdbInitializationFailureEx")
{
}

TmcdbGuiErrType::TmcdbInitializationFailureEx::~TmcdbInitializationFailureEx (void)
{
}

TmcdbGuiErrType::TmcdbInitializationFailureEx::TmcdbInitializationFailureEx (const ::TmcdbGuiErrType::TmcdbInitializationFailureEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbInitializationFailureEx&
TmcdbGuiErrType::TmcdbInitializationFailureEx::operator= (const ::TmcdbGuiErrType::TmcdbInitializationFailureEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbInitializationFailureEx *_tao_tmp_pointer =
    static_cast<TmcdbInitializationFailureEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbInitializationFailureEx *
TmcdbGuiErrType::TmcdbInitializationFailureEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbInitializationFailureEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbInitializationFailureEx *
TmcdbGuiErrType::TmcdbInitializationFailureEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbInitializationFailureEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbInitializationFailureEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbInitializationFailureEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbInitializationFailureEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbInitializationFailureEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbInitializationFailureEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbInitializationFailureEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbInitializationFailureEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbInitializationFailureEx:1.0",
  "TmcdbInitializationFailureEx",
  _tao_fields_TmcdbGuiErrType_TmcdbInitializationFailureEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbInitializationFailureEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbInitializationFailureEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbDuplicateKeyEx::TmcdbDuplicateKeyEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbDuplicateKeyEx:1.0",
        "TmcdbDuplicateKeyEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbDuplicateKeyEx::TmcdbDuplicateKeyEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbDuplicateKeyEx:1.0",
        "TmcdbDuplicateKeyEx")
{
}

TmcdbGuiErrType::TmcdbDuplicateKeyEx::~TmcdbDuplicateKeyEx (void)
{
}

TmcdbGuiErrType::TmcdbDuplicateKeyEx::TmcdbDuplicateKeyEx (const ::TmcdbGuiErrType::TmcdbDuplicateKeyEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbDuplicateKeyEx&
TmcdbGuiErrType::TmcdbDuplicateKeyEx::operator= (const ::TmcdbGuiErrType::TmcdbDuplicateKeyEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbDuplicateKeyEx *_tao_tmp_pointer =
    static_cast<TmcdbDuplicateKeyEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbDuplicateKeyEx *
TmcdbGuiErrType::TmcdbDuplicateKeyEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbDuplicateKeyEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbDuplicateKeyEx *
TmcdbGuiErrType::TmcdbDuplicateKeyEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbDuplicateKeyEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbDuplicateKeyEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbDuplicateKeyEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbDuplicateKeyEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbDuplicateKeyEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbDuplicateKeyEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbDuplicateKeyEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbDuplicateKeyEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbDuplicateKeyEx:1.0",
  "TmcdbDuplicateKeyEx",
  _tao_fields_TmcdbGuiErrType_TmcdbDuplicateKeyEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbDuplicateKeyEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbDuplicateKeyEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbSqlEx::TmcdbSqlEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbSqlEx:1.0",
        "TmcdbSqlEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbSqlEx::TmcdbSqlEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbSqlEx:1.0",
        "TmcdbSqlEx")
{
}

TmcdbGuiErrType::TmcdbSqlEx::~TmcdbSqlEx (void)
{
}

TmcdbGuiErrType::TmcdbSqlEx::TmcdbSqlEx (const ::TmcdbGuiErrType::TmcdbSqlEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbSqlEx&
TmcdbGuiErrType::TmcdbSqlEx::operator= (const ::TmcdbGuiErrType::TmcdbSqlEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbSqlEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbSqlEx *_tao_tmp_pointer =
    static_cast<TmcdbSqlEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbSqlEx *
TmcdbGuiErrType::TmcdbSqlEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbSqlEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbSqlEx *
TmcdbGuiErrType::TmcdbSqlEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbSqlEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbSqlEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbSqlEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbSqlEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbSqlEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbSqlEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbSqlEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbSqlEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbSqlEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbSqlEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbSqlEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbSqlEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbSqlEx:1.0",
  "TmcdbSqlEx",
  _tao_fields_TmcdbGuiErrType_TmcdbSqlEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbSqlEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbSqlEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbKeyUpdateEx::TmcdbKeyUpdateEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbKeyUpdateEx:1.0",
        "TmcdbKeyUpdateEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbKeyUpdateEx::TmcdbKeyUpdateEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbKeyUpdateEx:1.0",
        "TmcdbKeyUpdateEx")
{
}

TmcdbGuiErrType::TmcdbKeyUpdateEx::~TmcdbKeyUpdateEx (void)
{
}

TmcdbGuiErrType::TmcdbKeyUpdateEx::TmcdbKeyUpdateEx (const ::TmcdbGuiErrType::TmcdbKeyUpdateEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbKeyUpdateEx&
TmcdbGuiErrType::TmcdbKeyUpdateEx::operator= (const ::TmcdbGuiErrType::TmcdbKeyUpdateEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbKeyUpdateEx *_tao_tmp_pointer =
    static_cast<TmcdbKeyUpdateEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbKeyUpdateEx *
TmcdbGuiErrType::TmcdbKeyUpdateEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbKeyUpdateEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbKeyUpdateEx *
TmcdbGuiErrType::TmcdbKeyUpdateEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbKeyUpdateEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbKeyUpdateEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbKeyUpdateEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbKeyUpdateEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbKeyUpdateEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbKeyUpdateEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbKeyUpdateEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbKeyUpdateEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbKeyUpdateEx:1.0",
  "TmcdbKeyUpdateEx",
  _tao_fields_TmcdbGuiErrType_TmcdbKeyUpdateEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbKeyUpdateEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbKeyUpdateEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbDuplicateRowEx::TmcdbDuplicateRowEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbDuplicateRowEx:1.0",
        "TmcdbDuplicateRowEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbDuplicateRowEx::TmcdbDuplicateRowEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbDuplicateRowEx:1.0",
        "TmcdbDuplicateRowEx")
{
}

TmcdbGuiErrType::TmcdbDuplicateRowEx::~TmcdbDuplicateRowEx (void)
{
}

TmcdbGuiErrType::TmcdbDuplicateRowEx::TmcdbDuplicateRowEx (const ::TmcdbGuiErrType::TmcdbDuplicateRowEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbDuplicateRowEx&
TmcdbGuiErrType::TmcdbDuplicateRowEx::operator= (const ::TmcdbGuiErrType::TmcdbDuplicateRowEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbDuplicateRowEx *_tao_tmp_pointer =
    static_cast<TmcdbDuplicateRowEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbDuplicateRowEx *
TmcdbGuiErrType::TmcdbDuplicateRowEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbDuplicateRowEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbDuplicateRowEx *
TmcdbGuiErrType::TmcdbDuplicateRowEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbDuplicateRowEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbDuplicateRowEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbDuplicateRowEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbDuplicateRowEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbDuplicateRowEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbDuplicateRowEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbDuplicateRowEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbDuplicateRowEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbDuplicateRowEx:1.0",
  "TmcdbDuplicateRowEx",
  _tao_fields_TmcdbGuiErrType_TmcdbDuplicateRowEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbDuplicateRowEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbDuplicateRowEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/exception_ctor.cpp:51

TmcdbGuiErrType::TmcdbInvalidDataTypeEx::TmcdbInvalidDataTypeEx (
    const ACSErr::ErrorTrace & _tao_errorTrace)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbInvalidDataTypeEx:1.0",
        "TmcdbInvalidDataTypeEx")
{
  this->errorTrace = _tao_errorTrace;
}



// TAO_IDL - Generated from
// be/be_visitor_exception/exception_cs.cpp:98

TmcdbGuiErrType::TmcdbInvalidDataTypeEx::TmcdbInvalidDataTypeEx (void)
  : ::CORBA::UserException (
        "IDL:alma/TmcdbGuiErrType/TmcdbInvalidDataTypeEx:1.0",
        "TmcdbInvalidDataTypeEx")
{
}

TmcdbGuiErrType::TmcdbInvalidDataTypeEx::~TmcdbInvalidDataTypeEx (void)
{
}

TmcdbGuiErrType::TmcdbInvalidDataTypeEx::TmcdbInvalidDataTypeEx (const ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx &_tao_excp)
  : ::CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ())
{
  this->errorTrace = _tao_excp.errorTrace;
}

TmcdbGuiErrType::TmcdbInvalidDataTypeEx&
TmcdbGuiErrType::TmcdbInvalidDataTypeEx::operator= (const ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx &_tao_excp)
{
  this->::CORBA::UserException::operator= (_tao_excp);
  this->errorTrace = _tao_excp.errorTrace;
  return *this;
}

void TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_any_destructor (void *_tao_void_pointer)
{
  TmcdbInvalidDataTypeEx *_tao_tmp_pointer =
    static_cast<TmcdbInvalidDataTypeEx *> (_tao_void_pointer);
  delete _tao_tmp_pointer;
}

TmcdbGuiErrType::TmcdbInvalidDataTypeEx *
TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_downcast ( ::CORBA::Exception *_tao_excp)
{
  return dynamic_cast<TmcdbInvalidDataTypeEx *> (_tao_excp);
}

const TmcdbGuiErrType::TmcdbInvalidDataTypeEx *
TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_downcast ( ::CORBA::Exception const *_tao_excp)
{
  return dynamic_cast<const TmcdbInvalidDataTypeEx *> (_tao_excp);
}

::CORBA::Exception *TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_alloc (void)
{
  ::CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx, 0);
  return retval;
}

::CORBA::Exception *
TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_duplicate (void) const
{
  ::CORBA::Exception *result = 0;
  ACE_NEW_RETURN (
      result,
      ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx (*this),
      0);
  return result;
}

void TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_raise (void) const
{
  throw *this;
}

void TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_encode (TAO_OutputCDR &cdr) const
{
  if (!(cdr << *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

void TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_decode (TAO_InputCDR &cdr)
{
  if (!(cdr >> *this))
    {
      throw ::CORBA::MARSHAL ();
    }
}

// TAO extension - the virtual _type method.
::CORBA::TypeCode_ptr TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_type (void) const
{
  return ::TmcdbGuiErrType::_tc_TmcdbInvalidDataTypeEx;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/struct_typecode.cpp:86

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_TmcdbGuiErrType_TmcdbInvalidDataTypeEx[] =
      {
        { "errorTrace", &ACSErr::_tc_ErrorTrace }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_TmcdbGuiErrType_TmcdbInvalidDataTypeEx (
  ::CORBA::tk_except,
  "IDL:alma/TmcdbGuiErrType/TmcdbInvalidDataTypeEx:1.0",
  "TmcdbInvalidDataTypeEx",
  _tao_fields_TmcdbGuiErrType_TmcdbInvalidDataTypeEx,
  1);


namespace TmcdbGuiErrType
{
  ::CORBA::TypeCode_ptr const _tc_TmcdbInvalidDataTypeEx =
    &_tao_tc_TmcdbGuiErrType_TmcdbInvalidDataTypeEx;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbGuiErrTypeEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbGuiErrTypeEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbGuiErrTypeEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbGuiErrTypeEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbGuiErrTypeEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbGuiErrTypeEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbGuiErrTypeEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbGuiErrTypeEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbGuiErrTypeEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbGuiErrTypeEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbGuiErrTypeEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbGuiErrTypeEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbGuiErrTypeEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbGuiErrTypeEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbGuiErrTypeEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbGuiErrTypeEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbGuiErrTypeEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbGuiErrTypeEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbGuiErrTypeEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbGuiErrTypeEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbErrorEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbErrorEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbErrorEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbErrorEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbErrorEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbErrorEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbErrorEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbErrorEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbErrorEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbErrorEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbErrorEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbErrorEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbErrorEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbErrorEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbErrorEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbErrorEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbErrorEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbErrorEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbErrorEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbErrorEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbErrorEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbErrorEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbErrorEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbErrorEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbErrorEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbNoSuchRowEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbNoSuchRowEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbNoSuchRowEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbNoSuchRowEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbNoSuchRowEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbNoSuchRowEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbNoSuchRowEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbNoSuchRowEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbNoSuchRowEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbNoSuchRowEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbNoSuchRowEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbNoSuchRowEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbNoSuchRowEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbNoSuchRowEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbNoSuchRowEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbNoSuchRowEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbNoSuchRowEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbNoSuchRowEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbNoSuchRowEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbNoSuchRowEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbRowAlreadyExistsEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbRowAlreadyExistsEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbRowAlreadyExistsEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbRowAlreadyExistsEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbRowAlreadyExistsEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbRowAlreadyExistsEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbRowAlreadyExistsEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbRowAlreadyExistsEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbRowAlreadyExistsEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbRowAlreadyExistsEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbRowAlreadyExistsEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbRowAlreadyExistsEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbRowAlreadyExistsEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbRowAlreadyExistsEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbConnectionFailureEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbConnectionFailureEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbConnectionFailureEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbConnectionFailureEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbConnectionFailureEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbConnectionFailureEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbConnectionFailureEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbConnectionFailureEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbConnectionFailureEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbConnectionFailureEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbConnectionFailureEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbConnectionFailureEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbConnectionFailureEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbConnectionFailureEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbConnectionFailureEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbConnectionFailureEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbConnectionFailureEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbConnectionFailureEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbConnectionFailureEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbConnectionFailureEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInitializationFailureEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbInitializationFailureEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbInitializationFailureEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbInitializationFailureEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbInitializationFailureEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbInitializationFailureEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbInitializationFailureEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbInitializationFailureEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbInitializationFailureEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbInitializationFailureEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbInitializationFailureEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInitializationFailureEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbInitializationFailureEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbInitializationFailureEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInitializationFailureEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbInitializationFailureEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbInitializationFailureEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInitializationFailureEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbInitializationFailureEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbInitializationFailureEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateKeyEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbDuplicateKeyEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbDuplicateKeyEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbDuplicateKeyEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbDuplicateKeyEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbDuplicateKeyEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbDuplicateKeyEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbDuplicateKeyEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbDuplicateKeyEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbDuplicateKeyEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbDuplicateKeyEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateKeyEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbDuplicateKeyEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbDuplicateKeyEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateKeyEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbDuplicateKeyEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbDuplicateKeyEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateKeyEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbDuplicateKeyEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbDuplicateKeyEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbSqlEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbSqlEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbSqlEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbSqlEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbSqlEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbSqlEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbSqlEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbSqlEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbSqlEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbSqlEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbSqlEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbSqlEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbSqlEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbSqlEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbSqlEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbSqlEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbSqlEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbSqlEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbSqlEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbSqlEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbSqlEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbSqlEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbSqlEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbSqlEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbSqlEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbKeyUpdateEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbKeyUpdateEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbKeyUpdateEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbKeyUpdateEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbKeyUpdateEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbKeyUpdateEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbKeyUpdateEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbKeyUpdateEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbKeyUpdateEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbKeyUpdateEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbKeyUpdateEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbKeyUpdateEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbKeyUpdateEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbKeyUpdateEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbKeyUpdateEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbKeyUpdateEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbKeyUpdateEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbKeyUpdateEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbKeyUpdateEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbKeyUpdateEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateRowEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbDuplicateRowEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbDuplicateRowEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbDuplicateRowEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbDuplicateRowEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbDuplicateRowEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbDuplicateRowEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbDuplicateRowEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbDuplicateRowEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbDuplicateRowEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbDuplicateRowEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateRowEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbDuplicateRowEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbDuplicateRowEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateRowEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbDuplicateRowEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbDuplicateRowEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbDuplicateRowEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbDuplicateRowEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbDuplicateRowEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/any_op_cs.cpp:38
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInvalidDataTypeEx>::demarshal_value (TAO_InputCDR & cdr)
  {
    ::CORBA::String_var id;

    if (!(cdr >> id.out ()))
      {
        return false;
      }
    
    try
      {
        this->value_->_tao_decode (cdr);
      }
    catch (const ::CORBA::Exception &)
      {
        return false;
      }

    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL



#if defined (ACE_ANY_OPS_USE_NAMESPACE)

namespace TmcdbGuiErrType
{
  

  /// Copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx &_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx>::insert_copy (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbInvalidDataTypeEx,
        _tao_elem);
  }

  /// Non-copying insertion.
  void operator<<= (
      ::CORBA::Any &_tao_any,
      ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx *_tao_elem)
  {
    TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx>::insert (
        _tao_any,
        ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_any_destructor,
        ::TmcdbGuiErrType::_tc_TmcdbInvalidDataTypeEx,
        _tao_elem);
  }

  /// Extraction to const pointer.
  ::CORBA::Boolean operator>>= (
      const ::CORBA::Any &_tao_any,
      const ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx *&_tao_elem)
  {
    return
      TAO::Any_Dual_Impl_T< ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx>::extract (
          _tao_any,
          ::TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_any_destructor,
          ::TmcdbGuiErrType::_tc_TmcdbInvalidDataTypeEx,
          _tao_elem);
  }
}

#else

TAO_BEGIN_VERSIONED_NAMESPACE_DECL



/// Copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbInvalidDataTypeEx &_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInvalidDataTypeEx>::insert_copy (
      _tao_any,
      TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbInvalidDataTypeEx,
      _tao_elem);
}

/// Non-copying insertion.
void operator<<= (
    ::CORBA::Any &_tao_any,
    TmcdbGuiErrType::TmcdbInvalidDataTypeEx *_tao_elem)
{
  TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInvalidDataTypeEx>::insert (
      _tao_any,
      TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_any_destructor,
      TmcdbGuiErrType::_tc_TmcdbInvalidDataTypeEx,
      _tao_elem);
}

/// Extraction to const pointer.
::CORBA::Boolean operator>>= (
    const ::CORBA::Any &_tao_any,
    const TmcdbGuiErrType::TmcdbInvalidDataTypeEx *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<TmcdbGuiErrType::TmcdbInvalidDataTypeEx>::extract (
        _tao_any,
        TmcdbGuiErrType::TmcdbInvalidDataTypeEx::_tao_any_destructor,
        TmcdbGuiErrType::_tc_TmcdbInvalidDataTypeEx,
        _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



#endif

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbGuiErrTypeEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbGuiErrTypeEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbErrorEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbErrorEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbNoSuchRowEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbNoSuchRowEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbRowAlreadyExistsEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbRowAlreadyExistsEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbConnectionFailureEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbConnectionFailureEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbInitializationFailureEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbInitializationFailureEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbDuplicateKeyEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbDuplicateKeyEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbSqlEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbSqlEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbKeyUpdateEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbKeyUpdateEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbDuplicateRowEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbDuplicateRowEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:48
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const TmcdbGuiErrType::TmcdbInvalidDataTypeEx &_tao_aggregate)
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      return (
        (strm << _tao_aggregate.errorTrace)
       );
    }
  else
    {
      return false;
    }
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    TmcdbGuiErrType::TmcdbInvalidDataTypeEx &_tao_aggregate)
{
  // Demarshal the members.
  return (
    (strm >> _tao_aggregate.errorTrace)
  );
}

TAO_END_VERSIONED_NAMESPACE_DECL



