TAO/tests/DynAny_Test/analyzer.cpp

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    analyzer.cpp
   6  *
   7  *  This file contains a DynAny analyzer that dumps the contents of a DynAny
   8  *  to the logging.
   9  *
  10  *  @author  Johnny Willemsen  (jwillemsen@remedy.nl)
  11  */
  12 //=============================================================================
  13
  14 #include "analyzer.h"
  15
  16 #include "tao/DynamicAny/DynCommon.h"
  17 #include "tao/DynamicAny/DynAnyFactory.h"
  18
  19 #define CASEE(type,CT,str) case CORBA::tk_##type: {\
  20   CORBA::CT b = da->get_##type(); \
  21   tab (level_); \
  22   if (debug_) \
  23     ACE_DEBUG ((LM_DEBUG, str , b)); \
  24   } break;
  25
  26 #define CASEBS(type,CT,str) case CORBA::tk_##type: \
  27   {\
  28     CORBA::CT##Seq_var seq = da->get_##type##_seq (); \
  29     ++level_; \
  30     CORBA::ULong len = seq->length (); \
  31     tab (level_); \
  32     if (debug_) \
  33       { \
  34         ACE_DEBUG ((LM_DEBUG, "length = %u\n", len)); \
  35       } \
  36     for (CORBA::ULong i = 0; i < len; ++i) \
  37       { \
  38         CORBA::CT b = seq[i]; \
  39         tab (level_); \
  40         if (debug_) \
  41           { \
  42             ACE_DEBUG ((LM_DEBUG, "[%d]\n", i)); \
  43             ACE_DEBUG ((LM_DEBUG, str, b)); \
  44           } \
  45       } \
  46     --level_; \
  47   } \
  48   break;
  49
  50 DynAnyAnalyzer::DynAnyAnalyzer (CORBA::ORB_ptr orb,
  51                                 DynamicAny::DynAnyFactory_ptr dynany_factory,
  52                                 int debug)
  53   : orb_ (CORBA::ORB::_duplicate (orb)),
  54     dynany_factory_ (DynamicAny::DynAnyFactory::_duplicate (dynany_factory)),
  55     level_ (0),
  56     debug_ (debug)
  57 {
  58 }
  59
  60 void DynAnyAnalyzer::tab (int t)
  61 {
  62   if (debug_)
  63     {
  64       for (int i = 0 ; i < t ; ++i)
  65         {
  66           ACE_DEBUG ((LM_DEBUG, "\t"));
  67         }
  68     }
  69 }
  70
  71 DynAnyAnalyzer::~DynAnyAnalyzer ()
  72 {
  73 }
  74
  75 void DynAnyAnalyzer::resetTab ()
  76 {
  77   level_ = 0;
  78 }
  79
  80 void DynAnyAnalyzer::analyze (DynamicAny::DynAny_ptr da)
  81 {
  82   CORBA::TypeCode_var tc = da->type ();
  83
  84   CORBA::TCKind kind = tc->kind ();
  85
  86   CORBA::TypeCode_var dup = CORBA::TypeCode::_duplicate (tc.in ());
  87
  88   // strip aliases
  89   while (kind == CORBA::tk_alias)
  90     {
  91       dup = dup->content_type ();
  92
  93       kind = dup->kind ();
  94     }
  95
  96   switch (kind)
  97    {
  98      case CORBA::tk_struct:
  99       {
 100         DynamicAny::DynStruct_var ds
 101           = DynamicAny::DynStruct::_narrow (da);
 102
 103         tab (level_);
 104
 105         if (debug_)
 106           {
 107             ACE_DEBUG ((LM_DEBUG,
 108                       "STRUCT\n"));
 109           }
 110
 111         if (da->seek (0) )
 112           {
 113             level_++;
 114
 115             do
 116               {
 117                 DynamicAny::DynAny_var cc =
 118                   ds->current_component ();
 119
 120                 DynamicAny::FieldName_var fn =
 121                   ds->current_member_name ();
 122
 123                 tab(level_);
 124
 125                 if (debug_)
 126                   {
 127                     ACE_DEBUG ((LM_DEBUG,
 128                               "Member = %C\n", fn.in ()));
 129                   }
 130
 131                 if (!CORBA::is_nil (cc.in ()))
 132                   {
 133                     this->analyze (cc.in ());
 134                   }
 135
 136               } while (da->next ());
 137
 138             level_--;
 139           }
 140       }
 141       break; // end tk_struct
 142
 143     case CORBA::tk_sequence:
 144       {
 145         if (TAO_DynCommon::is_basic_type_seq (tc.in ()))
 146           {
 147             this->analyze_basic_seq (dup.in (), da);
 148           }
 149         else
 150           {
 151             DynamicAny::DynSequence_var ds =
 152               DynamicAny::DynSequence::_narrow (da);
 153
 154             int i = 0;
 155             tab(level_);
 156
 157             if (debug_)
 158               {
 159                 ACE_DEBUG ((LM_DEBUG,
 160                             "SEQUENCE\n"));
 161               }
 162
 163             if (ds->seek (0UL))
 164               {
 165                 level_++;
 166
 167                 do
 168                   {
 169                     tab(level_);
 170
 171                     if (debug_)
 172                       ACE_DEBUG ((LM_DEBUG,
 173                                   "[%d]\n", i));
 174
 175                     DynamicAny::DynAny_var cc (ds->current_component ());
 176
 177                     if (!CORBA::is_nil (cc.in ()))
 178                       {
 179                         analyze (cc.in ());
 180                       }
 181
 182                     i++;
 183                   } while (da->next ());
 184
 185                 level_--;
 186               }
 187           }
 188       }
 189       break; // end tk_sequence
 190
 191     case CORBA::tk_array:
 192       {
 193         tab (level_);
 194
 195         if (debug_)
 196           {
 197             ACE_DEBUG ((LM_DEBUG,
 198                         "ARRAY\n"));
 199           }
 200
 201         level_++;
 202
 203         CORBA::ULong const len =
 204           dup->length ();
 205
 206         for (CORBA::ULong i = 0 ; i < len; ++i)
 207           {
 208             tab (level_);
 209
 210             if (debug_)
 211               {
 212                 ACE_DEBUG ((LM_DEBUG, "[%d]\n", i));
 213               }
 214
 215             DynamicAny::DynAny_var cc = da->current_component();
 216
 217             if (!CORBA::is_nil (cc.in ()))
 218               {
 219                 analyze (cc.in ());
 220               }
 221
 222             da->next ();
 223           }
 224         level_--;
 225       }
 226       break;
 227
 228     case CORBA::tk_union:
 229       {
 230         DynamicAny::DynUnion_var value =
 231           DynamicAny::DynUnion::_narrow (da);
 232
 233         if (!value->has_no_active_member ())
 234           {
 235             DynamicAny::DynAny_var disc = value->member ();
 236
 237             if (!CORBA::is_nil (disc.in ()))
 238               {
 239                 this->analyze (disc.in ());
 240               }
 241           }
 242       }
 243       break;
 244
 245     case CORBA::tk_any:
 246       {
 247         DynamicAny::DynAny_var dynany;
 248         CORBA::Any_var any = da->get_any ();
 249
 250         dynany =
 251           dynany_factory_->create_dyn_any (any.in ());
 252
 253         if (!CORBA::is_nil (dynany.in ()))
 254           {
 255             this->analyze (dynany.in ());
 256           }
 257
 258         dynany->destroy ();
 259       }
 260       break;
 261
 262     case CORBA::tk_enum:
 263       {
 264         DynamicAny::DynEnum_var value =
 265           DynamicAny::DynEnum::_narrow (da);
 266
 267         CORBA::String_var s = value->get_as_string ();
 268         tab (level_);
 269
 270         if (debug_)
 271           {
 272             ACE_DEBUG ((LM_DEBUG, "  Value (enum) = %C\n", s.in()));
 273           }
 274       }
 275       break;
 276
 277     CASEE (boolean, Boolean, "  Value (bool) = %d\n");
 278     CASEE (short, Short, "  Value (short) = %d\n");
 279     CASEE (ushort, UShort, "  Value (ushort) = %u\n");
 280     CASEE (long, Long, "  Value (long) = %d\n");
 281     CASEE (ulong, ULong, "  Value (ulong) = %u\n");
 282     CASEE (longlong, LongLong, "  Value (longlong) %Ld\n");
 283     CASEE (ulonglong, ULongLong, "  Value (ulonglong) %Lu\n");
 284     CASEE (char, Char, "  Value (char) = %c\n");
 285     CASEE (float, Float, "  Value (float) = %f\n");
 286     CASEE (double, Double, "  Value (double) = %f\n");
 287     CASEE (octet, Octet, "  Value (octet) = %c\n");
 288
 289     case CORBA::tk_string:
 290       {
 291         CORBA::String_var b (da->get_string ());
 292         tab (level_);
 293
 294         if (debug_)
 295           {
 296             ACE_DEBUG ((LM_DEBUG, "  Value (string) = %C\n", b.in ()));
 297           }
 298       }
 299       break;
 300
 301     case CORBA::tk_TypeCode:
 302       {
 303         tab (level_);
 304
 305         if (debug_)
 306           {
 307             CORBA::TCKind const kind =
 308               da->get_typecode ()->kind ();
 309
 310             ACE_DEBUG ((LM_DEBUG,
 311                         "  Value (TypeCode) = %d\n",
 312                         static_cast<int> (kind)));
 313           }
 314       }
 315       break;
 316
 317     default:
 318       {
 319         tab (level_);
 320
 321         if (debug_)
 322           {
 323             CORBA::TCKind const kind =
 324               tc->kind ();
 325
 326             ACE_DEBUG ((LM_DEBUG,
 327                         "  unhandled typecode = %d\n",
 328                         static_cast<int> (kind)));
 329           }
 330       }
 331       break;
 332   }
 333
 334   if (debug_)
 335     {
 336       ACE_DEBUG ((LM_DEBUG, "\n"));
 337     }
 338 }
 339
 340 void
 341 DynAnyAnalyzer::analyze_basic_seq (CORBA::TypeCode_ptr tc,
 342                                    DynamicAny::DynAny_ptr da)
 343 {
 344   CORBA::TypeCode_var ct = tc->content_type ();
 345   CORBA::TCKind tk = ct->kind ();
 346
 347   tab (level_);
 348
 349   if (debug_)
 350     {
 351       ACE_DEBUG ((LM_DEBUG,
 352                   "BASIC TYPE SEQUENCE\n"));
 353     }
 354
 355   switch (tk)
 356     {
 357       CASEBS (boolean, Boolean, "  Value (bool) = %d\n");
 358       CASEBS (octet, Octet, "  Value (octet) = %c\n");
 359       CASEBS (char, Char, "  Value (char) = %c\n");
 360       CASEBS (wchar, WChar, "  Value (wchar) = %u\n");
 361       CASEBS (short, Short, "  Value (short) = %d\n");
 362       CASEBS (ushort, UShort, "  Value (ushort) = %u\n");
 363       CASEBS (long, Long, "  Value (long) = %d\n");
 364       CASEBS (ulong, ULong, "  Value (ulong) = %u\n");
 365       CASEBS (longlong, LongLong, "  Value (longlong) = %Ld\n");
 366       CASEBS (ulonglong, ULongLong, "  Value (ulonglong) = %Lu\n");
 367       CASEBS (float, Float, "  Value (float) = %f\n");
 368       CASEBS (double, Double, "  Value (double) = %f\n");
 369       case CORBA::tk_longdouble:
 370       default:
 371         tab (level_);
 372
 373         if (debug_)
 374           {
 375             ACE_DEBUG ((LM_DEBUG,
 376                         "  unhandled typecode = %d\n",
 377                         static_cast<int> (tk)));
 378           }
 379
 380         break;
 381     }
 382 }