Exemple #1
0
int
Test_Objref_Struct::init_parameters (Param_Test_ptr objref)
{
  try
    {
      Generator *gen = GENERATOR::instance (); // value generator

      // Set the long member.
      this->in_.x = gen->gen_long ();

      this->in_.y = objref->make_coffee ();

      Coffee::Desc d;
      d.name = gen->gen_string ();

      this->in_.y->description (d);

            this->inout_->x = 0;

            this->inout_->y = Coffee::_nil ();

      Coffee::Desc dd;
            dd.name = CORBA::string_dup ("");

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_Objref_Struct::init_parameters\n");

    }
  return -1;
}
Exemple #2
0
int
Test_Unbounded_Struct_Sequence::run_sii_test (Param_Test_ptr objref)
{
  Param_Test::PathSpec_out out (this->out_.out ());
  this->ret_ = objref->test_unbounded_struct_sequence (this->in_,
                                                       this->inout_.inout (),
                                                       out);

  return 0;
}
Exemple #3
0
int
Test_Any::init_parameters (Param_Test_ptr objref)
{
  try
    {
      // get access to a Coffee Object
      this->cobj_ = objref->make_coffee ();

      this->reset_parameters ();
      return 0;
    }
  catch (const CORBA::SystemException& sysex)
    {
      sysex._tao_print_exception ("System Exception doing make_coffee");
    }
  return -1;
}
Exemple #4
0
int
Test_Fixed_Struct::run_sii_test (Param_Test_ptr objref)
{
  try
    {
      this->ret_ = objref->test_fixed_struct (this->in_,
                                              this->inout_,
                                              this->out_);

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_Fixed_Struct::run_sii_test\n");

    }
  return -1;
}
Exemple #5
0
int
Test_Small_Union::run_sii_test (Param_Test_ptr objref)
{
  try
    {
      this->ret_ = objref->test_small_union (this->in_,
                                           this->inout_,
                                           this->out_);

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_Small_Union::run_sii_test\n");

    }
  return -1;
}
int
Test_Var_Array::run_sii_test (Param_Test_ptr objref)
{
  try
    {
      Param_Test::Var_Array_out out_arr (this->out_.out ());
      this->ret_ = objref->test_var_array (this->in_,
                                           this->inout_,
                                           out_arr);

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_Var_Array::run_sii_test\n");

    }
  return -1;
}
Exemple #7
0
int
Test_Nested_Struct::run_sii_test (Param_Test_ptr objref)
{
  try
    {
      Param_Test::Nested_Struct_out out (this->out_.out ());
      this->ret_ = objref->test_nested_struct (this->in_,
                                               this->inout_.inout (),
                                               out);

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_Nested_Struct::run_sii_test\n");

    }
  return -1;
}
Exemple #8
0
int
Test_Bounded_Long_Sequence::run_sii_test (Param_Test_ptr objref)
{
  try
    {
      Param_Test::Bounded_Long_Seq_out out (this->out_.out ());
      this->ret_ = objref->test_bounded_long_sequence (this->in_.in (),
                                                       this->inout_.inout (),
                                                       out);

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_Bounded_Long_Sequence::run_sii_test\n");

    }
  return -1;
}
int
Test_String_Sequence::run_sii_test (Param_Test_ptr objref)
{
  try
    {
      CORBA::StringSeq_out out (this->out_.out ());

      this->ret_ = objref->test_strseq (this->in_.in (),
                                        this->inout_.inout (),
                                        out);

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_String_Sequence::run_sii_test\n");

    }
  return -1;
}
Exemple #10
0
int
Test_Bounded_WString::run_sii_test (Param_Test_ptr objref)
{
    try
    {
        CORBA::WString_out str_out (this->out_);

        this->ret_ = objref->test_bounded_wstring (this->in_,
                     this->inout_,
                     str_out);

        return 0;
    }
    catch (const CORBA::Exception& ex)
    {
        ex._tao_print_exception ("Test_Bounded_WString::run_sii_test\n");

    }
    return -1;
}
Exemple #11
0
int
Test_ObjRef_Sequence::run_sii_test (Param_Test_ptr objref)
{
  try
    {
      Param_Test::Coffee_Mix_out out (this->out_.out ());

      this->ret_ = objref->test_coffe_mix (this->in_,
                                           this->inout_.inout (),
                                           out);

      return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_ObjRef_Sequence::run_sii_test\n");

    }
  return -1;
}
Exemple #12
0
int
Test_ObjRef_Sequence::init_parameters (Param_Test_ptr objref)
{
  try
    {
      Coffee::Desc desc;
      Generator *gen = GENERATOR::instance (); // value generator

      // get some sequence length (not more than 10)
      CORBA::ULong len = (CORBA::ULong) (gen->gen_long () % 5) + 5;

      // set the length of the sequence
      this->in_.length (len);
      // now set each individual element

      for (CORBA::ULong i = 0; i < this->in_.length (); i++)
        {
          // generate some arbitrary string to be filled into the ith location in
          // the sequence
          this->in_[i] = objref->make_coffee ();

          // select a Coffee flavor at random
          CORBA::ULong index = (CORBA::ULong) (gen->gen_long () % 6);

          desc.name = Coffee_Flavor [index];
          // set the attribute for the in object
          Coffee_ptr tmp = this->in_[i];

          tmp->description (desc);
        }

        return 0;
    }
  catch (const CORBA::Exception& ex)
    {
      ex._tao_print_exception ("Test_ObjRef_Sequence::init_parameters\n");

    }
  return -1;
}