idl3_client.cpp

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

    }

  const char *tmp = 0;

  for (CORBA::ULong i = 0; i < ATTRS_LEN; ++i)
    {
      tmp = desc->attributes[i].name.in ();

      if (tmp == 0 || ACE_OS::strcmp (tmp, ATTR_LOCAL_NAMES[i]) != 0)
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_attribute_test: "
                          "wrong local name for attribute #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      CORBA::TCKind kind = 
        desc->attributes[i].type->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK_RETURN (-1);

      if (kind != ATTR_TC_KINDS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_attribute_test: "
                          "wrong TCKind for attribute #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      if (desc->attributes[i].get_exceptions.length () != GET_EXCEP_LEN[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_attribute_test: "
                          "wrong number of get-exceptions"
                          " for attribute #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      if (desc->attributes[i].put_exceptions.length () != PUT_EXCEP_LEN[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_attribute_test: "
                          "wrong number of put-exceptions"
                          " for attribute #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }
    }

  return 0;
}

int
IDL3_Client::valuetype_operation_test (
    CORBA::ExtValueDef::ExtFullValueDescription_var &desc,
    const char *prefix
    ACE_ENV_ARG_DECL
  )
{
  CORBA::ULong ops_length = desc->operations.length ();

  if (ops_length != OPS_LEN)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "%stype_operation_test: "
                      "wrong number of operations\n",
                      prefix));
        }

      return -1;
    }

  const char *tmp = 0;
  CORBA::ULong j = 0;
  CORBA::ULong length = 0;

  for (CORBA::ULong i = 0; i < ops_length; ++i)
    {
      tmp = desc->operations[i].name.in ();

      if (tmp == 0 || ACE_OS::strcmp (tmp, OP_NAMES[i]) != 0)
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_operation_test: "
                          "wrong name for operation #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      CORBA::TCKind ret_kind = 
        desc->operations[i].result.in ()->kind (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK_RETURN (-1);

      if (ret_kind != OP_RET_KINDS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_operation_test: "
                          "wrong return type\n",
                          prefix));
            }

          return -1;
        }

      length = desc->operations[i].parameters.length ();

      if (length != PARAMS_LEN[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_operation_test: "
                          "wrong number of parameters in operation #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      for (j = 0; j < length; ++j)
        {
          tmp = desc->operations[i].parameters[j].name.in ();

          if (tmp == 0 || ACE_OS::strcmp (tmp, PARAM_NAMES[j]) != 0)
            {
              if (this->debug_)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              "%stype_operation_test: "
                              "wrong name for operation #%d,"
                              "parameter #%d\n",
                              prefix,
                              i + 1, 
                              j + 1));
                }

              return -1;
            }
        }

      length = desc->operations[i].exceptions.length ();

      if (length != OP_EXCEP_LEN[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_operation_test: "
                          "wrong number of exceptions in operation #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }
    }

  return 0;
}

int
IDL3_Client::valuetype_member_test (
    CORBA::ExtValueDef::ExtFullValueDescription_var &desc,
    const char *prefix
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  CORBA::ULong length = desc->members.length ();

  if (length != MEM_LEN)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "%stype_member_test: "
                      "wrong number of members\n",
                      prefix));
        }

      return -1;
    }

  const char *tmp = 0;

  for (CORBA::ULong i = 0; i < length; ++i)
    {
      if (desc->members[i].access != MEM_VIS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_member_test: "
                          "wrong access value in member #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      tmp = desc->members[i].name.in ();

      if (tmp == 0 || ACE_OS::strcmp (tmp, MEM_NAMES[i]) != 0)
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_member_test: "
                          "wrong repo id for member #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }
    }

  return 0;
}

int
IDL3_Client::valuetype_factory_test (
    CORBA::ExtValueDef::ExtFullValueDescription_var &desc,
    const char *prefix
    ACE_ENV_ARG_DECL_NOT_USED
  )
{
  CORBA::ULong length = desc->initializers.length ();

  if (length != FACTORY_LEN)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "%stype_factory_test: "
                      "wrong number of factories\n",
                      prefix));
        }

      return -1;
    }

  CORBA::ULong inside_len = 0;
  const char *tmp = 0;

  for (CORBA::ULong i = 0; i < FACTORY_LEN; ++i)
    {
      inside_len = desc->initializers[i].members.length ();

      if (inside_len != VT_FACTORY_PARAM_LENS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_factory_test: "
                          "wrong number of params in factory #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      CORBA::ULong j = 0;

      for (j = 0; j < VT_FACTORY_PARAM_LENS[i]; ++j)
        {
          tmp = desc->initializers[i].members[j].name.in ();

          if (tmp == 0 
              || ACE_OS::strcmp (tmp, VT_FACTORY_PARAM_NAMES[i][j]) != 0)
            {
              if (this->debug_)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              "%stype_factory_test: "
                              "wrong name for arg #%d in factory #%d\n",
                              prefix,
                              j + 1,
                              i + 1));
                }

              return -1;
            }
        }

      inside_len = desc->initializers[i].exceptions.length ();

      if (inside_len != VT_FACTORY_EXCEP_LENS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "%stype_factory_test: "
                          "wrong number of exceptions in factory #%d\n",
                          prefix,
                          i + 1));
            }

          return -1;
        }

      for (j = 0; j < VT_FACTORY_EXCEP_LENS[i]; ++j)
        {
          tmp = desc->initializers[i].exceptions[j].name.in ();

          if (tmp == 0 
              || ACE_OS::strcmp (tmp, VT_FACTORY_EXCEP_NAMES[i][j]) != 0)
            {
              if (this->debug_)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              "%stype_factory_test: "
                              "wrong name for exception #%d in factory #%d\n",
                              prefix,
                              j + 1,
                              i + 1));
                }

              return -1;
            }
        }
    }

  return 0;
}

int
IDL3_Client::home_inheritance_test (CORBA::ComponentIR::HomeDef_var &hd
                                    ACE_ENV_ARG_DECL)
{
  CORBA::ComponentIR::HomeDef_var bhd = 
    hd->base_home (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (bhd.in ()))
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_inheritance_test: "
                      "base home is null\n"));
        }

      return -1;
    }

  CORBA::String_var str = bhd->id (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (str.in () == 0 || ACE_OS::strcmp (str.in (), HOME_BASE_ID) != 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_inheritance_test: "
                      "wrong repo id for base home\n"));
        }

      return -1;
    }

  CORBA::InterfaceDefSeq_var supported = 
    hd->supported_interfaces (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  CORBA::ULong length = supported->length ();

  if (length != HOME_SUPPORTED_LEN)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_inheritance_test: "
                      "wrong number of supported interfaces\n"));
        }

      return -1;
    }

  for (CORBA::ULong i = 0; i < length; ++i)
    {
      str = supported[i].in ()->id (ACE_ENV_SINGLE_ARG_PARAMETER);
      ACE_CHECK_RETURN (-1);

      if (str.in () == 0 
          || ACE_OS::strcmp (str.in (), HOME_SUPPORTED_IDS[i]) != 0)
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "home_inheritance_test: "
                          "bad id on supported interface #%d\n",
                          i + 1));
            }

          return -1;
        }
    }

  return 0;
}

int
IDL3_Client::home_factory_test (CORBA::ComponentIR::HomeDescription *hd
                                ACE_ENV_ARG_DECL_NOT_USED)
{
  CORBA::ULong length = hd->factories.length ();

  if (length != HOME_FACTORY_LEN)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_factory_test: "
                      "wrong number of factories\n"));
        }

      return -1;
    }

  CORBA::ULong inside_len = 0;
  CORBA::ULong j = 0;
  const char *tmp = 0;

  for (CORBA::ULong i = 0; i < HOME_FACTORY_LEN; ++i)
    {
      inside_len = hd->factories[i].parameters.length ();

      if (inside_len != HOME_FACTORY_PARAM_LENS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "home_factory_test: "
                          "wrong number of params in factory #%d\n",
                          i + 1));
            }

          return -1;
        }

      for (j = 0; j < inside_len; ++j)
        {
          tmp = hd->factories[i].parameters[j].name.in ();

          if (tmp == 0 
              || ACE_OS::strcmp (tmp, HOME_FACTORY_PARAM_NAMES[i][j]) != 0)
            {
              if (this->debug_)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              "home_factory_test: "
                              "wrong name for param #%d in factory #%d\n",
                              j + 1,
                              i + 1));
                }

              return -1;
            }
        }

      inside_len = hd->factories[i].exceptions.length ();

      if (inside_len != HOME_FACTORY_EXCEP_LENS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "home_factory_test: "
                          "wrong number of exceptions in factory #%d\n",
                          i + 1));
            }

          return -1;
        }

      for (j = 0; j < inside_len; ++j)
        {
          tmp = hd->factories[i].exceptions[j].name.in ();

          if (tmp == 0 
              || ACE_OS::strcmp (tmp, HOME_FACTORY_EXCEP_NAMES[i][j]) != 0)
            {
              if (this->debug_)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              "home_factory_test: "
                              "wrong name for exception #%d in factory #%d\n",
                              j + 1,
                              i + 1));
                }

              return -1;
            }
        }
    }

  return 0;
}

int
IDL3_Client::home_finder_test (CORBA::ComponentIR::HomeDescription *hd
                               ACE_ENV_ARG_DECL_NOT_USED)
{
  CORBA::ULong length = hd->finders.length ();

  if (length != HOME_FINDER_LEN)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_finder_test: "
                      "wrong number of finders\n"));
        }

      return -1;
    }

  CORBA::ULong inside_len = 0;
  CORBA::ULong j = 0;
  const char *tmp = 0;

  for (CORBA::ULong i = 0; i < HOME_FINDER_LEN; ++i)
    {
      inside_len = hd->finders[i].parameters.length ();

      if (inside_len != HOME_FINDER_PARAM_LENS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "home_finder_test: "
                          "wrong number of params in finder #%d\n",
                          i + 1));
            }

          return -1;
        }

      for (j = 0; j < inside_len; ++j)
        {
          tmp = hd->finders[i].parameters[j].name.in ();

          if (tmp == 0 
              || ACE_OS::strcmp (tmp, HOME_FINDER_PARAM_NAMES[i][j]) != 0)
            {
              if (this->debug_)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              "home_finder_test: "
                              "wrong name for param #%d in finder #%d\n",
                              j + 1,
                              i + 1));
                }

              return -1;
            }
        }

      inside_len = hd->finders[i].exceptions.length ();

      if (inside_len != HOME_FINDER_EXCEP_LENS[i])
        {
          if (this->debug_)
            {
              ACE_DEBUG ((LM_DEBUG,
                          "home_finder_test: "
                          "wrong number of exceptions in finder #%d\n",
                          i + 1));
            }

          return -1;
        }

      for (j = 0; j < inside_len; ++j)
        {
          tmp = hd->finders[i].exceptions[j].name.in ();

          if (tmp == 0 
              || ACE_OS::strcmp (tmp, HOME_FINDER_EXCEP_NAMES[i][j]) != 0)
            {
              if (this->debug_)
                {
                  ACE_DEBUG ((LM_DEBUG,
                              "home_finder_test: "
                              "wrong name for exception #%d in finder #%d\n",
                              j + 1,
                              i + 1));
                }

              return -1;
            }
        }
    }

  return 0;
}