TAO/tao/ETCL/TAO_ETCL_Constraint.cpp

   1 // -*- C++ -*-
   2 #include "ace/ETCL/ETCL_Constraint_Visitor.h"
   3
   4 #include "tao/AnyTypeCode/AnyTypeCode_methods.h"
   5 #include "tao/AnyTypeCode/Any_Unknown_IDL_Type.h"
   6 #include "tao/AnyTypeCode/TypeCode.h"
   7 #include "tao/AnyTypeCode/Any.h"
   8 #include "tao/CDR.h"
   9 #include "tao/SystemException.h"
  10
  11 #include "tao/ETCL/TAO_ETCL_Constraint.h"
  12
  13 #if ! defined (__ACE_INLINE__)
  14 #include "tao/ETCL/TAO_ETCL_Constraint.inl"
  15 #endif /* __ACE_INLINE__ */
  16
  17 TAO_BEGIN_VERSIONED_NAMESPACE_DECL
  18
  19 TAO_ETCL_Literal_Constraint::TAO_ETCL_Literal_Constraint (
  20   const TAO_ETCL_Literal_Constraint & lit)
  21   : ETCL_Literal_Constraint (),
  22     any_ (0)
  23 {
  24   this->copy (lit);
  25 }
  26
  27 TAO_ETCL_Literal_Constraint::TAO_ETCL_Literal_Constraint (CORBA::Any * any)
  28   : any_ (0)
  29 {
  30   CORBA::Any& any_ref = *any;
  31   CORBA::TypeCode_var type = any_ref.type ();
  32   CORBA::TCKind corba_type = CORBA::tk_null;
  33
  34   try
  35     {
  36       corba_type = type->kind ();
  37     }
  38   catch (const CORBA::Exception&)
  39     {
  40       // @@ Seth: Don't know what else to do. Make sure we can tell
  41       // when this constructor fails.
  42       return;
  43     }
  44
  45   this->type_ =
  46     TAO_ETCL_Literal_Constraint::comparable_type (type.in ());
  47
  48   switch (this->type_)
  49     {
  50     case ACE_ETCL_SIGNED:
  51       this->op_.integer_ = 0;
  52
  53       if (corba_type == CORBA::tk_short)
  54         {
  55           CORBA::Short sh;
  56           any_ref >>= sh;
  57           this->op_.integer_ = (CORBA::Long) sh;
  58         }
  59       else
  60         {
  61           any_ref >>= this->op_.integer_;
  62         }
  63
  64       break;
  65     case ACE_ETCL_UNSIGNED:
  66       this->op_.uinteger_ = 0;
  67
  68       if (corba_type == CORBA::tk_ushort)
  69         {
  70           CORBA::UShort sh;
  71           any_ref >>= sh;
  72           this->op_.uinteger_ = (CORBA::ULong) sh;
  73         }
  74       else if (corba_type == CORBA::tk_enum)
  75         {
  76           TAO::Any_Impl *impl = any->impl ();
  77
  78           if (impl->encoded ())
  79             {
  80               TAO::Unknown_IDL_Type *unk =
  81                 dynamic_cast<TAO::Unknown_IDL_Type *> (impl);
  82
  83               if (unk == 0)
  84                 {
  85                   throw CORBA::INTERNAL ();
  86                 }
  87
  88               // We don't want unk's rd_ptr to move, in case we are shared by
  89               // another Any, so we use this to copy the state, not the buffer.
  90               TAO_InputCDR for_reading (unk->_tao_get_cdr ());
  91               for_reading.read_ulong (this->op_.uinteger_);
  92             }
  93           else
  94             {
  95               TAO_OutputCDR out;
  96               impl->marshal_value (out);
  97               TAO_InputCDR in (out);
  98               in.read_ulong (this->op_.uinteger_);
  99             }
 100         }
 101       else
 102         {
 103           any_ref >>= this->op_.uinteger_;
 104         }
 105
 106       break;
 107     case ACE_ETCL_DOUBLE:
 108       if (corba_type == CORBA::tk_float)
 109         {
 110           CORBA::Float fl;
 111           (*any) >>= fl;
 112           this->op_.double_ = (CORBA::Double) fl;
 113         }
 114       else
 115         {
 116           (*any) >>= this->op_.double_;
 117         }
 118
 119       break;
 120     case ACE_ETCL_BOOLEAN:
 121       {
 122         CORBA::Any::to_boolean tmp (this->op_.bool_);
 123         (*any) >>= tmp;
 124       }
 125       break;
 126     case ACE_ETCL_STRING:
 127       {
 128         const char* s;
 129         any_ref >>= s;
 130         this->op_.str_ = CORBA::string_dup (s);
 131       }
 132       break;
 133     case ACE_ETCL_COMPONENT:
 134       this->any_ = any->impl ();
 135       this->any_->_add_ref ();
 136       break;
 137     }
 138 }
 139
 140 TAO_ETCL_Literal_Constraint::~TAO_ETCL_Literal_Constraint ()
 141 {
 142   if (this->any_ != 0)
 143     {
 144       this->any_->_remove_ref ();
 145     }
 146 }
 147
 148 void
 149 TAO_ETCL_Literal_Constraint::operator= (const TAO_ETCL_Literal_Constraint& co)
 150 {
 151   this->copy (co);
 152 }
 153
 154 TAO_ETCL_Literal_Constraint::operator CORBA::Boolean () const
 155 {
 156   return this->ETCL_Literal_Constraint::operator ACE_CDR::Boolean ();
 157 }
 158
 159 TAO_ETCL_Literal_Constraint::operator CORBA::ULong () const
 160 {
 161   switch (this->type_)
 162   {
 163     case ACE_ETCL_COMPONENT:
 164       {
 165         CORBA::ULong retval = 0;
 166         CORBA::Any tmp;
 167         tmp.replace (this->any_);
 168         this->any_->_add_ref ();
 169         tmp >>= retval;
 170         return retval;
 171       }
 172     default:
 173       return this->ETCL_Literal_Constraint::operator ACE_CDR::ULong ();
 174   }
 175 }
 176
 177 TAO_ETCL_Literal_Constraint::operator CORBA::Long () const
 178 {
 179   switch (this->type_)
 180   {
 181     case ACE_ETCL_COMPONENT:
 182       {
 183         CORBA::Long retval = 0;
 184         CORBA::Any tmp;
 185         tmp.replace (this->any_);
 186         this->any_->_add_ref ();
 187         tmp >>= retval;
 188         return retval;
 189       }
 190     default:
 191       return this->ETCL_Literal_Constraint::operator ACE_CDR::Long ();
 192   }
 193 }
 194
 195 TAO_ETCL_Literal_Constraint::operator CORBA::Double () const
 196 {
 197   switch (this->type_)
 198   {
 199     case ACE_ETCL_COMPONENT:
 200       {
 201         CORBA::Double retval = 0.0;
 202         CORBA::Any tmp;
 203         tmp.replace (this->any_);
 204         this->any_->_add_ref ();
 205         tmp >>= retval;
 206         return retval;
 207       }
 208     default:
 209       return this->ETCL_Literal_Constraint::operator ACE_CDR::Double ();
 210   }
 211 }
 212
 213 TAO_ETCL_Literal_Constraint::operator const char* () const
 214 {
 215   switch (this->type_)
 216   {
 217     case ACE_ETCL_COMPONENT:
 218       {
 219         const char *retval = 0;
 220         CORBA::Any tmp;
 221         tmp.replace (this->any_);
 222         this->any_->_add_ref ();
 223         tmp >>= retval;
 224         return retval;
 225       }
 226     default:
 227       return this->ETCL_Literal_Constraint::operator const char * ();
 228   }
 229 }
 230
 231 TAO_ETCL_Literal_Constraint::operator TAO::Any_Impl* () const
 232 {
 233   return (this->type_ == ACE_ETCL_COMPONENT) ? this->any_ : 0;
 234 }
 235
 236 Literal_Type
 237 TAO_ETCL_Literal_Constraint::comparable_type (CORBA::TypeCode_ptr type)
 238 {
 239   // Convert a CORBA::TCKind into a Literal_Type
 240   Literal_Type return_value = ACE_ETCL_UNKNOWN;
 241   CORBA::TCKind kind = CORBA::tk_null;
 242
 243   try
 244   {
 245     kind = type->kind ();
 246     CORBA::TypeCode_var tmp = CORBA::TypeCode::_duplicate (type);
 247
 248     while (kind == CORBA::tk_alias)
 249       {
 250         tmp = tmp->content_type ();
 251
 252         kind = tmp->kind ();
 253       }
 254   }
 255   catch (const CORBA::Exception&)
 256   {
 257     return return_value;
 258   }
 259   // Since this is a top level try block, no need to check again.
 260
 261   switch (kind)
 262     {
 263     case CORBA::tk_ushort:
 264     case CORBA::tk_ulong:
 265     case CORBA::tk_enum:
 266     case CORBA::tk_ulonglong:
 267       return_value = ACE_ETCL_UNSIGNED;
 268       break;
 269     case CORBA::tk_short:
 270     case CORBA::tk_long:
 271     case CORBA::tk_longlong:
 272       return_value = ACE_ETCL_SIGNED;
 273       break;
 274     case CORBA::tk_boolean:
 275       return_value = ACE_ETCL_BOOLEAN;
 276       break;
 277     case CORBA::tk_float:
 278     case CORBA::tk_double:
 279       return_value = ACE_ETCL_DOUBLE;
 280       break;
 281     case CORBA::tk_string:
 282       return_value = ACE_ETCL_STRING;
 283       break;
 284     default:
 285       return_value = ACE_ETCL_COMPONENT;
 286       break;
 287     }
 288
 289   return return_value;
 290 }
 291
 292 TAO_ETCL_Literal_Constraint
 293 TAO_ETCL_Literal_Constraint::operator+ (const TAO_ETCL_Literal_Constraint & rhs)
 294 {
 295   Literal_Type widest_type = this->widest_type (rhs);
 296
 297   switch (widest_type)
 298     {
 299     case ACE_ETCL_DOUBLE:
 300       {
 301         CORBA::Double result = (CORBA::Double) *this + (CORBA::Double) rhs;
 302         return TAO_ETCL_Literal_Constraint ((CORBA::Double) result);
 303       }
 304     case ACE_ETCL_INTEGER:
 305     case ACE_ETCL_SIGNED:
 306       {
 307         CORBA::Long result = (CORBA::Long) *this + (CORBA::Long) rhs;
 308         return TAO_ETCL_Literal_Constraint ((CORBA::Long) result);
 309       }
 310     case ACE_ETCL_UNSIGNED:
 311       {
 312         CORBA::ULong result = (CORBA::ULong) *this + (CORBA::ULong) rhs;
 313         return TAO_ETCL_Literal_Constraint ((CORBA::ULong) result);
 314       }
 315     default:
 316       return TAO_ETCL_Literal_Constraint ((CORBA::Long) 0);
 317     }
 318 }
 319
 320 TAO_ETCL_Literal_Constraint
 321 TAO_ETCL_Literal_Constraint::operator- (const TAO_ETCL_Literal_Constraint & rhs)
 322 {
 323   Literal_Type widest_type = this->widest_type (rhs);
 324
 325   switch (widest_type)
 326     {
 327     case ACE_ETCL_DOUBLE:
 328       {
 329         CORBA::Double result = (CORBA::Double) *this - (CORBA::Double) rhs;
 330         return TAO_ETCL_Literal_Constraint ((CORBA::Double) result);
 331       }
 332     case ACE_ETCL_INTEGER:
 333     case ACE_ETCL_SIGNED:
 334       {
 335         CORBA::Long result = (CORBA::Long) *this - (CORBA::Long) rhs;
 336         return TAO_ETCL_Literal_Constraint ((CORBA::Long) result);
 337       }
 338     case ACE_ETCL_UNSIGNED:
 339       {
 340         CORBA::ULong result = (CORBA::ULong) *this - (CORBA::ULong) rhs;
 341         return TAO_ETCL_Literal_Constraint ((CORBA::ULong) result);
 342       }
 343     default:
 344       return TAO_ETCL_Literal_Constraint ((CORBA::Long) 0);
 345     }
 346 }
 347
 348 TAO_ETCL_Literal_Constraint
 349 TAO_ETCL_Literal_Constraint::operator* (const TAO_ETCL_Literal_Constraint & rhs)
 350 {
 351   Literal_Type widest_type = this->widest_type (rhs);
 352
 353   switch (widest_type)
 354     {
 355     case ACE_ETCL_DOUBLE:
 356       {
 357         CORBA::Double result = (CORBA::Double) *this * (CORBA::Double) rhs;
 358         return TAO_ETCL_Literal_Constraint ((CORBA::Double) result);
 359       }
 360     case ACE_ETCL_INTEGER:
 361     case ACE_ETCL_SIGNED:
 362       {
 363         CORBA::Long result = (CORBA::Long) *this * (CORBA::Long) rhs;
 364         return TAO_ETCL_Literal_Constraint ((CORBA::Long) result);
 365       }
 366     case ACE_ETCL_UNSIGNED:
 367       {
 368         CORBA::ULong result = (CORBA::ULong) *this * (CORBA::ULong) rhs;
 369         return TAO_ETCL_Literal_Constraint ((CORBA::ULong) result);
 370       }
 371     default:
 372       return TAO_ETCL_Literal_Constraint ((CORBA::Long) 0);
 373     }
 374 }
 375
 376 TAO_ETCL_Literal_Constraint
 377 TAO_ETCL_Literal_Constraint::operator/ (const TAO_ETCL_Literal_Constraint & rhs)
 378 {
 379   Literal_Type widest_type = this->widest_type (rhs);
 380
 381   switch (widest_type)
 382     {
 383     case ACE_ETCL_DOUBLE:
 384       {
 385         if (ACE::is_equal ((ACE_CDR::Double) rhs, 0.0))
 386           return TAO_ETCL_Literal_Constraint ((ACE_CDR::Double) 0.0);
 387
 388         CORBA::Double result = (CORBA::Double) *this / (CORBA::Double) rhs;
 389         return TAO_ETCL_Literal_Constraint ((CORBA::Double) result);
 390       }
 391     case ACE_ETCL_INTEGER:
 392     case ACE_ETCL_SIGNED:
 393       {
 394         if ((ACE_CDR::Long) rhs == 0)
 395           return TAO_ETCL_Literal_Constraint ((ACE_CDR::Long) 0);
 396
 397         CORBA::Long result = (CORBA::Long) *this / (CORBA::Long) rhs;
 398         return TAO_ETCL_Literal_Constraint ((CORBA::Long) result);
 399       }
 400     case ACE_ETCL_UNSIGNED:
 401       {
 402         if ((ACE_CDR::ULong) rhs == 0)
 403           return TAO_ETCL_Literal_Constraint ((ACE_CDR::ULong) 0);
 404
 405         CORBA::ULong result = (CORBA::ULong) *this / (CORBA::ULong) rhs;
 406         return TAO_ETCL_Literal_Constraint ((CORBA::ULong) result);
 407       }
 408     default:
 409       return TAO_ETCL_Literal_Constraint ((CORBA::Long) 0);
 410     }
 411 }
 412
 413 TAO_ETCL_Literal_Constraint
 414 TAO_ETCL_Literal_Constraint::operator- ()
 415 {
 416   switch (this->type_)
 417   {
 418     case ACE_ETCL_DOUBLE:
 419       return TAO_ETCL_Literal_Constraint (- this->op_.double_);
 420     case ACE_ETCL_INTEGER:
 421     case ACE_ETCL_SIGNED:
 422       return TAO_ETCL_Literal_Constraint (- this->op_.integer_);
 423     case ACE_ETCL_UNSIGNED:
 424       return TAO_ETCL_Literal_Constraint (- (CORBA::Long) this->op_.uinteger_);
 425     default:
 426       return TAO_ETCL_Literal_Constraint ((CORBA::Long) 0);
 427   }
 428 }
 429
 430 Literal_Type
 431 TAO_ETCL_Literal_Constraint::widest_type (
 432   const ETCL_Literal_Constraint & rhs)
 433 {
 434   Literal_Type rhs_type = rhs.expr_type ();
 435   Literal_Type return_value = rhs_type;
 436
 437   if (rhs_type == ACE_ETCL_COMPONENT)
 438     {
 439       const TAO_ETCL_Literal_Constraint& actual =
 440         dynamic_cast<const TAO_ETCL_Literal_Constraint&> (rhs);
 441       CORBA::TypeCode_var tc = actual.any_->type ();
 442       rhs_type = TAO_ETCL_Literal_Constraint::comparable_type (tc.in ());
 443       return return_value;
 444     }
 445
 446   return this->ETCL_Literal_Constraint::widest_type (rhs);
 447 }
 448
 449 void
 450 TAO_ETCL_Literal_Constraint::copy (const TAO_ETCL_Literal_Constraint &lit)
 451 {
 452   if (this->type_ == ACE_ETCL_COMPONENT && this->any_ != 0)
 453     {
 454       this->any_->_remove_ref ();
 455       this->any_ = 0;
 456     }
 457
 458   switch (lit.type_)
 459     {
 460     case ACE_ETCL_COMPONENT:
 461       this->type_ = ACE_ETCL_COMPONENT;
 462       this->any_ = lit.any_;
 463       this->any_->_add_ref ();
 464       break;
 465     default:
 466       this->ETCL_Literal_Constraint::copy (lit);
 467       break;
 468     }
 469 }
 470
 471 TAO_END_VERSIONED_NAMESPACE_DECL