admin_client.cpp

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

  length = cont_desc->length ();

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

  ACE_ASSERT (length == 2);

  CORBA::TypeDescription *td;
  for (i = 0; i < length; i++)
    {
      CORBA::DefinitionKind kind = cont_desc[i].kind;
      if (kind == CORBA::dk_Exception)
        {
          cont_desc[i].value >>= ed;
          CORBA::TypeCode_ptr tc = ed->type.in ();

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

          if (this->debug_)
            ACE_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("Repository::describe_contents[%d]")
                        ACE_TEXT ("::value::type::member_count: %d\n"),
                        i,
                        length));

          ACE_ASSERT (length == 2);

          if (this->debug_)
            ACE_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("Repository::describe_contents[%d]")
                        ACE_TEXT ("::value::name: %s\n"),
                        i,
                        ed->name.in ()));

          ACE_ASSERT (!ACE_OS::strcmp (ed->name, "my_exception"));
        }
      else
        {
          cont_desc[i].value >>= td;
          CORBA::TypeCode_ptr tc = td->type.in ();

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

          if (this->debug_)
            ACE_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("Repository::describe_contents[%d]")
                        ACE_TEXT ("::value::type::member_count: %d\n"),
                        i,
                        length));

          ACE_ASSERT (length == 2);

          if (this->debug_)
            ACE_DEBUG ((LM_DEBUG,
                        ACE_TEXT ("Repository::describe_contents[%d]")
                        ACE_TEXT ("::value::name: %s\n"),
                        i,
                        td->name.in ()));

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

  exvar->name ("your_exception"
               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

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

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

  length = contents->length ();
  const char *tmp = "::your_exception";

  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 ()
          ));

      ACE_ASSERT (!ACE_OS::strncmp (str.in (), tmp, ACE_OS::strlen (tmp)));
    }

#if defined (ACE_NDEBUG)
  // ACE_ASSERT macro expands to nothing, so...
  ACE_UNUSED_ARG (tmp);
#endif /* ACE_NDEBUG */

  e_var->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  exvar->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
}

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

  CORBA::IDLType_var ivar = this->repo_->get_primitive (CORBA::pk_string
                                                        ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::Any any;
  const char *s = "hello";
  any <<= s;

  CORBA::ConstantDef_var cvar =
    this->repo_->create_constant ("IDL:my_constant:1.0",
                                  "my_constant",
                                  "1.0",
                                  ivar.in (),
                                  any
                                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::TypeCode_var tc = cvar->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 ("ConstantDef::type::kind: %d\n"),
                kind));

  ACE_ASSERT (kind == CORBA::tk_string);

  CORBA::IDLType_var tdef = cvar->type_def (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
  CORBA::DefinitionKind def_kind = tdef->def_kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (def_kind == CORBA::dk_Primitive);

  CORBA::Any_var out_any;
  out_any = cvar->value (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  const char *out_s;
  out_any >>= out_s;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ConstantDef::value (string): %s\n"),
                out_s));

  ACE_ASSERT (!ACE_OS::strcmp (out_s, s));

  ivar = this->repo_->get_primitive (CORBA::pk_double
                                     ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  cvar->type_def (ivar.in ()
                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::Double double_val = -1223.42256;
  any <<= double_val;
  cvar->value (any
               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nConstantDef::type_def (set)\n")
                ACE_TEXT ("ConstantDef::value (set)\n")));

  out_any = cvar->value (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::Double out_double_val;
  out_any >>= out_double_val;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ConstantDef::value (double): %.5f\n"),
                out_double_val));

  ACE_ASSERT (out_double_val == double_val);

  ivar = this->repo_->get_primitive (CORBA::pk_short
                                     ACE_ENV_ARG_PARAMETER);
  cvar->type_def (ivar.in ()
                  ACE_ENV_ARG_PARAMETER);

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nConstantDef::type_def (set)\n")
                ACE_TEXT ("ConstantDef::value (set)\n")));

  CORBA::Short short_val = -65;
  any <<= short_val;

  cvar->value (any
               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  out_any = cvar->value (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::Short out_short_val;
  out_any >>= out_short_val;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ConstantDef::value (short): %hd\n"),
                out_short_val));

  ACE_ASSERT (out_short_val == short_val);

  ivar = this->repo_->get_primitive (CORBA::pk_float
                                     ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  cvar->type_def (ivar.in ()
                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nConstantDef::type_def (set)\n")
                ACE_TEXT ("ConstantDef::value (set)\n")));

  CORBA::Float float_val = 2.33f;
  any <<= float_val;

  cvar->value (any
               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  out_any = cvar->value (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::Float out_float_val;
  out_any >>= out_float_val;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("ConstantDef::value (float): %.2f\n"),
                out_float_val));

  ACE_ASSERT (out_float_val == float_val);

  ivar = this->repo_->get_primitive (CORBA::pk_ulonglong
                                     ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  cvar->type_def (ivar.in ()
                  ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nConstantDef::type_def (set)\n")
                ACE_TEXT ("ConstantDef::value (set)\n")));

  CORBA::ULongLong ull_val = 1234567890;
  any <<= ull_val;

  cvar->value (any
               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;
  out_any = cvar->value (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::ULongLong out_ull_val;
  out_any >>= out_ull_val;

  if (this->debug_)
    {
#if defined (ACE_LACKS_LONGLONG_T)
      char buffer[32];
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("ConstantDef::value (ulonglong): %s\n"),
                  out_ull_val.as_string (buffer)));
#else
      ACE_DEBUG ((LM_DEBUG,
                  ACE_TEXT ("ConstantDef::value (ulonglong): %Q\n"),
                  out_ull_val));
#endif
    }
  ACE_ASSERT (out_ull_val == ull_val);

  cvar->destroy (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;
}

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

  CORBA::ULong i, length;

  CORBA::InterfaceDefSeq in_bases (1);
  in_bases.length (0);

  CORBA::InterfaceDef_var gp_ivar =
    this->repo_->create_interface ("IDL:gp_iface:1.0",
                                   "gp_iface",
                                   "1.0",
                                   in_bases
                                   ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::PrimitiveDef_var p_long =
    this->repo_->get_primitive (CORBA::pk_long
                                ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::AttributeDef_var gp_attr =
    gp_ivar->create_attribute ("IDL:gp_iface/gp_attr:1.0",
                               "gp_attr",
                               "1.0",
                               p_long.in (),
                               CORBA::ATTR_NORMAL
                               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  in_bases.length (1);
  in_bases[0] = CORBA::InterfaceDef::_duplicate (gp_ivar.in ());

  CORBA::InterfaceDef_var p_ivar =
    this->repo_->create_interface ("IDL:p_iface:1.0",
                                   "p_iface",
                                   "1.0",
                                   in_bases
                                   ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::StringDef_var p_string = this->repo_->create_string (5
                                                              ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  CORBA::AttributeDef_var p_attr =
    p_ivar->create_attribute ("IDL:p_iface/p_attr:1.0",
                              "p_attr",
                              "1.0",
                              p_string.in (),
                              CORBA::ATTR_READONLY
                              ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

  const char *names[] = {"inarg", "inoutarg", "outarg"};

  const CORBA::ParameterMode modes[] =
    {CORBA::PARAM_IN, CORBA::PARAM_INOUT, CORBA::PARAM_OUT};

  const char *contexts[] = {"straw", "sticks", "bricks"};

  length = 3;
  CORBA::ParDescriptionSeq par_seq (3);
  par_seq.length (3);

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

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

  CORBA::ExceptionDefSeq get_seq (1);
  get_seq.length (1);
  get_seq[0] = CORBA::ExceptionDef::_duplicate (ex_var.in ());

  CORBA::ContextIdSeq con_seq (3);
  con_seq.length (3);

  for (i = 0; i < length; ++i)
    {
      par_seq[i].name = names[i];
      par_seq[i].type_def = CORBA::PrimitiveDef::_duplicate (p_long.in ());
      par_seq[i].type = p_long->type (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK;
      par_seq[i].mode = modes[i];
      con_seq[i] = contexts[i];
    }

  CORBA::OperationDef_var p_op =
    p_ivar->create_operation ("IDL:p_iface/p_op:1.0",
                              "p_op",
                              "1.0",
                              p_long.in (),
                              CORBA::OP_NORMAL,
                              par_seq,
                              get_seq,
                              con_seq
                              ACE_ENV_ARG_PARAMETER);
  ACE_CHECK;

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

  CORBA::OperationDescription *od;
  desc->value >>= od;

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

  ACE_ASSERT (!ACE_OS::strcmp (od->defined_in, "IDL:p_iface:1.0"));

  CORBA::TypeCode_var result = od->result;
  CORBA::TCKind kind = result->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK;

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

  ACE_ASSERT (kind == CORBA::tk_long);

  length = od->parameters.length ();

  if (this->debug_)
    ACE_DEBUG ((LM_DEBUG,
                ACE_TEXT ("\nOpe