📄 cubit_client.cpp
字号:
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_union");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
// Cube a short.
void
Cubit_Client::cube_short (int i
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
CORBA::Short arg_short = this->func (i);
// Cube a short.
CORBA::Short ret_short;
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_SHORT_START);
ret_short = cubit_->cube_short (arg_short
ACE_ENV_ARG_PARAMETER);
}
ACE_TRY_CHECK;
this->call_count_++;
if (TAO_debug_level > 2)
{
ACE_DEBUG ((LM_DEBUG,
"cube short: %d --> %d\n",
arg_short,
ret_short));
}
arg_short = arg_short * arg_short * arg_short;
if (arg_short != ret_short)
{
ACE_ERROR ((LM_ERROR, "** cube_short (%d) ERROR (--> %d)\n",
(CORBA::Short) this->func (i),
ret_short));
this->error_count_++;
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_short");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
// Oneway test.
void
Cubit_Client::cube_oneway (int
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_ONEWAY_START);
this->cubit_->cube_oneway (ACE_ENV_SINGLE_ARG_PARAMETER);
ACE_TRY_CHECK;
this->call_count_++;
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_oneway");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
void
Cubit_Client::cube_void (int
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_VOID_START);
this->cubit_->cube_void (ACE_ENV_SINGLE_ARG_PARAMETER);
ACE_TRY_CHECK;
this->call_count_++;
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_void");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
// Cube an octet
void
Cubit_Client::cube_octet (int i
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
CORBA::Octet arg_octet = this->func (i);
// Cube an octet.
CORBA::Octet ret_octet;
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_START);
ret_octet = this->cubit_->cube_octet (arg_octet
ACE_ENV_ARG_PARAMETER);
}
ACE_TRY_CHECK;
this->call_count_++;
if (TAO_debug_level > 2)
{
ACE_DEBUG ((LM_DEBUG,
"cube octet: %d --> %d\n",
arg_octet, ret_octet));
}
arg_octet = arg_octet * arg_octet * arg_octet;
if (arg_octet != ret_octet)
{
ACE_DEBUG ((LM_DEBUG,
"** cube_octet (%d) ERROR (--> %d)\n",
(CORBA::Octet) this->func (i),
ret_octet));
this->error_count_++;
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_octet");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
// calculate the cube from a long
void
Cubit_Client::cube_long (int i
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
CORBA::Long arg_long = this->func (i);
// Cube a long.
CORBA::Long ret_long;
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_START);
ret_long = this->cubit_->cube_long (arg_long
ACE_ENV_ARG_PARAMETER);
}
ACE_TRY_CHECK;
this->call_count_++;
if (TAO_debug_level > 2)
{
ACE_DEBUG ((LM_DEBUG,
"cube long: %d --> %d\n",
arg_long,
ret_long));
}
arg_long = arg_long * arg_long * arg_long;
if (arg_long != ret_long)
{
// CORBA::Long is 32 bits, which can be handled by %d on
// most platforms.
ACE_ERROR ((LM_ERROR,
"** cube_long (%d) ERROR (--> %d)\n",
(CORBA::Long) this->func (i),
ret_long));
this->error_count_++;
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_long");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
// Cube the numbers in a struct
void
Cubit_Client::cube_struct (int i
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
Cubit::Many arg_struct;
Cubit::Many ret_struct;
this->call_count_++;
arg_struct.l = this->func (i);
arg_struct.s = this->func (i);
arg_struct.o = this->func (i);
// Cube a "struct" ...
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_STRUCT_START);
ret_struct = this->cubit_->cube_struct (arg_struct
ACE_ENV_ARG_PARAMETER);
}
ACE_TRY_CHECK;
if (TAO_debug_level > 2)
{
ACE_DEBUG ((LM_DEBUG,
"cube struct ..."));
}
arg_struct.l = arg_struct.l * arg_struct.l * arg_struct.l;
arg_struct.s = arg_struct.s * arg_struct.s * arg_struct.s;
arg_struct.o = arg_struct.o * arg_struct.o * arg_struct.o;
if (arg_struct.l != ret_struct.l
|| arg_struct.s != ret_struct.s
|| arg_struct.o != ret_struct.o)
{
ACE_ERROR ((LM_ERROR, "** cube_struct ERROR\n"));
this->error_count_++;
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_struct");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
// Cube the numbers in a sequence
void
Cubit_Client::cube_long_sequence (int,
int l
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
this->call_count_++;
Cubit::long_seq input (l);
input.length (l);
// Just set the first item, otherwise it is hard to compare the
// results for longer sequences, i.e. more than just marshalling
// gets in the way.
input[0] = 4;
#if (ACE_HAS_PURIFY == 1)
for(int i=1;i<l;i++)
input[i]=11;
#endif /* ACE_HAS_PURIFY == 1 */
Cubit::long_seq_var output;
Cubit::long_seq_out vout (output);
// Cube the sequence
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_LONG_SEQUENCE_START);
this->cubit_->cube_long_sequence (input,
vout
ACE_ENV_ARG_PARAMETER);
}
ACE_TRY_CHECK;
if (output->length () != input.length ())
{
ACE_ERROR ((LM_ERROR,
"** cube sequence, wrong length\n"));
this->error_count_++;
return;
}
u_int rl = output->length ();
if (input.length () < rl)
{
rl = input.length ();
}
CORBA::Long x = input[0];
if (x * x *x != output[0])
{
ACE_ERROR ((LM_ERROR,
"** cube_long_sequence ERROR\n"));
this->error_count_++;
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_long_sequence");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
void
Cubit_Client::cube_octet_sequence (int,
int l
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
this->call_count_++;
ACE_Message_Block mb (l);
mb.wr_ptr (l);
Cubit::octet_seq input (l, &mb);
// Just set the first item, otherwise it is hard to compare the
// results for longer sequences, i.e. more than just marshalling
// gets in the way.
input[0] = 4;
#if (ACE_HAS_PURIFY == 1)
for(int i=1;i<l;i++)
input[i]=10;
#endif /* ACE_HAS_PURIFY == 1 */
Cubit::octet_seq_var output;
Cubit::octet_seq_out vout (output);
// Cube the sequence
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_OCTET_SEQUENCE_START);
this->cubit_->cube_octet_sequence (input,
vout
ACE_ENV_ARG_PARAMETER);
}
ACE_TRY_CHECK;
if (output->length () != input.length ())
{
ACE_ERROR ((LM_ERROR,
"** cube octet, wrong length\n"));
this->error_count_++;
return;
}
u_int rl = output->length ();
if (input.length () < rl)
{
rl = input.length ();
}
CORBA::Octet x = input[0];
if (x * x *x != output[0])
{
ACE_ERROR ((LM_ERROR,
"** cube_octet ERROR\n"));
this->error_count_++;
}
}
ACE_CATCHANY
{
ACE_PRINT_EXCEPTION (ACE_ANY_EXCEPTION,
"from cube_octet_sequence");
this->error_count_++;
}
ACE_ENDTRY;
ACE_CHECK;
}
// Cube the many in a sequence
void
Cubit_Client::cube_many_sequence (int,
int l
ACE_ENV_ARG_DECL)
{
ACE_TRY
{
this->call_count_++;
Cubit::many_seq input (l);
input.length (l);
// Just set the first item, otherwise it is hard to compare the
// results for longer sequences, i.e. more than just marshalling
// gets in the way.
Cubit::Many &in = input[0];
in.l = 4;
in.s = 5;
in.o = 6;
#if (ACE_HAS_PURIFY == 1)
for(int i=1;i<l;i++)
{
Cubit::Many &inb = input[i];
inb.l=7;
inb.s=8;
inb.o=9;
}
#endif /* ACE_HAS_PURIFY == 1 */
Cubit::many_seq_var output;
Cubit::many_seq_out vout (output);
// Cube the sequence
{
ACE_FUNCTION_TIMEPROBE (CUBIT_CLIENT_CUBE_MANY_SEQUENCE_START);
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -