dyncommon.cpp

来自「这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用」· C++ 代码 · 共 1,854 行 · 第 1/3 页

CPP
1,854 行
字号
123
/* -*- C++ -*- */
// DynCommon.cpp,v 1.35 2003/11/19 20:04:20 parsons Exp

#include "DynCommon.h"
#include "DynAnyFactory.h"
#include "DynAny_i.h"
#include "DynArray_i.h"
#include "DynEnum_i.h"
#include "DynSequence_i.h"
#include "DynStruct_i.h"
#include "DynUnion_i.h"
#include "tao/Any_Unknown_IDL_Type.h"
#include "ace/OS_NS_wchar.h"

ACE_RCSID (DynamicAny,
           DynCommon,
           "DynCommon.cpp,v 1.35 2003/11/19 20:04:20 parsons Exp")


TAO_DynCommon::TAO_DynCommon (void)
{
}

TAO_DynCommon::~TAO_DynCommon (void)
{
}

// *****************************************************************

CORBA::TypeCode_ptr
TAO_DynCommon::type (ACE_ENV_SINGLE_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW_RETURN (CORBA::OBJECT_NOT_EXIST (),
                        CORBA::TypeCode::_nil ());
    }

  return CORBA::TypeCode::_duplicate (this->type_.in ());
}

void
TAO_DynCommon::assign (DynamicAny::DynAny_ptr dyn_any
                       ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  CORBA::TypeCode_var tc = dyn_any->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::Boolean equivalent =
    this->type_.in ()->equivalent (tc.in ()
                                   ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  if (equivalent)
    {
      CORBA::Any_var any = dyn_any->to_any (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      this->from_any (any.in ()
                      ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
    }
}

void
TAO_DynCommon::insert_boolean (CORBA::Boolean value
                               ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_boolean (value
                          ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_boolean
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= CORBA::Any::from_boolean (value);
    }
}

void
TAO_DynCommon::insert_octet (CORBA::Octet value
                             ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_octet (value
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_octet
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= CORBA::Any::from_octet (value);
    }
}

void
TAO_DynCommon::insert_char (CORBA::Char value
                            ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_char (value
                       ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_char
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= CORBA::Any::from_char (value);
    }
}

void
TAO_DynCommon::insert_short (CORBA::Short value
                             ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_short (value
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_short
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_ushort (CORBA::UShort value
                              ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_ushort (value
                         ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_ushort
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_long (CORBA::Long value
                            ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_long (value
                       ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_long
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_ulong (CORBA::ULong value
                             ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_ulong (value
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_ulong
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_float (CORBA::Float value
                             ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_float (value
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_float
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_double (CORBA::Double value
                              ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_double (value
                         ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_double
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_string (const char * value
                              ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_string (value
                         ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      CORBA::TypeCode_var unaliased_tc =
        TAO_DynAnyFactory::strip_alias (this->type_.in ()
                                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      CORBA::TCKind kind = 
        unaliased_tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      if (kind != CORBA::tk_string)
        {
          ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
        }

      CORBA::ULong bound = 
        unaliased_tc->length (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      if (bound > 0 && bound < ACE_OS::strlen (value))
        {
          ACE_THROW (DynamicAny::DynAny::InvalidValue ());
        }

      this->any_ <<= CORBA::Any::from_string (ACE_const_cast (char *,
                                                              value),
                                              bound);
    }
}

void
TAO_DynCommon::insert_reference (CORBA::Object_ptr value
                                 ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_reference (value
                            ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      CORBA::Boolean good_type = 1;
      CORBA::TCKind kind = 
        TAO_DynAnyFactory::unalias (this->type_.in ()
                                    ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      if (kind != CORBA::tk_objref)
        {
          good_type = 0;
        }
      else if (!CORBA::is_nil (value))
        {
          const char *value_id = value->_interface_repository_id ();

          if (ACE_OS::strcmp (value_id, "IDL:omg.org/CORBA/Object:1.0") != 0)
            {
              const char *my_id = 
                this->type_->id (ACE_ENV_SINGLE_ARG_PARAMETER);
              ACE_CHECK;

              if (ACE_OS::strcmp (value_id, my_id) != 0)
                {
                  good_type = value->_is_a (my_id
                                            ACE_ENV_ARG_PARAMETER);
                  ACE_CHECK;
                }
            }
        }

      if (good_type)
        {
          TAO_OutputCDR cdr;

          if (CORBA::is_nil (value))
            {
              // Empty type hint, no profile.
              cdr.write_ulong (1);
              cdr.write_char ('\0');
              cdr.write_ulong (0);
            }
          else
            {
              value->marshal (cdr);
            }

          TAO::Unknown_IDL_Type *unk = 0;
          ACE_NEW (unk,
                   TAO::Unknown_IDL_Type (this->type_.in (),
                                          cdr.begin (),
                                          TAO_ENCAP_BYTE_ORDER));
          this->any_.replace (unk);
        }
      else
        {
          ACE_THROW (DynamicAny::DynAny::TypeMismatch ());
        }
    }
}

void
TAO_DynCommon::insert_typecode (CORBA::TypeCode_ptr value
                                ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_typecode (value
                           ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_TypeCode
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_longlong (CORBA::LongLong value
                                ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_longlong (value
                           ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
  else
    {
      this->check_type (CORBA::_tc_longlong
                        ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      this->any_ <<= value;
    }
}

void
TAO_DynCommon::insert_ulonglong (CORBA::ULongLong value
                                 ACE_ENV_ARG_DECL)
  ACE_THROW_SPEC ((
      CORBA::SystemException,
      DynamicAny::DynAny::TypeMismatch,
      DynamicAny::DynAny::InvalidValue
    ))
{
  if (this->destroyed_)
    {
      ACE_THROW (CORBA::OBJECT_NOT_EXIST ());
    }

  if (this->has_components_)
    {
      DynamicAny::DynAny_var cc = 
        this->check_component (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      cc->insert_ulonglong (value
                            ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;
    }
123

dyncommon.cpp - 源码说明

本页面展示了「这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料」中的 dyncommon.cpp 源码文件，采用 C++ 编程语言编写，共 1,854 行代码。您可以在线阅读完整代码内容，也可以返回资源详情页下载完整源码包进行本地学习和开发。

虫虫开发者社区收录了大量与通信框架相关的技术资源，包括源代码、技术文档、电路图等，是电子工程师和嵌入式开发者的专业学习平台。

⌨️ 快捷键说明

复制代码Ctrl + C
搜索代码Ctrl + F
全屏模式F11
增大字号Ctrl + =
减小字号Ctrl + -
显示快捷键?