// -*- C++ -*-
//
// $Id$

// ****  Code generated by the The ACE ORB (TAO) IDL Compiler ****
// 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
//       http://doc.ece.uci.edu/
// and
//       Institute for Software Integrated Systems
//       Vanderbilt University
//       Nashville, TN
//       USA
//       http://www.isis.vanderbilt.edu/
//
// Information about TAO is available at:
//     http://www.cs.wustl.edu/~schmidt/TAO.html

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


#include "DsLogAdminC.h"
#include "tao/CDR.h"
#include "tao/Exception_Data.h"
#include "tao/Invocation_Adapter.h"
#include "tao/Object_T.h"
#include "tao/Typecode.h"
#include "tao/Any_Impl_T.h"
#include "tao/Any_Dual_Impl_T.h"
#include "tao/Any_Basic_Impl_T.h"
#include "tao/Basic_Arguments.h"
#include "tao/Fixed_Size_Argument_T.h"
#include "tao/Object_Argument_T.h"
#include "tao/UB_String_Arguments.h"
#include "tao/Var_Size_Argument_T.h"
#include "ace/OS_NS_string.h"

#if defined (__BORLANDC__)
#pragma option -w-rvl -w-rch -w-ccc -w-aus -w-sig
#endif /* __BORLANDC__ */

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

// TAO_IDL - Generated from
// be/be_visitor_arg_traits.cpp:64

// Arg traits specializations.
namespace TAO
{
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_RECORDIDLIST__ARG_TRAITS_CS_)
#define _DSLOGADMIN_RECORDIDLIST__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::RecordIdList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::RecordIdList,
            DsLogAdmin::RecordIdList_var,
            DsLogAdmin::RecordIdList_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_NVLIST__ARG_TRAITS_CS_)
#define _DSLOGADMIN_NVLIST__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::NVList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::NVList,
            DsLogAdmin::NVList_var,
            DsLogAdmin::NVList_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:618

#if !defined (_DSLOGADMIN_TIMEINTERVAL__ARG_TRAITS_CS_)
#define _DSLOGADMIN_TIMEINTERVAL__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::TimeInterval>
    : public
        Fixed_Size_Arg_Traits_T<
            DsLogAdmin::TimeInterval
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_RECORDLIST__ARG_TRAITS_CS_)
#define _DSLOGADMIN_RECORDLIST__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::RecordList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::RecordList,
            DsLogAdmin::RecordList_var,
            DsLogAdmin::RecordList_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_ANYS__ARG_TRAITS_CS_)
#define _DSLOGADMIN_ANYS__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::Anys>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::Anys,
            DsLogAdmin::Anys_var,
            DsLogAdmin::Anys_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_DSLOGADMIN_ITERATOR__ARG_TRAITS_CS_)
#define _DSLOGADMIN_ITERATOR__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::Iterator>
    : public
        Object_Arg_Traits_T<
            DsLogAdmin::Iterator_ptr,
            DsLogAdmin::Iterator_var,
            DsLogAdmin::Iterator_out,
            TAO::Objref_Traits<DsLogAdmin::Iterator>
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:618

#if !defined (_DSLOGADMIN_AVAILABILITYSTATUS__ARG_TRAITS_CS_)
#define _DSLOGADMIN_AVAILABILITYSTATUS__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::AvailabilityStatus>
    : public
        Fixed_Size_Arg_Traits_T<
            DsLogAdmin::AvailabilityStatus
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_WEEKMASK__ARG_TRAITS_CS_)
#define _DSLOGADMIN_WEEKMASK__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::WeekMask>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::WeekMask,
            DsLogAdmin::WeekMask_var,
            DsLogAdmin::WeekMask_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_CAPACITYALARMTHRESHOLDLIST__ARG_TRAITS_CS_)
#define _DSLOGADMIN_CAPACITYALARMTHRESHOLDLIST__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::CapacityAlarmThresholdList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::CapacityAlarmThresholdList,
            DsLogAdmin::CapacityAlarmThresholdList_var,
            DsLogAdmin::CapacityAlarmThresholdList_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_DSLOGADMIN_LOGMGR__ARG_TRAITS_CS_)
#define _DSLOGADMIN_LOGMGR__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::LogMgr>
    : public
        Object_Arg_Traits_T<
            DsLogAdmin::LogMgr_ptr,
            DsLogAdmin::LogMgr_var,
            DsLogAdmin::LogMgr_out,
            TAO::Objref_Traits<DsLogAdmin::LogMgr>
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:537

#if !defined (_DSLOGADMIN_OPERATIONALSTATE__ARG_TRAITS_CS_)
#define _DSLOGADMIN_OPERATIONALSTATE__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::OperationalState>
    : public
        Basic_Arg_Traits_T<
            DsLogAdmin::OperationalState
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:537

#if !defined (_DSLOGADMIN_ADMINISTRATIVESTATE__ARG_TRAITS_CS_)
#define _DSLOGADMIN_ADMINISTRATIVESTATE__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::AdministrativeState>
    : public
        Basic_Arg_Traits_T<
            DsLogAdmin::AdministrativeState
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:537

#if !defined (_DSLOGADMIN_FORWARDINGSTATE__ARG_TRAITS_CS_)
#define _DSLOGADMIN_FORWARDINGSTATE__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::ForwardingState>
    : public
        Basic_Arg_Traits_T<
            DsLogAdmin::ForwardingState
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_QOSLIST__ARG_TRAITS_CS_)
#define _DSLOGADMIN_QOSLIST__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::QoSList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::QoSList,
            DsLogAdmin::QoSList_var,
            DsLogAdmin::QoSList_out
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_DSLOGADMIN_LOG__ARG_TRAITS_CS_)
#define _DSLOGADMIN_LOG__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::Log>
    : public
        Object_Arg_Traits_T<
            DsLogAdmin::Log_ptr,
            DsLogAdmin::Log_var,
            DsLogAdmin::Log_out,
            TAO::Objref_Traits<DsLogAdmin::Log>
          >
  {
  };

#endif /* end #if !defined */

#if !defined (_DSLOGADMIN_BASICLOG__ARG_TRAITS_CS_)
#define _DSLOGADMIN_BASICLOG__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::BasicLog>
    : public
        Object_Arg_Traits_T<
            DsLogAdmin::BasicLog_ptr,
            DsLogAdmin::BasicLog_var,
            DsLogAdmin::BasicLog_out,
            TAO::Objref_Traits<DsLogAdmin::BasicLog>
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_LOGLIST__ARG_TRAITS_CS_)
#define _DSLOGADMIN_LOGLIST__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::LogList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::LogList,
            DsLogAdmin::LogList_var,
            DsLogAdmin::LogList_out
          >
  {
  };

#endif /* end #if !defined */
  
  // TAO_IDL - Generated from
  // be/be_visitor_arg_traits.cpp:379

#if !defined (_DSLOGADMIN_LOGIDLIST__ARG_TRAITS_CS_)
#define _DSLOGADMIN_LOGIDLIST__ARG_TRAITS_CS_
  
  ACE_TEMPLATE_SPECIALIZATION
  class TAO_Log_Export Arg_Traits<DsLogAdmin::LogIdList>
    : public
        Var_Size_Arg_Traits_T<
            DsLogAdmin::LogIdList,
            DsLogAdmin::LogIdList_var,
            DsLogAdmin::LogIdList_out
          >
  {
  };

#endif /* end #if !defined */
}


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

DsLogAdmin::InvalidParam::InvalidParam (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidParam:1.0",
        "InvalidParam"
      )
{
}

DsLogAdmin::InvalidParam::~InvalidParam (void)
{
}

DsLogAdmin::InvalidParam::InvalidParam (const ::DsLogAdmin::InvalidParam &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
  this->details = CORBA::string_dup (_tao_excp.details.in ());
}

DsLogAdmin::InvalidParam&
DsLogAdmin::InvalidParam::operator= (const ::DsLogAdmin::InvalidParam &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  this->details = CORBA::string_dup (_tao_excp.details.in ());
  return *this;
}

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

DsLogAdmin::InvalidParam *
DsLogAdmin::InvalidParam::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidParam:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidParam *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidParam::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidParam (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidParam::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidParam::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidParam::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}



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

DsLogAdmin::InvalidParam::InvalidParam (
    const char * _tao_details
  )
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidParam:1.0",
        "InvalidParam"
      )
{
  this->details = CORBA::string_dup (_tao_details);
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidParam::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidParam;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidParam[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69645061), 
  ACE_NTOHL (0x72616d3a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidParam:1.0
    13,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696450), 
  ACE_NTOHL (0x6172616d), 
  ACE_NTOHL (0x0),  // name = InvalidParam
  1, // member count
    8,
  ACE_NTOHL (0x64657461), 
  ACE_NTOHL (0x696c7300),  // name = details
    CORBA::tk_string, 
  0U, // string length
};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidParam (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidParam),
    (char *) &_oc_DsLogAdmin_InvalidParam,
    0,
    sizeof (DsLogAdmin::InvalidParam)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidParam =
    &_tc_TAO_tc_DsLogAdmin_InvalidParam;
}

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

DsLogAdmin::InvalidThreshold::InvalidThreshold (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidThreshold:1.0",
        "InvalidThreshold"
      )
{
}

DsLogAdmin::InvalidThreshold::~InvalidThreshold (void)
{
}

DsLogAdmin::InvalidThreshold::InvalidThreshold (const ::DsLogAdmin::InvalidThreshold &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidThreshold&
DsLogAdmin::InvalidThreshold::operator= (const ::DsLogAdmin::InvalidThreshold &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidThreshold *
DsLogAdmin::InvalidThreshold::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidThreshold:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidThreshold *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidThreshold::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidThreshold (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidThreshold::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidThreshold::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidThreshold::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidThreshold::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidThreshold;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidThreshold[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  44,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69645468), 
  ACE_NTOHL (0x72657368), 
  ACE_NTOHL (0x6f6c643a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidThreshold:1.0
    17,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696454), 
  ACE_NTOHL (0x68726573), 
  ACE_NTOHL (0x686f6c64), 
  ACE_NTOHL (0x0),  // name = InvalidThreshold
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidThreshold (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidThreshold),
    (char *) &_oc_DsLogAdmin_InvalidThreshold,
    0,
    sizeof (DsLogAdmin::InvalidThreshold)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidThreshold =
    &_tc_TAO_tc_DsLogAdmin_InvalidThreshold;
}

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

DsLogAdmin::InvalidTime::InvalidTime (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidTime:1.0",
        "InvalidTime"
      )
{
}

DsLogAdmin::InvalidTime::~InvalidTime (void)
{
}

DsLogAdmin::InvalidTime::InvalidTime (const ::DsLogAdmin::InvalidTime &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidTime&
DsLogAdmin::InvalidTime::operator= (const ::DsLogAdmin::InvalidTime &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidTime *
DsLogAdmin::InvalidTime::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidTime:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidTime *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidTime::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidTime (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidTime::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidTime::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidTime::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidTime::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidTime;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidTime[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69645469), 
  ACE_NTOHL (0x6d653a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidTime:1.0
    12,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696454), 
  ACE_NTOHL (0x696d6500),  // name = InvalidTime
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidTime (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidTime),
    (char *) &_oc_DsLogAdmin_InvalidTime,
    0,
    sizeof (DsLogAdmin::InvalidTime)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidTime =
    &_tc_TAO_tc_DsLogAdmin_InvalidTime;
}

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

DsLogAdmin::InvalidTimeInterval::InvalidTimeInterval (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidTimeInterval:1.0",
        "InvalidTimeInterval"
      )
{
}

DsLogAdmin::InvalidTimeInterval::~InvalidTimeInterval (void)
{
}

DsLogAdmin::InvalidTimeInterval::InvalidTimeInterval (const ::DsLogAdmin::InvalidTimeInterval &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidTimeInterval&
DsLogAdmin::InvalidTimeInterval::operator= (const ::DsLogAdmin::InvalidTimeInterval &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidTimeInterval *
DsLogAdmin::InvalidTimeInterval::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidTimeInterval:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidTimeInterval *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidTimeInterval::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidTimeInterval (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidTimeInterval::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidTimeInterval::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidTimeInterval::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidTimeInterval::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidTimeInterval;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidTimeInterval[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  47,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69645469), 
  ACE_NTOHL (0x6d65496e), 
  ACE_NTOHL (0x74657276), 
  ACE_NTOHL (0x616c3a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidTimeInterval:1.0
    20,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696454), 
  ACE_NTOHL (0x696d6549), 
  ACE_NTOHL (0x6e746572), 
  ACE_NTOHL (0x76616c00),  // name = InvalidTimeInterval
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidTimeInterval (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidTimeInterval),
    (char *) &_oc_DsLogAdmin_InvalidTimeInterval,
    0,
    sizeof (DsLogAdmin::InvalidTimeInterval)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidTimeInterval =
    &_tc_TAO_tc_DsLogAdmin_InvalidTimeInterval;
}

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

DsLogAdmin::InvalidMask::InvalidMask (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidMask:1.0",
        "InvalidMask"
      )
{
}

DsLogAdmin::InvalidMask::~InvalidMask (void)
{
}

DsLogAdmin::InvalidMask::InvalidMask (const ::DsLogAdmin::InvalidMask &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidMask&
DsLogAdmin::InvalidMask::operator= (const ::DsLogAdmin::InvalidMask &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidMask *
DsLogAdmin::InvalidMask::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidMask:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidMask *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidMask::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidMask (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidMask::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidMask::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidMask::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidMask::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidMask;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidMask[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69644d61), 
  ACE_NTOHL (0x736b3a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidMask:1.0
    12,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c69644d), 
  ACE_NTOHL (0x61736b00),  // name = InvalidMask
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidMask (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidMask),
    (char *) &_oc_DsLogAdmin_InvalidMask,
    0,
    sizeof (DsLogAdmin::InvalidMask)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidMask =
    &_tc_TAO_tc_DsLogAdmin_InvalidMask;
}

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

DsLogAdmin::LogIdAlreadyExists::LogIdAlreadyExists (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/LogIdAlreadyExists:1.0",
        "LogIdAlreadyExists"
      )
{
}

DsLogAdmin::LogIdAlreadyExists::~LogIdAlreadyExists (void)
{
}

DsLogAdmin::LogIdAlreadyExists::LogIdAlreadyExists (const ::DsLogAdmin::LogIdAlreadyExists &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::LogIdAlreadyExists&
DsLogAdmin::LogIdAlreadyExists::operator= (const ::DsLogAdmin::LogIdAlreadyExists &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::LogIdAlreadyExists *
DsLogAdmin::LogIdAlreadyExists::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/LogIdAlreadyExists:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LogIdAlreadyExists *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::LogIdAlreadyExists::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::LogIdAlreadyExists (*this),
      0
    );
  return result;
}

void DsLogAdmin::LogIdAlreadyExists::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::LogIdAlreadyExists::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::LogIdAlreadyExists::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::LogIdAlreadyExists::_type (void) const
{
  return ::DsLogAdmin::_tc_LogIdAlreadyExists;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogIdAlreadyExists[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  46,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674964), 
  ACE_NTOHL (0x416c7265), 
  ACE_NTOHL (0x61647945), 
  ACE_NTOHL (0x78697374), 
  ACE_NTOHL (0x733a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/LogIdAlreadyExists:1.0
    19,
  ACE_NTOHL (0x4c6f6749), 
  ACE_NTOHL (0x64416c72), 
  ACE_NTOHL (0x65616479), 
  ACE_NTOHL (0x45786973), 
  ACE_NTOHL (0x74730000),  // name = LogIdAlreadyExists
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogIdAlreadyExists (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_LogIdAlreadyExists),
    (char *) &_oc_DsLogAdmin_LogIdAlreadyExists,
    0,
    sizeof (DsLogAdmin::LogIdAlreadyExists)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogIdAlreadyExists =
    &_tc_TAO_tc_DsLogAdmin_LogIdAlreadyExists;
}

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

DsLogAdmin::InvalidGrammar::InvalidGrammar (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidGrammar:1.0",
        "InvalidGrammar"
      )
{
}

DsLogAdmin::InvalidGrammar::~InvalidGrammar (void)
{
}

DsLogAdmin::InvalidGrammar::InvalidGrammar (const ::DsLogAdmin::InvalidGrammar &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidGrammar&
DsLogAdmin::InvalidGrammar::operator= (const ::DsLogAdmin::InvalidGrammar &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidGrammar *
DsLogAdmin::InvalidGrammar::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidGrammar:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidGrammar *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidGrammar::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidGrammar (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidGrammar::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidGrammar::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidGrammar::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidGrammar::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidGrammar;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidGrammar[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69644772), 
  ACE_NTOHL (0x616d6d61), 
  ACE_NTOHL (0x723a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidGrammar:1.0
    15,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696447), 
  ACE_NTOHL (0x72616d6d), 
  ACE_NTOHL (0x61720000),  // name = InvalidGrammar
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidGrammar (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidGrammar),
    (char *) &_oc_DsLogAdmin_InvalidGrammar,
    0,
    sizeof (DsLogAdmin::InvalidGrammar)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidGrammar =
    &_tc_TAO_tc_DsLogAdmin_InvalidGrammar;
}

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

DsLogAdmin::InvalidConstraint::InvalidConstraint (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidConstraint:1.0",
        "InvalidConstraint"
      )
{
}

DsLogAdmin::InvalidConstraint::~InvalidConstraint (void)
{
}

DsLogAdmin::InvalidConstraint::InvalidConstraint (const ::DsLogAdmin::InvalidConstraint &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidConstraint&
DsLogAdmin::InvalidConstraint::operator= (const ::DsLogAdmin::InvalidConstraint &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidConstraint *
DsLogAdmin::InvalidConstraint::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidConstraint:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidConstraint *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidConstraint::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidConstraint (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidConstraint::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidConstraint::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidConstraint::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidConstraint::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidConstraint;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidConstraint[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  45,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x6964436f), 
  ACE_NTOHL (0x6e737472), 
  ACE_NTOHL (0x61696e74), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidConstraint:1.0
    18,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696443), 
  ACE_NTOHL (0x6f6e7374), 
  ACE_NTOHL (0x7261696e), 
  ACE_NTOHL (0x74000000),  // name = InvalidConstraint
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidConstraint (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidConstraint),
    (char *) &_oc_DsLogAdmin_InvalidConstraint,
    0,
    sizeof (DsLogAdmin::InvalidConstraint)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidConstraint =
    &_tc_TAO_tc_DsLogAdmin_InvalidConstraint;
}

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

DsLogAdmin::LogFull::LogFull (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/LogFull:1.0",
        "LogFull"
      )
{
}

DsLogAdmin::LogFull::~LogFull (void)
{
}

DsLogAdmin::LogFull::LogFull (const ::DsLogAdmin::LogFull &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
  this->n_records_written = _tao_excp.n_records_written;
}

DsLogAdmin::LogFull&
DsLogAdmin::LogFull::operator= (const ::DsLogAdmin::LogFull &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  this->n_records_written = _tao_excp.n_records_written;
  return *this;
}

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

DsLogAdmin::LogFull *
DsLogAdmin::LogFull::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/LogFull:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LogFull *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::LogFull::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::LogFull (*this),
      0
    );
  return result;
}

void DsLogAdmin::LogFull::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::LogFull::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::LogFull::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}



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

DsLogAdmin::LogFull::LogFull (
    CORBA::Short _tao_n_records_written
  )
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/LogFull:1.0",
        "LogFull"
      )
{
  this->n_records_written = _tao_n_records_written;
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::LogFull::_type (void) const
{
  return ::DsLogAdmin::_tc_LogFull;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogFull[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  35,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674675), 
  ACE_NTOHL (0x6c6c3a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/LogFull:1.0
    8,
  ACE_NTOHL (0x4c6f6746), 
  ACE_NTOHL (0x756c6c00),  // name = LogFull
  1, // member count
    18,
  ACE_NTOHL (0x6e5f7265), 
  ACE_NTOHL (0x636f7264), 
  ACE_NTOHL (0x735f7772), 
  ACE_NTOHL (0x69747465), 
  ACE_NTOHL (0x6e000000),  // name = n_records_written
    CORBA::tk_short,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogFull (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_LogFull),
    (char *) &_oc_DsLogAdmin_LogFull,
    0,
    sizeof (DsLogAdmin::LogFull)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogFull =
    &_tc_TAO_tc_DsLogAdmin_LogFull;
}

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

DsLogAdmin::LogOffDuty::LogOffDuty (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/LogOffDuty:1.0",
        "LogOffDuty"
      )
{
}

DsLogAdmin::LogOffDuty::~LogOffDuty (void)
{
}

DsLogAdmin::LogOffDuty::LogOffDuty (const ::DsLogAdmin::LogOffDuty &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::LogOffDuty&
DsLogAdmin::LogOffDuty::operator= (const ::DsLogAdmin::LogOffDuty &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::LogOffDuty *
DsLogAdmin::LogOffDuty::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/LogOffDuty:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LogOffDuty *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::LogOffDuty::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::LogOffDuty (*this),
      0
    );
  return result;
}

void DsLogAdmin::LogOffDuty::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::LogOffDuty::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::LogOffDuty::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::LogOffDuty::_type (void) const
{
  return ::DsLogAdmin::_tc_LogOffDuty;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogOffDuty[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674f66), 
  ACE_NTOHL (0x66447574), 
  ACE_NTOHL (0x793a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/LogOffDuty:1.0
    11,
  ACE_NTOHL (0x4c6f674f), 
  ACE_NTOHL (0x66664475), 
  ACE_NTOHL (0x74790000),  // name = LogOffDuty
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogOffDuty (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_LogOffDuty),
    (char *) &_oc_DsLogAdmin_LogOffDuty,
    0,
    sizeof (DsLogAdmin::LogOffDuty)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogOffDuty =
    &_tc_TAO_tc_DsLogAdmin_LogOffDuty;
}

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

DsLogAdmin::LogLocked::LogLocked (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/LogLocked:1.0",
        "LogLocked"
      )
{
}

DsLogAdmin::LogLocked::~LogLocked (void)
{
}

DsLogAdmin::LogLocked::LogLocked (const ::DsLogAdmin::LogLocked &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::LogLocked&
DsLogAdmin::LogLocked::operator= (const ::DsLogAdmin::LogLocked &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::LogLocked *
DsLogAdmin::LogLocked::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/LogLocked:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LogLocked *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::LogLocked::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::LogLocked (*this),
      0
    );
  return result;
}

void DsLogAdmin::LogLocked::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::LogLocked::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::LogLocked::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::LogLocked::_type (void) const
{
  return ::DsLogAdmin::_tc_LogLocked;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogLocked[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674c6f), 
  ACE_NTOHL (0x636b6564), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/LogLocked:1.0
    10,
  ACE_NTOHL (0x4c6f674c), 
  ACE_NTOHL (0x6f636b65), 
  ACE_NTOHL (0x64000000),  // name = LogLocked
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogLocked (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_LogLocked),
    (char *) &_oc_DsLogAdmin_LogLocked,
    0,
    sizeof (DsLogAdmin::LogLocked)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogLocked =
    &_tc_TAO_tc_DsLogAdmin_LogLocked;
}

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

DsLogAdmin::LogDisabled::LogDisabled (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/LogDisabled:1.0",
        "LogDisabled"
      )
{
}

DsLogAdmin::LogDisabled::~LogDisabled (void)
{
}

DsLogAdmin::LogDisabled::LogDisabled (const ::DsLogAdmin::LogDisabled &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::LogDisabled&
DsLogAdmin::LogDisabled::operator= (const ::DsLogAdmin::LogDisabled &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::LogDisabled *
DsLogAdmin::LogDisabled::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/LogDisabled:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<LogDisabled *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::LogDisabled::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::LogDisabled (*this),
      0
    );
  return result;
}

void DsLogAdmin::LogDisabled::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::LogDisabled::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::LogDisabled::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::LogDisabled::_type (void) const
{
  return ::DsLogAdmin::_tc_LogDisabled;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogDisabled[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  39,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674469), 
  ACE_NTOHL (0x7361626c), 
  ACE_NTOHL (0x65643a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/LogDisabled:1.0
    12,
  ACE_NTOHL (0x4c6f6744), 
  ACE_NTOHL (0x69736162), 
  ACE_NTOHL (0x6c656400),  // name = LogDisabled
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogDisabled (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_LogDisabled),
    (char *) &_oc_DsLogAdmin_LogDisabled,
    0,
    sizeof (DsLogAdmin::LogDisabled)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogDisabled =
    &_tc_TAO_tc_DsLogAdmin_LogDisabled;
}

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

DsLogAdmin::InvalidRecordId::InvalidRecordId (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidRecordId:1.0",
        "InvalidRecordId"
      )
{
}

DsLogAdmin::InvalidRecordId::~InvalidRecordId (void)
{
}

DsLogAdmin::InvalidRecordId::InvalidRecordId (const ::DsLogAdmin::InvalidRecordId &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidRecordId&
DsLogAdmin::InvalidRecordId::operator= (const ::DsLogAdmin::InvalidRecordId &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidRecordId *
DsLogAdmin::InvalidRecordId::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidRecordId:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidRecordId *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidRecordId::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidRecordId (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidRecordId::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidRecordId::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidRecordId::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidRecordId::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidRecordId;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidRecordId[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  43,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69645265), 
  ACE_NTOHL (0x636f7264), 
  ACE_NTOHL (0x49643a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidRecordId:1.0
    16,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696452), 
  ACE_NTOHL (0x65636f72), 
  ACE_NTOHL (0x64496400),  // name = InvalidRecordId
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidRecordId (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidRecordId),
    (char *) &_oc_DsLogAdmin_InvalidRecordId,
    0,
    sizeof (DsLogAdmin::InvalidRecordId)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidRecordId =
    &_tc_TAO_tc_DsLogAdmin_InvalidRecordId;
}

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

DsLogAdmin::InvalidAttribute::InvalidAttribute (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidAttribute:1.0",
        "InvalidAttribute"
      )
{
}

DsLogAdmin::InvalidAttribute::~InvalidAttribute (void)
{
}

DsLogAdmin::InvalidAttribute::InvalidAttribute (const ::DsLogAdmin::InvalidAttribute &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
  this->attr_name = CORBA::string_dup (_tao_excp.attr_name.in ());
  this->value = _tao_excp.value;
}

DsLogAdmin::InvalidAttribute&
DsLogAdmin::InvalidAttribute::operator= (const ::DsLogAdmin::InvalidAttribute &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  this->attr_name = CORBA::string_dup (_tao_excp.attr_name.in ());
  this->value = _tao_excp.value;
  return *this;
}

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

DsLogAdmin::InvalidAttribute *
DsLogAdmin::InvalidAttribute::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidAttribute:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidAttribute *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidAttribute::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidAttribute (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidAttribute::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidAttribute::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidAttribute::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}



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

DsLogAdmin::InvalidAttribute::InvalidAttribute (
    const char * _tao_attr_name,
    const CORBA::Any & _tao_value
  )
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidAttribute:1.0",
        "InvalidAttribute"
      )
{
  this->attr_name = CORBA::string_dup (_tao_attr_name);
  this->value = _tao_value;
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidAttribute::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidAttribute;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidAttribute[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  44,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69644174), 
  ACE_NTOHL (0x74726962), 
  ACE_NTOHL (0x7574653a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidAttribute:1.0
    17,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c696441), 
  ACE_NTOHL (0x74747269), 
  ACE_NTOHL (0x62757465), 
  ACE_NTOHL (0x0),  // name = InvalidAttribute
  2, // member count
    10,
  ACE_NTOHL (0x61747472), 
  ACE_NTOHL (0x5f6e616d), 
  ACE_NTOHL (0x65000000),  // name = attr_name
    CORBA::tk_string, 
  0U, // string length
  6,
  ACE_NTOHL (0x76616c75), 
  ACE_NTOHL (0x65000000),  // name = value
    CORBA::tk_any,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidAttribute (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidAttribute),
    (char *) &_oc_DsLogAdmin_InvalidAttribute,
    0,
    sizeof (DsLogAdmin::InvalidAttribute)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidAttribute =
    &_tc_TAO_tc_DsLogAdmin_InvalidAttribute;
}

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

DsLogAdmin::InvalidLogFullAction::InvalidLogFullAction (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/InvalidLogFullAction:1.0",
        "InvalidLogFullAction"
      )
{
}

DsLogAdmin::InvalidLogFullAction::~InvalidLogFullAction (void)
{
}

DsLogAdmin::InvalidLogFullAction::InvalidLogFullAction (const ::DsLogAdmin::InvalidLogFullAction &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

DsLogAdmin::InvalidLogFullAction&
DsLogAdmin::InvalidLogFullAction::operator= (const ::DsLogAdmin::InvalidLogFullAction &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  return *this;
}

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

DsLogAdmin::InvalidLogFullAction *
DsLogAdmin::InvalidLogFullAction::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/InvalidLogFullAction:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<InvalidLogFullAction *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::InvalidLogFullAction::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::InvalidLogFullAction (*this),
      0
    );
  return result;
}

void DsLogAdmin::InvalidLogFullAction::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::InvalidLogFullAction::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::InvalidLogFullAction::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::InvalidLogFullAction::_type (void) const
{
  return ::DsLogAdmin::_tc_InvalidLogFullAction;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_InvalidLogFullAction[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  48,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e76616c), 
  ACE_NTOHL (0x69644c6f), 
  ACE_NTOHL (0x6746756c), 
  ACE_NTOHL (0x6c416374), 
  ACE_NTOHL (0x696f6e3a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/InvalidLogFullAction:1.0
    21,
  ACE_NTOHL (0x496e7661), 
  ACE_NTOHL (0x6c69644c), 
  ACE_NTOHL (0x6f674675), 
  ACE_NTOHL (0x6c6c4163), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x0),  // name = InvalidLogFullAction
  0, // member count
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_InvalidLogFullAction (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_InvalidLogFullAction),
    (char *) &_oc_DsLogAdmin_InvalidLogFullAction,
    0,
    sizeof (DsLogAdmin::InvalidLogFullAction)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_InvalidLogFullAction =
    &_tc_TAO_tc_DsLogAdmin_InvalidLogFullAction;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogId[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  33,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674964), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/LogId:1.0
    6,
  ACE_NTOHL (0x4c6f6749), 
  ACE_NTOHL (0x64000000),  // name = LogId
    CORBA::tk_ulong,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogId (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_LogId),
    (char *) &_oc_DsLogAdmin_LogId,
    0,
    sizeof (DsLogAdmin::LogId)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogId =
    &_tc_TAO_tc_DsLogAdmin_LogId;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_RecordId[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  36,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f52), 
  ACE_NTOHL (0x65636f72), 
  ACE_NTOHL (0x6449643a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/RecordId:1.0
    9,
  ACE_NTOHL (0x5265636f), 
  ACE_NTOHL (0x72644964), 
  ACE_NTOHL (0x0),  // name = RecordId
    CORBA::tk_ulonglong,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_RecordId (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_RecordId),
    (char *) &_oc_DsLogAdmin_RecordId,
    0,
    sizeof (DsLogAdmin::RecordId)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_RecordId =
    &_tc_TAO_tc_DsLogAdmin_RecordId;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_RECORDIDLIST_CS_)
#define _DSLOGADMIN_RECORDIDLIST_CS_

DsLogAdmin::RecordIdList::RecordIdList (void)
{}

DsLogAdmin::RecordIdList::RecordIdList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::RecordId
      >
    (max)
{}

DsLogAdmin::RecordIdList::RecordIdList (
    CORBA::ULong max,
    CORBA::ULong length,
    CORBA::ULongLong * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::RecordId
      >
    (max, length, buffer, release)
{}

DsLogAdmin::RecordIdList::RecordIdList (
    const RecordIdList &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::RecordId
      >
    (seq)
{}

DsLogAdmin::RecordIdList::~RecordIdList (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_RecordIdList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f52), 
  ACE_NTOHL (0x65636f72), 
  ACE_NTOHL (0x6449644c), 
  ACE_NTOHL (0x6973743a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/RecordIdList:1.0
    13,
  ACE_NTOHL (0x5265636f), 
  ACE_NTOHL (0x72644964), 
  ACE_NTOHL (0x4c697374), 
  ACE_NTOHL (0x0),  // name = RecordIdList
    CORBA::tk_sequence, // typecode kind
  80, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_alias, // typecode kind for typedefs
    64, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      36,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f52), 
      ACE_NTOHL (0x65636f72), 
      ACE_NTOHL (0x6449643a), 
      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/RecordId:1.0
            9,
      ACE_NTOHL (0x5265636f), 
      ACE_NTOHL (0x72644964), 
      ACE_NTOHL (0x0),  // name = RecordId
            CORBA::tk_ulonglong,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_RecordIdList (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_RecordIdList),
    (char *) &_oc_DsLogAdmin_RecordIdList,
    0,
    sizeof (DsLogAdmin::RecordIdList)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_RecordIdList =
    &_tc_TAO_tc_DsLogAdmin_RecordIdList;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_Constraint[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f43), 
  ACE_NTOHL (0x6f6e7374), 
  ACE_NTOHL (0x7261696e), 
  ACE_NTOHL (0x743a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Constraint:1.0
    11,
  ACE_NTOHL (0x436f6e73), 
  ACE_NTOHL (0x74726169), 
  ACE_NTOHL (0x6e740000),  // name = Constraint
    CORBA::tk_string, 
  0U, // string length
};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_Constraint (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_Constraint),
    (char *) &_oc_DsLogAdmin_Constraint,
    0,
    sizeof (DsLogAdmin::Constraint)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_Constraint =
    &_tc_TAO_tc_DsLogAdmin_Constraint;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_TimeT[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  33,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f54), 
  ACE_NTOHL (0x696d6554), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/TimeT:1.0
    6,
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x54000000),  // name = TimeT
    CORBA::tk_alias, // typecode kind for typedefs
  56, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    31,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x54696d65), 
    ACE_NTOHL (0x42617365), 
    ACE_NTOHL (0x2f54696d), 
    ACE_NTOHL (0x65543a31), 
    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/TimeBase/TimeT:1.0
        6,
    ACE_NTOHL (0x54696d65), 
    ACE_NTOHL (0x54000000),  // name = TimeT
        CORBA::tk_ulonglong,


};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_TimeT (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_TimeT),
    (char *) &_oc_DsLogAdmin_TimeT,
    0,
    sizeof (DsLogAdmin::TimeT)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_TimeT =
    &_tc_TAO_tc_DsLogAdmin_TimeT;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_NVPair[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  34,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4e), 
  ACE_NTOHL (0x56506169), 
  ACE_NTOHL (0x723a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/NVPair:1.0
    7,
  ACE_NTOHL (0x4e565061), 
  ACE_NTOHL (0x69720000),  // name = NVPair
  2, // member count
    5,
  ACE_NTOHL (0x6e616d65), 
  ACE_NTOHL (0x0),  // name = name
    CORBA::tk_string, 
  0U, // string length
  6,
  ACE_NTOHL (0x76616c75), 
  ACE_NTOHL (0x65000000),  // name = value
    CORBA::tk_any,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_NVPair (
    CORBA::tk_struct,
    sizeof (_oc_DsLogAdmin_NVPair),
    (char *) &_oc_DsLogAdmin_NVPair,
    0,
    sizeof (DsLogAdmin::NVPair)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_NVPair =
    &_tc_TAO_tc_DsLogAdmin_NVPair;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:66

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_NVLIST_CS_)
#define _DSLOGADMIN_NVLIST_CS_

DsLogAdmin::NVList::NVList (void)
{}

DsLogAdmin::NVList::NVList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::NVPair
      >
    (max)
{}

DsLogAdmin::NVList::NVList (
    CORBA::ULong max,
    CORBA::ULong length,
    DsLogAdmin::NVPair * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::NVPair
      >
    (max, length, buffer, release)
{}

DsLogAdmin::NVList::NVList (
    const NVList &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::NVPair
      >
    (seq)
{}

DsLogAdmin::NVList::~NVList (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_NVList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  34,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4e), 
  ACE_NTOHL (0x564c6973), 
  ACE_NTOHL (0x743a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/NVList:1.0
    7,
  ACE_NTOHL (0x4e564c69), 
  ACE_NTOHL (0x73740000),  // name = NVList
    CORBA::tk_sequence, // typecode kind
  112, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    96, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      34,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f4e), 
      ACE_NTOHL (0x56506169), 
      ACE_NTOHL (0x723a312e), 
      ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/NVPair:1.0
            7,
      ACE_NTOHL (0x4e565061), 
      ACE_NTOHL (0x69720000),  // name = NVPair
      2, // member count
            5,
      ACE_NTOHL (0x6e616d65), 
      ACE_NTOHL (0x0),  // name = name
            CORBA::tk_string, 
      0U, // string length
      6,
      ACE_NTOHL (0x76616c75), 
      ACE_NTOHL (0x65000000),  // name = value
            CORBA::tk_any,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_NVList (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_NVList),
    (char *) &_oc_DsLogAdmin_NVList,
    0,
    sizeof (DsLogAdmin::NVList)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_NVList =
    &_tc_TAO_tc_DsLogAdmin_NVList;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_TimeInterval[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f54), 
  ACE_NTOHL (0x696d6549), 
  ACE_NTOHL (0x6e746572), 
  ACE_NTOHL (0x76616c3a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/TimeInterval:1.0
    13,
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x496e7465), 
  ACE_NTOHL (0x7276616c), 
  ACE_NTOHL (0x0),  // name = TimeInterval
  2, // member count
    6,
  ACE_NTOHL (0x73746172), 
  ACE_NTOHL (0x74000000),  // name = start
    CORBA::tk_alias, // typecode kind for typedefs
  120, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    33,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f54), 
    ACE_NTOHL (0x696d6554), 
    ACE_NTOHL (0x3a312e30), 
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/TimeT:1.0
        6,
    ACE_NTOHL (0x54696d65), 
    ACE_NTOHL (0x54000000),  // name = TimeT
        CORBA::tk_alias, // typecode kind for typedefs
    56, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      31,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x54696d65), 
      ACE_NTOHL (0x42617365), 
      ACE_NTOHL (0x2f54696d), 
      ACE_NTOHL (0x65543a31), 
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/TimeBase/TimeT:1.0
            6,
      ACE_NTOHL (0x54696d65), 
      ACE_NTOHL (0x54000000),  // name = TimeT
            CORBA::tk_ulonglong,



  5,
  ACE_NTOHL (0x73746f70), 
  ACE_NTOHL (0x0),  // name = stop
    CORBA::tk_alias, // typecode kind for typedefs
  120, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    33,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f54), 
    ACE_NTOHL (0x696d6554), 
    ACE_NTOHL (0x3a312e30), 
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/TimeT:1.0
        6,
    ACE_NTOHL (0x54696d65), 
    ACE_NTOHL (0x54000000),  // name = TimeT
        CORBA::tk_alias, // typecode kind for typedefs
    56, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      31,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x54696d65), 
      ACE_NTOHL (0x42617365), 
      ACE_NTOHL (0x2f54696d), 
      ACE_NTOHL (0x65543a31), 
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/TimeBase/TimeT:1.0
            6,
      ACE_NTOHL (0x54696d65), 
      ACE_NTOHL (0x54000000),  // name = TimeT
            CORBA::tk_ulonglong,



};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_TimeInterval (
    CORBA::tk_struct,
    sizeof (_oc_DsLogAdmin_TimeInterval),
    (char *) &_oc_DsLogAdmin_TimeInterval,
    0,
    sizeof (DsLogAdmin::TimeInterval)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_TimeInterval =
    &_tc_TAO_tc_DsLogAdmin_TimeInterval;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:66

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogRecord[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f675265), 
  ACE_NTOHL (0x636f7264), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/LogRecord:1.0
    10,
  ACE_NTOHL (0x4c6f6752), 
  ACE_NTOHL (0x65636f72), 
  ACE_NTOHL (0x64000000),  // name = LogRecord
  4, // member count
    3,
  ACE_NTOHL (0x69640000),  // name = id
    CORBA::tk_alias, // typecode kind for typedefs
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    36,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f52), 
    ACE_NTOHL (0x65636f72), 
    ACE_NTOHL (0x6449643a), 
    ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/RecordId:1.0
        9,
    ACE_NTOHL (0x5265636f), 
    ACE_NTOHL (0x72644964), 
    ACE_NTOHL (0x0),  // name = RecordId
        CORBA::tk_ulonglong,


  5,
  ACE_NTOHL (0x74696d65), 
  ACE_NTOHL (0x0),  // name = time
    CORBA::tk_alias, // typecode kind for typedefs
  120, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    33,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f54), 
    ACE_NTOHL (0x696d6554), 
    ACE_NTOHL (0x3a312e30), 
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/TimeT:1.0
        6,
    ACE_NTOHL (0x54696d65), 
    ACE_NTOHL (0x54000000),  // name = TimeT
        CORBA::tk_alias, // typecode kind for typedefs
    56, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      31,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x54696d65), 
      ACE_NTOHL (0x42617365), 
      ACE_NTOHL (0x2f54696d), 
      ACE_NTOHL (0x65543a31), 
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/TimeBase/TimeT:1.0
            6,
      ACE_NTOHL (0x54696d65), 
      ACE_NTOHL (0x54000000),  // name = TimeT
            CORBA::tk_ulonglong,



  10,
  ACE_NTOHL (0x61747472), 
  ACE_NTOHL (0x5f6c6973), 
  ACE_NTOHL (0x74000000),  // name = attr_list
    CORBA::tk_alias, // typecode kind for typedefs
  176, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    34,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f4e), 
    ACE_NTOHL (0x564c6973), 
    ACE_NTOHL (0x743a312e), 
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/NVList:1.0
        7,
    ACE_NTOHL (0x4e564c69), 
    ACE_NTOHL (0x73740000),  // name = NVList
        CORBA::tk_sequence, // typecode kind
    112, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_struct, // typecode kind
      96, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        34,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f4e), 
        ACE_NTOHL (0x56506169), 
        ACE_NTOHL (0x723a312e), 
        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/NVPair:1.0
                7,
        ACE_NTOHL (0x4e565061), 
        ACE_NTOHL (0x69720000),  // name = NVPair
        2, // member count
                5,
        ACE_NTOHL (0x6e616d65), 
        ACE_NTOHL (0x0),  // name = name
                CORBA::tk_string, 
        0U, // string length
        6,
        ACE_NTOHL (0x76616c75), 
        ACE_NTOHL (0x65000000),  // name = value
                CORBA::tk_any,


      0U,


  5,
  ACE_NTOHL (0x696e666f), 
  ACE_NTOHL (0x0),  // name = info
    CORBA::tk_any,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogRecord (
    CORBA::tk_struct,
    sizeof (_oc_DsLogAdmin_LogRecord),
    (char *) &_oc_DsLogAdmin_LogRecord,
    0,
    sizeof (DsLogAdmin::LogRecord)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogRecord =
    &_tc_TAO_tc_DsLogAdmin_LogRecord;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:66

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_RECORDLIST_CS_)
#define _DSLOGADMIN_RECORDLIST_CS_

DsLogAdmin::RecordList::RecordList (void)
{}

DsLogAdmin::RecordList::RecordList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::LogRecord
      >
    (max)
{}

DsLogAdmin::RecordList::RecordList (
    CORBA::ULong max,
    CORBA::ULong length,
    DsLogAdmin::LogRecord * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::LogRecord
      >
    (max, length, buffer, release)
{}

DsLogAdmin::RecordList::RecordList (
    const RecordList &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::LogRecord
      >
    (seq)
{}

DsLogAdmin::RecordList::~RecordList (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_RecordList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f52), 
  ACE_NTOHL (0x65636f72), 
  ACE_NTOHL (0x644c6973), 
  ACE_NTOHL (0x743a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/RecordList:1.0
    11,
  ACE_NTOHL (0x5265636f), 
  ACE_NTOHL (0x72644c69), 
  ACE_NTOHL (0x73740000),  // name = RecordList
    CORBA::tk_sequence, // typecode kind
  520, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    504, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      37,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f4c), 
      ACE_NTOHL (0x6f675265), 
      ACE_NTOHL (0x636f7264), 
      ACE_NTOHL (0x3a312e30), 
      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/LogRecord:1.0
            10,
      ACE_NTOHL (0x4c6f6752), 
      ACE_NTOHL (0x65636f72), 
      ACE_NTOHL (0x64000000),  // name = LogRecord
      4, // member count
            3,
      ACE_NTOHL (0x69640000),  // name = id
            CORBA::tk_alias, // typecode kind for typedefs
      64, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        36,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f52), 
        ACE_NTOHL (0x65636f72), 
        ACE_NTOHL (0x6449643a), 
        ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/RecordId:1.0
                9,
        ACE_NTOHL (0x5265636f), 
        ACE_NTOHL (0x72644964), 
        ACE_NTOHL (0x0),  // name = RecordId
                CORBA::tk_ulonglong,


      5,
      ACE_NTOHL (0x74696d65), 
      ACE_NTOHL (0x0),  // name = time
            CORBA::tk_alias, // typecode kind for typedefs
      120, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        33,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f54), 
        ACE_NTOHL (0x696d6554), 
        ACE_NTOHL (0x3a312e30), 
        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/TimeT:1.0
                6,
        ACE_NTOHL (0x54696d65), 
        ACE_NTOHL (0x54000000),  // name = TimeT
                CORBA::tk_alias, // typecode kind for typedefs
        56, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          31,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x6f6d672e), 
          ACE_NTOHL (0x6f72672f), 
          ACE_NTOHL (0x54696d65), 
          ACE_NTOHL (0x42617365), 
          ACE_NTOHL (0x2f54696d), 
          ACE_NTOHL (0x65543a31), 
          ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/TimeBase/TimeT:1.0
                    6,
          ACE_NTOHL (0x54696d65), 
          ACE_NTOHL (0x54000000),  // name = TimeT
                    CORBA::tk_ulonglong,



      10,
      ACE_NTOHL (0x61747472), 
      ACE_NTOHL (0x5f6c6973), 
      ACE_NTOHL (0x74000000),  // name = attr_list
            CORBA::tk_alias, // typecode kind for typedefs
      176, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        34,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f4e), 
        ACE_NTOHL (0x564c6973), 
        ACE_NTOHL (0x743a312e), 
        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/NVList:1.0
                7,
        ACE_NTOHL (0x4e564c69), 
        ACE_NTOHL (0x73740000),  // name = NVList
                CORBA::tk_sequence, // typecode kind
        112, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          CORBA::tk_struct, // typecode kind
          96, // encapsulation length
            TAO_ENCAP_BYTE_ORDER, // byte order
            34,
            ACE_NTOHL (0x49444c3a), 
            ACE_NTOHL (0x6f6d672e), 
            ACE_NTOHL (0x6f72672f), 
            ACE_NTOHL (0x44734c6f), 
            ACE_NTOHL (0x6741646d), 
            ACE_NTOHL (0x696e2f4e), 
            ACE_NTOHL (0x56506169), 
            ACE_NTOHL (0x723a312e), 
            ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/NVPair:1.0
                        7,
            ACE_NTOHL (0x4e565061), 
            ACE_NTOHL (0x69720000),  // name = NVPair
            2, // member count
                        5,
            ACE_NTOHL (0x6e616d65), 
            ACE_NTOHL (0x0),  // name = name
                        CORBA::tk_string, 
            0U, // string length
            6,
            ACE_NTOHL (0x76616c75), 
            ACE_NTOHL (0x65000000),  // name = value
                        CORBA::tk_any,


          0U,


      5,
      ACE_NTOHL (0x696e666f), 
      ACE_NTOHL (0x0),  // name = info
            CORBA::tk_any,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_RecordList (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_RecordList),
    (char *) &_oc_DsLogAdmin_RecordList,
    0,
    sizeof (DsLogAdmin::RecordList)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_RecordList =
    &_tc_TAO_tc_DsLogAdmin_RecordList;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_ANYS_CS_)
#define _DSLOGADMIN_ANYS_CS_

DsLogAdmin::Anys::Anys (void)
{}

DsLogAdmin::Anys::Anys (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        CORBA::Any
      >
    (max)
{}

DsLogAdmin::Anys::Anys (
    CORBA::ULong max,
    CORBA::ULong length,
    CORBA::Any * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        CORBA::Any
      >
    (max, length, buffer, release)
{}

DsLogAdmin::Anys::Anys (
    const Anys &seq
  )
  : TAO_Unbounded_Sequence<
        CORBA::Any
      >
    (seq)
{}

DsLogAdmin::Anys::~Anys (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_Anys[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  32,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f41), 
  ACE_NTOHL (0x6e79733a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/Anys:1.0
    5,
  ACE_NTOHL (0x416e7973), 
  ACE_NTOHL (0x0),  // name = Anys
    CORBA::tk_sequence, // typecode kind
  12, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_any,

    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_Anys (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_Anys),
    (char *) &_oc_DsLogAdmin_Anys,
    0,
    sizeof (DsLogAdmin::Anys)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_Anys =
    &_tc_TAO_tc_DsLogAdmin_Anys;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:60

// Traits specializations for DsLogAdmin::Iterator.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::Iterator_ptr
TAO::Objref_Traits<DsLogAdmin::Iterator>::tao_duplicate (
    DsLogAdmin::Iterator_ptr p
  )
{
  return DsLogAdmin::Iterator::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<DsLogAdmin::Iterator>::tao_release (
    DsLogAdmin::Iterator_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::Iterator_ptr
TAO::Objref_Traits<DsLogAdmin::Iterator>::tao_nil (void)
{
  return DsLogAdmin::Iterator::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<DsLogAdmin::Iterator>::tao_marshal (
    DsLogAdmin::Iterator_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*DsLogAdmin__TAO_Iterator_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::RecordList * DsLogAdmin::Iterator::get (
    ::CORBA::ULong position,
    ::CORBA::ULong how_many
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidParam
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Iterator_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Iterator_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::RecordList>::ret_val _tao_retval;
  TAO::Arg_Traits< CORBA::ULong>::in_arg_val _tao_position (position);
  TAO::Arg_Traits< CORBA::ULong>::in_arg_val _tao_how_many (how_many);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_position,
      &_tao_how_many
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Iterator_get_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidParam:1.0",
        DsLogAdmin::InvalidParam::_alloc,
        DsLogAdmin::_tc_InvalidParam
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "get",
      3,
      this->the_TAO_Iterator_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Iterator_get_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Iterator::destroy (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Iterator_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Iterator_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "destroy",
      7,
      this->the_TAO_Iterator_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

DsLogAdmin::Iterator::Iterator (void)
 : the_TAO_Iterator_Proxy_Broker_ (0)
{
  this->DsLogAdmin_Iterator_setup_collocation ();
}

void
DsLogAdmin::Iterator::DsLogAdmin_Iterator_setup_collocation ()
{
  if (::DsLogAdmin__TAO_Iterator_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_Iterator_Proxy_Broker_ =
        ::DsLogAdmin__TAO_Iterator_Proxy_Broker_Factory_function_pointer (this);
    }
}

DsLogAdmin::Iterator::~Iterator (void)
{}

void 
DsLogAdmin::Iterator::_tao_any_destructor (void *_tao_void_pointer)
{
  Iterator *_tao_tmp_pointer =
    static_cast<Iterator *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

DsLogAdmin::Iterator_ptr
DsLogAdmin::Iterator::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<Iterator>::narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/Iterator:1.0",
        DsLogAdmin__TAO_Iterator_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::Iterator_ptr
DsLogAdmin::Iterator::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<Iterator>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/Iterator:1.0",
        DsLogAdmin__TAO_Iterator_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::Iterator_ptr
DsLogAdmin::Iterator::_duplicate (Iterator_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
DsLogAdmin::Iterator::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/Iterator:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

const char* DsLogAdmin::Iterator::_interface_repository_id (void) const
{
  return "IDL:omg.org/DsLogAdmin/Iterator:1.0";
}

CORBA::Boolean
DsLogAdmin::Iterator::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_Iterator[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  36,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x74657261), 
  ACE_NTOHL (0x746f723a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/Iterator:1.0
    9,
  ACE_NTOHL (0x49746572), 
  ACE_NTOHL (0x61746f72), 
  ACE_NTOHL (0x0),  // name = Iterator
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_Iterator (
    CORBA::tk_objref,
    sizeof (_oc_DsLogAdmin_Iterator),
    (char *) &_oc_DsLogAdmin_Iterator,
    0,
    sizeof (DsLogAdmin::Iterator)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_Iterator =
    &_tc_TAO_tc_DsLogAdmin_Iterator;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_AvailabilityStatus[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  46,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f41), 
  ACE_NTOHL (0x7661696c), 
  ACE_NTOHL (0x6162696c), 
  ACE_NTOHL (0x69747953), 
  ACE_NTOHL (0x74617475), 
  ACE_NTOHL (0x733a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/AvailabilityStatus:1.0
    19,
  ACE_NTOHL (0x41766169), 
  ACE_NTOHL (0x6c616269), 
  ACE_NTOHL (0x6c697479), 
  ACE_NTOHL (0x53746174), 
  ACE_NTOHL (0x75730000),  // name = AvailabilityStatus
  2, // member count
    9,
  ACE_NTOHL (0x6f66665f), 
  ACE_NTOHL (0x64757479), 
  ACE_NTOHL (0x0),  // name = off_duty
    CORBA::tk_boolean,

  9,
  ACE_NTOHL (0x6c6f675f), 
  ACE_NTOHL (0x66756c6c), 
  ACE_NTOHL (0x0),  // name = log_full
    CORBA::tk_boolean,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_AvailabilityStatus (
    CORBA::tk_struct,
    sizeof (_oc_DsLogAdmin_AvailabilityStatus),
    (char *) &_oc_DsLogAdmin_AvailabilityStatus,
    0,
    sizeof (DsLogAdmin::AvailabilityStatus)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_AvailabilityStatus =
    &_tc_TAO_tc_DsLogAdmin_AvailabilityStatus;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:66

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogFullActionType[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  45,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674675), 
  ACE_NTOHL (0x6c6c4163), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x54797065), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/LogFullActionType:1.0
    18,
  ACE_NTOHL (0x4c6f6746), 
  ACE_NTOHL (0x756c6c41), 
  ACE_NTOHL (0x6374696f), 
  ACE_NTOHL (0x6e547970), 
  ACE_NTOHL (0x65000000),  // name = LogFullActionType
    CORBA::tk_ushort,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogFullActionType (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_LogFullActionType),
    (char *) &_oc_DsLogAdmin_LogFullActionType,
    0,
    sizeof (DsLogAdmin::LogFullActionType)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogFullActionType =
    &_tc_TAO_tc_DsLogAdmin_LogFullActionType;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_Time24[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  34,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f54), 
  ACE_NTOHL (0x696d6532), 
  ACE_NTOHL (0x343a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
    7,
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x32340000),  // name = Time24
  2, // member count
    5,
  ACE_NTOHL (0x686f7572), 
  ACE_NTOHL (0x0),  // name = hour
    CORBA::tk_ushort,

  7,
  ACE_NTOHL (0x6d696e75), 
  ACE_NTOHL (0x74650000),  // name = minute
    CORBA::tk_ushort,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_Time24 (
    CORBA::tk_struct,
    sizeof (_oc_DsLogAdmin_Time24),
    (char *) &_oc_DsLogAdmin_Time24,
    0,
    sizeof (DsLogAdmin::Time24)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_Time24 =
    &_tc_TAO_tc_DsLogAdmin_Time24;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:66

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_Time24Interval[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f54), 
  ACE_NTOHL (0x696d6532), 
  ACE_NTOHL (0x34496e74), 
  ACE_NTOHL (0x65727661), 
  ACE_NTOHL (0x6c3a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24Interval:1.0
    15,
  ACE_NTOHL (0x54696d65), 
  ACE_NTOHL (0x3234496e), 
  ACE_NTOHL (0x74657276), 
  ACE_NTOHL (0x616c0000),  // name = Time24Interval
  2, // member count
    6,
  ACE_NTOHL (0x73746172), 
  ACE_NTOHL (0x74000000),  // name = start
    CORBA::tk_struct, // typecode kind
  92, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    34,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f54), 
    ACE_NTOHL (0x696d6532), 
    ACE_NTOHL (0x343a312e), 
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
        7,
    ACE_NTOHL (0x54696d65), 
    ACE_NTOHL (0x32340000),  // name = Time24
    2, // member count
        5,
    ACE_NTOHL (0x686f7572), 
    ACE_NTOHL (0x0),  // name = hour
        CORBA::tk_ushort,

    7,
    ACE_NTOHL (0x6d696e75), 
    ACE_NTOHL (0x74650000),  // name = minute
        CORBA::tk_ushort,


  5,
  ACE_NTOHL (0x73746f70), 
  ACE_NTOHL (0x0),  // name = stop
    CORBA::tk_struct, // typecode kind
  92, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    34,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f54), 
    ACE_NTOHL (0x696d6532), 
    ACE_NTOHL (0x343a312e), 
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
        7,
    ACE_NTOHL (0x54696d65), 
    ACE_NTOHL (0x32340000),  // name = Time24
    2, // member count
        5,
    ACE_NTOHL (0x686f7572), 
    ACE_NTOHL (0x0),  // name = hour
        CORBA::tk_ushort,

    7,
    ACE_NTOHL (0x6d696e75), 
    ACE_NTOHL (0x74650000),  // name = minute
        CORBA::tk_ushort,


};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_Time24Interval (
    CORBA::tk_struct,
    sizeof (_oc_DsLogAdmin_Time24Interval),
    (char *) &_oc_DsLogAdmin_Time24Interval,
    0,
    sizeof (DsLogAdmin::Time24Interval)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_Time24Interval =
    &_tc_TAO_tc_DsLogAdmin_Time24Interval;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:66

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_INTERVALSOFDAY_CS_)
#define _DSLOGADMIN_INTERVALSOFDAY_CS_

DsLogAdmin::IntervalsOfDay::IntervalsOfDay (void)
{}

DsLogAdmin::IntervalsOfDay::IntervalsOfDay (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::Time24Interval
      >
    (max)
{}

DsLogAdmin::IntervalsOfDay::IntervalsOfDay (
    CORBA::ULong max,
    CORBA::ULong length,
    DsLogAdmin::Time24Interval * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::Time24Interval
      >
    (max, length, buffer, release)
{}

DsLogAdmin::IntervalsOfDay::IntervalsOfDay (
    const IntervalsOfDay &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::Time24Interval
      >
    (seq)
{}

DsLogAdmin::IntervalsOfDay::~IntervalsOfDay (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_IntervalsOfDay[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f49), 
  ACE_NTOHL (0x6e746572), 
  ACE_NTOHL (0x76616c73), 
  ACE_NTOHL (0x4f664461), 
  ACE_NTOHL (0x793a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/IntervalsOfDay:1.0
    15,
  ACE_NTOHL (0x496e7465), 
  ACE_NTOHL (0x7276616c), 
  ACE_NTOHL (0x734f6644), 
  ACE_NTOHL (0x61790000),  // name = IntervalsOfDay
    CORBA::tk_sequence, // typecode kind
  316, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    300, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      42,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f54), 
      ACE_NTOHL (0x696d6532), 
      ACE_NTOHL (0x34496e74), 
      ACE_NTOHL (0x65727661), 
      ACE_NTOHL (0x6c3a312e), 
      ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24Interval:1.0
            15,
      ACE_NTOHL (0x54696d65), 
      ACE_NTOHL (0x3234496e), 
      ACE_NTOHL (0x74657276), 
      ACE_NTOHL (0x616c0000),  // name = Time24Interval
      2, // member count
            6,
      ACE_NTOHL (0x73746172), 
      ACE_NTOHL (0x74000000),  // name = start
            CORBA::tk_struct, // typecode kind
      92, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        34,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f54), 
        ACE_NTOHL (0x696d6532), 
        ACE_NTOHL (0x343a312e), 
        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
                7,
        ACE_NTOHL (0x54696d65), 
        ACE_NTOHL (0x32340000),  // name = Time24
        2, // member count
                5,
        ACE_NTOHL (0x686f7572), 
        ACE_NTOHL (0x0),  // name = hour
                CORBA::tk_ushort,

        7,
        ACE_NTOHL (0x6d696e75), 
        ACE_NTOHL (0x74650000),  // name = minute
                CORBA::tk_ushort,


      5,
      ACE_NTOHL (0x73746f70), 
      ACE_NTOHL (0x0),  // name = stop
            CORBA::tk_struct, // typecode kind
      92, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        34,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f54), 
        ACE_NTOHL (0x696d6532), 
        ACE_NTOHL (0x343a312e), 
        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
                7,
        ACE_NTOHL (0x54696d65), 
        ACE_NTOHL (0x32340000),  // name = Time24
        2, // member count
                5,
        ACE_NTOHL (0x686f7572), 
        ACE_NTOHL (0x0),  // name = hour
                CORBA::tk_ushort,

        7,
        ACE_NTOHL (0x6d696e75), 
        ACE_NTOHL (0x74650000),  // name = minute
                CORBA::tk_ushort,



    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_IntervalsOfDay (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_IntervalsOfDay),
    (char *) &_oc_DsLogAdmin_IntervalsOfDay,
    0,
    sizeof (DsLogAdmin::IntervalsOfDay)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_IntervalsOfDay =
    &_tc_TAO_tc_DsLogAdmin_IntervalsOfDay;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_DaysOfWeek[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  38,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f44), 
  ACE_NTOHL (0x6179734f), 
  ACE_NTOHL (0x66576565), 
  ACE_NTOHL (0x6b3a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/DaysOfWeek:1.0
    11,
  ACE_NTOHL (0x44617973), 
  ACE_NTOHL (0x4f665765), 
  ACE_NTOHL (0x656b0000),  // name = DaysOfWeek
    CORBA::tk_ushort,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_DaysOfWeek (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_DaysOfWeek),
    (char *) &_oc_DsLogAdmin_DaysOfWeek,
    0,
    sizeof (DsLogAdmin::DaysOfWeek)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_DaysOfWeek =
    &_tc_TAO_tc_DsLogAdmin_DaysOfWeek;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_WeekMaskItem[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  40,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f57), 
  ACE_NTOHL (0x65656b4d), 
  ACE_NTOHL (0x61736b49), 
  ACE_NTOHL (0x74656d3a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/WeekMaskItem:1.0
    13,
  ACE_NTOHL (0x5765656b), 
  ACE_NTOHL (0x4d61736b), 
  ACE_NTOHL (0x4974656d), 
  ACE_NTOHL (0x0),  // name = WeekMaskItem
  2, // member count
    5,
  ACE_NTOHL (0x64617973), 
  ACE_NTOHL (0x0),  // name = days
    CORBA::tk_alias, // typecode kind for typedefs
  68, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    38,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f44), 
    ACE_NTOHL (0x6179734f), 
    ACE_NTOHL (0x66576565), 
    ACE_NTOHL (0x6b3a312e), 
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/DaysOfWeek:1.0
        11,
    ACE_NTOHL (0x44617973), 
    ACE_NTOHL (0x4f665765), 
    ACE_NTOHL (0x656b0000),  // name = DaysOfWeek
        CORBA::tk_ushort,


  10,
  ACE_NTOHL (0x696e7465), 
  ACE_NTOHL (0x7276616c), 
  ACE_NTOHL (0x73000000),  // name = intervals
    CORBA::tk_alias, // typecode kind for typedefs
  396, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    42,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f49), 
    ACE_NTOHL (0x6e746572), 
    ACE_NTOHL (0x76616c73), 
    ACE_NTOHL (0x4f664461), 
    ACE_NTOHL (0x793a312e), 
    ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/IntervalsOfDay:1.0
        15,
    ACE_NTOHL (0x496e7465), 
    ACE_NTOHL (0x7276616c), 
    ACE_NTOHL (0x734f6644), 
    ACE_NTOHL (0x61790000),  // name = IntervalsOfDay
        CORBA::tk_sequence, // typecode kind
    316, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_struct, // typecode kind
      300, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        42,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f54), 
        ACE_NTOHL (0x696d6532), 
        ACE_NTOHL (0x34496e74), 
        ACE_NTOHL (0x65727661), 
        ACE_NTOHL (0x6c3a312e), 
        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24Interval:1.0
                15,
        ACE_NTOHL (0x54696d65), 
        ACE_NTOHL (0x3234496e), 
        ACE_NTOHL (0x74657276), 
        ACE_NTOHL (0x616c0000),  // name = Time24Interval
        2, // member count
                6,
        ACE_NTOHL (0x73746172), 
        ACE_NTOHL (0x74000000),  // name = start
                CORBA::tk_struct, // typecode kind
        92, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          34,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x6f6d672e), 
          ACE_NTOHL (0x6f72672f), 
          ACE_NTOHL (0x44734c6f), 
          ACE_NTOHL (0x6741646d), 
          ACE_NTOHL (0x696e2f54), 
          ACE_NTOHL (0x696d6532), 
          ACE_NTOHL (0x343a312e), 
          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
                    7,
          ACE_NTOHL (0x54696d65), 
          ACE_NTOHL (0x32340000),  // name = Time24
          2, // member count
                    5,
          ACE_NTOHL (0x686f7572), 
          ACE_NTOHL (0x0),  // name = hour
                    CORBA::tk_ushort,

          7,
          ACE_NTOHL (0x6d696e75), 
          ACE_NTOHL (0x74650000),  // name = minute
                    CORBA::tk_ushort,


        5,
        ACE_NTOHL (0x73746f70), 
        ACE_NTOHL (0x0),  // name = stop
                CORBA::tk_struct, // typecode kind
        92, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          34,
          ACE_NTOHL (0x49444c3a), 
          ACE_NTOHL (0x6f6d672e), 
          ACE_NTOHL (0x6f72672f), 
          ACE_NTOHL (0x44734c6f), 
          ACE_NTOHL (0x6741646d), 
          ACE_NTOHL (0x696e2f54), 
          ACE_NTOHL (0x696d6532), 
          ACE_NTOHL (0x343a312e), 
          ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
                    7,
          ACE_NTOHL (0x54696d65), 
          ACE_NTOHL (0x32340000),  // name = Time24
          2, // member count
                    5,
          ACE_NTOHL (0x686f7572), 
          ACE_NTOHL (0x0),  // name = hour
                    CORBA::tk_ushort,

          7,
          ACE_NTOHL (0x6d696e75), 
          ACE_NTOHL (0x74650000),  // name = minute
                    CORBA::tk_ushort,



      0U,


};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_WeekMaskItem (
    CORBA::tk_struct,
    sizeof (_oc_DsLogAdmin_WeekMaskItem),
    (char *) &_oc_DsLogAdmin_WeekMaskItem,
    0,
    sizeof (DsLogAdmin::WeekMaskItem)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_WeekMaskItem =
    &_tc_TAO_tc_DsLogAdmin_WeekMaskItem;
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/structure_cs.cpp:66

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_WEEKMASK_CS_)
#define _DSLOGADMIN_WEEKMASK_CS_

DsLogAdmin::WeekMask::WeekMask (void)
{}

DsLogAdmin::WeekMask::WeekMask (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::WeekMaskItem
      >
    (max)
{}

DsLogAdmin::WeekMask::WeekMask (
    CORBA::ULong max,
    CORBA::ULong length,
    DsLogAdmin::WeekMaskItem * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::WeekMaskItem
      >
    (max, length, buffer, release)
{}

DsLogAdmin::WeekMask::WeekMask (
    const WeekMask &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::WeekMaskItem
      >
    (seq)
{}

DsLogAdmin::WeekMask::~WeekMask (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_WeekMask[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  36,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f57), 
  ACE_NTOHL (0x65656b4d), 
  ACE_NTOHL (0x61736b3a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/WeekMask:1.0
    9,
  ACE_NTOHL (0x5765656b), 
  ACE_NTOHL (0x4d61736b), 
  ACE_NTOHL (0x0),  // name = WeekMask
    CORBA::tk_sequence, // typecode kind
  596, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    580, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      40,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f57), 
      ACE_NTOHL (0x65656b4d), 
      ACE_NTOHL (0x61736b49), 
      ACE_NTOHL (0x74656d3a), 
      ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/WeekMaskItem:1.0
            13,
      ACE_NTOHL (0x5765656b), 
      ACE_NTOHL (0x4d61736b), 
      ACE_NTOHL (0x4974656d), 
      ACE_NTOHL (0x0),  // name = WeekMaskItem
      2, // member count
            5,
      ACE_NTOHL (0x64617973), 
      ACE_NTOHL (0x0),  // name = days
            CORBA::tk_alias, // typecode kind for typedefs
      68, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        38,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f44), 
        ACE_NTOHL (0x6179734f), 
        ACE_NTOHL (0x66576565), 
        ACE_NTOHL (0x6b3a312e), 
        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/DaysOfWeek:1.0
                11,
        ACE_NTOHL (0x44617973), 
        ACE_NTOHL (0x4f665765), 
        ACE_NTOHL (0x656b0000),  // name = DaysOfWeek
                CORBA::tk_ushort,


      10,
      ACE_NTOHL (0x696e7465), 
      ACE_NTOHL (0x7276616c), 
      ACE_NTOHL (0x73000000),  // name = intervals
            CORBA::tk_alias, // typecode kind for typedefs
      396, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        42,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f49), 
        ACE_NTOHL (0x6e746572), 
        ACE_NTOHL (0x76616c73), 
        ACE_NTOHL (0x4f664461), 
        ACE_NTOHL (0x793a312e), 
        ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/IntervalsOfDay:1.0
                15,
        ACE_NTOHL (0x496e7465), 
        ACE_NTOHL (0x7276616c), 
        ACE_NTOHL (0x734f6644), 
        ACE_NTOHL (0x61790000),  // name = IntervalsOfDay
                CORBA::tk_sequence, // typecode kind
        316, // encapsulation length
          TAO_ENCAP_BYTE_ORDER, // byte order
          CORBA::tk_struct, // typecode kind
          300, // encapsulation length
            TAO_ENCAP_BYTE_ORDER, // byte order
            42,
            ACE_NTOHL (0x49444c3a), 
            ACE_NTOHL (0x6f6d672e), 
            ACE_NTOHL (0x6f72672f), 
            ACE_NTOHL (0x44734c6f), 
            ACE_NTOHL (0x6741646d), 
            ACE_NTOHL (0x696e2f54), 
            ACE_NTOHL (0x696d6532), 
            ACE_NTOHL (0x34496e74), 
            ACE_NTOHL (0x65727661), 
            ACE_NTOHL (0x6c3a312e), 
            ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24Interval:1.0
                        15,
            ACE_NTOHL (0x54696d65), 
            ACE_NTOHL (0x3234496e), 
            ACE_NTOHL (0x74657276), 
            ACE_NTOHL (0x616c0000),  // name = Time24Interval
            2, // member count
                        6,
            ACE_NTOHL (0x73746172), 
            ACE_NTOHL (0x74000000),  // name = start
                        CORBA::tk_struct, // typecode kind
            92, // encapsulation length
              TAO_ENCAP_BYTE_ORDER, // byte order
              34,
              ACE_NTOHL (0x49444c3a), 
              ACE_NTOHL (0x6f6d672e), 
              ACE_NTOHL (0x6f72672f), 
              ACE_NTOHL (0x44734c6f), 
              ACE_NTOHL (0x6741646d), 
              ACE_NTOHL (0x696e2f54), 
              ACE_NTOHL (0x696d6532), 
              ACE_NTOHL (0x343a312e), 
              ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
                            7,
              ACE_NTOHL (0x54696d65), 
              ACE_NTOHL (0x32340000),  // name = Time24
              2, // member count
                            5,
              ACE_NTOHL (0x686f7572), 
              ACE_NTOHL (0x0),  // name = hour
                            CORBA::tk_ushort,

              7,
              ACE_NTOHL (0x6d696e75), 
              ACE_NTOHL (0x74650000),  // name = minute
                            CORBA::tk_ushort,


            5,
            ACE_NTOHL (0x73746f70), 
            ACE_NTOHL (0x0),  // name = stop
                        CORBA::tk_struct, // typecode kind
            92, // encapsulation length
              TAO_ENCAP_BYTE_ORDER, // byte order
              34,
              ACE_NTOHL (0x49444c3a), 
              ACE_NTOHL (0x6f6d672e), 
              ACE_NTOHL (0x6f72672f), 
              ACE_NTOHL (0x44734c6f), 
              ACE_NTOHL (0x6741646d), 
              ACE_NTOHL (0x696e2f54), 
              ACE_NTOHL (0x696d6532), 
              ACE_NTOHL (0x343a312e), 
              ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/Time24:1.0
                            7,
              ACE_NTOHL (0x54696d65), 
              ACE_NTOHL (0x32340000),  // name = Time24
              2, // member count
                            5,
              ACE_NTOHL (0x686f7572), 
              ACE_NTOHL (0x0),  // name = hour
                            CORBA::tk_ushort,

              7,
              ACE_NTOHL (0x6d696e75), 
              ACE_NTOHL (0x74650000),  // name = minute
                            CORBA::tk_ushort,



          0U,



    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_WeekMask (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_WeekMask),
    (char *) &_oc_DsLogAdmin_WeekMask,
    0,
    sizeof (DsLogAdmin::WeekMask)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_WeekMask =
    &_tc_TAO_tc_DsLogAdmin_WeekMask;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_Threshold[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f54), 
  ACE_NTOHL (0x68726573), 
  ACE_NTOHL (0x686f6c64), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/Threshold:1.0
    10,
  ACE_NTOHL (0x54687265), 
  ACE_NTOHL (0x73686f6c), 
  ACE_NTOHL (0x64000000),  // name = Threshold
    CORBA::tk_ushort,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_Threshold (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_Threshold),
    (char *) &_oc_DsLogAdmin_Threshold,
    0,
    sizeof (DsLogAdmin::Threshold)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_Threshold =
    &_tc_TAO_tc_DsLogAdmin_Threshold;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_CAPACITYALARMTHRESHOLDLIST_CS_)
#define _DSLOGADMIN_CAPACITYALARMTHRESHOLDLIST_CS_

DsLogAdmin::CapacityAlarmThresholdList::CapacityAlarmThresholdList (void)
{}

DsLogAdmin::CapacityAlarmThresholdList::CapacityAlarmThresholdList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::Threshold
      >
    (max)
{}

DsLogAdmin::CapacityAlarmThresholdList::CapacityAlarmThresholdList (
    CORBA::ULong max,
    CORBA::ULong length,
    CORBA::UShort * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::Threshold
      >
    (max, length, buffer, release)
{}

DsLogAdmin::CapacityAlarmThresholdList::CapacityAlarmThresholdList (
    const CapacityAlarmThresholdList &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::Threshold
      >
    (seq)
{}

DsLogAdmin::CapacityAlarmThresholdList::~CapacityAlarmThresholdList (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_CapacityAlarmThresholdList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  54,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f43), 
  ACE_NTOHL (0x61706163), 
  ACE_NTOHL (0x69747941), 
  ACE_NTOHL (0x6c61726d), 
  ACE_NTOHL (0x54687265), 
  ACE_NTOHL (0x73686f6c), 
  ACE_NTOHL (0x644c6973), 
  ACE_NTOHL (0x743a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/CapacityAlarmThresholdList:1.0
    27,
  ACE_NTOHL (0x43617061), 
  ACE_NTOHL (0x63697479), 
  ACE_NTOHL (0x416c6172), 
  ACE_NTOHL (0x6d546872), 
  ACE_NTOHL (0x6573686f), 
  ACE_NTOHL (0x6c644c69), 
  ACE_NTOHL (0x73740000),  // name = CapacityAlarmThresholdList
    CORBA::tk_sequence, // typecode kind
  84, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_alias, // typecode kind for typedefs
    68, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      37,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f54), 
      ACE_NTOHL (0x68726573), 
      ACE_NTOHL (0x686f6c64), 
      ACE_NTOHL (0x3a312e30), 
      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/Threshold:1.0
            10,
      ACE_NTOHL (0x54687265), 
      ACE_NTOHL (0x73686f6c), 
      ACE_NTOHL (0x64000000),  // name = Threshold
            CORBA::tk_ushort,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_CapacityAlarmThresholdList (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_CapacityAlarmThresholdList),
    (char *) &_oc_DsLogAdmin_CapacityAlarmThresholdList,
    0,
    sizeof (DsLogAdmin::CapacityAlarmThresholdList)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_CapacityAlarmThresholdList =
    &_tc_TAO_tc_DsLogAdmin_CapacityAlarmThresholdList;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_OperationalState[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  44,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4f), 
  ACE_NTOHL (0x70657261), 
  ACE_NTOHL (0x74696f6e), 
  ACE_NTOHL (0x616c5374), 
  ACE_NTOHL (0x6174653a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/OperationalState:1.0
  17,
  ACE_NTOHL (0x4f706572), 
  ACE_NTOHL (0x6174696f), 
  ACE_NTOHL (0x6e616c53), 
  ACE_NTOHL (0x74617465), 
  ACE_NTOHL (0x0),  // name = OperationalState
  2, // member count
  9,
  ACE_NTOHL (0x64697361), 
  ACE_NTOHL (0x626c6564), 
  ACE_NTOHL (0x0),  // name = disabled
  8,
  ACE_NTOHL (0x656e6162), 
  ACE_NTOHL (0x6c656400),  // name = enabled
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_OperationalState (
    CORBA::tk_enum,
    sizeof (_oc_DsLogAdmin_OperationalState),
    (char *) &_oc_DsLogAdmin_OperationalState,
    0,
    sizeof (DsLogAdmin::OperationalState)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_OperationalState =
    &_tc_TAO_tc_DsLogAdmin_OperationalState;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_AdministrativeState[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  47,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f41), 
  ACE_NTOHL (0x646d696e), 
  ACE_NTOHL (0x69737472), 
  ACE_NTOHL (0x61746976), 
  ACE_NTOHL (0x65537461), 
  ACE_NTOHL (0x74653a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/AdministrativeState:1.0
  20,
  ACE_NTOHL (0x41646d69), 
  ACE_NTOHL (0x6e697374), 
  ACE_NTOHL (0x72617469), 
  ACE_NTOHL (0x76655374), 
  ACE_NTOHL (0x61746500),  // name = AdministrativeState
  2, // member count
  7,
  ACE_NTOHL (0x6c6f636b), 
  ACE_NTOHL (0x65640000),  // name = locked
  9,
  ACE_NTOHL (0x756e6c6f), 
  ACE_NTOHL (0x636b6564), 
  ACE_NTOHL (0x0),  // name = unlocked
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_AdministrativeState (
    CORBA::tk_enum,
    sizeof (_oc_DsLogAdmin_AdministrativeState),
    (char *) &_oc_DsLogAdmin_AdministrativeState,
    0,
    sizeof (DsLogAdmin::AdministrativeState)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_AdministrativeState =
    &_tc_TAO_tc_DsLogAdmin_AdministrativeState;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_ForwardingState[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  43,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f46), 
  ACE_NTOHL (0x6f727761), 
  ACE_NTOHL (0x7264696e), 
  ACE_NTOHL (0x67537461), 
  ACE_NTOHL (0x74653a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/ForwardingState:1.0
  16,
  ACE_NTOHL (0x466f7277), 
  ACE_NTOHL (0x61726469), 
  ACE_NTOHL (0x6e675374), 
  ACE_NTOHL (0x61746500),  // name = ForwardingState
  2, // member count
  3,
  ACE_NTOHL (0x6f6e0000),  // name = on
  4,
  ACE_NTOHL (0x6f666600),  // name = off
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_ForwardingState (
    CORBA::tk_enum,
    sizeof (_oc_DsLogAdmin_ForwardingState),
    (char *) &_oc_DsLogAdmin_ForwardingState,
    0,
    sizeof (DsLogAdmin::ForwardingState)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_ForwardingState =
    &_tc_TAO_tc_DsLogAdmin_ForwardingState;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_QoSType[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  35,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f51), 
  ACE_NTOHL (0x6f535479), 
  ACE_NTOHL (0x70653a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/QoSType:1.0
    8,
  ACE_NTOHL (0x516f5354), 
  ACE_NTOHL (0x79706500),  // name = QoSType
    CORBA::tk_ushort,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_QoSType (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_QoSType),
    (char *) &_oc_DsLogAdmin_QoSType,
    0,
    sizeof (DsLogAdmin::QoSType)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_QoSType =
    &_tc_TAO_tc_DsLogAdmin_QoSType;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_QOSLIST_CS_)
#define _DSLOGADMIN_QOSLIST_CS_

DsLogAdmin::QoSList::QoSList (void)
{}

DsLogAdmin::QoSList::QoSList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::QoSType
      >
    (max)
{}

DsLogAdmin::QoSList::QoSList (
    CORBA::ULong max,
    CORBA::ULong length,
    CORBA::UShort * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::QoSType
      >
    (max, length, buffer, release)
{}

DsLogAdmin::QoSList::QoSList (
    const QoSList &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::QoSType
      >
    (seq)
{}

DsLogAdmin::QoSList::~QoSList (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_QoSList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  35,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f51), 
  ACE_NTOHL (0x6f534c69), 
  ACE_NTOHL (0x73743a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/QoSList:1.0
    8,
  ACE_NTOHL (0x516f534c), 
  ACE_NTOHL (0x69737400),  // name = QoSList
    CORBA::tk_sequence, // typecode kind
  76, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_alias, // typecode kind for typedefs
    60, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      35,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f51), 
      ACE_NTOHL (0x6f535479), 
      ACE_NTOHL (0x70653a31), 
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/QoSType:1.0
            8,
      ACE_NTOHL (0x516f5354), 
      ACE_NTOHL (0x79706500),  // name = QoSType
            CORBA::tk_ushort,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_QoSList (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_QoSList),
    (char *) &_oc_DsLogAdmin_QoSList,
    0,
    sizeof (DsLogAdmin::QoSList)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_QoSList =
    &_tc_TAO_tc_DsLogAdmin_QoSList;
}

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

DsLogAdmin::UnsupportedQoS::UnsupportedQoS (void)
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/UnsupportedQoS:1.0",
        "UnsupportedQoS"
      )
{
}

DsLogAdmin::UnsupportedQoS::~UnsupportedQoS (void)
{
}

DsLogAdmin::UnsupportedQoS::UnsupportedQoS (const ::DsLogAdmin::UnsupportedQoS &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
  this->denied = _tao_excp.denied;
}

DsLogAdmin::UnsupportedQoS&
DsLogAdmin::UnsupportedQoS::operator= (const ::DsLogAdmin::UnsupportedQoS &_tao_excp)
{
  this->ACE_NESTED_CLASS (CORBA, UserException)::operator= (_tao_excp);
  this->denied = _tao_excp.denied;
  return *this;
}

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

DsLogAdmin::UnsupportedQoS *
DsLogAdmin::UnsupportedQoS::_downcast (CORBA::Exception *_tao_excp)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DsLogAdmin/UnsupportedQoS:1.0", _tao_excp->_rep_id ()))
    {
      return dynamic_cast<UnsupportedQoS *> (_tao_excp);
    }
  else
    {
      return 0;
    }
}

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

CORBA::Exception *
DsLogAdmin::UnsupportedQoS::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      ::DsLogAdmin::UnsupportedQoS (*this),
      0
    );
  return result;
}

void DsLogAdmin::UnsupportedQoS::_raise (void) const
{
  TAO_RAISE (*this);
}

void DsLogAdmin::UnsupportedQoS::_tao_encode (
    TAO_OutputCDR &cdr
    ACE_ENV_ARG_DECL
  ) const
{
  if (cdr << *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}

void DsLogAdmin::UnsupportedQoS::_tao_decode (
    TAO_InputCDR &cdr
    ACE_ENV_ARG_DECL
  )
{
  if (cdr >> *this)
    {
      return;
    }
  
  ACE_THROW (CORBA::MARSHAL ());
}



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

DsLogAdmin::UnsupportedQoS::UnsupportedQoS (
    const DsLogAdmin::QoSList & _tao_denied
  )
  : CORBA::UserException (
        "IDL:omg.org/DsLogAdmin/UnsupportedQoS:1.0",
        "UnsupportedQoS"
      )
{
  this->denied = _tao_denied;
}

// TAO extension - the virtual _type method.
CORBA::TypeCode_ptr DsLogAdmin::UnsupportedQoS::_type (void) const
{
  return ::DsLogAdmin::_tc_UnsupportedQoS;
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_UnsupportedQoS[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  42,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f55), 
  ACE_NTOHL (0x6e737570), 
  ACE_NTOHL (0x706f7274), 
  ACE_NTOHL (0x6564516f), 
  ACE_NTOHL (0x533a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/UnsupportedQoS:1.0
    15,
  ACE_NTOHL (0x556e7375), 
  ACE_NTOHL (0x70706f72), 
  ACE_NTOHL (0x74656451), 
  ACE_NTOHL (0x6f530000),  // name = UnsupportedQoS
  1, // member count
    7,
  ACE_NTOHL (0x64656e69), 
  ACE_NTOHL (0x65640000),  // name = denied
    CORBA::tk_alias, // typecode kind for typedefs
  140, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    35,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44734c6f), 
    ACE_NTOHL (0x6741646d), 
    ACE_NTOHL (0x696e2f51), 
    ACE_NTOHL (0x6f534c69), 
    ACE_NTOHL (0x73743a31), 
    ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/QoSList:1.0
        8,
    ACE_NTOHL (0x516f534c), 
    ACE_NTOHL (0x69737400),  // name = QoSList
        CORBA::tk_sequence, // typecode kind
    76, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      CORBA::tk_alias, // typecode kind for typedefs
      60, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        35,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44734c6f), 
        ACE_NTOHL (0x6741646d), 
        ACE_NTOHL (0x696e2f51), 
        ACE_NTOHL (0x6f535479), 
        ACE_NTOHL (0x70653a31), 
        ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/QoSType:1.0
                8,
        ACE_NTOHL (0x516f5354), 
        ACE_NTOHL (0x79706500),  // name = QoSType
                CORBA::tk_ushort,


      0U,


};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_UnsupportedQoS (
    CORBA::tk_except,
    sizeof (_oc_DsLogAdmin_UnsupportedQoS),
    (char *) &_oc_DsLogAdmin_UnsupportedQoS,
    0,
    sizeof (DsLogAdmin::UnsupportedQoS)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_UnsupportedQoS =
    &_tc_TAO_tc_DsLogAdmin_UnsupportedQoS;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:60

// Traits specializations for DsLogAdmin::Log.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::Log_ptr
TAO::Objref_Traits<DsLogAdmin::Log>::tao_duplicate (
    DsLogAdmin::Log_ptr p
  )
{
  return DsLogAdmin::Log::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<DsLogAdmin::Log>::tao_release (
    DsLogAdmin::Log_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::Log_ptr
TAO::Objref_Traits<DsLogAdmin::Log>::tao_nil (void)
{
  return DsLogAdmin::Log::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<DsLogAdmin::Log>::tao_marshal (
    DsLogAdmin::Log_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*DsLogAdmin__TAO_Log_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::LogMgr_ptr DsLogAdmin::Log::my_factory (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::LogMgr>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "my_factory",
      10,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

DsLogAdmin::LogId DsLogAdmin::Log::id (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< DsLogAdmin::LogId>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "id",
      2,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::QoSList * DsLogAdmin::Log::get_log_qos (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::QoSList>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_log_qos",
      11,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_log_qos (
    const ::DsLogAdmin::QoSList & qos
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::UnsupportedQoS
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::QoSList>::in_arg_val _tao_qos (qos);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_qos
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_log_qos_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/UnsupportedQoS:1.0",
        DsLogAdmin::UnsupportedQoS::_alloc,
        DsLogAdmin::_tc_UnsupportedQoS
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_log_qos",
      11,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_log_qos_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULong DsLogAdmin::Log::get_max_record_life (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULong>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_max_record_life",
      19,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_max_record_life (
    ::CORBA::ULong life
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< CORBA::ULong>::in_arg_val _tao_life (life);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_life
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_max_record_life",
      19,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULongLong DsLogAdmin::Log::get_max_size (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULongLong>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_max_size",
      12,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_max_size (
    ::CORBA::ULongLong size
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidParam
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< CORBA::ULongLong>::in_arg_val _tao_size (size);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_size
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_max_size_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidParam:1.0",
        DsLogAdmin::InvalidParam::_alloc,
        DsLogAdmin::_tc_InvalidParam
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_max_size",
      12,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_max_size_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULongLong DsLogAdmin::Log::get_current_size (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULongLong>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_current_size",
      16,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULongLong DsLogAdmin::Log::get_n_records (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULongLong>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_n_records",
      13,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

DsLogAdmin::LogFullActionType DsLogAdmin::Log::get_log_full_action (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< DsLogAdmin::LogFullActionType>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_log_full_action",
      19,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_log_full_action (
    ::DsLogAdmin::LogFullActionType action
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidLogFullAction
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::LogFullActionType>::in_arg_val _tao_action (action);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_action
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_log_full_action_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidLogFullAction:1.0",
        DsLogAdmin::InvalidLogFullAction::_alloc,
        DsLogAdmin::_tc_InvalidLogFullAction
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_log_full_action",
      19,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_log_full_action_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::AdministrativeState DsLogAdmin::Log::get_administrative_state (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::AdministrativeState>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_administrative_state",
      24,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_administrative_state (
    ::DsLogAdmin::AdministrativeState state
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::AdministrativeState>::in_arg_val _tao_state (state);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_state
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_administrative_state",
      24,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::ForwardingState DsLogAdmin::Log::get_forwarding_state (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::ForwardingState>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_forwarding_state",
      20,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_forwarding_state (
    ::DsLogAdmin::ForwardingState state
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::ForwardingState>::in_arg_val _tao_state (state);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_state
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_forwarding_state",
      20,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::OperationalState DsLogAdmin::Log::get_operational_state (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::OperationalState>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_operational_state",
      21,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::TimeInterval DsLogAdmin::Log::get_interval (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::TimeInterval>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_interval",
      12,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_interval (
    const ::DsLogAdmin::TimeInterval & interval
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidTime,
    ::DsLogAdmin::InvalidTimeInterval
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::TimeInterval>::in_arg_val _tao_interval (interval);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_interval
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_interval_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidTime:1.0",
        DsLogAdmin::InvalidTime::_alloc,
        DsLogAdmin::_tc_InvalidTime
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidTimeInterval:1.0",
        DsLogAdmin::InvalidTimeInterval::_alloc,
        DsLogAdmin::_tc_InvalidTimeInterval
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_interval",
      12,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_interval_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::AvailabilityStatus DsLogAdmin::Log::get_availability_status (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::AvailabilityStatus>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_availability_status",
      23,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::CapacityAlarmThresholdList * DsLogAdmin::Log::get_capacity_alarm_thresholds (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::CapacityAlarmThresholdList>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_capacity_alarm_thresholds",
      29,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_capacity_alarm_thresholds (
    const ::DsLogAdmin::CapacityAlarmThresholdList & threshs
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidThreshold
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::CapacityAlarmThresholdList>::in_arg_val _tao_threshs (threshs);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_threshs
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_capacity_alarm_thresholds_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidThreshold:1.0",
        DsLogAdmin::InvalidThreshold::_alloc,
        DsLogAdmin::_tc_InvalidThreshold
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_capacity_alarm_thresholds",
      29,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_capacity_alarm_thresholds_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::WeekMask * DsLogAdmin::Log::get_week_mask (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::WeekMask>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "get_week_mask",
      13,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_week_mask (
    const ::DsLogAdmin::WeekMask & masks
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidTime,
    ::DsLogAdmin::InvalidTimeInterval,
    ::DsLogAdmin::InvalidMask
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::WeekMask>::in_arg_val _tao_masks (masks);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_masks
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_week_mask_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidTime:1.0",
        DsLogAdmin::InvalidTime::_alloc,
        DsLogAdmin::_tc_InvalidTime
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidTimeInterval:1.0",
        DsLogAdmin::InvalidTimeInterval::_alloc,
        DsLogAdmin::_tc_InvalidTimeInterval
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidMask:1.0",
        DsLogAdmin::InvalidMask::_alloc,
        DsLogAdmin::_tc_InvalidMask
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "set_week_mask",
      13,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_week_mask_exceptiondata,
      3
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::RecordList * DsLogAdmin::Log::query (
    const char * grammar,
    const char * c,
    ::DsLogAdmin::Iterator_out i
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidGrammar,
    ::DsLogAdmin::InvalidConstraint
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::RecordList>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val _tao_grammar (grammar);
  TAO::Arg_Traits< ::DsLogAdmin::Constraint>::in_arg_val _tao_c (c);
  TAO::Arg_Traits< ::DsLogAdmin::Iterator>::out_arg_val _tao_i (i);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_grammar,
      &_tao_c,
      &_tao_i
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_query_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidGrammar:1.0",
        DsLogAdmin::InvalidGrammar::_alloc,
        DsLogAdmin::_tc_InvalidGrammar
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidConstraint:1.0",
        DsLogAdmin::InvalidConstraint::_alloc,
        DsLogAdmin::_tc_InvalidConstraint
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      4,
      "query",
      5,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_query_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::RecordList * DsLogAdmin::Log::retrieve (
    ::DsLogAdmin::TimeT from_time,
    ::CORBA::Long how_many,
    ::DsLogAdmin::Iterator_out i
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::RecordList>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::TimeT>::in_arg_val _tao_from_time (from_time);
  TAO::Arg_Traits< CORBA::Long>::in_arg_val _tao_how_many (how_many);
  TAO::Arg_Traits< ::DsLogAdmin::Iterator>::out_arg_val _tao_i (i);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_from_time,
      &_tao_how_many,
      &_tao_i
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      4,
      "retrieve",
      8,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULong DsLogAdmin::Log::match (
    const char * grammar,
    const char * c
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidGrammar,
    ::DsLogAdmin::InvalidConstraint
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULong>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val _tao_grammar (grammar);
  TAO::Arg_Traits< ::DsLogAdmin::Constraint>::in_arg_val _tao_c (c);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_grammar,
      &_tao_c
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_match_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidGrammar:1.0",
        DsLogAdmin::InvalidGrammar::_alloc,
        DsLogAdmin::_tc_InvalidGrammar
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidConstraint:1.0",
        DsLogAdmin::InvalidConstraint::_alloc,
        DsLogAdmin::_tc_InvalidConstraint
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "match",
      5,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_match_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULong DsLogAdmin::Log::delete_records (
    const char * grammar,
    const char * c
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidGrammar,
    ::DsLogAdmin::InvalidConstraint
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULong>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val _tao_grammar (grammar);
  TAO::Arg_Traits< ::DsLogAdmin::Constraint>::in_arg_val _tao_c (c);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_grammar,
      &_tao_c
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_delete_records_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidGrammar:1.0",
        DsLogAdmin::InvalidGrammar::_alloc,
        DsLogAdmin::_tc_InvalidGrammar
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidConstraint:1.0",
        DsLogAdmin::InvalidConstraint::_alloc,
        DsLogAdmin::_tc_InvalidConstraint
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "delete_records",
      14,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_delete_records_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULong DsLogAdmin::Log::delete_records_by_id (
    const ::DsLogAdmin::RecordIdList & ids
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULong>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::RecordIdList>::in_arg_val _tao_ids (ids);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_ids
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "delete_records_by_id",
      20,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::write_records (
    const ::DsLogAdmin::Anys & records
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::LogFull,
    ::DsLogAdmin::LogOffDuty,
    ::DsLogAdmin::LogLocked,
    ::DsLogAdmin::LogDisabled
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::Anys>::in_arg_val _tao_records (records);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_records
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_write_records_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/LogFull:1.0",
        DsLogAdmin::LogFull::_alloc,
        DsLogAdmin::_tc_LogFull
      },
      
      {
        "IDL:omg.org/DsLogAdmin/LogOffDuty:1.0",
        DsLogAdmin::LogOffDuty::_alloc,
        DsLogAdmin::_tc_LogOffDuty
      },
      
      {
        "IDL:omg.org/DsLogAdmin/LogLocked:1.0",
        DsLogAdmin::LogLocked::_alloc,
        DsLogAdmin::_tc_LogLocked
      },
      
      {
        "IDL:omg.org/DsLogAdmin/LogDisabled:1.0",
        DsLogAdmin::LogDisabled::_alloc,
        DsLogAdmin::_tc_LogDisabled
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "write_records",
      13,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_write_records_exceptiondata,
      4
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::write_recordlist (
    const ::DsLogAdmin::RecordList & list
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::LogFull,
    ::DsLogAdmin::LogOffDuty,
    ::DsLogAdmin::LogLocked,
    ::DsLogAdmin::LogDisabled
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::DsLogAdmin::RecordList>::in_arg_val _tao_list (list);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_list
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_write_recordlist_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/LogFull:1.0",
        DsLogAdmin::LogFull::_alloc,
        DsLogAdmin::_tc_LogFull
      },
      
      {
        "IDL:omg.org/DsLogAdmin/LogOffDuty:1.0",
        DsLogAdmin::LogOffDuty::_alloc,
        DsLogAdmin::_tc_LogOffDuty
      },
      
      {
        "IDL:omg.org/DsLogAdmin/LogLocked:1.0",
        DsLogAdmin::LogLocked::_alloc,
        DsLogAdmin::_tc_LogLocked
      },
      
      {
        "IDL:omg.org/DsLogAdmin/LogDisabled:1.0",
        DsLogAdmin::LogDisabled::_alloc,
        DsLogAdmin::_tc_LogDisabled
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "write_recordlist",
      16,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_write_recordlist_exceptiondata,
      4
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::set_record_attribute (
    ::DsLogAdmin::RecordId id,
    const ::DsLogAdmin::NVList & attr_list
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidRecordId,
    ::DsLogAdmin::InvalidAttribute
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::RecordId>::in_arg_val _tao_id (id);
  TAO::Arg_Traits< ::DsLogAdmin::NVList>::in_arg_val _tao_attr_list (attr_list);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_id,
      &_tao_attr_list
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_record_attribute_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidRecordId:1.0",
        DsLogAdmin::InvalidRecordId::_alloc,
        DsLogAdmin::_tc_InvalidRecordId
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidAttribute:1.0",
        DsLogAdmin::InvalidAttribute::_alloc,
        DsLogAdmin::_tc_InvalidAttribute
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      3,
      "set_record_attribute",
      20,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_record_attribute_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

CORBA::ULong DsLogAdmin::Log::set_records_attribute (
    const char * grammar,
    const char * c,
    const ::DsLogAdmin::NVList & attr_list
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidGrammar,
    ::DsLogAdmin::InvalidConstraint,
    ::DsLogAdmin::InvalidAttribute
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< CORBA::ULong>::ret_val _tao_retval;
  TAO::Arg_Traits< ::CORBA::Char *>::in_arg_val _tao_grammar (grammar);
  TAO::Arg_Traits< ::DsLogAdmin::Constraint>::in_arg_val _tao_c (c);
  TAO::Arg_Traits< ::DsLogAdmin::NVList>::in_arg_val _tao_attr_list (attr_list);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_grammar,
      &_tao_c,
      &_tao_attr_list
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_set_records_attribute_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidGrammar:1.0",
        DsLogAdmin::InvalidGrammar::_alloc,
        DsLogAdmin::_tc_InvalidGrammar
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidConstraint:1.0",
        DsLogAdmin::InvalidConstraint::_alloc,
        DsLogAdmin::_tc_InvalidConstraint
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidAttribute:1.0",
        DsLogAdmin::InvalidAttribute::_alloc,
        DsLogAdmin::_tc_InvalidAttribute
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      4,
      "set_records_attribute",
      21,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_set_records_attribute_exceptiondata,
      3
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::NVList * DsLogAdmin::Log::get_record_attribute (
    ::DsLogAdmin::RecordId id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidRecordId
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::NVList>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::RecordId>::in_arg_val _tao_id (id);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_id
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_get_record_attribute_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidRecordId:1.0",
        DsLogAdmin::InvalidRecordId::_alloc,
        DsLogAdmin::_tc_InvalidRecordId
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "get_record_attribute",
      20,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_get_record_attribute_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::Log_ptr DsLogAdmin::Log::copy (
    ::DsLogAdmin::LogId_out id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::Log>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::LogId>::out_arg_val _tao_id (id);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_id
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "copy",
      4,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::Log_ptr DsLogAdmin::Log::copy_with_id (
    ::DsLogAdmin::LogId id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::LogIdAlreadyExists
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::Log>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::LogId>::in_arg_val _tao_id (id);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_id
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_copy_with_id_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/LogIdAlreadyExists:1.0",
        DsLogAdmin::LogIdAlreadyExists::_alloc,
        DsLogAdmin::_tc_LogIdAlreadyExists
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "copy_with_id",
      12,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_copy_with_id_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::Log::flush (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::UnsupportedQoS
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_Log_Proxy_Broker_ == 0)
    {
      DsLogAdmin_Log_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_Log_flush_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/UnsupportedQoS:1.0",
        DsLogAdmin::UnsupportedQoS::_alloc,
        DsLogAdmin::_tc_UnsupportedQoS
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "flush",
      5,
      this->the_TAO_Log_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_Log_flush_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK;
}

DsLogAdmin::Log::Log (void)
 : the_TAO_Log_Proxy_Broker_ (0)
{
  this->DsLogAdmin_Log_setup_collocation ();
}

void
DsLogAdmin::Log::DsLogAdmin_Log_setup_collocation ()
{
  if (::DsLogAdmin__TAO_Log_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_Log_Proxy_Broker_ =
        ::DsLogAdmin__TAO_Log_Proxy_Broker_Factory_function_pointer (this);
    }
}

DsLogAdmin::Log::~Log (void)
{}

void 
DsLogAdmin::Log::_tao_any_destructor (void *_tao_void_pointer)
{
  Log *_tao_tmp_pointer =
    static_cast<Log *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

DsLogAdmin::Log_ptr
DsLogAdmin::Log::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<Log>::narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/Log:1.0",
        DsLogAdmin__TAO_Log_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::Log_ptr
DsLogAdmin::Log::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<Log>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/Log:1.0",
        DsLogAdmin__TAO_Log_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::Log_ptr
DsLogAdmin::Log::_duplicate (Log_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
DsLogAdmin::Log::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/Log:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

const char* DsLogAdmin::Log::_interface_repository_id (void) const
{
  return "IDL:omg.org/DsLogAdmin/Log:1.0";
}

CORBA::Boolean
DsLogAdmin::Log::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_Log[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  31,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f673a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/Log:1.0
    4,
  ACE_NTOHL (0x4c6f6700),  // name = Log
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_Log (
    CORBA::tk_objref,
    sizeof (_oc_DsLogAdmin_Log),
    (char *) &_oc_DsLogAdmin_Log,
    0,
    sizeof (DsLogAdmin::Log)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_Log =
    &_tc_TAO_tc_DsLogAdmin_Log;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:60

// Traits specializations for DsLogAdmin::BasicLog.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::BasicLog_ptr
TAO::Objref_Traits<DsLogAdmin::BasicLog>::tao_duplicate (
    DsLogAdmin::BasicLog_ptr p
  )
{
  return DsLogAdmin::BasicLog::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<DsLogAdmin::BasicLog>::tao_release (
    DsLogAdmin::BasicLog_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::BasicLog_ptr
TAO::Objref_Traits<DsLogAdmin::BasicLog>::tao_nil (void)
{
  return DsLogAdmin::BasicLog::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<DsLogAdmin::BasicLog>::tao_marshal (
    DsLogAdmin::BasicLog_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*DsLogAdmin__TAO_BasicLog_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

void DsLogAdmin::BasicLog::destroy (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_BasicLog_Proxy_Broker_ == 0)
    {
      DsLogAdmin_BasicLog_setup_collocation ();
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "destroy",
      7,
      this->the_TAO_BasicLog_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

DsLogAdmin::BasicLog::BasicLog (void)
 : the_TAO_BasicLog_Proxy_Broker_ (0)
{
  this->DsLogAdmin_BasicLog_setup_collocation ();
}

void
DsLogAdmin::BasicLog::DsLogAdmin_BasicLog_setup_collocation ()
{
  if (::DsLogAdmin__TAO_BasicLog_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_BasicLog_Proxy_Broker_ =
        ::DsLogAdmin__TAO_BasicLog_Proxy_Broker_Factory_function_pointer (this);
    }
  
  this->DsLogAdmin_Log_setup_collocation ();
}

DsLogAdmin::BasicLog::~BasicLog (void)
{}

void 
DsLogAdmin::BasicLog::_tao_any_destructor (void *_tao_void_pointer)
{
  BasicLog *_tao_tmp_pointer =
    static_cast<BasicLog *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

DsLogAdmin::BasicLog_ptr
DsLogAdmin::BasicLog::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<BasicLog>::narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/BasicLog:1.0",
        DsLogAdmin__TAO_BasicLog_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::BasicLog_ptr
DsLogAdmin::BasicLog::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<BasicLog>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/BasicLog:1.0",
        DsLogAdmin__TAO_BasicLog_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::BasicLog_ptr
DsLogAdmin::BasicLog::_duplicate (BasicLog_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
DsLogAdmin::BasicLog::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/Log:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/BasicLog:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

const char* DsLogAdmin::BasicLog::_interface_repository_id (void) const
{
  return "IDL:omg.org/DsLogAdmin/BasicLog:1.0";
}

CORBA::Boolean
DsLogAdmin::BasicLog::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_BasicLog[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  36,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f42), 
  ACE_NTOHL (0x61736963), 
  ACE_NTOHL (0x4c6f673a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DsLogAdmin/BasicLog:1.0
    9,
  ACE_NTOHL (0x42617369), 
  ACE_NTOHL (0x634c6f67), 
  ACE_NTOHL (0x0),  // name = BasicLog
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_BasicLog (
    CORBA::tk_objref,
    sizeof (_oc_DsLogAdmin_BasicLog),
    (char *) &_oc_DsLogAdmin_BasicLog,
    0,
    sizeof (DsLogAdmin::BasicLog)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_BasicLog =
    &_tc_TAO_tc_DsLogAdmin_BasicLog;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_LOGLIST_CS_)
#define _DSLOGADMIN_LOGLIST_CS_

DsLogAdmin::LogList::LogList (void)
{}

DsLogAdmin::LogList::LogList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Object_Sequence<
        DsLogAdmin::Log,
        DsLogAdmin::Log_var
      >
    (max)
{}

DsLogAdmin::LogList::LogList (
    CORBA::ULong max,
    CORBA::ULong length,
    DsLogAdmin::Log_ptr * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Object_Sequence<
        DsLogAdmin::Log,
        DsLogAdmin::Log_var
      >
    (max, length, buffer, release)
{}

DsLogAdmin::LogList::LogList (
    const LogList &seq
  )
  : TAO_Unbounded_Object_Sequence<
        DsLogAdmin::Log,
        DsLogAdmin::Log_var
      >
    (seq)
{}

DsLogAdmin::LogList::~LogList (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  35,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674c69), 
  ACE_NTOHL (0x73743a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/LogList:1.0
    8,
  ACE_NTOHL (0x4c6f674c), 
  ACE_NTOHL (0x69737400),  // name = LogList
    CORBA::tk_sequence, // typecode kind
  64, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_objref, // typecode kind
    48, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      31,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f4c), 
      ACE_NTOHL (0x6f673a31), 
      ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/Log:1.0
            4,
      ACE_NTOHL (0x4c6f6700),  // name = Log
      
    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogList (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_LogList),
    (char *) &_oc_DsLogAdmin_LogList,
    0,
    sizeof (DsLogAdmin::LogList)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogList =
    &_tc_TAO_tc_DsLogAdmin_LogList;
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/sequence_cs.cpp:65

#if !defined (_DSLOGADMIN_LOGIDLIST_CS_)
#define _DSLOGADMIN_LOGIDLIST_CS_

DsLogAdmin::LogIdList::LogIdList (void)
{}

DsLogAdmin::LogIdList::LogIdList (
    CORBA::ULong max
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::LogId
      >
    (max)
{}

DsLogAdmin::LogIdList::LogIdList (
    CORBA::ULong max,
    CORBA::ULong length,
    CORBA::ULong * buffer,
    CORBA::Boolean release
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::LogId
      >
    (max, length, buffer, release)
{}

DsLogAdmin::LogIdList::LogIdList (
    const LogIdList &seq
  )
  : TAO_Unbounded_Sequence<
        DsLogAdmin::LogId
      >
    (seq)
{}

DsLogAdmin::LogIdList::~LogIdList (void)
{}

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

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogIdList[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674964), 
  ACE_NTOHL (0x4c697374), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/LogIdList:1.0
    10,
  ACE_NTOHL (0x4c6f6749), 
  ACE_NTOHL (0x644c6973), 
  ACE_NTOHL (0x74000000),  // name = LogIdList
    CORBA::tk_sequence, // typecode kind
  76, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_alias, // typecode kind for typedefs
    60, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      33,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44734c6f), 
      ACE_NTOHL (0x6741646d), 
      ACE_NTOHL (0x696e2f4c), 
      ACE_NTOHL (0x6f674964), 
      ACE_NTOHL (0x3a312e30), 
      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DsLogAdmin/LogId:1.0
            6,
      ACE_NTOHL (0x4c6f6749), 
      ACE_NTOHL (0x64000000),  // name = LogId
            CORBA::tk_ulong,


    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogIdList (
    CORBA::tk_alias,
    sizeof (_oc_DsLogAdmin_LogIdList),
    (char *) &_oc_DsLogAdmin_LogIdList,
    0,
    sizeof (DsLogAdmin::LogIdList)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogIdList =
    &_tc_TAO_tc_DsLogAdmin_LogIdList;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:60

// Traits specializations for DsLogAdmin::LogMgr.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::LogMgr_ptr
TAO::Objref_Traits<DsLogAdmin::LogMgr>::tao_duplicate (
    DsLogAdmin::LogMgr_ptr p
  )
{
  return DsLogAdmin::LogMgr::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<DsLogAdmin::LogMgr>::tao_release (
    DsLogAdmin::LogMgr_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::LogMgr_ptr
TAO::Objref_Traits<DsLogAdmin::LogMgr>::tao_nil (void)
{
  return DsLogAdmin::LogMgr::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<DsLogAdmin::LogMgr>::tao_marshal (
    DsLogAdmin::LogMgr_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*DsLogAdmin__TAO_LogMgr_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::LogList * DsLogAdmin::LogMgr::list_logs (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LogMgr_Proxy_Broker_ == 0)
    {
      DsLogAdmin_LogMgr_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::LogList>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "list_logs",
      9,
      this->the_TAO_LogMgr_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::Log_ptr DsLogAdmin::LogMgr::find_log (
    ::DsLogAdmin::LogId id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LogMgr_Proxy_Broker_ == 0)
    {
      DsLogAdmin_LogMgr_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::Log>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::LogId>::in_arg_val _tao_id (id);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_id
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "find_log",
      8,
      this->the_TAO_LogMgr_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::LogIdList * DsLogAdmin::LogMgr::list_logs_by_id (
    ACE_ENV_SINGLE_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_LogMgr_Proxy_Broker_ == 0)
    {
      DsLogAdmin_LogMgr_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::LogIdList>::ret_val _tao_retval;
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      1,
      "list_logs_by_id",
      15,
      this->the_TAO_LogMgr_Proxy_Broker_
    );
  
  _tao_call.invoke (0, 0 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

DsLogAdmin::LogMgr::LogMgr (void)
 : the_TAO_LogMgr_Proxy_Broker_ (0)
{
  this->DsLogAdmin_LogMgr_setup_collocation ();
}

void
DsLogAdmin::LogMgr::DsLogAdmin_LogMgr_setup_collocation ()
{
  if (::DsLogAdmin__TAO_LogMgr_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_LogMgr_Proxy_Broker_ =
        ::DsLogAdmin__TAO_LogMgr_Proxy_Broker_Factory_function_pointer (this);
    }
}

DsLogAdmin::LogMgr::~LogMgr (void)
{}

void 
DsLogAdmin::LogMgr::_tao_any_destructor (void *_tao_void_pointer)
{
  LogMgr *_tao_tmp_pointer =
    static_cast<LogMgr *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

DsLogAdmin::LogMgr_ptr
DsLogAdmin::LogMgr::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LogMgr>::narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/LogMgr:1.0",
        DsLogAdmin__TAO_LogMgr_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::LogMgr_ptr
DsLogAdmin::LogMgr::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<LogMgr>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/LogMgr:1.0",
        DsLogAdmin__TAO_LogMgr_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::LogMgr_ptr
DsLogAdmin::LogMgr::_duplicate (LogMgr_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
DsLogAdmin::LogMgr::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/LogMgr:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

const char* DsLogAdmin::LogMgr::_interface_repository_id (void) const
{
  return "IDL:omg.org/DsLogAdmin/LogMgr:1.0";
}

CORBA::Boolean
DsLogAdmin::LogMgr::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_LogMgr[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  34,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f4c), 
  ACE_NTOHL (0x6f674d67), 
  ACE_NTOHL (0x723a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DsLogAdmin/LogMgr:1.0
    7,
  ACE_NTOHL (0x4c6f674d), 
  ACE_NTOHL (0x67720000),  // name = LogMgr
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_LogMgr (
    CORBA::tk_objref,
    sizeof (_oc_DsLogAdmin_LogMgr),
    (char *) &_oc_DsLogAdmin_LogMgr,
    0,
    sizeof (DsLogAdmin::LogMgr)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_LogMgr =
    &_tc_TAO_tc_DsLogAdmin_LogMgr;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_cs.cpp:60

// Traits specializations for DsLogAdmin::BasicLogFactory.

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::BasicLogFactory_ptr
TAO::Objref_Traits<DsLogAdmin::BasicLogFactory>::tao_duplicate (
    DsLogAdmin::BasicLogFactory_ptr p
  )
{
  return DsLogAdmin::BasicLogFactory::_duplicate (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
void
TAO::Objref_Traits<DsLogAdmin::BasicLogFactory>::tao_release (
    DsLogAdmin::BasicLogFactory_ptr p
  )
{
  CORBA::release (p);
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
DsLogAdmin::BasicLogFactory_ptr
TAO::Objref_Traits<DsLogAdmin::BasicLogFactory>::tao_nil (void)
{
  return DsLogAdmin::BasicLogFactory::_nil ();
}

ACE_TEMPLATE_CLASS_MEMBER_SPECIALIZATION
CORBA::Boolean
TAO::Objref_Traits<DsLogAdmin::BasicLogFactory>::tao_marshal (
    DsLogAdmin::BasicLogFactory_ptr p,
    TAO_OutputCDR & cdr
  )
{
  return CORBA::Object::marshal (p, cdr);
}

// Function pointer for collocation factory initialization.
TAO::Collocation_Proxy_Broker * 
(*DsLogAdmin__TAO_BasicLogFactory_Proxy_Broker_Factory_function_pointer) (
    CORBA::Object_ptr obj
  ) = 0;

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::BasicLog_ptr DsLogAdmin::BasicLogFactory::create (
    ::DsLogAdmin::LogFullActionType full_action,
    ::CORBA::ULongLong max_size,
    ::DsLogAdmin::LogId_out id
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::InvalidLogFullAction
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_BasicLogFactory_Proxy_Broker_ == 0)
    {
      DsLogAdmin_BasicLogFactory_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::BasicLog>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::LogFullActionType>::in_arg_val _tao_full_action (full_action);
  TAO::Arg_Traits< CORBA::ULongLong>::in_arg_val _tao_max_size (max_size);
  TAO::Arg_Traits< DsLogAdmin::LogId>::out_arg_val _tao_id (id);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_full_action,
      &_tao_max_size,
      &_tao_id
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_BasicLogFactory_create_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/InvalidLogFullAction:1.0",
        DsLogAdmin::InvalidLogFullAction::_alloc,
        DsLogAdmin::_tc_InvalidLogFullAction
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      4,
      "create",
      6,
      this->the_TAO_BasicLogFactory_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_BasicLogFactory_create_exceptiondata,
      1
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

// TAO_IDL - Generated from
// be/be_visitor_operation/operation_cs.cpp:78

::DsLogAdmin::BasicLog_ptr DsLogAdmin::BasicLogFactory::create_with_id (
    ::DsLogAdmin::LogId id,
    ::DsLogAdmin::LogFullActionType full_action,
    ::CORBA::ULongLong max_size
    ACE_ENV_ARG_DECL
  )
  ACE_THROW_SPEC ((
    CORBA::SystemException,
    ::DsLogAdmin::LogIdAlreadyExists,
    ::DsLogAdmin::InvalidLogFullAction
  ))
{
  if (!this->is_evaluated ())
    {
      ACE_NESTED_CLASS (CORBA, Object)::tao_object_initialize (this);
    }
  
  if (this->the_TAO_BasicLogFactory_Proxy_Broker_ == 0)
    {
      DsLogAdmin_BasicLogFactory_setup_collocation ();
    }
  
  TAO::Arg_Traits< ::DsLogAdmin::BasicLog>::ret_val _tao_retval;
  TAO::Arg_Traits< DsLogAdmin::LogId>::in_arg_val _tao_id (id);
  TAO::Arg_Traits< DsLogAdmin::LogFullActionType>::in_arg_val _tao_full_action (full_action);
  TAO::Arg_Traits< CORBA::ULongLong>::in_arg_val _tao_max_size (max_size);
  
  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_id,
      &_tao_full_action,
      &_tao_max_size
    };
  
  static TAO::Exception_Data
  _tao_DsLogAdmin_BasicLogFactory_create_with_id_exceptiondata [] = 
    {
      {
        "IDL:omg.org/DsLogAdmin/LogIdAlreadyExists:1.0",
        DsLogAdmin::LogIdAlreadyExists::_alloc,
        DsLogAdmin::_tc_LogIdAlreadyExists
      },
      
      {
        "IDL:omg.org/DsLogAdmin/InvalidLogFullAction:1.0",
        DsLogAdmin::InvalidLogFullAction::_alloc,
        DsLogAdmin::_tc_InvalidLogFullAction
      }
    };
  
  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      4,
      "create_with_id",
      14,
      this->the_TAO_BasicLogFactory_Proxy_Broker_
    );
  
  _tao_call.invoke (
      _tao_DsLogAdmin_BasicLogFactory_create_with_id_exceptiondata,
      2
      ACE_ENV_ARG_PARAMETER
    );
  ACE_CHECK_RETURN (_tao_retval.excp ());
  
  return _tao_retval.retn ();
}

DsLogAdmin::BasicLogFactory::BasicLogFactory (void)
 : the_TAO_BasicLogFactory_Proxy_Broker_ (0)
{
  this->DsLogAdmin_BasicLogFactory_setup_collocation ();
}

void
DsLogAdmin::BasicLogFactory::DsLogAdmin_BasicLogFactory_setup_collocation ()
{
  if (::DsLogAdmin__TAO_BasicLogFactory_Proxy_Broker_Factory_function_pointer)
    {
      this->the_TAO_BasicLogFactory_Proxy_Broker_ =
        ::DsLogAdmin__TAO_BasicLogFactory_Proxy_Broker_Factory_function_pointer (this);
    }
  
  this->DsLogAdmin_LogMgr_setup_collocation ();
}

DsLogAdmin::BasicLogFactory::~BasicLogFactory (void)
{}

void 
DsLogAdmin::BasicLogFactory::_tao_any_destructor (void *_tao_void_pointer)
{
  BasicLogFactory *_tao_tmp_pointer =
    static_cast<BasicLogFactory *> (_tao_void_pointer);
  CORBA::release (_tao_tmp_pointer);
}

DsLogAdmin::BasicLogFactory_ptr
DsLogAdmin::BasicLogFactory::_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<BasicLogFactory>::narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/BasicLogFactory:1.0",
        DsLogAdmin__TAO_BasicLogFactory_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::BasicLogFactory_ptr
DsLogAdmin::BasicLogFactory::_unchecked_narrow (
    CORBA::Object_ptr _tao_objref
    ACE_ENV_ARG_DECL
  )
{
  return
    TAO::Narrow_Utils<BasicLogFactory>::unchecked_narrow (
        _tao_objref,
        "IDL:omg.org/DsLogAdmin/BasicLogFactory:1.0",
        DsLogAdmin__TAO_BasicLogFactory_Proxy_Broker_Factory_function_pointer
        ACE_ENV_ARG_PARAMETER
      );
}

DsLogAdmin::BasicLogFactory_ptr
DsLogAdmin::BasicLogFactory::_duplicate (BasicLogFactory_ptr obj)
{
  if (! CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  
  return obj;
}

CORBA::Boolean
DsLogAdmin::BasicLogFactory::_is_a (
    const char *value
    ACE_ENV_ARG_DECL
  )
{
  if (
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/LogMgr:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/DsLogAdmin/BasicLogFactory:1.0"
        ) ||
      !ACE_OS::strcmp (
          (char *)value,
          "IDL:omg.org/CORBA/Object:1.0"
        )
     )
    {
      return 1; // success using local knowledge
    }
  else
    {
      return this->ACE_NESTED_CLASS (CORBA, Object)::_is_a (
          value
          ACE_ENV_ARG_PARAMETER
        );
    }
}

const char* DsLogAdmin::BasicLogFactory::_interface_repository_id (void) const
{
  return "IDL:omg.org/DsLogAdmin/BasicLogFactory:1.0";
}

CORBA::Boolean
DsLogAdmin::BasicLogFactory::marshal (TAO_OutputCDR &cdr)
{
  return (cdr << this);
}

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_defn.cpp:290

static const CORBA::Long _oc_DsLogAdmin_BasicLogFactory[] =
{
    TAO_ENCAP_BYTE_ORDER, // byte order
  43,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44734c6f), 
  ACE_NTOHL (0x6741646d), 
  ACE_NTOHL (0x696e2f42), 
  ACE_NTOHL (0x61736963), 
  ACE_NTOHL (0x4c6f6746), 
  ACE_NTOHL (0x6163746f), 
  ACE_NTOHL (0x72793a31), 
  ACE_NTOHL (0x2e300000),  // repository ID = IDL:omg.org/DsLogAdmin/BasicLogFactory:1.0
    16,
  ACE_NTOHL (0x42617369), 
  ACE_NTOHL (0x634c6f67), 
  ACE_NTOHL (0x46616374), 
  ACE_NTOHL (0x6f727900),  // name = BasicLogFactory
  };

static CORBA::TypeCode _tc_TAO_tc_DsLogAdmin_BasicLogFactory (
    CORBA::tk_objref,
    sizeof (_oc_DsLogAdmin_BasicLogFactory),
    (char *) &_oc_DsLogAdmin_BasicLogFactory,
    0,
    sizeof (DsLogAdmin::BasicLogFactory)
  );

namespace DsLogAdmin
{
  ::CORBA::TypeCode_ptr _tc_BasicLogFactory =
    &_tc_TAO_tc_DsLogAdmin_BasicLogFactory;
}

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidParam>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidParam *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidParam *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidThreshold>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidThreshold *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidThreshold *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidTime>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidTime *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidTime *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidTimeInterval>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidTimeInterval *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidTimeInterval *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidMask>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidMask *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidMask *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::LogIdAlreadyExists>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogIdAlreadyExists *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogIdAlreadyExists *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidGrammar>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidGrammar *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidGrammar *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidConstraint>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidConstraint *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidConstraint *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::LogFull>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogFull *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogFull *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::LogOffDuty>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogOffDuty *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogOffDuty *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::LogLocked>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogLocked *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogLocked *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::LogDisabled>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogDisabled *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogDisabled *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidRecordId>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidRecordId *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidRecordId *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidAttribute>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidAttribute *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidAttribute *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::InvalidLogFullAction>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::InvalidLogFullAction *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::InvalidLogFullAction *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::RecordIdList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::RecordIdList *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::NVPair *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::NVPair *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::NVList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::NVList *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::TimeInterval *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::TimeInterval *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogRecord *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogRecord *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::RecordList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::RecordList *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::Anys *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::Anys *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<DsLogAdmin::Iterator>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::Iterator_ptr _tao_elem
  )
{
  DsLogAdmin::Iterator_ptr _tao_objptr =
    DsLogAdmin::Iterator::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::Iterator_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<DsLogAdmin::Iterator>::insert (
      _tao_any,
      DsLogAdmin::Iterator::_tao_any_destructor,
      DsLogAdmin::_tc_Iterator,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::Iterator_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<DsLogAdmin::Iterator>::extract (
        _tao_any,
        DsLogAdmin::Iterator::_tao_any_destructor,
        DsLogAdmin::_tc_Iterator,
        _tao_elem
      );
}

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::AvailabilityStatus *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::AvailabilityStatus *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::Time24 *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::Time24 *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::Time24Interval *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::Time24Interval *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::IntervalsOfDay *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::IntervalsOfDay *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_structure/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::WeekMaskItem *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::WeekMaskItem *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::WeekMask *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::WeekMask *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::CapacityAlarmThresholdList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::CapacityAlarmThresholdList *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from
// be/be_visitor_enum/any_op_cs.cpp:52

void operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::OperationalState _tao_elem
  )
{
  TAO::Any_Basic_Impl_T<DsLogAdmin::OperationalState>::insert (
      _tao_any,
      DsLogAdmin::_tc_OperationalState,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::OperationalState &_tao_elem
  )
{
  return
    TAO::Any_Basic_Impl_T<DsLogAdmin::OperationalState>::extract (
        _tao_any,
        DsLogAdmin::_tc_OperationalState,
        _tao_elem 
      );
}

// TAO_IDL - Generated from
// be/be_visitor_enum/any_op_cs.cpp:52

void operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::AdministrativeState _tao_elem
  )
{
  TAO::Any_Basic_Impl_T<DsLogAdmin::AdministrativeState>::insert (
      _tao_any,
      DsLogAdmin::_tc_AdministrativeState,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::AdministrativeState &_tao_elem
  )
{
  return
    TAO::Any_Basic_Impl_T<DsLogAdmin::AdministrativeState>::extract (
        _tao_any,
        DsLogAdmin::_tc_AdministrativeState,
        _tao_elem 
      );
}

// TAO_IDL - Generated from
// be/be_visitor_enum/any_op_cs.cpp:52

void operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::ForwardingState _tao_elem
  )
{
  TAO::Any_Basic_Impl_T<DsLogAdmin::ForwardingState>::insert (
      _tao_any,
      DsLogAdmin::_tc_ForwardingState,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::ForwardingState &_tao_elem
  )
{
  return
    TAO::Any_Basic_Impl_T<DsLogAdmin::ForwardingState>::extract (
        _tao_any,
        DsLogAdmin::_tc_ForwardingState,
        _tao_elem 
      );
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::QoSList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::QoSList *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_exception/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Dual_Impl_T<DsLogAdmin::UnsupportedQoS>::demarshal_value (
    TAO_InputCDR & cdr
  )
{
  CORBA::String_var id;
  
  if ((cdr >> id.out ()) == 0)
    {
      return 0;
    }
  
  ACE_TRY_NEW_ENV
    {
      this->value_->_tao_decode (cdr ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;
    }
  ACE_CATCHANY
    {
      return 0;
    }
  ACE_ENDTRY;
  
  return 1;
}

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::UnsupportedQoS *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::UnsupportedQoS *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<DsLogAdmin::Log>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::Log_ptr _tao_elem
  )
{
  DsLogAdmin::Log_ptr _tao_objptr =
    DsLogAdmin::Log::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::Log_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<DsLogAdmin::Log>::insert (
      _tao_any,
      DsLogAdmin::Log::_tao_any_destructor,
      DsLogAdmin::_tc_Log,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::Log_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<DsLogAdmin::Log>::extract (
        _tao_any,
        DsLogAdmin::Log::_tao_any_destructor,
        DsLogAdmin::_tc_Log,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<DsLogAdmin::BasicLog>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::BasicLog_ptr _tao_elem
  )
{
  DsLogAdmin::BasicLog_ptr _tao_objptr =
    DsLogAdmin::BasicLog::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::BasicLog_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<DsLogAdmin::BasicLog>::insert (
      _tao_any,
      DsLogAdmin::BasicLog::_tao_any_destructor,
      DsLogAdmin::_tc_BasicLog,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::BasicLog_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<DsLogAdmin::BasicLog>::extract (
        _tao_any,
        DsLogAdmin::BasicLog::_tao_any_destructor,
        DsLogAdmin::_tc_BasicLog,
        _tao_elem
      );
}

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogList *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from 
// be/be_visitor_sequence/any_op_cs.cpp:54

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

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

// Extraction to non-const pointer (deprecated).
CORBA::Boolean operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogIdList *&_tao_elem
  )
{
  return _tao_any >>= const_cast<
      const DsLogAdmin::LogIdList *&> (
      _tao_elem
    );
}

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

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<DsLogAdmin::LogMgr>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::LogMgr_ptr _tao_elem
  )
{
  DsLogAdmin::LogMgr_ptr _tao_objptr =
    DsLogAdmin::LogMgr::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::LogMgr_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<DsLogAdmin::LogMgr>::insert (
      _tao_any,
      DsLogAdmin::LogMgr::_tao_any_destructor,
      DsLogAdmin::_tc_LogMgr,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::LogMgr_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<DsLogAdmin::LogMgr>::extract (
        _tao_any,
        DsLogAdmin::LogMgr::_tao_any_destructor,
        DsLogAdmin::_tc_LogMgr,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_cs.cpp:50

ACE_TEMPLATE_SPECIALIZATION
CORBA::Boolean
TAO::Any_Impl_T<DsLogAdmin::BasicLogFactory>::to_object (
    CORBA::Object_ptr &_tao_elem
  ) const
{
  _tao_elem = CORBA::Object::_duplicate (this->value_);
  return 1;
}

// Copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::BasicLogFactory_ptr _tao_elem
  )
{
  DsLogAdmin::BasicLogFactory_ptr _tao_objptr =
    DsLogAdmin::BasicLogFactory::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

// Non-copying insertion.
void
operator<<= (
    CORBA::Any &_tao_any,
    DsLogAdmin::BasicLogFactory_ptr *_tao_elem
  )
{
  TAO::Any_Impl_T<DsLogAdmin::BasicLogFactory>::insert (
      _tao_any,
      DsLogAdmin::BasicLogFactory::_tao_any_destructor,
      DsLogAdmin::_tc_BasicLogFactory,
      *_tao_elem
    );
}

CORBA::Boolean
operator>>= (
    const CORBA::Any &_tao_any,
    DsLogAdmin::BasicLogFactory_ptr &_tao_elem
  )
{
  return
    TAO::Any_Impl_T<DsLogAdmin::BasicLogFactory>::extract (
        _tao_any,
        DsLogAdmin::BasicLogFactory::_tao_any_destructor,
        DsLogAdmin::_tc_BasicLogFactory,
        _tao_elem
      );
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidParam &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      if (
        (strm << _tao_aggregate.details.in ())
       )
        {
          return 1;
        }
      else
        {
          return 0;
        }
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::InvalidParam &_tao_aggregate
  )
{
  // Demarshal the members.
  if (
    (strm >> _tao_aggregate.details.out ())
  )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidThreshold &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidThreshold&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidTime &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidTime&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidTimeInterval &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidTimeInterval&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidMask &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidMask&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogIdAlreadyExists &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::LogIdAlreadyExists&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidGrammar &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidGrammar&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidConstraint &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidConstraint&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogFull &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      if (
        (strm << _tao_aggregate.n_records_written)
       )
        {
          return 1;
        }
      else
        {
          return 0;
        }
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::LogFull &_tao_aggregate
  )
{
  // Demarshal the members.
  if (
    (strm >> _tao_aggregate.n_records_written)
  )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogOffDuty &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::LogOffDuty&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogLocked &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::LogLocked&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogDisabled &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::LogDisabled&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidRecordId &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidRecordId&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidAttribute &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      if (
        (strm << _tao_aggregate.attr_name.in ()) &&
        (strm << _tao_aggregate.value)
       )
        {
          return 1;
        }
      else
        {
          return 0;
        }
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::InvalidAttribute &_tao_aggregate
  )
{
  // Demarshal the members.
  if (
    (strm >> _tao_aggregate.attr_name.out ()) &&
    (strm >> _tao_aggregate.value)
  )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::InvalidLogFullAction &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &,
    DsLogAdmin::InvalidLogFullAction&
  )
{
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_RecordIdList_CPP_
#define _TAO_CDR_OP_DsLogAdmin_RecordIdList_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::RecordIdList &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      return strm.write_ulonglong_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::RecordIdList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      return strm.read_ulonglong_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_RecordIdList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::NVPair &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.name.in ()) &&
    (strm << _tao_aggregate.value);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::NVPair &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.name.out ()) &&
    (strm >> _tao_aggregate.value);
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_NVList_CPP_
#define _TAO_CDR_OP_DsLogAdmin_NVList_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::NVList &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::NVList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_NVList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::TimeInterval &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.start) &&
    (strm << _tao_aggregate.stop);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::TimeInterval &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.start) &&
    (strm >> _tao_aggregate.stop);
}

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogRecord &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.id) &&
    (strm << _tao_aggregate.time) &&
    (strm << _tao_aggregate.attr_list) &&
    (strm << _tao_aggregate.info);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::LogRecord &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.id) &&
    (strm >> _tao_aggregate.time) &&
    (strm >> _tao_aggregate.attr_list) &&
    (strm >> _tao_aggregate.info);
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_RecordList_CPP_
#define _TAO_CDR_OP_DsLogAdmin_RecordList_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::RecordList &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::RecordList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_RecordList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_Anys_CPP_
#define _TAO_CDR_OP_DsLogAdmin_Anys_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::Anys &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::Anys &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_Anys_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::Iterator_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::Iterator_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::DsLogAdmin::Iterator RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        DsLogAdmin__TAO_Iterator_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::AvailabilityStatus &_tao_aggregate
  )
{
  return
    (strm << CORBA::Any::from_boolean (_tao_aggregate.off_duty)) &&
    (strm << CORBA::Any::from_boolean (_tao_aggregate.log_full));
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::AvailabilityStatus &_tao_aggregate
  )
{
  return
    (strm >> CORBA::Any::to_boolean (_tao_aggregate.off_duty)) &&
    (strm >> CORBA::Any::to_boolean (_tao_aggregate.log_full));
}

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::Time24 &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.hour) &&
    (strm << _tao_aggregate.minute);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::Time24 &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.hour) &&
    (strm >> _tao_aggregate.minute);
}

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::Time24Interval &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.start) &&
    (strm << _tao_aggregate.stop);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::Time24Interval &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.start) &&
    (strm >> _tao_aggregate.stop);
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_IntervalsOfDay_CPP_
#define _TAO_CDR_OP_DsLogAdmin_IntervalsOfDay_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::IntervalsOfDay &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::IntervalsOfDay &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_IntervalsOfDay_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:61

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::WeekMaskItem &_tao_aggregate
  )
{
  return
    (strm << _tao_aggregate.days) &&
    (strm << _tao_aggregate.intervals);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::WeekMaskItem &_tao_aggregate
  )
{
  return
    (strm >> _tao_aggregate.days) &&
    (strm >> _tao_aggregate.intervals);
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_WeekMask_CPP_
#define _TAO_CDR_OP_DsLogAdmin_WeekMask_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::WeekMask &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm << _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::WeekMask &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i]);
        }
      
      return _tao_marshal_flag;
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_WeekMask_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_CapacityAlarmThresholdList_CPP_
#define _TAO_CDR_OP_DsLogAdmin_CapacityAlarmThresholdList_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::CapacityAlarmThresholdList &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      return strm.write_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::CapacityAlarmThresholdList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      return strm.read_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_CapacityAlarmThresholdList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_enum/cdr_op_cs.cpp:51

CORBA::Boolean operator<< (TAO_OutputCDR &strm, const DsLogAdmin::OperationalState &_tao_enumval)
{
  CORBA::ULong _tao_temp = _tao_enumval;
  return strm << _tao_temp;
}

CORBA::Boolean operator>> (TAO_InputCDR &strm, DsLogAdmin::OperationalState &_tao_enumval)
{
  CORBA::ULong _tao_temp = 0;
  CORBA::Boolean _tao_result = strm >> _tao_temp;
  
  if (_tao_result == 1)
    {
      _tao_enumval = static_cast<DsLogAdmin::OperationalState> (_tao_temp);
    }
  
  return _tao_result;
}

// TAO_IDL - Generated from
// be/be_visitor_enum/cdr_op_cs.cpp:51

CORBA::Boolean operator<< (TAO_OutputCDR &strm, const DsLogAdmin::AdministrativeState &_tao_enumval)
{
  CORBA::ULong _tao_temp = _tao_enumval;
  return strm << _tao_temp;
}

CORBA::Boolean operator>> (TAO_InputCDR &strm, DsLogAdmin::AdministrativeState &_tao_enumval)
{
  CORBA::ULong _tao_temp = 0;
  CORBA::Boolean _tao_result = strm >> _tao_temp;
  
  if (_tao_result == 1)
    {
      _tao_enumval = static_cast<DsLogAdmin::AdministrativeState> (_tao_temp);
    }
  
  return _tao_result;
}

// TAO_IDL - Generated from
// be/be_visitor_enum/cdr_op_cs.cpp:51

CORBA::Boolean operator<< (TAO_OutputCDR &strm, const DsLogAdmin::ForwardingState &_tao_enumval)
{
  CORBA::ULong _tao_temp = _tao_enumval;
  return strm << _tao_temp;
}

CORBA::Boolean operator>> (TAO_InputCDR &strm, DsLogAdmin::ForwardingState &_tao_enumval)
{
  CORBA::ULong _tao_temp = 0;
  CORBA::Boolean _tao_result = strm >> _tao_temp;
  
  if (_tao_result == 1)
    {
      _tao_enumval = static_cast<DsLogAdmin::ForwardingState> (_tao_temp);
    }
  
  return _tao_result;
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_QoSList_CPP_
#define _TAO_CDR_OP_DsLogAdmin_QoSList_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::QoSList &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      return strm.write_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::QoSList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      return strm.read_ushort_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_QoSList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_exception/cdr_op_cs.cpp:60

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::UnsupportedQoS &_tao_aggregate
  )
{
  // First marshal the repository ID.
  if (strm << _tao_aggregate._rep_id ())
    {
      // Now marshal the members (if any).
      if (
        (strm << _tao_aggregate.denied)
       )
        {
          return 1;
        }
      else
        {
          return 0;
        }
    }
  else
    {
      return 0;
    }
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::UnsupportedQoS &_tao_aggregate
  )
{
  // Demarshal the members.
  if (
    (strm >> _tao_aggregate.denied)
  )
    {
      return 1;
    }
  else
    {
      return 0;
    }
}

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::Log_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::Log_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::DsLogAdmin::Log RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        DsLogAdmin__TAO_Log_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::BasicLog_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::BasicLog_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::DsLogAdmin::BasicLog RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        DsLogAdmin__TAO_BasicLog_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_LogList_CPP_
#define _TAO_CDR_OP_DsLogAdmin_LogList_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogList &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag =
            _tao_sequence[i].in ()->marshal (strm);
        }
      
      return _tao_marshal_flag;
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::LogList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      CORBA::Boolean _tao_marshal_flag = 1;
      
      for (CORBA::ULong i = 0; i < _tao_seq_len && _tao_marshal_flag; ++i)
        {
          _tao_marshal_flag = (strm >> _tao_sequence[i].out ());
        }
      
      return _tao_marshal_flag;
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_LogList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_sequence/cdr_op_cs.cpp:96

#if !defined _TAO_CDR_OP_DsLogAdmin_LogIdList_CPP_
#define _TAO_CDR_OP_DsLogAdmin_LogIdList_CPP_

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogIdList &_tao_sequence
  )
{
  const CORBA::ULong _tao_seq_len = _tao_sequence.length ();
  
  if (strm << _tao_seq_len)
    {
      // Encode all elements.
      return strm.write_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    }
  
  return 0;
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::LogIdList &_tao_sequence
  )
{
  CORBA::ULong _tao_seq_len;
  
  if (strm >> _tao_seq_len)
    {
      // Add a check to the length of the sequence
      // to make sure it does not exceed the length
      // of the stream. (See bug 58.)
      if (_tao_seq_len > strm.length ())
        {
          return 0;
        }
      
      // Set the length of the sequence.
      _tao_sequence.length (_tao_seq_len);
      
      // If length is 0 we return true.
      if (0 >= _tao_seq_len) 
        {
          return 1;
        }
      
      // Retrieve all the elements.
      return strm.read_ulong_array (_tao_sequence.get_buffer (), _tao_sequence.length ());
    
    }
  
  return 0;
}

#endif /* _TAO_CDR_OP_DsLogAdmin_LogIdList_CPP_ */

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::LogMgr_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::LogMgr_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::DsLogAdmin::LogMgr RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        DsLogAdmin__TAO_LogMgr_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:63

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DsLogAdmin::BasicLogFactory_ptr _tao_objref
  )
{
  CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DsLogAdmin::BasicLogFactory_ptr &_tao_objref
  )
{
  CORBA::Object_var obj;
  
  if ((strm >> obj.inout ()) == 0)
    {
      return 0;
    }
  
  typedef ::DsLogAdmin::BasicLogFactory RHS_SCOPED_NAME;
  
  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (
        obj.in (),
        DsLogAdmin__TAO_BasicLogFactory_Proxy_Broker_Factory_function_pointer
      );
    
  return 1;
}

