TAO/tests/Portable_Interceptors/Dynamic/client_interceptor.cpp

   1 #include "client_interceptor.h"
   2 #include "testC.h"
   3
   4 #include "tao/AnyTypeCode/DynamicC.h"
   5 #include "tao/AnyTypeCode/TypeCode.h"
   6 #include "tao/AnyTypeCode/AnyTypeCode_Adapter_Impl.h"
   7
   8 #include "ace/Log_Msg.h"
   9 #include "ace/OS_NS_string.h"
  10
  11 Echo_Client_Request_Interceptor::Echo_Client_Request_Interceptor (void)
  12   : myname_ ("Echo_Client_Interceptor")
  13 {
  14 }
  15
  16 Echo_Client_Request_Interceptor::~Echo_Client_Request_Interceptor ()
  17 {
  18 }
  19
  20 char *
  21 Echo_Client_Request_Interceptor::name (void)
  22 {
  23   return CORBA::string_dup (this->myname_);
  24 }
  25
  26 void
  27 Echo_Client_Request_Interceptor::destroy (void)
  28 {
  29 }
  30
  31 void
  32 Echo_Client_Request_Interceptor::send_poll (
  33     PortableInterceptor::ClientRequestInfo_ptr)
  34 {
  35   // Do nothing
  36 }
  37
  38 void
  39 Echo_Client_Request_Interceptor::send_request (
  40     PortableInterceptor::ClientRequestInfo_ptr ri)
  41 {
  42   bool catched_exception = false;
  43   try
  44     {
  45       PortableInterceptor::ReplyStatus rstatus = ri->reply_status ();
  46       ACE_UNUSED_ARG (rstatus);
  47     }
  48   catch (const ::CORBA::BAD_INV_ORDER&)
  49     {
  50       catched_exception = true;
  51     }
  52
  53   if (!catched_exception)
  54     {
  55       ACE_ERROR ((LM_ERROR,
  56                   "(%P|%t) ERROR, no exception when getting reply status\n"));
  57     }
  58
  59   CORBA::String_var op = ri->operation ();
  60
  61   ACE_DEBUG ((LM_DEBUG,
  62               "Echo_Client_Request_Interceptor::send_request from "
  63               "\"%C\"\n",
  64               op.in ()));
  65
  66   // For the "normal" operation, get the argument list.
  67   if (ACE_OS::strcmp (op.in (),
  68                       "normal") == 0)
  69     {
  70       Dynamic::ParameterList_var paramlist =
  71         ri->arguments ();
  72
  73       if (paramlist->length () != 2)
  74         {
  75           ACE_ERROR ((LM_ERROR,
  76                       "(%P|%t) All parameters not available\n"));
  77
  78         }
  79
  80       CORBA::ULong first = 0, second = 1; // If you dont understand
  81                                           // why this is  done, then
  82                                           // try changing it.
  83       if (paramlist[first].mode != CORBA::PARAM_IN ||
  84           paramlist[second].mode != CORBA::PARAM_OUT)
  85         {
  86           ACE_ERROR ((LM_ERROR,
  87                       "(%P|%t) ERROR in the extracted argument list\n"));
  88         }
  89
  90       CORBA::Long param = 0;
  91       paramlist[first].argument >>= param;
  92
  93       if (param != 10)
  94         {
  95           ACE_ERROR ((LM_ERROR,
  96                       "(%P|%t) ERROR in send_request while checking "
  97                       "the value of the extracted "
  98                       "arguments\n"));
  99         }
 100
 101       CORBA::TypeCode_var second_typecode = paramlist[second].argument.type ();
 102       if (second_typecode->kind () != CORBA::tk_null)
 103         {
 104           ACE_ERROR ((LM_ERROR,
 105                       "(%P|%t) ERROR in send_request while checking "
 106                       "the type of the extracted out"
 107                       "argument\n"));
 108         }
 109     }
 110 }
 111
 112 void
 113 Echo_Client_Request_Interceptor::receive_other (
 114   PortableInterceptor::ClientRequestInfo_ptr ri)
 115 {
 116
 117   CORBA::String_var op = ri->operation ();
 118
 119   ACE_DEBUG ((LM_DEBUG,
 120               "Echo_Client_Request_Interceptor::receive_other "
 121               "from \"%C\"\n",
 122               op.in ()));
 123 }
 124
 125 void
 126 Echo_Client_Request_Interceptor::receive_reply (
 127     PortableInterceptor::ClientRequestInfo_ptr ri)
 128 {
 129   CORBA::String_var op = ri->operation ();
 130
 131   ACE_DEBUG ((LM_DEBUG,
 132               "Echo_Client_Request_Interceptor::receive_reply "
 133               "from \"%C\"\n",
 134               op.in ()));
 135
 136     // For the "normal" operation, get the argument list.
 137   if (ACE_OS::strcmp (op.in (),
 138                       "normal") == 0)
 139     {
 140       Dynamic::ParameterList_var paramlist =
 141         ri->arguments ();
 142
 143       if (paramlist->length () != 2)
 144         {
 145           ACE_ERROR ((LM_ERROR,
 146                       "(%P|%t) All parameters not available\n"));
 147
 148         }
 149
 150       CORBA::ULong first = 0, second = 1; // If you dont understand
 151                                           // why this is  done, then
 152                                           // try changing it.
 153       if (paramlist[first].mode != CORBA::PARAM_IN ||
 154           paramlist[second].mode != CORBA::PARAM_OUT)
 155         {
 156           ACE_ERROR ((LM_ERROR,
 157                       "(%P|%t) ERROR in the extracted argument list\n"));
 158         }
 159
 160       CORBA::Long param = 0;
 161       paramlist[first].argument >>= param;
 162
 163       if (param != 10)
 164         {
 165           ACE_ERROR ((LM_ERROR,
 166                       "(%P|%t) ERROR in send_request while checking "
 167                       "the value of the extracted "
 168                       "arguments\n"));
 169         }
 170
 171       const char *str = 0;
 172
 173       paramlist[second].argument >>= str;
 174
 175       CORBA::String_var transfer (str);
 176
 177       if (ACE_OS::strcmp (str,
 178                           "DO_NOT_INSULT_MY_INTELLIGENCE") != 0)
 179         {
 180           ACE_ERROR ((LM_ERROR,
 181                       "(%P|%t) ERROR in send_request while checking "
 182                       "the value of the extracted "
 183                       "out arguments\n"));
 184         }
 185     }
 186
 187   if (ACE_OS::strcmp (op.in (), "calculate") == 0)
 188     {
 189       Dynamic::ParameterList_var paramlist =
 190         ri->arguments ();
 191
 192       CORBA::Long param1, param2, result;
 193       CORBA::ULong i = 0;  // index -- explicitly used to avoid
 194                            // overloaded operator ambiguity.
 195       paramlist[i++].argument >>= param1;
 196       paramlist[i].argument >>= param2;
 197
 198       CORBA::Any_var result_any = ri->result ();
 199
 200       (result_any.in ()) >>= result;
 201
 202       ACE_DEBUG ((LM_DEBUG,
 203                   "The result of calculate() is %d + %d = %d\n",
 204                   param1,
 205                   param2,
 206                   result));
 207     }
 208
 209   if (ACE_OS::strcmp (op.in (), "_get_the_structure") == 0)
 210     {
 211       CORBA::Any_var a = ri->result ();
 212
 213       const Test_Interceptors::Visual::VarLenStruct * v = 0;
 214
 215       (a.in ()) >>= v;
 216
 217       ACE_DEBUG ((LM_DEBUG,
 218                   "The result of the_structure() is:\n"
 219                   "  flag    = %d\n"
 220                   "  message = %C\n",
 221                   v->flag,
 222                   v->message.in ()));
 223     }
 224 }
 225
 226 void
 227 Echo_Client_Request_Interceptor::receive_exception (
 228     PortableInterceptor::ClientRequestInfo_ptr ri)
 229 {
 230
 231   CORBA::String_var op = ri->operation ();
 232
 233   ACE_DEBUG ((LM_DEBUG,
 234               "Echo_Client_Request_Interceptor::received_exception "
 235               "from \"%C\"\n",
 236               op.in ()));
 237
 238
 239   CORBA::String_var exception_id =
 240     ri->received_exception_id ();
 241
 242   ACE_DEBUG ((LM_DEBUG,
 243               "Exception ID = %C\n",
 244               exception_id.in ()));
 245 }
 246
 247