// -*- 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/
//
// Information about TAO is available at:
//     http://www.cs.wustl.edu/~schmidt/TAO.html

#include "DynamicAny.h"

#include "tao/Stub.h"
#include "tao/Invocation.h"
#include "tao/PortableInterceptor.h"

#if TAO_HAS_INTERCEPTORS == 1
#include "tao/RequestInfo_Util.h"
#include "tao/ClientRequestInfo_i.h"
#include "tao/ClientInterceptorAdapter.h"
#endif  /* TAO_HAS_INTERCEPTORS == 1 */

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

#if !defined (__ACE_INLINE__)
#include "DynamicAnyC.i"
#endif /* !defined INLINE */

int DynamicAny::DynAny::_tao_class_id = 0;

DynamicAny::DynAny_ptr
tao_DynamicAny_DynAny_duplicate (
    DynamicAny::DynAny_ptr p
  )
{
  return DynamicAny::DynAny::_duplicate (p);
}

void
tao_DynamicAny_DynAny_release (
    DynamicAny::DynAny_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynAny_ptr
tao_DynamicAny_DynAny_nil (
    void
  )
{
  return DynamicAny::DynAny::_nil ();
}

DynamicAny::DynAny_ptr
tao_DynamicAny_DynAny_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynAny::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynAny_upcast (
    void *src
  )
{
  DynamicAny::DynAny **tmp =
    ACE_static_cast (DynamicAny::DynAny **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynAny_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynAny_var::DynAny_var (void) // default constructor
  : ptr_ (DynAny::_nil ())
{}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynAny_var::DynAny_var (const ::DynamicAny::DynAny_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynAny::_duplicate (p.ptr ()))
{}

DynamicAny::DynAny_var::~DynAny_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynAny_var &
DynamicAny::DynAny_var::operator= (DynAny_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynAny_var &
DynamicAny::DynAny_var::operator= (const ::DynamicAny::DynAny_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynAny::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynAny_var::operator const ::DynamicAny::DynAny_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynAny_var::operator ::DynamicAny::DynAny_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynAny_ptr &
DynamicAny::DynAny_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynAny_ptr &
DynamicAny::DynAny_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynAny::_nil ();
  return this->ptr_;
}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynAny_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynAny::_nil ();
  return val;
}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_var::tao_duplicate (DynAny_ptr p)
{
  return ::DynamicAny::DynAny::_duplicate (p);
}

void
DynamicAny::DynAny_var::tao_release (DynAny_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_var::tao_nil (void)
{
  return ::DynamicAny::DynAny::_nil ();
}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynAny::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynAny_var::tao_upcast (void *src)
{
  DynAny **tmp =
    ACE_static_cast (DynAny **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynAny_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynAny_out::DynAny_out (DynAny_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynAny::_nil ();
}

DynamicAny::DynAny_out::DynAny_out (DynAny_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynAny::_nil ();
}

DynamicAny::DynAny_out::DynAny_out (const ::DynamicAny::DynAny_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynAny_out &, p).ptr_)
{}

::DynamicAny::DynAny_out &
DynamicAny::DynAny_out::operator= (const ::DynamicAny::DynAny_out &p)
{
  this->ptr_ = ACE_const_cast (DynAny_out&, p).ptr_;
  return *this;
}

DynamicAny::DynAny_out &
DynamicAny::DynAny_out::operator= (const ::DynamicAny::DynAny_var &p)
{
  this->ptr_ = ::DynamicAny::DynAny::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynAny_out &
DynamicAny::DynAny_out::operator= (DynAny_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynAny_out::operator ::DynamicAny::DynAny_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynAny_ptr &
DynamicAny::DynAny_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynAny_ptr
DynamicAny::DynAny_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynAny::DynAny (void)
{}

DynamicAny::DynAny::~DynAny (void)
{}

DynamicAny::DynAny_ptr DynamicAny::DynAny::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynAny::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynAny_ptr 
DynamicAny::DynAny::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynAny::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynAny_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynAny::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynAny_ptr
DynamicAny::DynAny::_duplicate (DynAny_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynAny::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

// Default constructor.
DynamicAny::DynAny::InvalidValue::InvalidValue (void)
  : CORBA::UserException (
        "IDL:omg.org/DynamicAny/DynAny/InvalidValue:1.0",
        "InvalidValue"
      )
{
}

// Destructor - all members are of self managing types.
DynamicAny::DynAny::InvalidValue::~InvalidValue (void)
{
}

// Copy constructor.
DynamicAny::DynAny::InvalidValue::InvalidValue (const ::DynamicAny::DynAny::InvalidValue &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

// Assignment operator.
DynamicAny::DynAny::InvalidValue&
DynamicAny::DynAny::InvalidValue::operator= (const ::DynamicAny::DynAny::InvalidValue &_tao_excp)
{
  this->UserException::operator= (_tao_excp);
  return *this;
}

DynamicAny::DynAny::InvalidValue *
DynamicAny::DynAny::InvalidValue::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DynamicAny/DynAny/InvalidValue:1.0", exc->_rep_id ()))
    {
      return ACE_dynamic_cast (InvalidValue *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *DynamicAny::DynAny::InvalidValue::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::DynamicAny::DynAny::InvalidValue, 0);
  return retval;
}

CORBA::Exception *
DynamicAny::DynAny::InvalidValue::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      DynamicAny::DynAny::InvalidValue (*this),
      0
    );
  return result;
}

void DynamicAny::DynAny::InvalidValue::_raise ()
{
  TAO_RAISE (*this);
}

void DynamicAny::DynAny::InvalidValue::_tao_encode (
    TAO_OutputCDR &
    ACE_ENV_ARG_DECL
  ) const
{
  ACE_THROW (CORBA::MARSHAL ());
}

void DynamicAny::DynAny::InvalidValue::_tao_decode (
    TAO_InputCDR &
    ACE_ENV_ARG_DECL
  )
{
  ACE_THROW (CORBA::MARSHAL ());
}

// Default constructor.
DynamicAny::DynAny::TypeMismatch::TypeMismatch (void)
  : CORBA::UserException (
        "IDL:omg.org/DynamicAny/DynAny/TypeMismatch:1.0",
        "TypeMismatch"
      )
{
}

// Destructor - all members are of self managing types.
DynamicAny::DynAny::TypeMismatch::~TypeMismatch (void)
{
}

// Copy constructor.
DynamicAny::DynAny::TypeMismatch::TypeMismatch (const ::DynamicAny::DynAny::TypeMismatch &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

// Assignment operator.
DynamicAny::DynAny::TypeMismatch&
DynamicAny::DynAny::TypeMismatch::operator= (const ::DynamicAny::DynAny::TypeMismatch &_tao_excp)
{
  this->UserException::operator= (_tao_excp);
  return *this;
}

DynamicAny::DynAny::TypeMismatch *
DynamicAny::DynAny::TypeMismatch::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DynamicAny/DynAny/TypeMismatch:1.0", exc->_rep_id ()))
    {
      return ACE_dynamic_cast (TypeMismatch *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *DynamicAny::DynAny::TypeMismatch::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::DynamicAny::DynAny::TypeMismatch, 0);
  return retval;
}

CORBA::Exception *
DynamicAny::DynAny::TypeMismatch::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      DynamicAny::DynAny::TypeMismatch (*this),
      0
    );
  return result;
}

void DynamicAny::DynAny::TypeMismatch::_raise ()
{
  TAO_RAISE (*this);
}

void DynamicAny::DynAny::TypeMismatch::_tao_encode (
    TAO_OutputCDR &
    ACE_ENV_ARG_DECL
  ) const
{
  ACE_THROW (CORBA::MARSHAL ());
}

void DynamicAny::DynAny::TypeMismatch::_tao_decode (
    TAO_InputCDR &
    ACE_ENV_ARG_DECL
  )
{
  ACE_THROW (CORBA::MARSHAL ());
}

int DynamicAny::DynFixed::_tao_class_id = 0;

DynamicAny::DynFixed_ptr
tao_DynamicAny_DynFixed_duplicate (
    DynamicAny::DynFixed_ptr p
  )
{
  return DynamicAny::DynFixed::_duplicate (p);
}

void
tao_DynamicAny_DynFixed_release (
    DynamicAny::DynFixed_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynFixed_ptr
tao_DynamicAny_DynFixed_nil (
    void
  )
{
  return DynamicAny::DynFixed::_nil ();
}

DynamicAny::DynFixed_ptr
tao_DynamicAny_DynFixed_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynFixed::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynFixed_upcast (
    void *src
  )
{
  DynamicAny::DynFixed **tmp =
    ACE_static_cast (DynamicAny::DynFixed **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynFixed_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynFixed_var::DynFixed_var (void) // default constructor
  : ptr_ (DynFixed::_nil ())
{}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynFixed_var::DynFixed_var (const ::DynamicAny::DynFixed_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynFixed::_duplicate (p.ptr ()))
{}

DynamicAny::DynFixed_var::~DynFixed_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynFixed_var &
DynamicAny::DynFixed_var::operator= (DynFixed_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynFixed_var &
DynamicAny::DynFixed_var::operator= (const ::DynamicAny::DynFixed_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynFixed::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynFixed_var::operator const ::DynamicAny::DynFixed_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynFixed_var::operator ::DynamicAny::DynFixed_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynFixed_ptr &
DynamicAny::DynFixed_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynFixed_ptr &
DynamicAny::DynFixed_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynFixed::_nil ();
  return this->ptr_;
}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynFixed_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynFixed::_nil ();
  return val;
}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_var::tao_duplicate (DynFixed_ptr p)
{
  return ::DynamicAny::DynFixed::_duplicate (p);
}

void
DynamicAny::DynFixed_var::tao_release (DynFixed_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_var::tao_nil (void)
{
  return ::DynamicAny::DynFixed::_nil ();
}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynFixed::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynFixed_var::tao_upcast (void *src)
{
  DynFixed **tmp =
    ACE_static_cast (DynFixed **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynFixed_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynFixed_out::DynFixed_out (DynFixed_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynFixed::_nil ();
}

DynamicAny::DynFixed_out::DynFixed_out (DynFixed_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynFixed::_nil ();
}

DynamicAny::DynFixed_out::DynFixed_out (const ::DynamicAny::DynFixed_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynFixed_out &, p).ptr_)
{}

::DynamicAny::DynFixed_out &
DynamicAny::DynFixed_out::operator= (const ::DynamicAny::DynFixed_out &p)
{
  this->ptr_ = ACE_const_cast (DynFixed_out&, p).ptr_;
  return *this;
}

DynamicAny::DynFixed_out &
DynamicAny::DynFixed_out::operator= (const ::DynamicAny::DynFixed_var &p)
{
  this->ptr_ = ::DynamicAny::DynFixed::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynFixed_out &
DynamicAny::DynFixed_out::operator= (DynFixed_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynFixed_out::operator ::DynamicAny::DynFixed_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynFixed_ptr &
DynamicAny::DynFixed_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynFixed_ptr
DynamicAny::DynFixed_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynFixed::DynFixed (void)
{}

DynamicAny::DynFixed::~DynFixed (void)
{}

DynamicAny::DynFixed_ptr DynamicAny::DynFixed::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynFixed::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynFixed_ptr 
DynamicAny::DynFixed::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynFixed::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynFixed_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynFixed::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynFixed_ptr
DynamicAny::DynFixed::_duplicate (DynFixed_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynFixed::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynFixed)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            DynamicAny::DynAny_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

int DynamicAny::DynEnum::_tao_class_id = 0;

DynamicAny::DynEnum_ptr
tao_DynamicAny_DynEnum_duplicate (
    DynamicAny::DynEnum_ptr p
  )
{
  return DynamicAny::DynEnum::_duplicate (p);
}

void
tao_DynamicAny_DynEnum_release (
    DynamicAny::DynEnum_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynEnum_ptr
tao_DynamicAny_DynEnum_nil (
    void
  )
{
  return DynamicAny::DynEnum::_nil ();
}

DynamicAny::DynEnum_ptr
tao_DynamicAny_DynEnum_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynEnum::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynEnum_upcast (
    void *src
  )
{
  DynamicAny::DynEnum **tmp =
    ACE_static_cast (DynamicAny::DynEnum **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynEnum_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynEnum_var::DynEnum_var (void) // default constructor
  : ptr_ (DynEnum::_nil ())
{}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynEnum_var::DynEnum_var (const ::DynamicAny::DynEnum_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynEnum::_duplicate (p.ptr ()))
{}

DynamicAny::DynEnum_var::~DynEnum_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynEnum_var &
DynamicAny::DynEnum_var::operator= (DynEnum_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynEnum_var &
DynamicAny::DynEnum_var::operator= (const ::DynamicAny::DynEnum_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynEnum::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynEnum_var::operator const ::DynamicAny::DynEnum_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynEnum_var::operator ::DynamicAny::DynEnum_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynEnum_ptr &
DynamicAny::DynEnum_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynEnum_ptr &
DynamicAny::DynEnum_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynEnum::_nil ();
  return this->ptr_;
}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynEnum_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynEnum::_nil ();
  return val;
}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_var::tao_duplicate (DynEnum_ptr p)
{
  return ::DynamicAny::DynEnum::_duplicate (p);
}

void
DynamicAny::DynEnum_var::tao_release (DynEnum_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_var::tao_nil (void)
{
  return ::DynamicAny::DynEnum::_nil ();
}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynEnum::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynEnum_var::tao_upcast (void *src)
{
  DynEnum **tmp =
    ACE_static_cast (DynEnum **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynEnum_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynEnum_out::DynEnum_out (DynEnum_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynEnum::_nil ();
}

DynamicAny::DynEnum_out::DynEnum_out (DynEnum_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynEnum::_nil ();
}

DynamicAny::DynEnum_out::DynEnum_out (const ::DynamicAny::DynEnum_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynEnum_out &, p).ptr_)
{}

::DynamicAny::DynEnum_out &
DynamicAny::DynEnum_out::operator= (const ::DynamicAny::DynEnum_out &p)
{
  this->ptr_ = ACE_const_cast (DynEnum_out&, p).ptr_;
  return *this;
}

DynamicAny::DynEnum_out &
DynamicAny::DynEnum_out::operator= (const ::DynamicAny::DynEnum_var &p)
{
  this->ptr_ = ::DynamicAny::DynEnum::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynEnum_out &
DynamicAny::DynEnum_out::operator= (DynEnum_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynEnum_out::operator ::DynamicAny::DynEnum_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynEnum_ptr &
DynamicAny::DynEnum_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynEnum_ptr
DynamicAny::DynEnum_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynEnum::DynEnum (void)
{}

DynamicAny::DynEnum::~DynEnum (void)
{}

DynamicAny::DynEnum_ptr DynamicAny::DynEnum::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynEnum::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynEnum_ptr 
DynamicAny::DynEnum::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynEnum::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynEnum_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynEnum::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynEnum_ptr
DynamicAny::DynEnum::_duplicate (DynEnum_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynEnum::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynEnum)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            DynamicAny::DynAny_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

static const CORBA::Long _oc_DynamicAny_FieldName[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  37,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44796e61), 
  ACE_NTOHL (0x6d696341), 
  ACE_NTOHL (0x6e792f46), 
  ACE_NTOHL (0x69656c64), 
  ACE_NTOHL (0x4e616d65), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DynamicAny/FieldName:1.0
  10,
  ACE_NTOHL (0x4669656c), 
  ACE_NTOHL (0x644e616d), 
  ACE_NTOHL (0x65000000),  // name = FieldName
  CORBA::tk_string, 
  0U, // string length
};

static CORBA::TypeCode _tc_TAO_tc_DynamicAny_FieldName (
    CORBA::tk_alias,
    sizeof (_oc_DynamicAny_FieldName),
    (char *) &_oc_DynamicAny_FieldName,
    0,
    sizeof (DynamicAny::FieldName)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (DynamicAny)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_FieldName, &_tc_TAO_tc_DynamicAny_FieldName)
TAO_NAMESPACE_END

static const CORBA::Long _oc_DynamicAny_NameValuePair[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  41,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44796e61), 
  ACE_NTOHL (0x6d696341), 
  ACE_NTOHL (0x6e792f4e), 
  ACE_NTOHL (0x616d6556), 
  ACE_NTOHL (0x616c7565), 
  ACE_NTOHL (0x50616972), 
  ACE_NTOHL (0x3a312e30), 
  ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DynamicAny/NameValuePair:1.0
  14,
  ACE_NTOHL (0x4e616d65), 
  ACE_NTOHL (0x56616c75), 
  ACE_NTOHL (0x65506169), 
  ACE_NTOHL (0x72000000),  // name = NameValuePair
  2, // member count
  3,
  ACE_NTOHL (0x69640000),  // name = id
  CORBA::tk_alias, // typecode kind for typedefs
  72, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    37,
    ACE_NTOHL (0x49444c3a), 
    ACE_NTOHL (0x6f6d672e), 
    ACE_NTOHL (0x6f72672f), 
    ACE_NTOHL (0x44796e61), 
    ACE_NTOHL (0x6d696341), 
    ACE_NTOHL (0x6e792f46), 
    ACE_NTOHL (0x69656c64), 
    ACE_NTOHL (0x4e616d65), 
    ACE_NTOHL (0x3a312e30), 
    ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DynamicAny/FieldName:1.0
    10,
    ACE_NTOHL (0x4669656c), 
    ACE_NTOHL (0x644e616d), 
    ACE_NTOHL (0x65000000),  // name = FieldName
    CORBA::tk_string, 
    0U, // string length

  6,
  ACE_NTOHL (0x76616c75), 
  ACE_NTOHL (0x65000000),  // name = value
  CORBA::tk_any,

};

static CORBA::TypeCode _tc_TAO_tc_DynamicAny_NameValuePair (
    CORBA::tk_struct,
    sizeof (_oc_DynamicAny_NameValuePair),
    (char *) &_oc_DynamicAny_NameValuePair,
    0,
    sizeof (DynamicAny::NameValuePair)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (DynamicAny)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_NameValuePair, &_tc_TAO_tc_DynamicAny_NameValuePair)
TAO_NAMESPACE_END

void DynamicAny::NameValuePair::_tao_any_destructor (void *_tao_void_pointer)
{
  NameValuePair *tmp = ACE_static_cast (NameValuePair*, _tao_void_pointer);
  delete tmp;
}


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_DYNAMICANY_NAMEVALUEPAIRSEQ_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_DYNAMICANY_NAMEVALUEPAIRSEQ_CS_

void
DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq::_allocate_buffer (CORBA::ULong length)
{
  DynamicAny::NameValuePair* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq::allocbuf (length);
  
  if (this->buffer_ != 0)
  {
    DynamicAny::NameValuePair *old = ACE_reinterpret_cast (DynamicAny::NameValuePair *,this->buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];
    
    if (this->release_)
      _TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq::freebuf (old);
    
  }
  this->buffer_ = tmp;
}

void
DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;
  
  DynamicAny::NameValuePair *tmp = ACE_reinterpret_cast (DynamicAny::NameValuePair *,this->buffer_);
  
  _TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq::freebuf (tmp);
  this->buffer_ = 0;
} 

DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq::~_TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_DYNAMICANY_NAMEVALUEPAIRSEQ_CS_)
#define _DYNAMICANY_NAMEVALUEPAIRSEQ_CS_

// *************************************************************
// DynamicAny::NameValuePairSeq
// *************************************************************

DynamicAny::NameValuePairSeq::NameValuePairSeq (void)
{}
DynamicAny::NameValuePairSeq::NameValuePairSeq (CORBA::ULong max) // uses max size
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<DynamicAny::NameValuePair>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max)
{}
DynamicAny::NameValuePairSeq::NameValuePairSeq (CORBA::ULong max, CORBA::ULong length, DynamicAny::NameValuePair *buffer, CORBA::Boolean release)
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<DynamicAny::NameValuePair>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max, length, buffer, release)
{}
DynamicAny::NameValuePairSeq::NameValuePairSeq (const NameValuePairSeq &seq) // copy ctor
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_NameValuePairSeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<DynamicAny::NameValuePair>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (seq)
{}
DynamicAny::NameValuePairSeq::~NameValuePairSeq (void) // dtor
{}
void DynamicAny::NameValuePairSeq::_tao_any_destructor (void *_tao_void_pointer)
{
  NameValuePairSeq *tmp = ACE_static_cast (NameValuePairSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

static const CORBA::Long _oc_DynamicAny_NameValuePairSeq[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  44,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44796e61), 
  ACE_NTOHL (0x6d696341), 
  ACE_NTOHL (0x6e792f4e), 
  ACE_NTOHL (0x616d6556), 
  ACE_NTOHL (0x616c7565), 
  ACE_NTOHL (0x50616972), 
  ACE_NTOHL (0x5365713a), 
  ACE_NTOHL (0x312e3000),  // repository ID = IDL:omg.org/DynamicAny/NameValuePairSeq:1.0
  17,
  ACE_NTOHL (0x4e616d65), 
  ACE_NTOHL (0x56616c75), 
  ACE_NTOHL (0x65506169), 
  ACE_NTOHL (0x72536571), 
  ACE_NTOHL (0x0),  // name = NameValuePairSeq
  CORBA::tk_sequence, // typecode kind
  196, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_struct, // typecode kind
    180, // encapsulation length
      TAO_ENCAP_BYTE_ORDER, // byte order
      41,
      ACE_NTOHL (0x49444c3a), 
      ACE_NTOHL (0x6f6d672e), 
      ACE_NTOHL (0x6f72672f), 
      ACE_NTOHL (0x44796e61), 
      ACE_NTOHL (0x6d696341), 
      ACE_NTOHL (0x6e792f4e), 
      ACE_NTOHL (0x616d6556), 
      ACE_NTOHL (0x616c7565), 
      ACE_NTOHL (0x50616972), 
      ACE_NTOHL (0x3a312e30), 
      ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DynamicAny/NameValuePair:1.0
      14,
      ACE_NTOHL (0x4e616d65), 
      ACE_NTOHL (0x56616c75), 
      ACE_NTOHL (0x65506169), 
      ACE_NTOHL (0x72000000),  // name = NameValuePair
      2, // member count
      3,
      ACE_NTOHL (0x69640000),  // name = id
      CORBA::tk_alias, // typecode kind for typedefs
      72, // encapsulation length
        TAO_ENCAP_BYTE_ORDER, // byte order
        37,
        ACE_NTOHL (0x49444c3a), 
        ACE_NTOHL (0x6f6d672e), 
        ACE_NTOHL (0x6f72672f), 
        ACE_NTOHL (0x44796e61), 
        ACE_NTOHL (0x6d696341), 
        ACE_NTOHL (0x6e792f46), 
        ACE_NTOHL (0x69656c64), 
        ACE_NTOHL (0x4e616d65), 
        ACE_NTOHL (0x3a312e30), 
        ACE_NTOHL (0x0),  // repository ID = IDL:omg.org/DynamicAny/FieldName:1.0
        10,
        ACE_NTOHL (0x4669656c), 
        ACE_NTOHL (0x644e616d), 
        ACE_NTOHL (0x65000000),  // name = FieldName
        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_DynamicAny_NameValuePairSeq (
    CORBA::tk_alias,
    sizeof (_oc_DynamicAny_NameValuePairSeq),
    (char *) &_oc_DynamicAny_NameValuePairSeq,
    0,
    sizeof (DynamicAny::NameValuePairSeq)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (DynamicAny)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_NameValuePairSeq, &_tc_TAO_tc_DynamicAny_NameValuePairSeq)
TAO_NAMESPACE_END


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_DYNAMICANY_NAMEDYNANYPAIRSEQ_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_DYNAMICANY_NAMEDYNANYPAIRSEQ_CS_

void
DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq::_allocate_buffer (CORBA::ULong length)
{
  DynamicAny::NameDynAnyPair* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq::allocbuf (length);
  
  if (this->buffer_ != 0)
  {
    DynamicAny::NameDynAnyPair *old = ACE_reinterpret_cast (DynamicAny::NameDynAnyPair *,this->buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];
    
    if (this->release_)
      _TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq::freebuf (old);
    
  }
  this->buffer_ = tmp;
}

void
DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;
  
  DynamicAny::NameDynAnyPair *tmp = ACE_reinterpret_cast (DynamicAny::NameDynAnyPair *,this->buffer_);
  
  _TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq::freebuf (tmp);
  this->buffer_ = 0;
} 

DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq::~_TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_DYNAMICANY_NAMEDYNANYPAIRSEQ_CS_)
#define _DYNAMICANY_NAMEDYNANYPAIRSEQ_CS_

// *************************************************************
// DynamicAny::NameDynAnyPairSeq
// *************************************************************

DynamicAny::NameDynAnyPairSeq::NameDynAnyPairSeq (void)
{}
DynamicAny::NameDynAnyPairSeq::NameDynAnyPairSeq (CORBA::ULong max) // uses max size
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<DynamicAny::NameDynAnyPair>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max)
{}
DynamicAny::NameDynAnyPairSeq::NameDynAnyPairSeq (CORBA::ULong max, CORBA::ULong length, DynamicAny::NameDynAnyPair *buffer, CORBA::Boolean release)
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<DynamicAny::NameDynAnyPair>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max, length, buffer, release)
{}
DynamicAny::NameDynAnyPairSeq::NameDynAnyPairSeq (const NameDynAnyPairSeq &seq) // copy ctor
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_NameDynAnyPairSeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<DynamicAny::NameDynAnyPair>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (seq)
{}
DynamicAny::NameDynAnyPairSeq::~NameDynAnyPairSeq (void) // dtor
{}
void DynamicAny::NameDynAnyPairSeq::_tao_any_destructor (void *_tao_void_pointer)
{
  NameDynAnyPairSeq *tmp = ACE_static_cast (NameDynAnyPairSeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

int DynamicAny::DynStruct::_tao_class_id = 0;

DynamicAny::DynStruct_ptr
tao_DynamicAny_DynStruct_duplicate (
    DynamicAny::DynStruct_ptr p
  )
{
  return DynamicAny::DynStruct::_duplicate (p);
}

void
tao_DynamicAny_DynStruct_release (
    DynamicAny::DynStruct_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynStruct_ptr
tao_DynamicAny_DynStruct_nil (
    void
  )
{
  return DynamicAny::DynStruct::_nil ();
}

DynamicAny::DynStruct_ptr
tao_DynamicAny_DynStruct_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynStruct::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynStruct_upcast (
    void *src
  )
{
  DynamicAny::DynStruct **tmp =
    ACE_static_cast (DynamicAny::DynStruct **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynStruct_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynStruct_var::DynStruct_var (void) // default constructor
  : ptr_ (DynStruct::_nil ())
{}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynStruct_var::DynStruct_var (const ::DynamicAny::DynStruct_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynStruct::_duplicate (p.ptr ()))
{}

DynamicAny::DynStruct_var::~DynStruct_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynStruct_var &
DynamicAny::DynStruct_var::operator= (DynStruct_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynStruct_var &
DynamicAny::DynStruct_var::operator= (const ::DynamicAny::DynStruct_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynStruct::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynStruct_var::operator const ::DynamicAny::DynStruct_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynStruct_var::operator ::DynamicAny::DynStruct_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynStruct_ptr &
DynamicAny::DynStruct_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynStruct_ptr &
DynamicAny::DynStruct_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynStruct::_nil ();
  return this->ptr_;
}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynStruct_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynStruct::_nil ();
  return val;
}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_var::tao_duplicate (DynStruct_ptr p)
{
  return ::DynamicAny::DynStruct::_duplicate (p);
}

void
DynamicAny::DynStruct_var::tao_release (DynStruct_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_var::tao_nil (void)
{
  return ::DynamicAny::DynStruct::_nil ();
}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynStruct::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynStruct_var::tao_upcast (void *src)
{
  DynStruct **tmp =
    ACE_static_cast (DynStruct **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynStruct_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynStruct_out::DynStruct_out (DynStruct_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynStruct::_nil ();
}

DynamicAny::DynStruct_out::DynStruct_out (DynStruct_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynStruct::_nil ();
}

DynamicAny::DynStruct_out::DynStruct_out (const ::DynamicAny::DynStruct_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynStruct_out &, p).ptr_)
{}

::DynamicAny::DynStruct_out &
DynamicAny::DynStruct_out::operator= (const ::DynamicAny::DynStruct_out &p)
{
  this->ptr_ = ACE_const_cast (DynStruct_out&, p).ptr_;
  return *this;
}

DynamicAny::DynStruct_out &
DynamicAny::DynStruct_out::operator= (const ::DynamicAny::DynStruct_var &p)
{
  this->ptr_ = ::DynamicAny::DynStruct::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynStruct_out &
DynamicAny::DynStruct_out::operator= (DynStruct_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynStruct_out::operator ::DynamicAny::DynStruct_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynStruct_ptr &
DynamicAny::DynStruct_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynStruct_ptr
DynamicAny::DynStruct_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynStruct::DynStruct (void)
{}

DynamicAny::DynStruct::~DynStruct (void)
{}

DynamicAny::DynStruct_ptr DynamicAny::DynStruct::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynStruct::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynStruct_ptr 
DynamicAny::DynStruct::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynStruct::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynStruct_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynStruct::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynStruct_ptr
DynamicAny::DynStruct::_duplicate (DynStruct_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynStruct::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynStruct)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            DynamicAny::DynAny_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

int DynamicAny::DynUnion::_tao_class_id = 0;

DynamicAny::DynUnion_ptr
tao_DynamicAny_DynUnion_duplicate (
    DynamicAny::DynUnion_ptr p
  )
{
  return DynamicAny::DynUnion::_duplicate (p);
}

void
tao_DynamicAny_DynUnion_release (
    DynamicAny::DynUnion_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynUnion_ptr
tao_DynamicAny_DynUnion_nil (
    void
  )
{
  return DynamicAny::DynUnion::_nil ();
}

DynamicAny::DynUnion_ptr
tao_DynamicAny_DynUnion_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynUnion::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynUnion_upcast (
    void *src
  )
{
  DynamicAny::DynUnion **tmp =
    ACE_static_cast (DynamicAny::DynUnion **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynUnion_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynUnion_var::DynUnion_var (void) // default constructor
  : ptr_ (DynUnion::_nil ())
{}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynUnion_var::DynUnion_var (const ::DynamicAny::DynUnion_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynUnion::_duplicate (p.ptr ()))
{}

DynamicAny::DynUnion_var::~DynUnion_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynUnion_var &
DynamicAny::DynUnion_var::operator= (DynUnion_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynUnion_var &
DynamicAny::DynUnion_var::operator= (const ::DynamicAny::DynUnion_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynUnion::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynUnion_var::operator const ::DynamicAny::DynUnion_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynUnion_var::operator ::DynamicAny::DynUnion_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynUnion_ptr &
DynamicAny::DynUnion_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynUnion_ptr &
DynamicAny::DynUnion_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynUnion::_nil ();
  return this->ptr_;
}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynUnion_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynUnion::_nil ();
  return val;
}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_var::tao_duplicate (DynUnion_ptr p)
{
  return ::DynamicAny::DynUnion::_duplicate (p);
}

void
DynamicAny::DynUnion_var::tao_release (DynUnion_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_var::tao_nil (void)
{
  return ::DynamicAny::DynUnion::_nil ();
}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynUnion::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynUnion_var::tao_upcast (void *src)
{
  DynUnion **tmp =
    ACE_static_cast (DynUnion **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynUnion_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynUnion_out::DynUnion_out (DynUnion_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynUnion::_nil ();
}

DynamicAny::DynUnion_out::DynUnion_out (DynUnion_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynUnion::_nil ();
}

DynamicAny::DynUnion_out::DynUnion_out (const ::DynamicAny::DynUnion_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynUnion_out &, p).ptr_)
{}

::DynamicAny::DynUnion_out &
DynamicAny::DynUnion_out::operator= (const ::DynamicAny::DynUnion_out &p)
{
  this->ptr_ = ACE_const_cast (DynUnion_out&, p).ptr_;
  return *this;
}

DynamicAny::DynUnion_out &
DynamicAny::DynUnion_out::operator= (const ::DynamicAny::DynUnion_var &p)
{
  this->ptr_ = ::DynamicAny::DynUnion::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynUnion_out &
DynamicAny::DynUnion_out::operator= (DynUnion_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynUnion_out::operator ::DynamicAny::DynUnion_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynUnion_ptr &
DynamicAny::DynUnion_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynUnion_ptr
DynamicAny::DynUnion_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynUnion::DynUnion (void)
{}

DynamicAny::DynUnion::~DynUnion (void)
{}

DynamicAny::DynUnion_ptr DynamicAny::DynUnion::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynUnion::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynUnion_ptr 
DynamicAny::DynUnion::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynUnion::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynUnion_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynUnion::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynUnion_ptr
DynamicAny::DynUnion::_duplicate (DynUnion_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynUnion::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynUnion)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            DynamicAny::DynAny_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_SEQUENCE_DYNAMICANY_ANYSEQ_CS_)
#define __TAO_UNBOUNDED_SEQUENCE_DYNAMICANY_ANYSEQ_CS_

void
DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_AnySeq::_allocate_buffer (CORBA::ULong length)
{
  CORBA::Any* tmp = 0;
  tmp = _TAO_Unbounded_Sequence_DynamicAny_AnySeq::allocbuf (length);
  
  if (this->buffer_ != 0)
  {
    CORBA::Any *old = ACE_reinterpret_cast (CORBA::Any *,this->buffer_);
    
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      tmp[i] = old[i];
    
    if (this->release_)
      _TAO_Unbounded_Sequence_DynamicAny_AnySeq::freebuf (old);
    
  }
  this->buffer_ = tmp;
}

void
DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_AnySeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;
  
  CORBA::Any *tmp = ACE_reinterpret_cast (CORBA::Any *,this->buffer_);
  
  _TAO_Unbounded_Sequence_DynamicAny_AnySeq::freebuf (tmp);
  this->buffer_ = 0;
} 

DynamicAny::_TAO_Unbounded_Sequence_DynamicAny_AnySeq::~_TAO_Unbounded_Sequence_DynamicAny_AnySeq (void) // Dtor.
{
  this->_deallocate_buffer ();
}


#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_DYNAMICANY_ANYSEQ_CS_)
#define _DYNAMICANY_ANYSEQ_CS_

// *************************************************************
// DynamicAny::AnySeq
// *************************************************************

DynamicAny::AnySeq::AnySeq (void)
{}
DynamicAny::AnySeq::AnySeq (CORBA::ULong max) // uses max size
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_AnySeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<CORBA::Any>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max)
{}
DynamicAny::AnySeq::AnySeq (CORBA::ULong max, CORBA::ULong length, CORBA::Any *buffer, CORBA::Boolean release)
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_AnySeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<CORBA::Any>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max, length, buffer, release)
{}
DynamicAny::AnySeq::AnySeq (const AnySeq &seq) // copy ctor
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Sequence_DynamicAny_AnySeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Sequence<CORBA::Any>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (seq)
{}
DynamicAny::AnySeq::~AnySeq (void) // dtor
{}
void DynamicAny::AnySeq::_tao_any_destructor (void *_tao_void_pointer)
{
  AnySeq *tmp = ACE_static_cast (AnySeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

static const CORBA::Long _oc_DynamicAny_AnySeq[] =
{
  TAO_ENCAP_BYTE_ORDER, // byte order
  34,
  ACE_NTOHL (0x49444c3a), 
  ACE_NTOHL (0x6f6d672e), 
  ACE_NTOHL (0x6f72672f), 
  ACE_NTOHL (0x44796e61), 
  ACE_NTOHL (0x6d696341), 
  ACE_NTOHL (0x6e792f41), 
  ACE_NTOHL (0x6e795365), 
  ACE_NTOHL (0x713a312e), 
  ACE_NTOHL (0x30000000),  // repository ID = IDL:omg.org/DynamicAny/AnySeq:1.0
  7,
  ACE_NTOHL (0x416e7953), 
  ACE_NTOHL (0x65710000),  // name = AnySeq
  CORBA::tk_sequence, // typecode kind
  12, // encapsulation length
    TAO_ENCAP_BYTE_ORDER, // byte order
    CORBA::tk_any,

    0U,

};

static CORBA::TypeCode _tc_TAO_tc_DynamicAny_AnySeq (
    CORBA::tk_alias,
    sizeof (_oc_DynamicAny_AnySeq),
    (char *) &_oc_DynamicAny_AnySeq,
    0,
    sizeof (DynamicAny::AnySeq)
  );

TAO_NAMESPACE_TYPE (CORBA::TypeCode_ptr)
TAO_NAMESPACE_BEGIN (DynamicAny)
TAO_NAMESPACE_DEFINE (::CORBA::TypeCode_ptr, _tc_AnySeq, &_tc_TAO_tc_DynamicAny_AnySeq)
TAO_NAMESPACE_END


#if !defined (TAO_USE_SEQUENCE_TEMPLATES)

#if !defined (__TAO_UNBOUNDED_OBJECT_SEQUENCE_DYNAMICANY_DYNANYSEQ_CS_)
#define __TAO_UNBOUNDED_OBJECT_SEQUENCE_DYNAMICANY_DYNANYSEQ_CS_

// The Base_Sequence functions, please see tao/Sequence.h
void
DynamicAny::_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::_allocate_buffer (CORBA::ULong length)
{
  DynamicAny::DynAny **tmp = 0;
  tmp = _TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::allocbuf (length);
  
  if (this->buffer_ != 0)
  {
    DynamicAny::DynAny **old = ACE_reinterpret_cast (DynamicAny::DynAny**, this->buffer_);
    for (CORBA::ULong i = 0; i < this->length_; ++i)
      {
        if (!this->release_)
          {
            tmp[i] = DynamicAny::DynAny::_duplicate (old[i]);
          }
        else
          {
            tmp[i] = old[i];
          }
      }
    
    if (this->release_)
      {
        delete[] old;
      }
  }
  this->buffer_ = tmp;
}

void
DynamicAny::_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::_deallocate_buffer (void)
{
  if (this->buffer_ == 0 || this->release_ == 0)
    return;
  DynamicAny::DynAny **tmp = ACE_reinterpret_cast (DynamicAny::DynAny**, this->buffer_);
  
  for (CORBA::ULong i = 0; i < this->length_; ++i)
    {
      CORBA::release (tmp[i]);
      tmp[i] = DynamicAny::DynAny::_nil ();
    }
  
  _TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::freebuf (tmp);
  this->buffer_ = 0;
}

DynamicAny::_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::~_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq (void)
{
  this->_deallocate_buffer ();
}

void
DynamicAny::_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::_shrink_buffer (CORBA::ULong nl, CORBA::ULong ol)
{
  DynamicAny::DynAny **tmp = ACE_reinterpret_cast (DynamicAny::DynAny**, this->buffer_);
  
  for (CORBA::ULong i = nl; i < ol; ++i)
    {
      CORBA::release (tmp[i]);
      tmp[i] = DynamicAny::DynAny::_nil ();
    }
}

void 
DynamicAny::_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::_downcast (
    void* target,
    CORBA::Object *src
    ACE_ENV_ARG_DECL
  )
{
  DynamicAny::DynAny **tmp = ACE_static_cast (DynamicAny::DynAny**, target);
  *tmp = DynamicAny::DynAny::_narrow (src ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
}

CORBA::Object*
DynamicAny::_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq::_upcast (void *src) const
{
  DynamicAny::DynAny **tmp = ACE_static_cast (DynamicAny::DynAny**, src);
  return *tmp;
}

#endif /* end #if !defined */


#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 

#if !defined (_DYNAMICANY_DYNANYSEQ_CS_)
#define _DYNAMICANY_DYNANYSEQ_CS_

// *************************************************************
// DynamicAny::DynAnySeq
// *************************************************************

DynamicAny::DynAnySeq::DynAnySeq (void)
{}
DynamicAny::DynAnySeq::DynAnySeq (CORBA::ULong max) // uses max size
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Object_Sequence<DynamicAny::DynAny,DynamicAny::DynAny_var>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max)
{}
DynamicAny::DynAnySeq::DynAnySeq (CORBA::ULong max, CORBA::ULong length, DynamicAny::DynAny_ptr *buffer, CORBA::Boolean release)
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Object_Sequence<DynamicAny::DynAny,DynamicAny::DynAny_var>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (max, length, buffer, release)
{}
DynamicAny::DynAnySeq::DynAnySeq (const DynAnySeq &seq) // copy ctor
  : 
#if !defined (TAO_USE_SEQUENCE_TEMPLATES)
_TAO_Unbounded_Object_Sequence_DynamicAny_DynAnySeq
#else /* TAO_USE_SEQUENCE_TEMPLATES */
TAO_Unbounded_Object_Sequence<DynamicAny::DynAny,DynamicAny::DynAny_var>
#endif /* !TAO_USE_SEQUENCE_TEMPLATES */ 
 (seq)
{}
DynamicAny::DynAnySeq::~DynAnySeq (void) // dtor
{}
void DynamicAny::DynAnySeq::_tao_any_destructor (void *_tao_void_pointer)
{
  DynAnySeq *tmp = ACE_static_cast (DynAnySeq*, _tao_void_pointer);
  delete tmp;
}


#endif /* end #if !defined */

int DynamicAny::DynSequence::_tao_class_id = 0;

DynamicAny::DynSequence_ptr
tao_DynamicAny_DynSequence_duplicate (
    DynamicAny::DynSequence_ptr p
  )
{
  return DynamicAny::DynSequence::_duplicate (p);
}

void
tao_DynamicAny_DynSequence_release (
    DynamicAny::DynSequence_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynSequence_ptr
tao_DynamicAny_DynSequence_nil (
    void
  )
{
  return DynamicAny::DynSequence::_nil ();
}

DynamicAny::DynSequence_ptr
tao_DynamicAny_DynSequence_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynSequence::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynSequence_upcast (
    void *src
  )
{
  DynamicAny::DynSequence **tmp =
    ACE_static_cast (DynamicAny::DynSequence **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynSequence_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynSequence_var::DynSequence_var (void) // default constructor
  : ptr_ (DynSequence::_nil ())
{}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynSequence_var::DynSequence_var (const ::DynamicAny::DynSequence_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynSequence::_duplicate (p.ptr ()))
{}

DynamicAny::DynSequence_var::~DynSequence_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynSequence_var &
DynamicAny::DynSequence_var::operator= (DynSequence_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynSequence_var &
DynamicAny::DynSequence_var::operator= (const ::DynamicAny::DynSequence_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynSequence::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynSequence_var::operator const ::DynamicAny::DynSequence_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynSequence_var::operator ::DynamicAny::DynSequence_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynSequence_ptr &
DynamicAny::DynSequence_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynSequence_ptr &
DynamicAny::DynSequence_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynSequence::_nil ();
  return this->ptr_;
}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynSequence_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynSequence::_nil ();
  return val;
}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_var::tao_duplicate (DynSequence_ptr p)
{
  return ::DynamicAny::DynSequence::_duplicate (p);
}

void
DynamicAny::DynSequence_var::tao_release (DynSequence_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_var::tao_nil (void)
{
  return ::DynamicAny::DynSequence::_nil ();
}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynSequence::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynSequence_var::tao_upcast (void *src)
{
  DynSequence **tmp =
    ACE_static_cast (DynSequence **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynSequence_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynSequence_out::DynSequence_out (DynSequence_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynSequence::_nil ();
}

DynamicAny::DynSequence_out::DynSequence_out (DynSequence_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynSequence::_nil ();
}

DynamicAny::DynSequence_out::DynSequence_out (const ::DynamicAny::DynSequence_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynSequence_out &, p).ptr_)
{}

::DynamicAny::DynSequence_out &
DynamicAny::DynSequence_out::operator= (const ::DynamicAny::DynSequence_out &p)
{
  this->ptr_ = ACE_const_cast (DynSequence_out&, p).ptr_;
  return *this;
}

DynamicAny::DynSequence_out &
DynamicAny::DynSequence_out::operator= (const ::DynamicAny::DynSequence_var &p)
{
  this->ptr_ = ::DynamicAny::DynSequence::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynSequence_out &
DynamicAny::DynSequence_out::operator= (DynSequence_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynSequence_out::operator ::DynamicAny::DynSequence_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynSequence_ptr &
DynamicAny::DynSequence_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynSequence_ptr
DynamicAny::DynSequence_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynSequence::DynSequence (void)
{}

DynamicAny::DynSequence::~DynSequence (void)
{}

DynamicAny::DynSequence_ptr DynamicAny::DynSequence::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynSequence::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynSequence_ptr 
DynamicAny::DynSequence::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynSequence::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynSequence_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynSequence::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynSequence_ptr
DynamicAny::DynSequence::_duplicate (DynSequence_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynSequence::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynSequence)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            DynamicAny::DynAny_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

int DynamicAny::DynArray::_tao_class_id = 0;

DynamicAny::DynArray_ptr
tao_DynamicAny_DynArray_duplicate (
    DynamicAny::DynArray_ptr p
  )
{
  return DynamicAny::DynArray::_duplicate (p);
}

void
tao_DynamicAny_DynArray_release (
    DynamicAny::DynArray_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynArray_ptr
tao_DynamicAny_DynArray_nil (
    void
  )
{
  return DynamicAny::DynArray::_nil ();
}

DynamicAny::DynArray_ptr
tao_DynamicAny_DynArray_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynArray::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynArray_upcast (
    void *src
  )
{
  DynamicAny::DynArray **tmp =
    ACE_static_cast (DynamicAny::DynArray **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynArray_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynArray_var::DynArray_var (void) // default constructor
  : ptr_ (DynArray::_nil ())
{}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynArray_var::DynArray_var (const ::DynamicAny::DynArray_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynArray::_duplicate (p.ptr ()))
{}

DynamicAny::DynArray_var::~DynArray_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynArray_var &
DynamicAny::DynArray_var::operator= (DynArray_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynArray_var &
DynamicAny::DynArray_var::operator= (const ::DynamicAny::DynArray_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynArray::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynArray_var::operator const ::DynamicAny::DynArray_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynArray_var::operator ::DynamicAny::DynArray_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynArray_ptr &
DynamicAny::DynArray_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynArray_ptr &
DynamicAny::DynArray_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynArray::_nil ();
  return this->ptr_;
}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynArray_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynArray::_nil ();
  return val;
}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_var::tao_duplicate (DynArray_ptr p)
{
  return ::DynamicAny::DynArray::_duplicate (p);
}

void
DynamicAny::DynArray_var::tao_release (DynArray_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_var::tao_nil (void)
{
  return ::DynamicAny::DynArray::_nil ();
}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynArray::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynArray_var::tao_upcast (void *src)
{
  DynArray **tmp =
    ACE_static_cast (DynArray **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynArray_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynArray_out::DynArray_out (DynArray_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynArray::_nil ();
}

DynamicAny::DynArray_out::DynArray_out (DynArray_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynArray::_nil ();
}

DynamicAny::DynArray_out::DynArray_out (const ::DynamicAny::DynArray_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynArray_out &, p).ptr_)
{}

::DynamicAny::DynArray_out &
DynamicAny::DynArray_out::operator= (const ::DynamicAny::DynArray_out &p)
{
  this->ptr_ = ACE_const_cast (DynArray_out&, p).ptr_;
  return *this;
}

DynamicAny::DynArray_out &
DynamicAny::DynArray_out::operator= (const ::DynamicAny::DynArray_var &p)
{
  this->ptr_ = ::DynamicAny::DynArray::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynArray_out &
DynamicAny::DynArray_out::operator= (DynArray_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynArray_out::operator ::DynamicAny::DynArray_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynArray_ptr &
DynamicAny::DynArray_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynArray_ptr
DynamicAny::DynArray_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynArray::DynArray (void)
{}

DynamicAny::DynArray::~DynArray (void)
{}

DynamicAny::DynArray_ptr DynamicAny::DynArray::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynArray::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynArray_ptr 
DynamicAny::DynArray::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynArray::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynArray_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynArray::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynArray_ptr
DynamicAny::DynArray::_duplicate (DynArray_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynArray::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynArray)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            DynamicAny::DynAny_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

int DynamicAny::DynValue::_tao_class_id = 0;

DynamicAny::DynValue_ptr
tao_DynamicAny_DynValue_duplicate (
    DynamicAny::DynValue_ptr p
  )
{
  return DynamicAny::DynValue::_duplicate (p);
}

void
tao_DynamicAny_DynValue_release (
    DynamicAny::DynValue_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynValue_ptr
tao_DynamicAny_DynValue_nil (
    void
  )
{
  return DynamicAny::DynValue::_nil ();
}

DynamicAny::DynValue_ptr
tao_DynamicAny_DynValue_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynValue::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynValue_upcast (
    void *src
  )
{
  DynamicAny::DynValue **tmp =
    ACE_static_cast (DynamicAny::DynValue **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynValue_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynValue_var::DynValue_var (void) // default constructor
  : ptr_ (DynValue::_nil ())
{}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynValue_var::DynValue_var (const ::DynamicAny::DynValue_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynValue::_duplicate (p.ptr ()))
{}

DynamicAny::DynValue_var::~DynValue_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynValue_var &
DynamicAny::DynValue_var::operator= (DynValue_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynValue_var &
DynamicAny::DynValue_var::operator= (const ::DynamicAny::DynValue_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynValue::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynValue_var::operator const ::DynamicAny::DynValue_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynValue_var::operator ::DynamicAny::DynValue_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynValue_ptr &
DynamicAny::DynValue_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynValue_ptr &
DynamicAny::DynValue_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynValue::_nil ();
  return this->ptr_;
}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynValue_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynValue::_nil ();
  return val;
}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_var::tao_duplicate (DynValue_ptr p)
{
  return ::DynamicAny::DynValue::_duplicate (p);
}

void
DynamicAny::DynValue_var::tao_release (DynValue_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_var::tao_nil (void)
{
  return ::DynamicAny::DynValue::_nil ();
}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynValue::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynValue_var::tao_upcast (void *src)
{
  DynValue **tmp =
    ACE_static_cast (DynValue **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynValue_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynValue_out::DynValue_out (DynValue_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynValue::_nil ();
}

DynamicAny::DynValue_out::DynValue_out (DynValue_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynValue::_nil ();
}

DynamicAny::DynValue_out::DynValue_out (const ::DynamicAny::DynValue_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynValue_out &, p).ptr_)
{}

::DynamicAny::DynValue_out &
DynamicAny::DynValue_out::operator= (const ::DynamicAny::DynValue_out &p)
{
  this->ptr_ = ACE_const_cast (DynValue_out&, p).ptr_;
  return *this;
}

DynamicAny::DynValue_out &
DynamicAny::DynValue_out::operator= (const ::DynamicAny::DynValue_var &p)
{
  this->ptr_ = ::DynamicAny::DynValue::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynValue_out &
DynamicAny::DynValue_out::operator= (DynValue_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynValue_out::operator ::DynamicAny::DynValue_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynValue_ptr &
DynamicAny::DynValue_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynValue_ptr
DynamicAny::DynValue_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynValue::DynValue (void)
{}

DynamicAny::DynValue::~DynValue (void)
{}

DynamicAny::DynValue_ptr DynamicAny::DynValue::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynValue::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynValue_ptr 
DynamicAny::DynValue::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynValue::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynValue_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynValue::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynValue_ptr
DynamicAny::DynValue::_duplicate (DynValue_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynValue::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynValue)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAny)::_tao_class_id))
    retv = ACE_reinterpret_cast
      (
        void *,
        ACE_static_cast
          (
            DynamicAny::DynAny_ptr,
            this
          )
      );
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

int DynamicAny::DynAnyFactory::_tao_class_id = 0;

DynamicAny::DynAnyFactory_ptr
tao_DynamicAny_DynAnyFactory_duplicate (
    DynamicAny::DynAnyFactory_ptr p
  )
{
  return DynamicAny::DynAnyFactory::_duplicate (p);
}

void
tao_DynamicAny_DynAnyFactory_release (
    DynamicAny::DynAnyFactory_ptr p
  )
{
  CORBA::release (p);
}

DynamicAny::DynAnyFactory_ptr
tao_DynamicAny_DynAnyFactory_nil (
    void
  )
{
  return DynamicAny::DynAnyFactory::_nil ();
}

DynamicAny::DynAnyFactory_ptr
tao_DynamicAny_DynAnyFactory_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return DynamicAny::DynAnyFactory::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
tao_DynamicAny_DynAnyFactory_upcast (
    void *src
  )
{
  DynamicAny::DynAnyFactory **tmp =
    ACE_static_cast (DynamicAny::DynAnyFactory **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynAnyFactory_var
// TAO_IDL - Generated from
// be/be_interface.cpp:654
// *************************************************************

DynamicAny::DynAnyFactory_var::DynAnyFactory_var (void) // default constructor
  : ptr_ (DynAnyFactory::_nil ())
{}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_var::ptr (void) const
{
  return this->ptr_;
}

DynamicAny::DynAnyFactory_var::DynAnyFactory_var (const ::DynamicAny::DynAnyFactory_var &p) // copy constructor
  : TAO_Base_var (),
    ptr_ (DynAnyFactory::_duplicate (p.ptr ()))
{}

DynamicAny::DynAnyFactory_var::~DynAnyFactory_var (void) // destructor
{
  CORBA::release (this->ptr_);
}

DynamicAny::DynAnyFactory_var &
DynamicAny::DynAnyFactory_var::operator= (DynAnyFactory_ptr p)
{
  CORBA::release (this->ptr_);
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynAnyFactory_var &
DynamicAny::DynAnyFactory_var::operator= (const ::DynamicAny::DynAnyFactory_var &p)
{
  if (this != &p)
  {
    CORBA::release (this->ptr_);
    this->ptr_ = ::DynamicAny::DynAnyFactory::_duplicate (p.ptr ());
  }
  return *this;
}

DynamicAny::DynAnyFactory_var::operator const ::DynamicAny::DynAnyFactory_ptr &() const // cast
{
  return this->ptr_;
}

DynamicAny::DynAnyFactory_var::operator ::DynamicAny::DynAnyFactory_ptr &() // cast 
{
  return this->ptr_;
}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_var::operator-> (void) const
{
  return this->ptr_;
}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_var::in (void) const
{
  return this->ptr_;
}

::DynamicAny::DynAnyFactory_ptr &
DynamicAny::DynAnyFactory_var::inout (void)
{
  return this->ptr_;
}

::DynamicAny::DynAnyFactory_ptr &
DynamicAny::DynAnyFactory_var::out (void)
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynAnyFactory::_nil ();
  return this->ptr_;
}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_var::_retn (void)
{
  // yield ownership of managed obj reference
  ::DynamicAny::DynAnyFactory_ptr val = this->ptr_;
  this->ptr_ = ::DynamicAny::DynAnyFactory::_nil ();
  return val;
}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_var::tao_duplicate (DynAnyFactory_ptr p)
{
  return ::DynamicAny::DynAnyFactory::_duplicate (p);
}

void
DynamicAny::DynAnyFactory_var::tao_release (DynAnyFactory_ptr p)
{
  CORBA::release (p);
}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_var::tao_nil (void)
{
  return ::DynamicAny::DynAnyFactory::_nil ();
}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_var::tao_narrow (
    CORBA::Object *p
    ACE_ENV_ARG_DECL
  )
{
  return ::DynamicAny::DynAnyFactory::_narrow (p ACE_ENV_ARG_PARAMETER);
}

CORBA::Object *
DynamicAny::DynAnyFactory_var::tao_upcast (void *src)
{
  DynAnyFactory **tmp =
    ACE_static_cast (DynAnyFactory **, src);
  return *tmp;
}

// *************************************************************
// DynamicAny::DynAnyFactory_out
// TAO_IDL - Generated from
// be/be_interface.cpp:932
// *************************************************************

DynamicAny::DynAnyFactory_out::DynAnyFactory_out (DynAnyFactory_ptr &p)
  : ptr_ (p)
{
  this->ptr_ = ::DynamicAny::DynAnyFactory::_nil ();
}

DynamicAny::DynAnyFactory_out::DynAnyFactory_out (DynAnyFactory_var &p) // constructor from _var
  : ptr_ (p.out ())
{
  CORBA::release (this->ptr_);
  this->ptr_ = ::DynamicAny::DynAnyFactory::_nil ();
}

DynamicAny::DynAnyFactory_out::DynAnyFactory_out (const ::DynamicAny::DynAnyFactory_out &p) // copy constructor
  : ptr_ (ACE_const_cast (DynAnyFactory_out &, p).ptr_)
{}

::DynamicAny::DynAnyFactory_out &
DynamicAny::DynAnyFactory_out::operator= (const ::DynamicAny::DynAnyFactory_out &p)
{
  this->ptr_ = ACE_const_cast (DynAnyFactory_out&, p).ptr_;
  return *this;
}

DynamicAny::DynAnyFactory_out &
DynamicAny::DynAnyFactory_out::operator= (const ::DynamicAny::DynAnyFactory_var &p)
{
  this->ptr_ = ::DynamicAny::DynAnyFactory::_duplicate (p.ptr ());
  return *this;
}

DynamicAny::DynAnyFactory_out &
DynamicAny::DynAnyFactory_out::operator= (DynAnyFactory_ptr p)
{
  this->ptr_ = p;
  return *this;
}

DynamicAny::DynAnyFactory_out::operator ::DynamicAny::DynAnyFactory_ptr &() // cast
{
  return this->ptr_;
}

::DynamicAny::DynAnyFactory_ptr &
DynamicAny::DynAnyFactory_out::ptr (void) // ptr
{
  return this->ptr_;
}

::DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory_out::operator-> (void)
{
  return this->ptr_;
}


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

DynamicAny::DynAnyFactory::DynAnyFactory (void)
{}

DynamicAny::DynAnyFactory::~DynAnyFactory (void)
{}

DynamicAny::DynAnyFactory_ptr DynamicAny::DynAnyFactory::_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL
  )
{
  return DynAnyFactory::_unchecked_narrow (obj ACE_ENV_ARG_PARAMETER);
}

DynamicAny::DynAnyFactory_ptr 
DynamicAny::DynAnyFactory::_unchecked_narrow (
    CORBA::Object_ptr obj
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  if (CORBA::is_nil (obj))
    return DynAnyFactory::_nil ();
  return
      ACE_reinterpret_cast
        (
          DynAnyFactory_ptr,
            obj->_tao_QueryInterface
              (
                ACE_reinterpret_cast
                  (
                    ptr_arith_t,
                    &DynAnyFactory::_tao_class_id
                  )
              )
        );
}

DynamicAny::DynAnyFactory_ptr
DynamicAny::DynAnyFactory::_duplicate (DynAnyFactory_ptr obj)
{
  if (!CORBA::is_nil (obj))
    obj->_add_ref ();
  return obj;
}

void *DynamicAny::DynAnyFactory::_tao_QueryInterface (ptr_arith_t type)
{
  void *retv = 0;
  if (type == ACE_reinterpret_cast
    (ptr_arith_t,
      &ACE_NESTED_CLASS (::DynamicAny, DynAnyFactory)::_tao_class_id))
    retv = ACE_reinterpret_cast (void*, this);
  else if (type == ACE_reinterpret_cast (ptr_arith_t, &CORBA::Object::_tao_class_id))
    retv = ACE_reinterpret_cast (void *,
      ACE_static_cast (CORBA::Object_ptr, this));
    
  if (retv)
    this->_add_ref ();
  return retv;
}

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

// Default constructor.
DynamicAny::DynAnyFactory::InconsistentTypeCode::InconsistentTypeCode (void)
  : CORBA::UserException (
        "IDL:omg.org/DynamicAny/DynAnyFactory/InconsistentTypeCode:1.0",
        "InconsistentTypeCode"
      )
{
}

// Destructor - all members are of self managing types.
DynamicAny::DynAnyFactory::InconsistentTypeCode::~InconsistentTypeCode (void)
{
}

// Copy constructor.
DynamicAny::DynAnyFactory::InconsistentTypeCode::InconsistentTypeCode (const ::DynamicAny::DynAnyFactory::InconsistentTypeCode &_tao_excp)
  : CORBA::UserException (
        _tao_excp._rep_id (),
        _tao_excp._name ()
      )
{
}

// Assignment operator.
DynamicAny::DynAnyFactory::InconsistentTypeCode&
DynamicAny::DynAnyFactory::InconsistentTypeCode::operator= (const ::DynamicAny::DynAnyFactory::InconsistentTypeCode &_tao_excp)
{
  this->UserException::operator= (_tao_excp);
  return *this;
}

DynamicAny::DynAnyFactory::InconsistentTypeCode *
DynamicAny::DynAnyFactory::InconsistentTypeCode::_downcast (CORBA::Exception *exc)
{
  if (!ACE_OS::strcmp ("IDL:omg.org/DynamicAny/DynAnyFactory/InconsistentTypeCode:1.0", exc->_rep_id ()))
    {
      return ACE_dynamic_cast (InconsistentTypeCode *, exc);
    }
  else
    {
      return 0;
    }
}

CORBA::Exception *DynamicAny::DynAnyFactory::InconsistentTypeCode::_alloc (void)
{
  CORBA::Exception *retval = 0;
  ACE_NEW_RETURN (retval, ::DynamicAny::DynAnyFactory::InconsistentTypeCode, 0);
  return retval;
}

CORBA::Exception *
DynamicAny::DynAnyFactory::InconsistentTypeCode::_tao_duplicate (void) const
{
  CORBA::Exception *result;
  ACE_NEW_RETURN (
      result,
      DynamicAny::DynAnyFactory::InconsistentTypeCode (*this),
      0
    );
  return result;
}

void DynamicAny::DynAnyFactory::InconsistentTypeCode::_raise ()
{
  TAO_RAISE (*this);
}

void DynamicAny::DynAnyFactory::InconsistentTypeCode::_tao_encode (
    TAO_OutputCDR &
    ACE_ENV_ARG_DECL
  ) const
{
  ACE_THROW (CORBA::MARSHAL ());
}

void DynamicAny::DynAnyFactory::InconsistentTypeCode::_tao_decode (
    TAO_InputCDR &
    ACE_ENV_ARG_DECL
  )
{
  ACE_THROW (CORBA::MARSHAL ());
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynAny,DynamicAny::DynAny_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynAny,DynamicAny::DynAny_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynFixed,DynamicAny::DynFixed_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynFixed,DynamicAny::DynFixed_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynEnum,DynamicAny::DynEnum_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynEnum,DynamicAny::DynEnum_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

void operator<<= (CORBA::Any &_tao_any, const DynamicAny::NameValuePair &_tao_elem) // copying
{
  TAO_OutputCDR stream;
  stream << _tao_elem;
  _tao_any._tao_replace (
      DynamicAny::_tc_NameValuePair,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin ()
    );
}

void operator<<= (CORBA::Any &_tao_any, DynamicAny::NameValuePair *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      DynamicAny::_tc_NameValuePair,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      DynamicAny::NameValuePair::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, DynamicAny::NameValuePair *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(const DynamicAny::NameValuePair*&,_tao_elem);
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const DynamicAny::NameValuePair *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (DynamicAny::_tc_NameValuePair ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const DynamicAny::NameValuePair*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      DynamicAny::NameValuePair *tmp;
      ACE_NEW_RETURN (tmp, DynamicAny::NameValuePair, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            DynamicAny::_tc_NameValuePair,
            1,
            ACE_static_cast (void *, tmp),
            DynamicAny::NameValuePair::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

void operator<<= (
    CORBA::Any &_tao_any,
    const DynamicAny::NameValuePairSeq &_tao_elem
  ) // copying
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        DynamicAny::_tc_NameValuePairSeq,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ()
      );
  }
}

void operator<<= (CORBA::Any &_tao_any, DynamicAny::NameValuePairSeq *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      DynamicAny::_tc_NameValuePairSeq,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      DynamicAny::NameValuePairSeq::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, DynamicAny::NameValuePairSeq *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const DynamicAny::NameValuePairSeq*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const DynamicAny::NameValuePairSeq *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (DynamicAny::_tc_NameValuePairSeq ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const DynamicAny::NameValuePairSeq*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      DynamicAny::NameValuePairSeq *tmp;
      ACE_NEW_RETURN (tmp, DynamicAny::NameValuePairSeq, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            DynamicAny::_tc_NameValuePairSeq,
            1,
            ACE_static_cast (void *, tmp),
            DynamicAny::NameValuePairSeq::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynStruct,DynamicAny::DynStruct_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynStruct,DynamicAny::DynStruct_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynUnion,DynamicAny::DynUnion_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynUnion,DynamicAny::DynUnion_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

void operator<<= (
    CORBA::Any &_tao_any,
    const DynamicAny::AnySeq &_tao_elem
  ) // copying
{
  TAO_OutputCDR stream;
  if (stream << _tao_elem)
  {
    _tao_any._tao_replace (
        DynamicAny::_tc_AnySeq,
        TAO_ENCAP_BYTE_ORDER,
        stream.begin ()
      );
  }
}

void operator<<= (CORBA::Any &_tao_any, DynamicAny::AnySeq *_tao_elem) // non copying
{
  TAO_OutputCDR stream;
  stream << *_tao_elem;
  _tao_any._tao_replace (
      DynamicAny::_tc_AnySeq,
      TAO_ENCAP_BYTE_ORDER,
      stream.begin (),
      1,
      _tao_elem,
      DynamicAny::AnySeq::_tao_any_destructor
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, DynamicAny::AnySeq *&_tao_elem)
{
  return _tao_any >>= ACE_const_cast(
      const DynamicAny::AnySeq*&,
      _tao_elem
    );
}

CORBA::Boolean operator>>= (const CORBA::Any &_tao_any, const DynamicAny::AnySeq *&_tao_elem)
{
  _tao_elem = 0;
  ACE_TRY_NEW_ENV
  {
    CORBA::TypeCode_var type = _tao_any.type ();
    
    CORBA::Boolean result = type->equivalent (DynamicAny::_tc_AnySeq ACE_ENV_ARG_PARAMETER);
    ACE_TRY_CHECK;
    
    if (!result)
      return 0; // not equivalent
    
    if (_tao_any.any_owns_data ())
    {
      _tao_elem = ACE_static_cast(
          const DynamicAny::AnySeq*,
          _tao_any.value ()
        );
      return 1;
    }
    else
    {
      DynamicAny::AnySeq *tmp;
      ACE_NEW_RETURN (tmp, DynamicAny::AnySeq, 0);
      TAO_InputCDR stream (
          _tao_any._tao_get_cdr (),
          _tao_any._tao_byte_order ()
        );
      if (stream >> *tmp)
      {
        ((CORBA::Any *)&_tao_any)->_tao_replace (
            DynamicAny::_tc_AnySeq,
            1,
            ACE_static_cast (void *, tmp),
            DynamicAny::AnySeq::_tao_any_destructor
          );
        _tao_elem = tmp;
        return 1;
      }
      else
      {
        delete tmp;
      }
    }
  }
  ACE_CATCHANY
  {
  }
  ACE_ENDTRY;
  return 0;
}

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynSequence,DynamicAny::DynSequence_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynSequence,DynamicAny::DynSequence_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynArray,DynamicAny::DynArray_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynArray,DynamicAny::DynArray_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynValue,DynamicAny::DynValue_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynValue,DynamicAny::DynValue_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

#if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION)  || \
    defined (ACE_HAS_GNU_REPO)
    template class TAO_Object_Manager<DynamicAny::DynAnyFactory,DynamicAny::DynAnyFactory_var>;
  #elif defined (ACE_HAS_TEMPLATE_INSTANTIATION_PRAGMA)
  #  pragma instantiate TAO_Object_Manager<DynamicAny::DynAnyFactory,DynamicAny::DynAnyFactory_var>
#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION */

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DynamicAny::NameValuePairSeq &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm << _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DynamicAny::NameValuePairSeq &_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 1159.)
    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_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm >> _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}

CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DynamicAny::AnySeq &_tao_sequence
  )
{
  if (strm << _tao_sequence.length ())
  {
    // encode all elements
    CORBA::Boolean _tao_marshal_flag = 1;
    for (CORBA::ULong i = 0; i < _tao_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm << _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}

CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DynamicAny::AnySeq &_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 1159.)
    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_sequence.length () && _tao_marshal_flag; i++)
    {
      _tao_marshal_flag = (strm >> _tao_sequence[i]);
    }
    return _tao_marshal_flag;
  }
  return 0; // error
}