admin_client.cpp

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

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

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("EnumDef::describe::value::type::kind: %d\n"),
                kind));

  ACE_ASSERT (kind == CORBA::tk_enum);

  str = td->type->id (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

  str = td->type->name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

  CORBA::ULong count = td->type->member_count ();

  if (this->debug_)
    ACE_DEBUG ((
        LM_DEBUG,
        ACE_TEXT ("EnumDef::describe::value::type::member_count: %d\n\n"),
        count
      ));

  ACE_ASSERT (count == 3);

  CORBA::ULong i = 0;

  for (i = 0; i < count; i++)
    {
      str = td->type->member_name (i ACE_ENV_ARG_PARAMETER);
      ACE_CHECK;

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

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


  members.length (4);
  members[0] = CORBA::string_dup ("NOTHINGNESS");
  members[1] = CORBA::string_dup ("UNITY");
  members[2] = CORBA::string_dup ("DUALITY");
  members[3] = CORBA::string_dup ("TRINITY");

  evar->members (members
                 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

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

  CORBA::EnumMemberSeq_var fellows = evar->members (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  count = fellows->length ();
  const char *tmp = 0;

  for (i = 0; i < count; i++)
    {
      tmp = fellows[i];

      if (this->debug_)
        ACE_DEBUG ((LM_DEBUG,
                    ACE_TEXT ("EnumDef::")
                    ACE_TEXT ("members[%d]: %s\n"),
                    i,
                    tmp));

      ACE_ASSERT (!ACE_OS::strcmp (fellows[i], members[i]));
    }

  evar->name ("another_enum"
              ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  str = evar->name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

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

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

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

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

  evar->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
}

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

  // This test also tests WstringDef and SequenceDef.

  CORBA::IDLType_var sq_elem = this->repo_->create_wstring (7
                                                            ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::SequenceDef_var sq_var =
    this->repo_->create_sequence (5,
                                  sq_elem.in ()
                                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::AliasDef_var a_var =
    this->repo_->create_alias ("IDL:my_alias:1.0",
                               "my_alias",
                               "1.0",
                               sq_var.in ()
                               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::String_var str = a_var->id (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (!ACE_OS::strcmp (str.in (), "IDL:my_alias:1.0"));

  str = a_var->name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

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

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

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

  str = a_var->version (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

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

  a_var->version ("1.1"
                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  str = a_var->version (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

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

  str = tc->name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

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

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("AliasDef::type::kind: %d\n"),
                kind));

  ACE_ASSERT (kind == CORBA::tk_alias);

  CORBA::TypeCode_var ct = tc->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  kind = ct->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("AliasDef::type::content_type::kind: %d\n"),
                kind));

  ACE_ASSERT (kind == CORBA::tk_sequence);

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

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

  ACE_ASSERT (length == 5);

  CORBA::TypeCode_var ct2 = ct->content_type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  kind = ct2->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("AliasDef::type::content_type::")
                ACE_TEXT ("content_type::kind: %d\n"),
                kind));

  ACE_ASSERT (kind == CORBA::tk_wstring);

  length = ct2->length (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (length == 7);

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

  CORBA::TypeDescription *td;
  desc->value >>= td;

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

  ACE_ASSERT (!ACE_OS::strcmp (td->name, "my_alias"));

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

  ACE_ASSERT (!ACE_OS::strcmp (td->version, "1.1"));

  kind = td->type->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("AliasDef::describe::value::type::kind: %d\n"),
                kind));

  ACE_ASSERT (kind == CORBA::tk_alias);

  str = td->type->id (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (!ACE_OS::strcmp (str.in (), "IDL:my_alias:1.0"));

  str = td->type->name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

  CORBA::IDLType_var i_var = a_var->original_type_def (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::SequenceDef_var seq_var =
    CORBA::SequenceDef::_narrow (i_var.in ()
                                 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  length = seq_var->bound (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("AliasDef::original_type_def::bound: %d\n"),
                length));

  ACE_ASSERT (length == 5);

  a_var->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
}

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

  CORBA::NativeDef_var nvar =
    this->repo_->create_native ("IDL:my_native:1.0",
                                "my_native",
                                "1.0"
                                ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::String_var str = nvar->id (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (!ACE_OS::strcmp (str.in (), "IDL:my_native:1.0"));

  str = nvar->name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

  str = nvar->version (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

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

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

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

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

  CORBA::DefinitionKind kind = nvar->def_kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("NativeDef::def_kind: %d\n"),
                kind));

  ACE_ASSERT (kind == CORBA::dk_Native);

  nvar->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
}

void
Admin_Client::struct_test (ACE_ENV_SINGLE_ARG_DECL)
{
  ACE_DEBUG ((
      LM_DEBUG,
      ACE_TEXT ("\n============== STRUCT 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 = CORBA::TypeCode::_duplicate (CORBA::_tc_void);

  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 = CORBA::TypeCode::_duplicate (CORBA::_tc_void);

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