admin_client.cpp

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

// -*- C++ -*-
// Admin_Client.cpp,v 1.24 2003/10/28 18:34:28 bala Exp

#include "Admin_Client.h"

#include "tao/Any_Unknown_IDL_Type.h"

#include "ace/Get_Opt.h"
#include "ace/SString.h"

ACE_RCSID (IFR_Test, 
           Admin_Client, 
           "Admin_Client.cpp,v 1.24 2003/10/28 18:34:28 bala Exp")

Admin_Client::Admin_Client (void)
  : debug_ (0),
    all_tests_ (1),
    which_test_ (0),
    iterations_ (1)
{
  // Initialize the array of pointers to member functions.
  this->test_array_[0] = &Admin_Client::array_test;
  this->test_array_[1] = &Admin_Client::enum_test;
  this->test_array_[2] = &Admin_Client::alias_test;
  this->test_array_[3] = &Admin_Client::native_test;
  this->test_array_[4] = &Admin_Client::struct_test;
  this->test_array_[5] = &Admin_Client::union_test;
  this->test_array_[6] = &Admin_Client::exception_test;
  this->test_array_[7] = &Admin_Client::constant_test;
  this->test_array_[8] = &Admin_Client::interface_test;
  this->test_array_[9] = &Admin_Client::move_test;
  this->test_array_[10] = &Admin_Client::module_test;
}

Admin_Client::~Admin_Client (void)
{
}

// An array of test names, so we can step through them when
// trying to find a match for a test selected on the command line.
const char *Admin_Client::test_names_[] =
{
  "array",
  "enum",
  "alias",
  "native",
  "struct",
  "union",
  "exception",
  "constant",
  "interface",
  "move",
  "module"
};

int
Admin_Client::init (int argc,
                    char *argv[])
{
  ACE_TRY_NEW_ENV
    {
      this->orb_ = CORBA::ORB_init (argc,
                                    argv,
                                    0
                                    ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      int retval = this->parse_args (argc,
                                     argv);

      if (retval != 0)
        return retval;

      CORBA::Object_var object =
        this->orb_->resolve_initial_references ("InterfaceRepository"
                                                ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      if (CORBA::is_nil (object.in ()))
        {
          ACE_ERROR_RETURN ((
              LM_ERROR,
              "Null objref from resolve_initial_references\n"
            ),
            -1
          );
        }

      this->repo_ =
        CORBA::Repository::_narrow (object.in ()
                                    ACE_ENV_ARG_PARAMETER);
      ACE_TRY_CHECK;

      if (CORBA::is_nil (this->repo_.in ()))
        {
          ACE_ERROR_RETURN ((LM_ERROR,
                             "CORBA::Repository::_narrow failed\n"),
                            -1);
        }
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "Admin_Client::init");
      return -1;
    }
  ACE_ENDTRY;

  return 0;
}

int
Admin_Client::run (void)
{
  ACE_TRY_NEW_ENV
    {
      if (this->all_tests_ == 1)
        {
          for (CORBA::ULong i = 0; i < NUMBER_OF_TESTS; ++i)
            {
              // Each test is run twice to make sure everything
              // gets destroyed properly. If not, we get a
              // CORBA::BAD_PARAM exception the second time.
              for (CORBA::ULong j = 0; j < this->iterations_; ++j)
                {
                  (this->*test_array_[i])(ACE_ENV_SINGLE_ARG_PARAMETER);
                  ACE_TRY_CHECK;
                }
            }
        }
      else
        {
          for (CORBA::ULong j = 0; j < this->iterations_; ++j)
            {
              (this->*test_array_[this->which_test_])(ACE_ENV_SINGLE_ARG_PARAMETER);
              ACE_TRY_CHECK;
            }
        }
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "Admin_Client::run");
      return -1;
    }
  ACE_ENDTRY;

  return 0;
}

int
Admin_Client::parse_args (int argc,
                          char *argv[])
{
  ACE_Get_Opt opts (argc, argv, "di:t:");
  int c;
  int result = 0;
  CORBA::ULong i = 0;
  char *name = 0;

  while ((c = opts ()) != -1)
    switch (c)
      {
      case 'd':   // debug flag
        this->debug_ = 1;
        break;
      case 'i':   // iterations
        result = ACE_OS::atoi (opts.opt_arg ());
        if (result > 0)
          this->iterations_ = result;
        break;
      case 't':   // test selection
        this->all_tests_ = 0;
        name = opts.opt_arg ();

        for (i = 0; i < NUMBER_OF_TESTS; ++i)
          {
            if (ACE_OS::strcmp (name, this->test_names_[i]) == 0)
              {
                this->which_test_ = i;
                break;
              }
          }

        break;
      case '?':
      default:
        ACE_ERROR_RETURN ((LM_ERROR,
                           "usage: %s"
                           " [-d]"
                           " [-i iterations]"
                           " [-t test name]"
                           "\n",
                           argv [0]),
                          -1);
      }

  return 0;
}

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

  CORBA::IDLType_var atype = this->repo_->create_string (7
                                                         ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::ArrayDef_var avar = this->repo_->create_array (5,
                                                        atype.in ()
                                                        ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

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

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

  ACE_ASSERT (bound == 5);

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

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

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

  ACE_ASSERT (kind == CORBA::tk_array);

  tc = avar->element_type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  kind = tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (kind == CORBA::tk_string);

  CORBA::IDLType_var tdef = avar->element_type_def (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  CORBA::DefinitionKind dk = tdef->def_kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((
        LM_DEBUG,
        ACE_TEXT ("ArrayDef::element_type_def::def_kind: %d\n"),
        dk
      ));

  ACE_ASSERT (dk == CORBA::dk_String);

  CORBA::StringDef_var pvar = CORBA::StringDef::_narrow (tdef.in ()
                                                         ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  bound = pvar->bound (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (bound == 7);

  CORBA::PrimitiveDef_var pdef =
    this->repo_->get_primitive (CORBA::pk_short
                                ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  avar->element_type_def (pdef.in ()
                          ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

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

  tc = avar->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  kind = tc->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (kind == CORBA::tk_array);

  tdef = avar->element_type_def (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  dk = tdef->def_kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ArrayDef::element_type_def::def_kind: %d\n"),
                dk));

  ACE_ASSERT (dk == CORBA::dk_Primitive);

  CORBA::PrimitiveDef_var zvar =
    CORBA::PrimitiveDef::_narrow (tdef.in ()
                                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  CORBA::PrimitiveKind pkind = zvar->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (pkind == CORBA::pk_short);

  avar->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
}

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

  CORBA::EnumMemberSeq members (4);
  members.length (3);

  members[0] = CORBA::string_dup ("ZERO");
  members[1] = CORBA::string_dup ("ONE");
  members[2] = CORBA::string_dup ("TWO");

  CORBA::EnumDef_var evar = this->repo_->create_enum ("IDL:my_enum:1.0",
                                                      "my_enum",
                                                      "1.0",
                                                      members
                                                      ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

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

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

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

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

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

  ACE_ASSERT (!ACE_OS::strcmp (str.in (), "my_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 (), "::my_enum"));

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

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

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

  CORBA::DefinitionKind dkind = evar->def_kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (dkind == CORBA::dk_Enum);

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

  dkind = desc->kind;

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

  ACE_ASSERT (dkind == CORBA::dk_Enum);

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

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

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

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

  ACE_ASSERT (!ACE_OS::strcmp (td->id, "IDL:my_enum:1.0"));

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

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

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

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