client.cpp

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

      // Create the request ...
      CORBA::Request_var req (this->obj_var_->_request ("cube_long"
                                                        ACE_ENV_ARG_PARAMETER));

      ACE_TRY_CHECK;

      CORBA::Long ret_long = 0;
      CORBA::Long arg_long = -7;

      // Add the long to the request arg list.
      req->add_in_arg () <<= arg_long;

      req->set_return_type (CORBA::_tc_long);

      this->call_count_++;

      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);

      ACE_TRY_CHECK;

      req->return_value () >>= ret_long;

      if (ret_long != arg_long * arg_long * arg_long)
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_long_dii -- bad results\n"));

            this->error_count_++;
        }
    }
  ACE_CATCHANY
    {
      this->error_count_++;
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "cube_long_dii");
      return;
    }
  ACE_ENDTRY;
}

void
DII_Cubit_Client::cube_octet_dii (void)
{
  ACE_TRY_NEW_ENV
    {
      // Create the request ...
      CORBA::Request_var req (this->obj_var_->_request ("cube_octet"
                                                        ACE_ENV_ARG_PARAMETER));

      ACE_TRY_CHECK;

      CORBA::Octet ret_octet = 0;
      CORBA::Octet arg_octet = 5;

      // Add the octet to the request arg list.
      CORBA::Any::from_octet from_arg_octet (arg_octet);
      req->add_in_arg () <<= from_arg_octet;

      req->set_return_type (CORBA::_tc_octet);

      // Invoke, check for an exception and verify the result.
      this->call_count_++;

      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);

      ACE_TRY_CHECK;

      CORBA::Any::to_octet to_ret_octet (ret_octet);
      req->return_value () >>= to_ret_octet;

      if (ret_octet != arg_octet * arg_octet * arg_octet)
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_octet_dii -- bad results\n"));

          this->error_count_++;
        }
    }
  ACE_CATCHANY
    {
      this->error_count_++;
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "cube_octet_dii");
      return;
    }
  ACE_ENDTRY;
}

void
DII_Cubit_Client::cube_union_dii (void)
{
  ACE_TRY_NEW_ENV
    {
      // Create the request ...
      CORBA::Request_var req (this->obj_var_->_request ("cube_union"
                                                        ACE_ENV_ARG_PARAMETER));

      ACE_TRY_CHECK;

      Cubit::oneof arg_union;

      arg_union._d(Cubit::e_3rd);
      arg_union.cm ().l = 5;
      arg_union.cm ().s = -7;
      arg_union.cm ().o = 3;

      // Add the union to the request arg list and set the return type.
      req->add_in_arg () <<= arg_union;

      req->set_return_type (Cubit::_tc_oneof);

      // Invoke, check for an exception and verify the result

      this->call_count_++;

      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);

      ACE_TRY_CHECK;

      // Extract the result and check validity.
      Cubit::oneof* ret_ptr;
      req->return_value () >>= ret_ptr;

      if (ret_ptr->cm ().l != arg_union.cm ().l * arg_union.cm ().l * arg_union.cm ().l
          || ret_ptr->cm ().s != arg_union.cm ().s * arg_union.cm ().s * arg_union.cm ().s
          || ret_ptr->cm ().o != arg_union.cm ().o * arg_union.cm ().o * arg_union.cm ().o)
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_union_dii -- bad results\n"));

          this->error_count_++;
        }
    }
  ACE_CATCHANY
    {
      this->error_count_++;
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "cube_union_dii");
      return;
    }
  ACE_ENDTRY;
}

void
DII_Cubit_Client::cube_struct_dii (void)
{
  ACE_TRY_NEW_ENV
    {
      // Create the request ...
      CORBA::Request_var req (this->obj_var_->_request ("cube_struct"
                                                        ACE_ENV_ARG_PARAMETER));

      ACE_TRY_CHECK;

      Cubit::Many arg_struct, *ret_struct_ptr;

      arg_struct.l = 5;
      arg_struct.s = -7;
      arg_struct.o = 3;

      // Add struct to the request arg list.
      req->add_in_arg () <<= arg_struct;

      req->set_return_type (Cubit::_tc_Many);

      // Invoke, check for an exception and verify the result.

      this->call_count_++;

      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);

      ACE_TRY_CHECK;

      req->return_value () >>= ret_struct_ptr;

      if (ret_struct_ptr->l != arg_struct.l * arg_struct.l * arg_struct.l
          || ret_struct_ptr->s != arg_struct.s * arg_struct.s * arg_struct.s
          || ret_struct_ptr->o != arg_struct.o * arg_struct.o * arg_struct.o)
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_struct_dii -- bad results\n"));

          this->error_count_++;
        }
    }
  ACE_CATCHANY
    {
      this->error_count_++;
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "cube_struct_dii");
      return;
    }
  ACE_ENDTRY;
}

void
DII_Cubit_Client::cube_octet_seq_dii (int length)
{
  ACE_TRY_NEW_ENV
    {
      // Create the request ...
      CORBA::Request_var req (this->obj_var_->_request ("cube_octet_sequence"
                                                         ACE_ENV_ARG_PARAMETER));

      ACE_TRY_CHECK;

      // Same length as in IDL_Cubit tests so timings can be compared.
      // Return value holder is set to a different length to test resizing.
      Cubit::octet_seq arg_octet_seq (length), *ret_octet_seq_ptr;
      arg_octet_seq.length (length);
      arg_octet_seq[0] = 4;

      // Add octet sequence to the request arg list

      req->add_in_arg () <<= arg_octet_seq;

      req->set_return_type (Cubit::_tc_octet_seq);

      // Invoke, check for an exception and verify the result.

      this->call_count_++;

      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);

      ACE_TRY_CHECK;

      req->return_value () >>= ret_octet_seq_ptr;

      // Check for correct length.
      if (ret_octet_seq_ptr->length () != arg_octet_seq.length ())
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_octet_seq_dii -- bad length\n"));

          this->error_count_++;
        }

      // Check for correct value(s).
      if ((*ret_octet_seq_ptr)[0] != arg_octet_seq[0] * arg_octet_seq[0] * arg_octet_seq[0])
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_octet_seq_dii -- bad results\n"));

          this->error_count_++;
        }
    }
  ACE_CATCHANY
    {
      this->error_count_++;
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "cube_octet_seq_dii");
      return;
    }
  ACE_ENDTRY;
}

void
DII_Cubit_Client::cube_long_seq_dii (int length)
{
  ACE_TRY_NEW_ENV
    {
      // Create the request ...
      CORBA::Request_var req (this->obj_var_->_request ("cube_long_sequence"
                                                        ACE_ENV_ARG_PARAMETER));

      ACE_TRY_CHECK;

      // Same length as in IDL_Cubit tests so timings can be compared.
      // Return value holder is set to a different length to test
      // resizing.
      Cubit::long_seq *ret_long_seq_ptr;
      Cubit::long_seq arg_long_seq (length);
      arg_long_seq.length (length);
      arg_long_seq[0] = 4;

      // Add the long_seq to the request arg list.
      req->add_in_arg () <<= arg_long_seq;

      req->set_return_type (Cubit::_tc_long_seq);

      // Invoke, check for an exception and verify the result.

      this->call_count_++;

      req->invoke (ACE_ENV_SINGLE_ARG_PARAMETER);

      ACE_TRY_CHECK;

      req->return_value () >>= ret_long_seq_ptr;

      // Check for correct length.
      if (ret_long_seq_ptr->length () != arg_long_seq.length ())
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_long_seq_dii -- bad length\n"));

          this->error_count_++;
        }

      // Check for correct value(s).
      if ((*ret_long_seq_ptr)[0] != arg_long_seq[0] * arg_long_seq[0] * arg_long_seq[0])
        {
          ACE_ERROR ((LM_ERROR,
                      "cube_long_seq_dii -- bad results\n"));

          this->error_count_++;
        }
    }
  ACE_CATCHANY
    {
      this->error_count_++;
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "cube_long_seq_dii");
      return;
    }
  ACE_ENDTRY;
}

// Wrappers for operations with non-void arg lists and the 3-in-1
// mixin test, so an array of pointers to functions can be stepped
// through in run ().

void
DII_Cubit_Client::cube_small_long_seq (void)
{
  this->cube_long_seq_dii (SMALL_LONG_SEQ_LENGTH);
}

void
DII_Cubit_Client::cube_large_long_seq (void)
{
  this->cube_long_seq_dii (LARGE_LONG_SEQ_LENGTH);
}

void
DII_Cubit_Client::cube_small_octet_seq (void)
{
  this->cube_octet_seq_dii (SMALL_OCTET_SEQ_LENGTH);
}

void
DII_Cubit_Client::cube_large_octet_seq (void)
{
  this->cube_octet_seq_dii (LARGE_OCTET_SEQ_LENGTH);
}

void
DII_Cubit_Client::cube_mixin (void)
{
  this->cube_short_dii ();
  this->cube_octet_dii ();
  this->cube_long_dii ();
}

int
DII_Cubit_Client::run (void)
{
  // loop counter.
  CORBA::ULong i;

  // Make a timer and an elapsed time holder.
  ACE_Profile_Timer dii_timer;
  ACE_Profile_Timer::ACE_Elapsed_Time dii_elapsed_time;

  // Order and format of test calls matches that of SII (IDL) tests
  // for easy comparison.

  for (int j = 0; j < NUMBER_OF_TESTS; j++)
    {
      this->call_count_ = 0;

      this->error_count_ = 0;

      dii_timer.start ();

      for (i = 0; i < this->loop_count_; i++)
        (this->*op_array_[j])();

      dii_timer.stop ();

      dii_timer.elapsed_time (dii_elapsed_time);

      this->print_stats (this->stats_messages_[j],
                         dii_elapsed_time);
    }

  ACE_TRY_NEW_ENV
    {
      // Shut down server via a DII request.
      if (this->shutdown_)
        {
          CORBA::Request_var req (this->obj_var_->_request ("shutdown"
                                                            ACE_ENV_ARG_PARAMETER));

          ACE_TRY_CHECK;

          // Cubit::shutdown () is a oneway operation.
          req->send_oneway (ACE_ENV_SINGLE_ARG_PARAMETER);

          ACE_TRY_CHECK;

          ACE_DEBUG ((LM_DEBUG,
                      "\n\t Shutting down IDL_Cubit server \n\n"));
        }
    }
  ACE_CATCHANY
    {
      ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
                           "DII_Cubit_Client: server shutdown");
      return -1;
    }
  ACE_ENDTRY;

  return this->error_count_ == 0 ? 0 : 1;
}

// Start the test.

int main (int argc, char *argv[])
{
  DII_Cubit_Client cubit_client;

  ACE_DEBUG ((LM_DEBUG,
              "\n\t DII_Cubit::CLIENT \n\n"));

  if (cubit_client.init (argc, argv) == -1)
    return 1;

  return cubit_client.run ();
}