ACE/ace/ETCL/ETCL_Constraint.cpp

   1 // -*- C++ -*-
   2 #include "ace/ACE.h"
   3
   4 #include "ace/ETCL/ETCL_Constraint.h"
   5 #include "ace/ETCL/ETCL_Constraint_Visitor.h"
   6
   7 #if ! defined (__ACE_INLINE__)
   8 #include "ace/ETCL/ETCL_Constraint.inl"
   9 #endif /* __ACE_INLINE__ */
  10
  11 #include "ace/OS_NS_string.h"
  12
  13 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  14
  15 ETCL_Constraint::ETCL_Constraint ()
  16 {
  17 }
  18
  19 ETCL_Constraint::~ETCL_Constraint ()
  20 {
  21 }
  22
  23 int
  24 ETCL_Constraint::accept (ETCL_Constraint_Visitor * /* visitor */)
  25 {
  26   return 0;
  27 }
  28
  29 // ****************************************************************
  30
  31 ETCL_Literal_Constraint::ETCL_Literal_Constraint (
  32     const ETCL_Literal_Constraint & lit)
  33   : ETCL_Constraint(),
  34     type_ (ACE_ETCL_UNKNOWN)
  35 {
  36   this->copy (lit);
  37 }
  38
  39 ETCL_Literal_Constraint::ETCL_Literal_Constraint (
  40     ACE_CDR::ULong uinteger) : type_ (ACE_ETCL_UNSIGNED)
  41 {
  42   this->op_.uinteger_ = uinteger;
  43 }
  44
  45 ETCL_Literal_Constraint::ETCL_Literal_Constraint (
  46     ACE_CDR::Long integer) : type_ (ACE_ETCL_SIGNED)
  47 {
  48   this->op_.integer_ = integer;
  49 }
  50
  51 ETCL_Literal_Constraint::ETCL_Literal_Constraint (
  52     ACE_CDR::Boolean boolean)
  53   : type_ (ACE_ETCL_BOOLEAN)
  54 {
  55   this->op_.bool_ = boolean;
  56 }
  57
  58 ETCL_Literal_Constraint::ETCL_Literal_Constraint (
  59     ACE_CDR::Double doub) : type_ (ACE_ETCL_DOUBLE)
  60 {
  61   this->op_.double_ = doub;
  62 }
  63
  64 ETCL_Literal_Constraint::ETCL_Literal_Constraint (
  65     const char* str) : type_ (ACE_ETCL_STRING)
  66 {
  67   this->op_.str_ = ACE::strnew (str);
  68 }
  69
  70 ETCL_Literal_Constraint::~ETCL_Literal_Constraint ()
  71 {
  72   if (this->type_ == ACE_ETCL_STRING)
  73     {
  74       ACE::strdelete (this->op_.str_);
  75     }
  76 }
  77
  78 int
  79 ETCL_Literal_Constraint::accept (ETCL_Constraint_Visitor* visitor)
  80 {
  81   return visitor->visit_literal (this);
  82 }
  83
  84 Literal_Type
  85 ETCL_Literal_Constraint::expr_type () const
  86 {
  87   return this->type_;
  88 }
  89
  90 void
  91 ETCL_Literal_Constraint::operator= (const ETCL_Literal_Constraint& co)
  92 {
  93   this->copy (co);
  94 }
  95
  96 ETCL_Literal_Constraint::operator ACE_CDR::Boolean () const
  97 {
  98   return (this->type_ == ACE_ETCL_BOOLEAN) ? this->op_.bool_ : false;
  99 }
 100
 101 ETCL_Literal_Constraint::operator ACE_CDR::ULong () const
 102 {
 103   switch (this->type_)
 104   {
 105     case ACE_ETCL_UNSIGNED:
 106       return this->op_.uinteger_;
 107     case ACE_ETCL_SIGNED:
 108     case ACE_ETCL_INTEGER:
 109       return
 110         (this->op_.integer_ > 0) ? (ACE_CDR::ULong) this->op_.integer_ : 0;
 111     case ACE_ETCL_DOUBLE:
 112       return
 113         (this->op_.double_ > 0) ?
 114         ((this->op_.double_ > ACE_UINT32_MAX) ?
 115          ACE_UINT32_MAX :
 116          (ACE_CDR::ULong) this->op_.double_)
 117         : 0;
 118     default:
 119       return 0;
 120   }
 121 }
 122
 123 ETCL_Literal_Constraint::operator ACE_CDR::Long () const
 124 {
 125   switch (this->type_)
 126   {
 127     case ACE_ETCL_SIGNED:
 128     case ACE_ETCL_INTEGER:
 129       return this->op_.integer_;
 130     case ACE_ETCL_UNSIGNED:
 131       return
 132         (this->op_.uinteger_ > (ACE_CDR::ULong) ACE_INT32_MAX) ?
 133         ACE_INT32_MAX : (ACE_CDR::Long) this->op_.uinteger_;
 134     case ACE_ETCL_DOUBLE:
 135       return
 136         (this->op_.double_ > 0) ?
 137          ((this->op_.double_ > ACE_INT32_MAX) ?
 138           ACE_INT32_MAX :
 139           (ACE_CDR::Long) this->op_.double_) :
 140           ((this->op_.double_ < ACE_INT32_MIN) ?
 141            ACE_INT32_MIN :
 142            (ACE_CDR::Long) this->op_.double_);
 143     default:
 144       return 0;
 145   }
 146 }
 147
 148 ETCL_Literal_Constraint::operator ACE_CDR::Double () const
 149 {
 150   switch (this->type_)
 151   {
 152     case ACE_ETCL_DOUBLE:
 153       return this->op_.double_;
 154     case ACE_ETCL_SIGNED:
 155     case ACE_ETCL_INTEGER:
 156       return (ACE_CDR::Double) this->op_.integer_;
 157     case ACE_ETCL_UNSIGNED:
 158       return (ACE_CDR::Double) this->op_.uinteger_;
 159     default:
 160       return 0.0;
 161   }
 162 }
 163
 164 ETCL_Literal_Constraint::operator const char* () const
 165 {
 166   switch (this->type_)
 167   {
 168     case ACE_ETCL_STRING:
 169       return this->op_.str_;
 170     default:
 171       return 0;
 172   }
 173 }
 174
 175 bool
 176 ETCL_Literal_Constraint::operator== (const ETCL_Literal_Constraint & rhs)
 177 {
 178   bool return_value = false;
 179   Literal_Type widest_type = this->widest_type (rhs);
 180
 181   switch (widest_type)
 182     {
 183     case ACE_ETCL_STRING:
 184       return_value = (ACE_OS::strcmp ((const char*) *this, (const char*) rhs) == 0);
 185       break;
 186     case ACE_ETCL_DOUBLE:
 187       return_value = ACE::is_equal ((ACE_CDR::Double) *this, (ACE_CDR::Double) rhs);
 188       break;
 189     case ACE_ETCL_INTEGER:
 190     case ACE_ETCL_SIGNED:
 191       return_value = (ACE_CDR::Long) *this == (ACE_CDR::Long) rhs;
 192       break;
 193     case ACE_ETCL_UNSIGNED:
 194       return_value = (ACE_CDR::ULong) *this == (ACE_CDR::ULong) rhs;
 195       break;
 196     case ACE_ETCL_BOOLEAN:
 197       return_value = (ACE_CDR::Boolean) *this == (ACE_CDR::Boolean) rhs;
 198       break;
 199     default:
 200      break;
 201     }
 202
 203   return return_value;
 204 }
 205
 206 bool
 207 ETCL_Literal_Constraint::operator< (const ETCL_Literal_Constraint & rhs)
 208 {
 209   bool return_value = false;
 210   Literal_Type widest_type = this->widest_type (rhs);
 211
 212   switch (widest_type)
 213     {
 214     case ACE_ETCL_STRING:
 215       return_value = (ACE_OS::strcmp ((const char*) *this, (const char*) rhs) < 0);
 216       break;
 217     case ACE_ETCL_DOUBLE:
 218       return_value = (ACE_CDR::Double) *this < (ACE_CDR::Double) rhs;
 219       break;
 220     case ACE_ETCL_INTEGER:
 221     case ACE_ETCL_SIGNED:
 222       return_value = (ACE_CDR::Long) *this < (ACE_CDR::Long) rhs;
 223       break;
 224     case ACE_ETCL_UNSIGNED:
 225       return_value = (ACE_CDR::ULong) *this < (ACE_CDR::ULong) rhs;
 226       break;
 227     case ACE_ETCL_BOOLEAN:
 228       return_value = (ACE_CDR::Boolean) *this < (ACE_CDR::Boolean) rhs;
 229       break;
 230     default:
 231       break;
 232     }
 233
 234   return return_value;
 235 }
 236
 237 bool
 238 ETCL_Literal_Constraint::operator> (const ETCL_Literal_Constraint & rhs)
 239 {
 240   bool return_value = false;
 241   Literal_Type widest_type = this->widest_type (rhs);
 242
 243   switch (widest_type)
 244     {
 245     case ACE_ETCL_STRING:
 246       return_value = (ACE_OS::strcmp ((const char*) *this, (const char*) rhs) > 0);
 247       break;
 248     case ACE_ETCL_DOUBLE:
 249       return_value = (ACE_CDR::Double) *this > (ACE_CDR::Double) rhs;
 250       break;
 251     case ACE_ETCL_INTEGER:
 252     case ACE_ETCL_SIGNED:
 253       return_value = (ACE_CDR::Long) *this > (ACE_CDR::Long) rhs;
 254       break;
 255     case ACE_ETCL_UNSIGNED:
 256       return_value = (ACE_CDR::ULong) *this > (ACE_CDR::ULong) rhs;
 257       break;
 258     default:
 259       break;
 260     }
 261
 262   return return_value;
 263 }
 264
 265 ETCL_Literal_Constraint
 266 ETCL_Literal_Constraint::operator+ (const ETCL_Literal_Constraint & rhs)
 267 {
 268   Literal_Type widest_type = this->widest_type (rhs);
 269
 270   switch (widest_type)
 271     {
 272     case ACE_ETCL_DOUBLE:
 273       {
 274         ACE_CDR::Double result = (ACE_CDR::Double) *this + (ACE_CDR::Double) rhs;
 275         return ETCL_Literal_Constraint ((ACE_CDR::Double) result);
 276       }
 277     case ACE_ETCL_INTEGER:
 278     case ACE_ETCL_SIGNED:
 279       {
 280         ACE_CDR::Long result = (ACE_CDR::Long) *this + (ACE_CDR::Long) rhs;
 281         return ETCL_Literal_Constraint ((ACE_CDR::Long) result);
 282       }
 283     case ACE_ETCL_UNSIGNED:
 284       {
 285         ACE_CDR::ULong result = (ACE_CDR::ULong) *this + (ACE_CDR::ULong) rhs;
 286         return ETCL_Literal_Constraint ((ACE_CDR::ULong) result);
 287       }
 288     default:
 289       return ETCL_Literal_Constraint ((ACE_CDR::Long) 0);
 290     }
 291 }
 292
 293 ETCL_Literal_Constraint
 294 ETCL_Literal_Constraint::operator- (const ETCL_Literal_Constraint & rhs)
 295 {
 296   Literal_Type widest_type = this->widest_type (rhs);
 297
 298   switch (widest_type)
 299     {
 300     case ACE_ETCL_DOUBLE:
 301       {
 302         ACE_CDR::Double result = (ACE_CDR::Double) *this - (ACE_CDR::Double) rhs;
 303         return ETCL_Literal_Constraint ((ACE_CDR::Double) result);
 304       }
 305     case ACE_ETCL_INTEGER:
 306     case ACE_ETCL_SIGNED:
 307       {
 308         ACE_CDR::Long result = (ACE_CDR::Long) *this - (ACE_CDR::Long) rhs;
 309         return ETCL_Literal_Constraint ((ACE_CDR::Long) result);
 310       }
 311     case ACE_ETCL_UNSIGNED:
 312       {
 313         ACE_CDR::ULong result = (ACE_CDR::ULong) *this - (ACE_CDR::ULong) rhs;
 314         return ETCL_Literal_Constraint ((ACE_CDR::ULong) result);
 315       }
 316     default:
 317       return ETCL_Literal_Constraint ((ACE_CDR::Long) 0);
 318     }
 319 }
 320
 321 ETCL_Literal_Constraint
 322 ETCL_Literal_Constraint::operator* (const ETCL_Literal_Constraint & rhs)
 323 {
 324   Literal_Type widest_type = this->widest_type (rhs);
 325
 326   switch (widest_type)
 327     {
 328     case ACE_ETCL_DOUBLE:
 329       {
 330         ACE_CDR::Double result = (ACE_CDR::Double) *this * (ACE_CDR::Double) rhs;
 331         return ETCL_Literal_Constraint ((ACE_CDR::Double) result);
 332       }
 333     case ACE_ETCL_INTEGER:
 334     case ACE_ETCL_SIGNED:
 335       {
 336         ACE_CDR::Long result = (ACE_CDR::Long) *this * (ACE_CDR::Long) rhs;
 337         return ETCL_Literal_Constraint ((ACE_CDR::Long) result);
 338       }
 339     case ACE_ETCL_UNSIGNED:
 340       {
 341         ACE_CDR::ULong result = (ACE_CDR::ULong) *this * (ACE_CDR::ULong) rhs;
 342         return ETCL_Literal_Constraint ((ACE_CDR::ULong) result);
 343       }
 344     default:
 345       return ETCL_Literal_Constraint ((ACE_CDR::Long) 0);
 346     }
 347 }
 348
 349 ETCL_Literal_Constraint
 350 ETCL_Literal_Constraint::operator/ (const ETCL_Literal_Constraint & rhs)
 351 {
 352   Literal_Type widest_type = this->widest_type (rhs);
 353
 354   switch (widest_type)
 355     {
 356     case ACE_ETCL_DOUBLE:
 357       {
 358         if (ACE::is_equal ((ACE_CDR::Double) rhs, 0.0))
 359           return ETCL_Literal_Constraint ((ACE_CDR::Double) 0.0);
 360
 361         ACE_CDR::Double result = (ACE_CDR::Double) *this / (ACE_CDR::Double) rhs;
 362         return ETCL_Literal_Constraint ((ACE_CDR::Double) result);
 363       }
 364     case ACE_ETCL_INTEGER:
 365     case ACE_ETCL_SIGNED:
 366       {
 367         if ((ACE_CDR::Long) rhs == 0)
 368           return ETCL_Literal_Constraint ((ACE_CDR::Long) 0);
 369
 370         ACE_CDR::Long result = (ACE_CDR::Long) *this / (ACE_CDR::Long) rhs;
 371         return ETCL_Literal_Constraint ((ACE_CDR::Long) result);
 372       }
 373     case ACE_ETCL_UNSIGNED:
 374       {
 375         if ((ACE_CDR::ULong) rhs == 0)
 376           return ETCL_Literal_Constraint ((ACE_CDR::ULong) 0);
 377
 378         ACE_CDR::ULong result = (ACE_CDR::ULong) *this / (ACE_CDR::ULong) rhs;
 379         return ETCL_Literal_Constraint ((ACE_CDR::ULong) result);
 380       }
 381     default:
 382       return ETCL_Literal_Constraint ((ACE_CDR::Long) 0);
 383     }
 384 }
 385
 386 ETCL_Literal_Constraint
 387 ETCL_Literal_Constraint::operator- ()
 388 {
 389   switch (this->type_)
 390   {
 391     case ACE_ETCL_DOUBLE:
 392       return ETCL_Literal_Constraint (- this->op_.double_);
 393     case ACE_ETCL_INTEGER:
 394     case ACE_ETCL_SIGNED:
 395       return ETCL_Literal_Constraint (- this->op_.integer_);
 396     case ACE_ETCL_UNSIGNED:
 397       return ETCL_Literal_Constraint (- (ACE_CDR::Long) this->op_.uinteger_);
 398     default:
 399       return ETCL_Literal_Constraint ((ACE_CDR::Long) 0);
 400   }
 401 }
 402
 403 Literal_Type
 404 ETCL_Literal_Constraint::widest_type (const ETCL_Literal_Constraint & rhs)
 405 {
 406   Literal_Type rhs_type = rhs.expr_type ();
 407   Literal_Type return_value = rhs_type;
 408
 409   if (rhs_type != this->type_)
 410     {
 411       if (rhs_type > this->type_)
 412         {
 413           return_value = rhs_type;
 414         }
 415       else
 416         {
 417           return_value = this->type_;
 418         }
 419     }
 420
 421   return return_value;
 422 }
 423
 424 void
 425 ETCL_Literal_Constraint::copy (const ETCL_Literal_Constraint &lit)
 426 {
 427   if (this->type_ == ACE_ETCL_STRING)
 428     {
 429       ACE::strdelete (this->op_.str_);
 430     }
 431
 432   this->type_ = lit.type_;
 433
 434   switch (this->type_)
 435   {
 436   case ACE_ETCL_STRING:
 437     this->op_.str_ = ACE::strnew (lit.op_.str_);
 438     break;
 439   case ACE_ETCL_DOUBLE:
 440     this->op_.double_ = lit.op_.double_;
 441     break;
 442   case ACE_ETCL_UNSIGNED:
 443     this->op_.uinteger_ = lit.op_.uinteger_;
 444     break;
 445   case ACE_ETCL_INTEGER:
 446   case ACE_ETCL_SIGNED:
 447     this->op_.integer_ = lit.op_.integer_;
 448     break;
 449   case ACE_ETCL_BOOLEAN:
 450     this->op_.bool_ = lit.op_.bool_;
 451     break;
 452   default:
 453     this->type_ = ACE_ETCL_UNKNOWN;
 454     break;
 455   }
 456 }
 457
 458 // ****************************************************************
 459
 460 int
 461 ETCL_Identifier::accept (ETCL_Constraint_Visitor *visitor)
 462 {
 463   return visitor->visit_identifier (this);
 464 }
 465
 466 // ****************************************************************
 467
 468 ETCL_Union_Value::~ETCL_Union_Value ()
 469 {
 470   delete this->string_;
 471   delete this->integer_;
 472 }
 473
 474 int
 475 ETCL_Union_Value::accept (ETCL_Constraint_Visitor *visitor)
 476 {
 477   return visitor->visit_union_value (this);
 478 }
 479
 480 // ****************************************************************
 481
 482 ETCL_Union_Pos::~ETCL_Union_Pos ()
 483 {
 484   delete this->component_;
 485   delete this->union_value_;
 486 }
 487
 488 int
 489 ETCL_Union_Pos::accept (ETCL_Constraint_Visitor *visitor)
 490 {
 491   return visitor->visit_union_pos (this);
 492 }
 493
 494 // ****************************************************************
 495
 496 ETCL_Component_Pos::~ETCL_Component_Pos ()
 497 {
 498   delete this->component_;
 499   delete this->integer_;
 500 }
 501
 502 int
 503 ETCL_Component_Pos::accept (ETCL_Constraint_Visitor *visitor)
 504 {
 505   return visitor->visit_component_pos (this);
 506 }
 507
 508 // ****************************************************************
 509
 510 ETCL_Component_Assoc::~ETCL_Component_Assoc ()
 511 {
 512   delete this->component_;
 513   delete this->identifier_;
 514 }
 515
 516 int
 517 ETCL_Component_Assoc::accept (ETCL_Constraint_Visitor *visitor)
 518 {
 519   return visitor->visit_component_assoc (this);
 520 }
 521
 522 // ****************************************************************
 523
 524 ETCL_Component_Array::~ETCL_Component_Array ()
 525 {
 526   delete this->component_;
 527   delete this->integer_;
 528 }
 529
 530 int
 531 ETCL_Component_Array::accept (ETCL_Constraint_Visitor *visitor)
 532 {
 533   return visitor->visit_component_array (this);
 534 }
 535
 536 // ****************************************************************
 537
 538 int
 539 ETCL_Special::accept (ETCL_Constraint_Visitor *visitor)
 540 {
 541   return visitor->visit_special (this);
 542 }
 543
 544 // ****************************************************************
 545
 546 ETCL_Component::~ETCL_Component ()
 547 {
 548   delete this->component_;
 549   delete this->identifier_;
 550 }
 551
 552 int
 553 ETCL_Component::accept (ETCL_Constraint_Visitor *visitor)
 554 {
 555   return visitor->visit_component (this);
 556 }
 557
 558 // ****************************************************************
 559
 560 ETCL_Dot::~ETCL_Dot ()
 561 {
 562   delete this->component_;
 563 }
 564
 565 int
 566 ETCL_Dot::accept (ETCL_Constraint_Visitor *visitor)
 567 {
 568   return visitor->visit_dot (this);
 569 }
 570
 571 // ****************************************************************
 572
 573 ETCL_Eval::~ETCL_Eval ()
 574 {
 575   delete this->component_;
 576 }
 577
 578 int
 579 ETCL_Eval::accept (ETCL_Constraint_Visitor *visitor)
 580 {
 581   return visitor->visit_eval (this);
 582 }
 583
 584 // ****************************************************************
 585
 586 ETCL_Default::~ETCL_Default ()
 587 {
 588   delete this->component_;
 589 }
 590
 591 int
 592 ETCL_Default::accept (ETCL_Constraint_Visitor *visitor)
 593 {
 594   return visitor->visit_default (this);
 595 }
 596
 597 // ****************************************************************
 598
 599 ETCL_Exist::~ETCL_Exist ()
 600 {
 601   delete this->component_;
 602 }
 603
 604 int
 605 ETCL_Exist::accept (ETCL_Constraint_Visitor *visitor)
 606 {
 607   return visitor->visit_exist (this);
 608 }
 609
 610 // ****************************************************************
 611
 612 ETCL_Unary_Expr::~ETCL_Unary_Expr ()
 613 {
 614   delete this->subexpr_;
 615 }
 616
 617 int
 618 ETCL_Unary_Expr::accept (ETCL_Constraint_Visitor *visitor)
 619 {
 620   return visitor->visit_unary_expr (this);
 621 }
 622
 623 // ****************************************************************
 624
 625 ETCL_Binary_Expr::~ETCL_Binary_Expr ()
 626 {
 627   delete this->lhs_;
 628   delete this->rhs_;
 629 }
 630
 631 int
 632 ETCL_Binary_Expr::accept (ETCL_Constraint_Visitor *visitor)
 633 {
 634   return visitor->visit_binary_expr (this);
 635 }
 636
 637 // ****************************************************************
 638
 639 ETCL_Preference::~ETCL_Preference ()
 640 {
 641   delete this->subexpr_;
 642 }
 643
 644 int
 645 ETCL_Preference::accept (ETCL_Constraint_Visitor *visitor)
 646 {
 647   return visitor->visit_preference (this);
 648 }
 649
 650 ACE_END_VERSIONED_NAMESPACE_DECL