MessageC.cpp

[$(NDDSHOME)/example/CPP/corba/MessageC.h]

// -*- C++ -*-
// TAO_IDL - Generated from
// be/be_codegen.cpp:149

#ifndef _TAO_IDL_MESSAGEC_XUUIMD_H_
#define _TAO_IDL_MESSAGEC_XUUIMD_H_


#include  "ace/config-all.h"

#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */


#include "tao/AnyTypeCode/AnyTypeCode_methods.h"
#include "tao/AnyTypeCode/Any.h"
#include "tao/ORB.h"
#include "tao/SystemException.h"
#include "tao/Basic_Types.h"
#include "tao/ORB_Constants.h"
#include "tao/Object.h"
#include "tao/String_Manager_T.h"
#include "tao/Objref_VarOut_T.h"
#include "tao/VarOut_T.h"
#include "tao/Arg_Traits_T.h"
#include "tao/Basic_Arguments.h"
#include "tao/Special_Basic_Arguments.h"
#include "tao/Any_Insert_Policy_T.h"
#include "tao/Fixed_Size_Argument_T.h"
#include "tao/Var_Size_Argument_T.h"
#include "tao/BD_String_Argument_T.h"
#include "tao/AnyTypeCode/Any.h"
#include "tao/Object_Argument_T.h"
#include  "tao/Version.h"
#include  "tao/Versioned_Namespace.h"

#if TAO_MAJOR_VERSION != 2 || TAO_MINOR_VERSION != 4 || TAO_MICRO_VERSION != 1
#error This file should be regenerated with TAO_IDL
#endif

#if defined (TAO_EXPORT_MACRO)
#undef TAO_EXPORT_MACRO
#endif
#define TAO_EXPORT_MACRO 

// TAO_IDL - Generated from
// be/be_visitor_root/root_ch.cpp:157
TAO_BEGIN_VERSIONED_NAMESPACE_DECL



namespace TAO
{
  template<typename T> class Narrow_Utils;
}
TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_constant/constant_ch.cpp:35

const CORBA::Long MSG_MAX_LENGTH = 255;

// TAO_IDL - Generated from
// be/be_type.cpp:258

struct DateTime;

typedef
  ::TAO_Fixed_Var_T<
      DateTime
    >
  DateTime_var;

typedef
  DateTime &
  DateTime_out;

// TAO_IDL - Generated from
// be/be_visitor_structure/structure_ch.cpp:48

struct  DateTime
{

  // TAO_IDL - Generated from
  // be/be_type.cpp:304

  
  typedef DateTime_var _var_type;
  typedef DateTime_out _out_type;

  static void _tao_any_destructor (void *);
  
  ::CORBA::Long year;
  ::CORBA::Long month;
  ::CORBA::Long day;
  ::CORBA::Long hour;
  ::CORBA::Long minute;
  ::CORBA::Long second;
};

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_decl.cpp:34

extern  ::CORBA::TypeCode_ptr const _tc_DateTime;

// TAO_IDL - Generated from
// be/be_visitor_typedef/typedef_ch.cpp:404

typedef char * MessageText;
typedef ::CORBA::String_var MessageText_var;
typedef ::CORBA::String_out MessageText_out;

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_decl.cpp:34

extern  ::CORBA::TypeCode_ptr const _tc_MessageText;

// TAO_IDL - Generated from
// be/be_type.cpp:258

struct Message;

typedef
  ::TAO_Var_Var_T<
      Message
    >
  Message_var;

typedef
  ::TAO_Out_T<
      Message
    >
  Message_out;

// TAO_IDL - Generated from
// be/be_visitor_structure/structure_ch.cpp:48

struct  Message
{

  // TAO_IDL - Generated from
  // be/be_type.cpp:304

  
  typedef Message_var _var_type;
  typedef Message_out _out_type;

  static void _tao_any_destructor (void *);
  
  DateTime time;
  ::TAO::String_Manager msg;
};

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_decl.cpp:34

extern  ::CORBA::TypeCode_ptr const _tc_Message;

// TAO_IDL - Generated from
// be/be_interface.cpp:748

#if !defined (_MESSAGERECEIVER__VAR_OUT_CH_)
#define _MESSAGERECEIVER__VAR_OUT_CH_

class MessageReceiver;
typedef MessageReceiver *MessageReceiver_ptr;

typedef
  TAO_Objref_Var_T<
      MessageReceiver
    >
  MessageReceiver_var;

typedef
  TAO_Objref_Out_T<
      MessageReceiver
    >
  MessageReceiver_out;

#endif /* end #if !defined */

// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ch.cpp:40

class  MessageReceiver
  : public virtual ::CORBA::Object
{
public:
  friend class TAO::Narrow_Utils<MessageReceiver>;

  // TAO_IDL - Generated from
  // be/be_type.cpp:304

  typedef MessageReceiver_ptr _ptr_type;
  typedef MessageReceiver_var _var_type;
  typedef MessageReceiver_out _out_type;

  static void _tao_any_destructor (void *);

  // The static operations.
  static MessageReceiver_ptr _duplicate (MessageReceiver_ptr obj);

  static void _tao_release (MessageReceiver_ptr obj);

  static MessageReceiver_ptr _narrow (::CORBA::Object_ptr obj);
  static MessageReceiver_ptr _unchecked_narrow (::CORBA::Object_ptr obj);
  static MessageReceiver_ptr _nil (void);

  virtual void sendMessage (
    const ::Message & msg);

  // TAO_IDL - Generated from
  // be/be_visitor_interface/interface_ch.cpp:137

  virtual ::CORBA::Boolean _is_a (const char *type_id);
  virtual const char* _interface_repository_id (void) const;
  virtual ::CORBA::Boolean marshal (TAO_OutputCDR &cdr);

protected:
  // Concrete interface only.
  MessageReceiver (void);

  // Concrete non-local interface only.
  MessageReceiver (
      ::IOP::IOR *ior,
      TAO_ORB_Core *orb_core);
  
  // Non-local interface only.
  MessageReceiver (
      TAO_Stub *objref,
      ::CORBA::Boolean _tao_collocated = false,
      TAO_Abstract_ServantBase *servant = 0,
      TAO_ORB_Core *orb_core = 0);

  virtual ~MessageReceiver (void);

private:
  // Private and unimplemented for concrete interfaces.
  MessageReceiver (const MessageReceiver &);

  void operator= (const MessageReceiver &);
};

// TAO_IDL - Generated from
// be/be_visitor_typecode/typecode_decl.cpp:34

extern  ::CORBA::TypeCode_ptr const _tc_MessageReceiver;

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

TAO_BEGIN_VERSIONED_NAMESPACE_DECL


// Arg traits specializations.
namespace TAO
{

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

  template<>
  class Arg_Traits< ::DateTime>
    : public
        Fixed_Size_Arg_Traits_T<
            ::DateTime,
            TAO::Any_Insert_Policy_Stream
          >
  {
  };

#if !defined (_MESSAGETEXT255__ARG_TRAITS_)
#define _MESSAGETEXT255__ARG_TRAITS_

  struct MessageText_255 {};

  template<>
  class Arg_Traits<MessageText_255>
    : public
        BD_String_Arg_Traits_T<
            CORBA::String_var,
            255,
            TAO::Any_Insert_Policy_Stream
        >
  {
  };

#endif /* end #if !defined */

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

  template<>
  class Arg_Traits< ::Message>
    : public
        Var_Size_Arg_Traits_T<
            ::Message,
            TAO::Any_Insert_Policy_Stream
          >
  {
  };

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

#if !defined (_MESSAGERECEIVER__ARG_TRAITS_)
#define _MESSAGERECEIVER__ARG_TRAITS_

  template<>
  class  Arg_Traits< ::MessageReceiver>
    : public
        Object_Arg_Traits_T<
            ::MessageReceiver_ptr,
            ::MessageReceiver_var,
            ::MessageReceiver_out,
            TAO::Objref_Traits<MessageReceiver>,
            TAO::Any_Insert_Policy_Stream
          >
  {
  };

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

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_traits.cpp:60

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

// Traits specializations.
namespace TAO
{

#if !defined (_MESSAGERECEIVER__TRAITS_)
#define _MESSAGERECEIVER__TRAITS_

  template<>
  struct  Objref_Traits< ::MessageReceiver>
  {
    static ::MessageReceiver_ptr duplicate (
        ::MessageReceiver_ptr p);
    static void release (
        ::MessageReceiver_ptr p);
    static ::MessageReceiver_ptr nil (void);
    static ::CORBA::Boolean marshal (
        const ::MessageReceiver_ptr p,
        TAO_OutputCDR & cdr);
  };

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



// TAO_IDL - Generated from
// be/be_visitor_structure/any_op_ch.cpp:42


TAO_BEGIN_VERSIONED_NAMESPACE_DECL

 void operator<<= (::CORBA::Any &, const DateTime &); // copying version
 void operator<<= (::CORBA::Any &, DateTime*); // noncopying version
 ::CORBA::Boolean operator>>= (const ::CORBA::Any &, DateTime *&); // deprecated
 ::CORBA::Boolean operator>>= (const ::CORBA::Any &, const DateTime *&);
TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_structure/any_op_ch.cpp:42


TAO_BEGIN_VERSIONED_NAMESPACE_DECL

 void operator<<= (::CORBA::Any &, const Message &); // copying version
 void operator<<= (::CORBA::Any &, Message*); // noncopying version
 ::CORBA::Boolean operator>>= (const ::CORBA::Any &, Message *&); // deprecated
 ::CORBA::Boolean operator>>= (const ::CORBA::Any &, const Message *&);
TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_interface/any_op_ch.cpp:41


TAO_BEGIN_VERSIONED_NAMESPACE_DECL

 void operator<<= (::CORBA::Any &, MessageReceiver_ptr); // copying
 void operator<<= (::CORBA::Any &, MessageReceiver_ptr *); // non-copying
 ::CORBA::Boolean operator>>= (const ::CORBA::Any &, MessageReceiver_ptr &);
TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_ch.cpp:43


TAO_BEGIN_VERSIONED_NAMESPACE_DECL

 ::CORBA::Boolean operator<< (TAO_OutputCDR &, const DateTime &);
 ::CORBA::Boolean operator>> (TAO_InputCDR &, DateTime &);

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_ch.cpp:43


TAO_BEGIN_VERSIONED_NAMESPACE_DECL

 ::CORBA::Boolean operator<< (TAO_OutputCDR &, const Message &);
 ::CORBA::Boolean operator>> (TAO_InputCDR &, Message &);

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_ch.cpp:41

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

 ::CORBA::Boolean operator<< (TAO_OutputCDR &, const MessageReceiver_ptr );
 ::CORBA::Boolean operator>> (TAO_InputCDR &, MessageReceiver_ptr &);

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_codegen.cpp:1700
#if defined (__ACE_INLINE__)
#include "MessageC.inl"
#endif /* defined INLINE */

#endif /* ifndef */

[$(NDDSHOME)/example/CPP/corba/MessageC.cpp]

// -*- C++ -*-
// TAO_IDL - Generated from
// be/be_codegen.cpp:373


#include "MessageC.h"
#include "tao/AnyTypeCode/Null_RefCount_Policy.h"
#include "tao/AnyTypeCode/TypeCode_Constants.h"
#include "tao/AnyTypeCode/Alias_TypeCode_Static.h"
#include "tao/AnyTypeCode/Objref_TypeCode_Static.h"
#include "tao/AnyTypeCode/String_TypeCode_Static.h"
#include "tao/AnyTypeCode/Struct_TypeCode_Static.h"
#include "tao/AnyTypeCode/TypeCode_Struct_Field.h"
#include "tao/CDR.h"
#include "tao/Exception_Data.h"
#include "tao/Invocation_Adapter.h"
#include "tao/Object_T.h"
#include "tao/CDR.h"
#include "tao/AnyTypeCode/Any.h"
#include "tao/AnyTypeCode/Any_Impl_T.h"
#include "tao/AnyTypeCode/Any_Dual_Impl_T.h"
#include "ace/OS_NS_string.h"

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

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

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_DateTime[] =
      {
        { "year", &CORBA::_tc_long },
        { "month", &CORBA::_tc_long },
        { "day", &CORBA::_tc_long },
        { "hour", &CORBA::_tc_long },
        { "minute", &CORBA::_tc_long },
        { "second", &CORBA::_tc_long }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_DateTime (
  ::CORBA::tk_struct,
  "IDL:DateTime:1.0",
  "DateTime",
  _tao_fields_DateTime,
  6);

::CORBA::TypeCode_ptr const _tc_DateTime =
  &_tao_tc_DateTime;

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

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/alias_typecode.cpp:49



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


#ifndef _TAO_TYPECODE_CORBA_STRING_255_GUARD
#define _TAO_TYPECODE_CORBA_STRING_255_GUARD

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

namespace TAO
{
  namespace TypeCode
  {
    namespace
    {
      TAO::TypeCode::String<TAO::Null_RefCount_Policy>
        CORBA_STRING_255 (
          ::CORBA::tk_string,
          255U);
        
      ::CORBA::TypeCode_ptr const tc_CORBA_STRING_255 =
        &CORBA_STRING_255;
    }
  }
}

TAO_END_VERSIONED_NAMESPACE_DECL

#endif /* _TAO_TYPECODE_CORBA_STRING_255_GUARD */

static TAO::TypeCode::Alias<char const *,
                            ::CORBA::TypeCode_ptr const *,
                            TAO::Null_RefCount_Policy>
  _tao_tc_MessageText (
    ::CORBA::tk_alias,
    "IDL:MessageText:1.0",
    "MessageText",
    &TAO::TypeCode::tc_CORBA_STRING_255);
  
::CORBA::TypeCode_ptr const _tc_MessageText =
  &_tao_tc_MessageText;

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

static TAO::TypeCode::Struct_Field<
  char const *,
  ::CORBA::TypeCode_ptr const *> const 
    _tao_fields_Message[] =
      {
        { "time", &_tc_DateTime },
        { "msg", &_tc_MessageText }
      };
  
static TAO::TypeCode::Struct<
  char const *,
  ::CORBA::TypeCode_ptr const *,
  TAO::TypeCode::Struct_Field<
    char const *,
    ::CORBA::TypeCode_ptr const *> const *,
  TAO::Null_RefCount_Policy>
_tao_tc_Message (
  ::CORBA::tk_struct,
  "IDL:Message:1.0",
  "Message",
  _tao_fields_Message,
  2);

::CORBA::TypeCode_ptr const _tc_Message =
  &_tao_tc_Message;

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

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

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

// Traits specializations for MessageReceiver.

MessageReceiver_ptr
TAO::Objref_Traits<MessageReceiver>::duplicate (
    MessageReceiver_ptr p)
{
  return MessageReceiver::_duplicate (p);
}

void
TAO::Objref_Traits<MessageReceiver>::release (
    MessageReceiver_ptr p)
{
  ::CORBA::release (p);
}

MessageReceiver_ptr
TAO::Objref_Traits<MessageReceiver>::nil (void)
{
  return MessageReceiver::_nil ();
}

::CORBA::Boolean
TAO::Objref_Traits<MessageReceiver>::marshal (
    const MessageReceiver_ptr p,
    TAO_OutputCDR & cdr)
{
  return ::CORBA::Object::marshal (p, cdr);
}

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

void
MessageReceiver::sendMessage (
  const ::Message & msg)
{
  if (!this->is_evaluated ())
    {
      ::CORBA::Object::tao_object_initialize (this);
    }
  
  TAO::Arg_Traits< void>::ret_val _tao_retval;
  TAO::Arg_Traits< ::Message>::in_arg_val _tao_msg (msg);

  TAO::Argument *_the_tao_operation_signature [] =
    {
      &_tao_retval,
      &_tao_msg
    };

  TAO::Invocation_Adapter _tao_call (
      this,
      _the_tao_operation_signature,
      2,
      "sendMessage",
      11,
      TAO::TAO_CO_NONE | TAO::TAO_CO_THRU_POA_STRATEGY
      
    );

  _tao_call.invoke (0, 0);
}

MessageReceiver::MessageReceiver (void)
{
}

MessageReceiver::~MessageReceiver (void)
{
}

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

MessageReceiver_ptr
MessageReceiver::_narrow (
    ::CORBA::Object_ptr _tao_objref)
{
  return
    TAO::Narrow_Utils<MessageReceiver>::narrow (
        _tao_objref,
        "IDL:MessageReceiver:1.0");
}

MessageReceiver_ptr
MessageReceiver::_unchecked_narrow (
    ::CORBA::Object_ptr _tao_objref)
{
  return
    TAO::Narrow_Utils<MessageReceiver>::unchecked_narrow (
        _tao_objref);
}

MessageReceiver_ptr
MessageReceiver::_nil (void)
{
  return 0;
}

MessageReceiver_ptr
MessageReceiver::_duplicate (MessageReceiver_ptr obj)
{
  if (! ::CORBA::is_nil (obj))
    {
      obj->_add_ref ();
    }
  return obj;
}

void
MessageReceiver::_tao_release (MessageReceiver_ptr obj)
{
  ::CORBA::release (obj);
}

::CORBA::Boolean
MessageReceiver::_is_a (const char *value)
{
  if (
      ACE_OS::strcmp (
          value,
          "IDL:MessageReceiver:1.0"
        ) == 0 ||
      ACE_OS::strcmp (
          value,
          "IDL:omg.org/CORBA/Object:1.0"
        ) == 0
    )
    {
      return true; // success using local knowledge
    }
  else
    {
      return this->::CORBA::Object::_is_a (value);
    }
}

const char* MessageReceiver::_interface_repository_id (void) const
{
  return "IDL:MessageReceiver:1.0";
}

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

// TAO_IDL - Generated from
// be/be_visitor_typecode/objref_typecode.cpp:70

static TAO::TypeCode::Objref<char const *,
                             TAO::Null_RefCount_Policy>
  _tao_tc_MessageReceiver (
    ::CORBA::tk_objref,
    "IDL:MessageReceiver:1.0",
    "MessageReceiver");
  
::CORBA::TypeCode_ptr const _tc_MessageReceiver =
  &_tao_tc_MessageReceiver;

// TAO_IDL - Generated from
// be/be_visitor_structure/any_op_cs.cpp:43


TAO_BEGIN_VERSIONED_NAMESPACE_DECL

void operator<<= (
  ::CORBA::Any &_tao_any,
  const DateTime &_tao_elem)
{
  TAO::Any_Dual_Impl_T<DateTime>::insert_copy (
    _tao_any,
    DateTime::_tao_any_destructor,
    _tc_DateTime,
    _tao_elem);
}

void operator<<= (
  ::CORBA::Any &_tao_any,
  DateTime *_tao_elem)
{
  TAO::Any_Dual_Impl_T<DateTime>::insert (
    _tao_any,
    DateTime::_tao_any_destructor,
    _tc_DateTime,
    _tao_elem);
}

::CORBA::Boolean operator>>= (
  const ::CORBA::Any &_tao_any,
  DateTime *&_tao_elem)
{
  return _tao_any >>= const_cast<
      const DateTime *&> (
      _tao_elem);
}

::CORBA::Boolean operator>>= (
  const ::CORBA::Any &_tao_any,
  const DateTime *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<DateTime>::extract (
      _tao_any,
      DateTime::_tao_any_destructor,
      _tc_DateTime,
      _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_structure/any_op_cs.cpp:43


TAO_BEGIN_VERSIONED_NAMESPACE_DECL

void operator<<= (
  ::CORBA::Any &_tao_any,
  const Message &_tao_elem)
{
  TAO::Any_Dual_Impl_T<Message>::insert_copy (
    _tao_any,
    Message::_tao_any_destructor,
    _tc_Message,
    _tao_elem);
}

void operator<<= (
  ::CORBA::Any &_tao_any,
  Message *_tao_elem)
{
  TAO::Any_Dual_Impl_T<Message>::insert (
    _tao_any,
    Message::_tao_any_destructor,
    _tc_Message,
    _tao_elem);
}

::CORBA::Boolean operator>>= (
  const ::CORBA::Any &_tao_any,
  Message *&_tao_elem)
{
  return _tao_any >>= const_cast<
      const Message *&> (
      _tao_elem);
}

::CORBA::Boolean operator>>= (
  const ::CORBA::Any &_tao_any,
  const Message *&_tao_elem)
{
  return
    TAO::Any_Dual_Impl_T<Message>::extract (
      _tao_any,
      Message::_tao_any_destructor,
      _tc_Message,
      _tao_elem);
}
TAO_END_VERSIONED_NAMESPACE_DECL



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



namespace TAO
{
  template<>
  ::CORBA::Boolean
  Any_Impl_T<MessageReceiver>::to_object (
      ::CORBA::Object_ptr &_tao_elem) const
  {
    _tao_elem = ::CORBA::Object::_duplicate (this->value_);
    return true;
  }
}
TAO_END_VERSIONED_NAMESPACE_DECL


TAO_BEGIN_VERSIONED_NAMESPACE_DECL



void
operator<<= (
    ::CORBA::Any &_tao_any,
    MessageReceiver_ptr _tao_elem)
{
  MessageReceiver_ptr _tao_objptr =
    MessageReceiver::_duplicate (_tao_elem);
  _tao_any <<= &_tao_objptr;
}

void
operator<<= (
    ::CORBA::Any &_tao_any,
    MessageReceiver_ptr *_tao_elem)
{
  TAO::Any_Impl_T<MessageReceiver>::insert (
      _tao_any,
      MessageReceiver::_tao_any_destructor,
      _tc_MessageReceiver,
      *_tao_elem);
}

::CORBA::Boolean
operator>>= (
    const ::CORBA::Any &_tao_any,
    MessageReceiver_ptr &_tao_elem)
{
  return
    TAO::Any_Impl_T<MessageReceiver>::extract (
        _tao_any,
        MessageReceiver::_tao_any_destructor,
        _tc_MessageReceiver,
        _tao_elem);
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:49

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const DateTime &_tao_aggregate)
{
  return
    (strm << _tao_aggregate.year) &&
    (strm << _tao_aggregate.month) &&
    (strm << _tao_aggregate.day) &&
    (strm << _tao_aggregate.hour) &&
    (strm << _tao_aggregate.minute) &&
    (strm << _tao_aggregate.second);
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    DateTime &_tao_aggregate)
{
  return
    (strm >> _tao_aggregate.year) &&
    (strm >> _tao_aggregate.month) &&
    (strm >> _tao_aggregate.day) &&
    (strm >> _tao_aggregate.hour) &&
    (strm >> _tao_aggregate.minute) &&
    (strm >> _tao_aggregate.second);
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_structure/cdr_op_cs.cpp:49

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const Message &_tao_aggregate)
{
  return
    (strm << _tao_aggregate.time) &&
    (strm << ACE_OutputCDR::from_string (_tao_aggregate.msg.in (), 255));
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    Message &_tao_aggregate)
{
  return
    (strm >> _tao_aggregate.time) &&
    (strm >> ACE_InputCDR::to_string (_tao_aggregate.msg.out (), 255));
}

TAO_END_VERSIONED_NAMESPACE_DECL



// TAO_IDL - Generated from
// be/be_visitor_interface/cdr_op_cs.cpp:51

TAO_BEGIN_VERSIONED_NAMESPACE_DECL

::CORBA::Boolean operator<< (
    TAO_OutputCDR &strm,
    const MessageReceiver_ptr _tao_objref)
{
  ::CORBA::Object_ptr _tao_corba_obj = _tao_objref;
  return (strm << _tao_corba_obj);
}

::CORBA::Boolean operator>> (
    TAO_InputCDR &strm,
    MessageReceiver_ptr &_tao_objref)
{
  ::CORBA::Object_var obj;

  if (!(strm >> obj.inout ()))
    {
      return false;
    }
  
  typedef ::MessageReceiver RHS_SCOPED_NAME;

  // Narrow to the right type.
  _tao_objref =
    TAO::Narrow_Utils<RHS_SCOPED_NAME>::unchecked_narrow (obj.in ());
    
  return true;
}

TAO_END_VERSIONED_NAMESPACE_DECL

[$(NDDSHOME)/example/CPP/corba/MessageC.inl]

// -*- C++ -*-
// TAO_IDL - Generated from
// be/be_visitor_interface/interface_ci.cpp:59

ACE_INLINE
MessageReceiver::MessageReceiver (
    TAO_Stub *objref,
    ::CORBA::Boolean _tao_collocated,
    TAO_Abstract_ServantBase *servant,
    TAO_ORB_Core *oc)
  : ::CORBA::Object (objref, _tao_collocated, servant, oc)
{
}

ACE_INLINE
MessageReceiver::MessageReceiver (
    ::IOP::IOR *ior,
    TAO_ORB_Core *oc)
  : ::CORBA::Object (ior, oc)
{
}