admin_client.cpp

这是广泛使用的通信开源项目,对于大容量,高并发的通讯要求完全能够胜任,他广泛可用于网络游戏医学图像网关的高qos要求.更详细的内容可阅读相应的材料

  ACE_NEW (impl0,
           TAO::Unknown_IDL_Type (d_type.in (),
                                  maker0.begin (),
                                  TAO_ENCAP_BYTE_ORDER));
  CORBA::Any any0;
  any0.replace (impl0);
  u_members[1].label = any0;

  u_members[2].name = CORBA::string_dup ("structval");
  u_members[2].type_def = CORBA::StructDef::_duplicate (s_var.in ());
  u_members[2].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);

  TAO_OutputCDR maker1;
  maker1.write_ulong (0); // ZERO
  TAO::Unknown_IDL_Type *impl1 = 0;
  ACE_NEW (impl1,
           TAO::Unknown_IDL_Type (d_type.in (),
                                  maker1.begin (),
                                  TAO_ENCAP_BYTE_ORDER));
  CORBA::Any any1;
  any1.replace (impl1);
  u_members[2].label = any1;

  u_members[3].name = CORBA::string_dup ("stringval");
  u_members[3].type_def = this->repo_->create_string (17
                                                      ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  u_members[3].type = CORBA::TypeCode::_duplicate (CORBA::_tc_void);
  u_members[3].label <<= CORBA::Any::from_octet (0);   // default case (ONE)

  CORBA::UnionDef_var u_var =
    this->repo_->create_union ("IDL:my_union:1.0",
                               "my_union",
                               "1.0",
                               d_var.in (),
                               u_members
                               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::TypeCode_var disc_tc = u_var->discriminator_type (ACE_ENV_SINGLE_ARG_PARAMETER);
   ACE_CHECK;

  CORBA::ULong length = disc_tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((
        LM_DEBUG,
        ACE_TEXT ("UnionDef::discriminator_type::member_count: %d\n"),
        length
      ));

  ACE_ASSERT (length == 4);

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

  length = tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("UnionDef::type::member_count: %d\n"),
                length));

  ACE_ASSERT (length == 3);

  CORBA::Long slot = tc->default_index (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("UnionDef::type::default_index: %d\n\n"),
                slot));

  ACE_ASSERT (slot == 2);

  CORBA::String_var str;
  const char *tmp = 0;

  for (CORBA::ULong i = 0; i < length; i++)
    {
      str = tc->member_name (i
                             ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      if (this->debug_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("UnionDef::type::member_name[%d]: %s\n"),
                    i,
                    str.in ()));

      // Multiple labels for first member shifts index by 1.
      ACE_ASSERT (!ACE_OS::strcmp (str.in (), u_members[i + 1].name));

      CORBA::Any_var label = tc->member_label (i
                                               ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      TAO_InputCDR cdr (label->_tao_get_cdr ());
      CORBA::ULong val;

      // If we're at the default index, it's in the label as octet 0,
      // so just assign the slot value to val.
      if (i != (CORBA::ULong) slot)
        {
          cdr.read_ulong (val);
          tmp = d_members[val];
        }

      if (this->debug_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("UnionDef::type::member_label[%d]: %s\n"),
                    i,
                    i == (CORBA::ULong) slot ? "default" : tmp));

      // Labels are not in order.
      switch (i)
      {
        case 0:
          ACE_ASSERT (val == 3 || val == 2);
          break;
        case 1:
          ACE_ASSERT (val == 0);
          break;
        default:
          break;
      }
    }

  u_var->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  s_var->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  d_var->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
}

void
Admin_Client::exception_test (ACE_ENV_SINGLE_ARG_DECL)
{
  ACE_DEBUG ((
      LM_DEBUG,
      ACE_TEXT ("\n============== EXCEPTION TEST ==============\n\n")
    ));

  CORBA::StructMemberSeq members (3);
  members.length (3);

  members[0].name = CORBA::string_dup ("ub_string");
  members[0].type_def = this->repo_->get_primitive (CORBA::pk_string
                                                    ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  members[0].type = members[0].type_def->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  members[1].name = CORBA::string_dup ("bd_string");
  members[1].type_def = this->repo_->create_string (5
                                                    ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  members[1].type = members[1].type_def->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::EnumMemberSeq e_members (2);
  e_members.length (2);

  e_members[0] = CORBA::string_dup ("ZERO");
  e_members[1] = CORBA::string_dup ("ONE");

  members[2].name = CORBA::string_dup ("my_exception_enum");
  CORBA::EnumDef_var e_var = this->repo_->create_enum ("IDL:my_enum:1.0",
                                                       "my_enum",
                                                       "1.0",
                                                       e_members
                                                       ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  members[2].type_def = CORBA::EnumDef::_duplicate (e_var.in ());

  members[2].type = members[2].type_def->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::ExceptionDef_var exvar =
    this->repo_->create_exception ("IDL:my_exception:1.0",
                                   "my_exception",
                                   "1.0",
                                   members
                                   ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

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

  CORBA::ULong length = tc->member_count (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ExceptionDef::type::member_count: %d\n"),
                length));

  ACE_ASSERT (length == 3);

  CORBA::String_var str;
  CORBA::ULong i = 0;

  for (i = 0; i < length; i++)
    {
      str = tc->member_name (i ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

      if (this->debug_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("ExceptionDef::type::member_name[%d]: %s\n"),
                    i,
                    str.in ()));

      ACE_ASSERT (!ACE_OS::strcmp (str.in (), members[i].name));
    }

  CORBA::Contained::Description_var desc = exvar->describe (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::ExceptionDescription *ed;
  desc->value >>= ed;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nExceptionDef::describe::value::name: %s\n"),
                ed->name.in ()));

  ACE_ASSERT (!ACE_OS::strcmp (ed->name, "my_exception"));

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ExceptionDef::describe::value::id: %s\n"),
                ed->id.in ()));

  ACE_ASSERT (!ACE_OS::strcmp (ed->id, "IDL:my_exception:1.0"));

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ExceptionDef::describe::value::defined_in: %s\n"),
                ed->defined_in.in ()));

  ACE_ASSERT (!ACE_OS::strcmp (ed->defined_in, ""));

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ExceptionDef::describe::value::version: %s\n"),
                ed->version.in ()));

  ACE_ASSERT (!ACE_OS::strcmp (ed->version, "1.0"));

  members.length (2);
  members[0].name = CORBA::string_dup ("long_mem");
  members[0].type_def = this->repo_->get_primitive (CORBA::pk_long
                                                    ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  members[0].type = members[0].type_def->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  members[1].name = CORBA::string_dup ("array_mem");
  CORBA::ArrayDef_ptr a_ptr =
    this->repo_->create_array (5,
                               members[0].type_def.in ()
                               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  members[1].type_def = a_ptr;
  members[1].type = members[1].type_def->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  exvar->members (members
                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nExceptionDef::members (set)\n\n")));

  CORBA::EnumMemberSeq def_members (2);
  def_members.length (2);

  def_members[0] = CORBA::string_dup ("FIRST");
  def_members[1] = CORBA::string_dup ("SECOND");

  CORBA::EnumDef_var e_def_var = exvar->create_enum ("IDL:my_def_enum:1.0",
                                                     "my_enum",
                                                     "1.0",
                                                     def_members
                                                     ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::StructMemberSeq_var out_members = exvar->members (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  length = out_members->length ();

  for (i = 0; i < length; i++)
    {
      if (this->debug_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("ExceptionDef::members[%d]::name: %s\n"),
                    i,
                    out_members[i].name.in ()));

      if (i == 2)
        ACE_ASSERT (!ACE_OS::strcmp (out_members[i].name, "my_enum"));
      else
        ACE_ASSERT (!ACE_OS::strcmp (out_members[i].name, members[i].name));
    }

  a_ptr->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nArrayDef::destroy\n\n")));

  out_members = exvar->members (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  length = out_members->length ();

  for (i = 0; i < length; i++)
    {
      if (this->debug_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("ExceptionDef::members[%d]::name: %s\n"),
                    i,
                    out_members[i].name.in ()));

      if (i == 1)
        ACE_ASSERT (!ACE_OS::strcmp (out_members[i].name, "my_enum"));
      else
        ACE_ASSERT (!ACE_OS::strcmp (out_members[i].name, members[i].name));
    }

  CORBA::Contained_var fox = this->repo_->lookup ("::my_exception::my_enum"
                                                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  str = fox->absolute_name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nRepository::lookup: %s\n"),
                str.in ()));

  ACE_ASSERT (!ACE_OS::strcmp (str.in (), "::my_exception::my_enum"));

  fox = exvar->lookup ("my_enum"
                       ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  str = fox->absolute_name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ExceptionDef::lookup: %s\n"),
                str.in ()));

  ACE_ASSERT (!ACE_OS::strcmp (str.in (), "::my_exception::my_enum"));

  CORBA::ContainedSeq_var contents = this->repo_->contents (CORBA::dk_all,
                                                            0
                                                            ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  length = contents->length ();

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nRepository::contents::length: %d\n"),
                length));

  ACE_ASSERT (length == 2);

  contents = exvar->contents (CORBA::dk_all,
                              0
                              ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  length = contents->length ();

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ExceptionDef::contents::length: %d\n"),
                length));

  ACE_ASSERT (length == 1);

  for (i = 0; i < length; i++)
    {
      str = contents[i]->absolute_name (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      if (this->debug_)
        ACE_DEBUG ((
            LM_DEBUG,
            ACE_TEXT ("ExceptionDef::contents[%d]::absolute_name: %s\n"),
            i,
            str.in ()
          ));

      // Should be only the one member.
      ACE_ASSERT (!ACE_OS::strcmp (str.in (), "::my_exception::my_enum"));
    }

  contents = this->repo_->lookup_name ("my_enum",
                                       -1,
                                       CORBA::dk_all,
                                       0
                                       ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  length = contents->length ();

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nRepository::lookup_name::length: %d\n"),
                length));

  ACE_ASSERT (length == 2);

  for (i = 0; i < length; i++)
    {
      str = contents[i]->absolute_name (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;

      if (this->debug_)
        ACE_DEBUG ((
            LM_DEBUG,
            ACE_TEXT ("Repository::lookup_name%d]::absolute_name: %s\n"),
            i,
            str.in ()
          ));

      // Can't use ACE_ASSERT here - order of search results is unknown.
    }

  CORBA::Container::DescriptionSeq_var cont_desc =
    this->repo_->describe_contents (CORBA::dk_all,
                                    0,
                                    -1
                                    ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;