idl3_client.cpp

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

// -*- C++ -*-
// idl3_client.cpp,v 1.12 2003/12/29 19:22:15 bala Exp

#include "idl3_client.h"
#include "ace/Get_Opt.h"
#include "ace/OS_NS_string.h"

ACE_RCSID (Application_Test, 
           ifr_dii_client, 
           "idl3_client.cpp,v 1.12 2003/12/29 19:22:15 bala Exp")

// All the magic quantities are here at the top.

const char *COMPONENT_ID = "IDL:mod/test_component:1.0";
const char *COMPONENT_SCOPED_NAME = "::mod::test_component";
const char *COMP_BASE_ID = "IDL:help/c_base:1.0";

const char *VALUETYPE_ID = "IDL:mod/test_valuetype:1.0";
const char *VALUETYPE_SCOPED_NAME = "::mod::test_valuetype";
const char *VT_BASE_ID = "IDL:help/v_base:1.0";

const char *HOME_ID = "IDL:mod/test_home:1.0";
const char *HOME_SCOPED_NAME = "::mod::test_home";
const char *HOME_BASE_ID = "IDL:help/h_base:1.0";
const char *HOME_KEY_ID = "IDL:help/h_key:1.0";

const char *EVENTTYPE_ID = "IDL:mod/test_eventtype:1.0";

const CORBA::ULong ATTRS_LEN = 1;
const CORBA::ULong OPS_LEN = 1;
const CORBA::ULong FACTORY_LEN = 2;

const char *ATTR_LOCAL_NAMES[] = 
  {
    "c_attr1"
  };

const CORBA::TCKind ATTR_TC_KINDS[] =
  {
    CORBA::tk_long
  };

const CORBA::ULong GET_EXCEP_LEN[] =
  {
    1
  };

const CORBA::ULong PUT_EXCEP_LEN[] =
  {
    2
  };

const char *OP_NAMES[] =
  {
    "v_op"
  };

const CORBA::TCKind OP_RET_KINDS[] =
  {
    CORBA::tk_string
  };

const CORBA::ULong PARAMS_LEN[] =
  {
    3
  };

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

const CORBA::ULong OP_EXCEP_LEN[] = 
  {
    2
  };

const CORBA::ULong COMP_SUPPORTED_LEN = 2;

const char *COMP_SUPPORTED_IDS[] = 
  {
    "IDL:help/c_supp1:1.0",
    "IDL:help/c_supp2:1.0"
  };

const CORBA::ULong PROVIDES_LEN = 1;
const CORBA::ULong USES_LEN = 2;
const CORBA::ULong EMITS_LEN = 1;
const CORBA::ULong PUBLISHES_LEN = 1;
const CORBA::ULong CONSUMES_LEN = 1;

const char *PROVIDES_NAMES[] =
  {
    "test_provides1"
  };

const char *PROVIDES_TYPE_IDS[] =
  {
    "IDL:help/c_provides1:1.0"
  };

const char *USES_NAMES[] =
  {
    "test_uses1",
    "test_uses2"
  };

const char *USES_TYPE_IDS[] =
  {
    "IDL:help/c_uses1:1.0",
    "IDL:help/c_uses2:1.0"
  };

const CORBA::Boolean USES_MULTIPLE_FLAGS[] =
  {
    0,
    1
  };

const char *EMITS_NAMES[] =
  {
    "test_emits1"
  };

const char *PUBLISHES_NAMES[] =
  {
    "test_publishes1"
  };

const char *CONSUMES_NAMES[] =
  {
    "test_consumes1"
  };

const char *EMITS_IDS[] =
  {
    "IDL:help/c_emits1:1.0"
  };

const char *PUBLISHES_IDS[] =
  {
    "IDL:help/c_publishes1:1.0"
  };

const char *CONSUMES_IDS[] =
  {
    "IDL:help/c_consumes1:1.0"
  };

const CORBA::ULong VT_SUPPORTED_LEN = 2;

const char *VT_SUPPORTED_IDS[] = 
  {
    "IDL:help/v_supp1:1.0",
    "IDL:help/v_supp2:1.0"
  };

const CORBA::ULong MEM_LEN = 2;

const CORBA::Visibility MEM_VIS[] =
  {
    CORBA::PUBLIC_MEMBER,
    CORBA::PRIVATE_MEMBER
  };

const char *MEM_NAMES[] =
  {
    "test_mem1",
    "test_mem2",
  };

const CORBA::ULong VT_FACTORY_PARAM_LENS[] =
  {
    1,
    2
  };

const CORBA::ULong VT_FACTORY_EXCEP_LENS[] =
  {
    0,
    2
  };

const char *VT_FACTORY_PARAM_NAMES[][2] =
  {
    {"set_tm1", 0},
    {"set_tm1a", "set_tm2"}
  };

const char *VT_FACTORY_EXCEP_NAMES[][2] =
  {
    {0, 0},
    {"whups", "doh"}
  };

const CORBA::ULong HOME_SUPPORTED_LEN = 2;

const char *HOME_SUPPORTED_IDS[] =
  {
    "IDL:help/h_supp1:1.0",
    "IDL:help/h_supp2:1.0"
  };

const CORBA::ULong HOME_FACTORY_LEN = 1;
const CORBA::ULong HOME_FINDER_LEN = 1;

const CORBA::ULong HOME_FACTORY_PARAM_LENS[] =
  {
    1
  };

const char *HOME_FACTORY_PARAM_NAMES[][1] =
  {
    {"set_uid"}
  };

const CORBA::ULong HOME_FACTORY_EXCEP_LENS[] =
  {
    1
  };

const char *HOME_FACTORY_EXCEP_NAMES[][1] =
  {
    {"doh"}
  };

const CORBA::ULong HOME_FINDER_PARAM_LENS[] =
  {
    3
  };

const char *HOME_FINDER_PARAM_NAMES[][3] =
  {
    {"id_number", "id_string", "pkey"}
  };

const CORBA::ULong HOME_FINDER_EXCEP_LENS[] =
  {
    1
  };

const char *HOME_FINDER_EXCEP_NAMES[][1] =
  {
    {"whups"}
  };

IDL3_Client::IDL3_Client (void)
  : debug_ (0)
{
}

IDL3_Client::~IDL3_Client (void)
{
}

int
IDL3_Client::init (int argc,
                   char *argv[]
                   ACE_ENV_ARG_DECL)
{
  this->orb_ = CORBA::ORB_init (argc,
                                argv,
                                0
                                ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  CORBA::Object_var obj =
    this->orb_->resolve_initial_references ("InterfaceRepository"
                                            ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (obj.in ()))
    {
      ACE_ERROR_RETURN ((LM_ERROR,
                         "IDL3_Client - IFR resolution failed\n"),
                        -1);
    }

  this->repo_ = 
    CORBA::ComponentIR::Repository::_narrow (obj.in ()
                                             ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (this->repo_.in ()))
    {
      ACE_ERROR_RETURN ((LM_ERROR,
                         "IDL3_Client - IFR narrow failed\n"),
                        -1);
    }

  if (this->parse_args (argc, argv) == -1)
    {
      return -1;
    }

  return 0;
}

int
IDL3_Client::run (ACE_ENV_SINGLE_ARG_DECL)
{
  int status = this->component_test (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return status;
    }

  status = this->valuetype_test (VALUETYPE_ID,
                                 "value"
                                 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return status;
    }

  status = this->home_test (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return status;
    }

  status = this->valuetype_test (EVENTTYPE_ID,
                                 "event"
                                 ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return status;
    }

  return 0;
}

int
IDL3_Client::parse_args (int argc,
                         char *argv[])
{
  ACE_Get_Opt opts (argc, argv, "d");
  int c;

  while ((c = opts ()) != -1)
    switch (c)
      {
      case 'd':   // Turn on debugging outoput.
        this->debug_ = 1;
        break;
      case '?':
      default:
        ACE_ERROR_RETURN ((LM_ERROR,
                           "usage: %s"
                           " [-d]"
                           "\n",
                           argv [0]),
                          -1);
      }

  return 0;
}

int
IDL3_Client::component_test (ACE_ENV_SINGLE_ARG_DECL)
{
  CORBA::Contained_var result =
    this->repo_->lookup_id (COMPONENT_ID
                            ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (result.in ()))
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "component_test: lookup by id failed\n"));
        }

      return -1;
    }

  CORBA::String_var str = 
    result->absolute_name (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  const char *tmp = str.in ();

  if (tmp == 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "component_test: component has null scoped name\n"));
        }

      return -1;
    }

  if (ACE_OS::strcmp (tmp, COMPONENT_SCOPED_NAME) != 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "component_test: "
                      "component has incorrect scoped name\n"));
        }

      return -1;
    }

  CORBA::ComponentIR::ComponentDef_var comp_def =
    CORBA::ComponentIR::ComponentDef::_narrow (result.in ()
                                               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  CORBA::TypeCode_var comp_tc = 
    comp_def->type (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (comp_tc.in ()))
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "component_test: "
                      "type code creation failed\n"));
        }

      return -1;
    }

  tmp = comp_tc->id (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (tmp == 0 || ACE_OS::strcmp (tmp, COMPONENT_ID) != 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "component_test: "
                      "bad id from type code\n"));
        }

      return -1;
    }

  CORBA::InterfaceAttrExtension::ExtFullInterfaceDescription_var desc =
    comp_def->describe_ext_interface (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (desc.ptr () == 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "component_test: "
                      "describe_ext_interface return null\n"));
        }

      return -1;
    }

  int status = this->component_attribute_test (desc
                                               ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return -1;
    }

  status = this->component_inheritance_test (comp_def
                                             ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return -1;
    }

  status = this->component_port_test (comp_def
                                      ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return -1;
    }

  return 0;
}

int
IDL3_Client::home_test (ACE_ENV_SINGLE_ARG_DECL)
{
  CORBA::Contained_var result =
    this->repo_->lookup_id (HOME_ID
                            ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (result.in ()))
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_test: lookup by id failed\n"));
        }

      return -1;
    }

  CORBA::ComponentIR::HomeDef_var home =
    CORBA::ComponentIR::HomeDef::_narrow (result.in ()
                                          ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (result.in ()))
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_test: home narrow failed\n"));
        }

      return -1;
    }

  CORBA::ComponentIR::ComponentDef_var managed =
    home->managed_component (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (managed.in ()))
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_test: managed component is null\n"));
        }

      return -1;
    }

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

  if (str.in () == 0 || ACE_OS::strcmp (str.in (), COMPONENT_ID) != 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_test: bad id for managed component\n"));
        }

      return -1;
    }

  CORBA::ValueDef_var pkey = 
    home->primary_key (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (CORBA::is_nil (pkey.in ()))
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_test: primary key is null\n"));
        }

      return -1;
    }

  str = pkey->id (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (str.in () == 0 || ACE_OS::strcmp (str.in (), HOME_KEY_ID) != 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_test: bad id for managed component\n"));
        }

      return -1;
    }

  int status = this->home_inheritance_test (home
                                            ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return -1;
    }

  CORBA::Contained::Description_var desc =
    home->describe (ACE_ENV_SINGLE_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  CORBA::ComponentIR::HomeDescription *home_desc = 0;

  if ((desc->value >>= home_desc) == 0)
    {
      if (this->debug_)
        {
          ACE_DEBUG ((LM_DEBUG,
                      "home_test: extraction of HomeDescription failed\n"));
        }

      return -1;
    }

  status = this->home_factory_test (home_desc
                                    ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {
      return -1;
    }

  status = this->home_finder_test (home_desc
                                   ACE_ENV_ARG_PARAMETER);
  ACE_CHECK_RETURN (-1);

  if (status != 0)
    {