00001 // -*- C++ -*- 00002 // $Id: ETCL_Constraint.cpp 82803 2008-09-22 14:55:37Z jtc $ 00003 00004 #include "ace/ACE.h" 00005 00006 #include "ace/ETCL/ETCL_Constraint.h" 00007 #include "ace/ETCL/ETCL_Constraint_Visitor.h" 00008 00009 #if ! defined (__ACE_INLINE__) 00010 #include "ace/ETCL/ETCL_Constraint.inl" 00011 #endif /* __ACE_INLINE__ */ 00012 00013 ACE_BEGIN_VERSIONED_NAMESPACE_DECL 00014 00015 ETCL_Constraint::ETCL_Constraint (void) 00016 { 00017 } 00018 00019 ETCL_Constraint::~ETCL_Constraint (void) 00020 { 00021 } 00022 00023 int 00024 ETCL_Constraint::accept (ETCL_Constraint_Visitor * /* visitor */) 00025 { 00026 return 0; 00027 } 00028 00029 // **************************************************************** 00030 00031 ETCL_Literal_Constraint::ETCL_Literal_Constraint ( 00032 const ETCL_Literal_Constraint & lit 00033 ) 00034 : ETCL_Constraint(), 00035 type_ (ACE_ETCL_UNKNOWN) 00036 { 00037 this->copy (lit); 00038 } 00039 00040 ETCL_Literal_Constraint::ETCL_Literal_Constraint ( 00041 ACE_CDR::ULong uinteger 00042 ) 00043 : type_ (ACE_ETCL_UNSIGNED) 00044 { 00045 this->op_.uinteger_ = uinteger; 00046 } 00047 00048 ETCL_Literal_Constraint::ETCL_Literal_Constraint ( 00049 ACE_CDR::Long integer 00050 ) 00051 : type_ (ACE_ETCL_SIGNED) 00052 { 00053 this->op_.integer_ = integer; 00054 } 00055 00056 ETCL_Literal_Constraint::ETCL_Literal_Constraint ( 00057 ACE_CDR::Boolean boolean 00058 ) 00059 : type_ (ACE_ETCL_BOOLEAN) 00060 { 00061 this->op_.bool_ = boolean; 00062 } 00063 00064 ETCL_Literal_Constraint::ETCL_Literal_Constraint ( 00065 ACE_CDR::Double doub 00066 ) 00067 : type_ (ACE_ETCL_DOUBLE) 00068 { 00069 this->op_.double_ = doub; 00070 } 00071 00072 ETCL_Literal_Constraint::ETCL_Literal_Constraint ( 00073 const char* str 00074 ) 00075 : type_ (ACE_ETCL_STRING) 00076 { 00077 this->op_.str_ = ACE::strnew (str); 00078 } 00079 00080 ETCL_Literal_Constraint::~ETCL_Literal_Constraint (void) 00081 { 00082 if (this->type_ == ACE_ETCL_STRING) 00083 { 00084 ACE::strdelete (this->op_.str_); 00085 } 00086 } 00087 00088 int 00089 ETCL_Literal_Constraint::accept (ETCL_Constraint_Visitor* visitor) 00090 { 00091 return visitor->visit_literal (this); 00092 } 00093 00094 Literal_Type 00095 ETCL_Literal_Constraint::expr_type (void) const 00096 { 00097 return this->type_; 00098 } 00099 00100 void 00101 ETCL_Literal_Constraint::operator= (const ETCL_Literal_Constraint& co) 00102 { 00103 this->copy (co); 00104 } 00105 00106 ETCL_Literal_Constraint::operator ACE_CDR::Boolean (void) const 00107 { 00108 return (this->type_ == ACE_ETCL_BOOLEAN) ? this->op_.bool_ : false; 00109 } 00110 00111 ETCL_Literal_Constraint::operator ACE_CDR::ULong (void) const 00112 { 00113 switch (this->type_) 00114 { 00115 case ACE_ETCL_UNSIGNED: 00116 return this->op_.uinteger_; 00117 case ACE_ETCL_SIGNED: 00118 case ACE_ETCL_INTEGER: 00119 return 00120 (this->op_.integer_ > 0) ? (ACE_CDR::ULong) this->op_.integer_ : 0; 00121 case ACE_ETCL_DOUBLE: 00122 return 00123 (this->op_.double_ > 0) ? 00124 ((this->op_.double_ > ACE_UINT32_MAX) ? 00125 ACE_UINT32_MAX : 00126 (ACE_CDR::ULong) this->op_.double_) 00127 : 0; 00128 default: 00129 return 0; 00130 } 00131 } 00132 00133 ETCL_Literal_Constraint::operator ACE_CDR::Long (void) const 00134 { 00135 switch (this->type_) 00136 { 00137 case ACE_ETCL_SIGNED: 00138 case ACE_ETCL_INTEGER: 00139 return this->op_.integer_; 00140 case ACE_ETCL_UNSIGNED: 00141 return 00142 (this->op_.uinteger_ > (ACE_CDR::ULong) ACE_INT32_MAX) ? 00143 ACE_INT32_MAX : (ACE_CDR::Long) this->op_.uinteger_; 00144 case ACE_ETCL_DOUBLE: 00145 return 00146 (this->op_.double_ > 0) ? 00147 ((this->op_.double_ > ACE_INT32_MAX) ? 00148 ACE_INT32_MAX : 00149 (ACE_CDR::Long) this->op_.double_) : 00150 ((this->op_.double_ < ACE_INT32_MIN) ? 00151 ACE_INT32_MIN : 00152 (ACE_CDR::Long) this->op_.double_); 00153 default: 00154 return 0; 00155 } 00156 } 00157 00158 ETCL_Literal_Constraint::operator ACE_CDR::Double (void) const 00159 { 00160 switch (this->type_) 00161 { 00162 case ACE_ETCL_DOUBLE: 00163 return this->op_.double_; 00164 case ACE_ETCL_SIGNED: 00165 case ACE_ETCL_INTEGER: 00166 return (ACE_CDR::Double) this->op_.integer_; 00167 case ACE_ETCL_UNSIGNED: 00168 return (ACE_CDR::Double) this->op_.uinteger_; 00169 default: 00170 return 0.0; 00171 } 00172 } 00173 00174 ETCL_Literal_Constraint::operator const char* (void) const 00175 { 00176 switch (this->type_) 00177 { 00178 case ACE_ETCL_STRING: 00179 return this->op_.str_; 00180 default: 00181 return 0; 00182 } 00183 } 00184 00185 bool 00186 ETCL_Literal_Constraint::operator== (const ETCL_Literal_Constraint & rhs) 00187 { 00188 bool return_value = false; 00189 Literal_Type widest_type = this->widest_type (rhs); 00190 00191 switch (widest_type) 00192 { 00193 case ACE_ETCL_STRING: 00194 return_value = (ACE_OS::strcmp ((const char*) *this, (const char*) rhs) == 0); 00195 break; 00196 case ACE_ETCL_DOUBLE: 00197 return_value = (ACE_CDR::Double) *this == (ACE_CDR::Double) rhs; 00198 break; 00199 case ACE_ETCL_INTEGER: 00200 case ACE_ETCL_SIGNED: 00201 return_value = (ACE_CDR::Long) *this == (ACE_CDR::Long) rhs; 00202 break; 00203 case ACE_ETCL_UNSIGNED: 00204 return_value = (ACE_CDR::ULong) *this == (ACE_CDR::ULong) rhs; 00205 break; 00206 case ACE_ETCL_BOOLEAN: 00207 return_value = (ACE_CDR::Boolean) *this == (ACE_CDR::Boolean) rhs; 00208 break; 00209 default: 00210 break; 00211 } 00212 00213 return return_value; 00214 } 00215 00216 bool 00217 ETCL_Literal_Constraint::operator< (const ETCL_Literal_Constraint & rhs) 00218 { 00219 bool return_value = false; 00220 Literal_Type widest_type = this->widest_type (rhs); 00221 00222 switch (widest_type) 00223 { 00224 case ACE_ETCL_STRING: 00225 return_value = (ACE_OS::strcmp ((const char*) *this, (const char*) rhs) < 0); 00226 break; 00227 case ACE_ETCL_DOUBLE: 00228 return_value = (ACE_CDR::Double) *this < (ACE_CDR::Double) rhs; 00229 break; 00230 case ACE_ETCL_INTEGER: 00231 case ACE_ETCL_SIGNED: 00232 return_value = (ACE_CDR::Long) *this < (ACE_CDR::Long) rhs; 00233 break; 00234 case ACE_ETCL_UNSIGNED: 00235 return_value = (ACE_CDR::ULong) *this < (ACE_CDR::ULong) rhs; 00236 break; 00237 case ACE_ETCL_BOOLEAN: 00238 return_value = (ACE_CDR::Boolean) *this < (ACE_CDR::Boolean) rhs; 00239 break; 00240 default: 00241 break; 00242 } 00243 00244 return return_value; 00245 } 00246 00247 bool 00248 ETCL_Literal_Constraint::operator> (const ETCL_Literal_Constraint & rhs) 00249 { 00250 bool return_value = false; 00251 Literal_Type widest_type = this->widest_type (rhs); 00252 00253 switch (widest_type) 00254 { 00255 case ACE_ETCL_STRING: 00256 return_value = (ACE_OS::strcmp ((const char*) *this, (const char*) rhs) > 0); 00257 break; 00258 case ACE_ETCL_DOUBLE: 00259 return_value = (ACE_CDR::Double) *this > (ACE_CDR::Double) rhs; 00260 break; 00261 case ACE_ETCL_INTEGER: 00262 case ACE_ETCL_SIGNED: 00263 return_value = (ACE_CDR::Long) *this > (ACE_CDR::Long) rhs; 00264 break; 00265 case ACE_ETCL_UNSIGNED: 00266 return_value = (ACE_CDR::ULong) *this > (ACE_CDR::ULong) rhs; 00267 break; 00268 default: 00269 break; 00270 } 00271 00272 return return_value; 00273 } 00274 00275 ETCL_Literal_Constraint 00276 ETCL_Literal_Constraint::operator+ (const ETCL_Literal_Constraint & rhs) 00277 { 00278 Literal_Type widest_type = this->widest_type (rhs); 00279 00280 switch (widest_type) 00281 { 00282 case ACE_ETCL_DOUBLE: 00283 { 00284 ACE_CDR::Double result = (ACE_CDR::Double) *this + (ACE_CDR::Double) rhs; 00285 return ETCL_Literal_Constraint ((ACE_CDR::Double) result); 00286 } 00287 case ACE_ETCL_INTEGER: 00288 case ACE_ETCL_SIGNED: 00289 { 00290 ACE_CDR::Long result = (ACE_CDR::Long) *this + (ACE_CDR::Long) rhs; 00291 return ETCL_Literal_Constraint ((ACE_CDR::Long) result); 00292 } 00293 case ACE_ETCL_UNSIGNED: 00294 { 00295 ACE_CDR::ULong result = (ACE_CDR::ULong) *this + (ACE_CDR::ULong) rhs; 00296 return ETCL_Literal_Constraint ((ACE_CDR::ULong) result); 00297 } 00298 default: 00299 return ETCL_Literal_Constraint ((ACE_CDR::Long) 0); 00300 } 00301 } 00302 00303 ETCL_Literal_Constraint 00304 ETCL_Literal_Constraint::operator- (const ETCL_Literal_Constraint & rhs) 00305 { 00306 Literal_Type widest_type = this->widest_type (rhs); 00307 00308 switch (widest_type) 00309 { 00310 case ACE_ETCL_DOUBLE: 00311 { 00312 ACE_CDR::Double result = (ACE_CDR::Double) *this - (ACE_CDR::Double) rhs; 00313 return ETCL_Literal_Constraint ((ACE_CDR::Double) result); 00314 } 00315 case ACE_ETCL_INTEGER: 00316 case ACE_ETCL_SIGNED: 00317 { 00318 ACE_CDR::Long result = (ACE_CDR::Long) *this - (ACE_CDR::Long) rhs; 00319 return ETCL_Literal_Constraint ((ACE_CDR::Long) result); 00320 } 00321 case ACE_ETCL_UNSIGNED: 00322 { 00323 ACE_CDR::ULong result = (ACE_CDR::ULong) *this - (ACE_CDR::ULong) rhs; 00324 return ETCL_Literal_Constraint ((ACE_CDR::ULong) result); 00325 } 00326 default: 00327 return ETCL_Literal_Constraint ((ACE_CDR::Long) 0); 00328 } 00329 } 00330 00331 ETCL_Literal_Constraint 00332 ETCL_Literal_Constraint::operator* (const ETCL_Literal_Constraint & rhs) 00333 { 00334 Literal_Type widest_type = this->widest_type (rhs); 00335 00336 switch (widest_type) 00337 { 00338 case ACE_ETCL_DOUBLE: 00339 { 00340 ACE_CDR::Double result = (ACE_CDR::Double) *this * (ACE_CDR::Double) rhs; 00341 return ETCL_Literal_Constraint ((ACE_CDR::Double) result); 00342 } 00343 case ACE_ETCL_INTEGER: 00344 case ACE_ETCL_SIGNED: 00345 { 00346 ACE_CDR::Long result = (ACE_CDR::Long) *this * (ACE_CDR::Long) rhs; 00347 return ETCL_Literal_Constraint ((ACE_CDR::Long) result); 00348 } 00349 case ACE_ETCL_UNSIGNED: 00350 { 00351 ACE_CDR::ULong result = (ACE_CDR::ULong) *this * (ACE_CDR::ULong) rhs; 00352 return ETCL_Literal_Constraint ((ACE_CDR::ULong) result); 00353 } 00354 default: 00355 return ETCL_Literal_Constraint ((ACE_CDR::Long) 0); 00356 } 00357 } 00358 00359 ETCL_Literal_Constraint 00360 ETCL_Literal_Constraint::operator/ (const ETCL_Literal_Constraint & rhs) 00361 { 00362 Literal_Type widest_type = this->widest_type (rhs); 00363 00364 switch (widest_type) 00365 { 00366 case ACE_ETCL_DOUBLE: 00367 { 00368 if ((ACE_CDR::Double) rhs == 0.0) 00369 return ETCL_Literal_Constraint ((ACE_CDR::Double) 0.0); 00370 00371 ACE_CDR::Double result = (ACE_CDR::Double) *this / (ACE_CDR::Double) rhs; 00372 return ETCL_Literal_Constraint ((ACE_CDR::Double) result); 00373 } 00374 case ACE_ETCL_INTEGER: 00375 case ACE_ETCL_SIGNED: 00376 { 00377 if ((ACE_CDR::Long) rhs == 0) 00378 return ETCL_Literal_Constraint ((ACE_CDR::Long) 0); 00379 00380 ACE_CDR::Long result = (ACE_CDR::Long) *this / (ACE_CDR::Long) rhs; 00381 return ETCL_Literal_Constraint ((ACE_CDR::Long) result); 00382 } 00383 case ACE_ETCL_UNSIGNED: 00384 { 00385 if ((ACE_CDR::ULong) rhs == 0) 00386 return ETCL_Literal_Constraint ((ACE_CDR::ULong) 0); 00387 00388 ACE_CDR::ULong result = (ACE_CDR::ULong) *this / (ACE_CDR::ULong) rhs; 00389 return ETCL_Literal_Constraint ((ACE_CDR::ULong) result); 00390 } 00391 default: 00392 return ETCL_Literal_Constraint ((ACE_CDR::Long) 0); 00393 } 00394 } 00395 00396 ETCL_Literal_Constraint 00397 ETCL_Literal_Constraint::operator- (void) 00398 { 00399 switch (this->type_) 00400 { 00401 case ACE_ETCL_DOUBLE: 00402 return ETCL_Literal_Constraint (- this->op_.double_); 00403 case ACE_ETCL_INTEGER: 00404 case ACE_ETCL_SIGNED: 00405 return ETCL_Literal_Constraint (- this->op_.integer_); 00406 case ACE_ETCL_UNSIGNED: 00407 return ETCL_Literal_Constraint (- (ACE_CDR::Long) this->op_.uinteger_); 00408 default: 00409 return ETCL_Literal_Constraint ((ACE_CDR::Long) 0); 00410 } 00411 } 00412 00413 Literal_Type 00414 ETCL_Literal_Constraint::widest_type (const ETCL_Literal_Constraint & rhs) 00415 { 00416 Literal_Type rhs_type = rhs.expr_type (); 00417 Literal_Type return_value = rhs_type; 00418 00419 if (rhs_type != this->type_) 00420 { 00421 if (rhs_type > this->type_) 00422 { 00423 return_value = rhs_type; 00424 } 00425 else 00426 { 00427 return_value = this->type_; 00428 } 00429 } 00430 00431 return return_value; 00432 } 00433 00434 void 00435 ETCL_Literal_Constraint::copy (const ETCL_Literal_Constraint &lit) 00436 { 00437 if (this->type_ == ACE_ETCL_STRING) 00438 { 00439 ACE::strdelete (this->op_.str_); 00440 } 00441 00442 this->type_ = lit.type_; 00443 00444 switch (this->type_) 00445 { 00446 case ACE_ETCL_STRING: 00447 this->op_.str_ = ACE::strnew (lit.op_.str_); 00448 break; 00449 case ACE_ETCL_DOUBLE: 00450 this->op_.double_ = lit.op_.double_; 00451 break; 00452 case ACE_ETCL_UNSIGNED: 00453 this->op_.uinteger_ = lit.op_.uinteger_; 00454 break; 00455 case ACE_ETCL_INTEGER: 00456 case ACE_ETCL_SIGNED: 00457 this->op_.integer_ = lit.op_.integer_; 00458 break; 00459 case ACE_ETCL_BOOLEAN: 00460 this->op_.bool_ = lit.op_.bool_; 00461 break; 00462 default: 00463 this->type_ = ACE_ETCL_UNKNOWN; 00464 break; 00465 } 00466 } 00467 00468 // **************************************************************** 00469 00470 int 00471 ETCL_Identifier::accept (ETCL_Constraint_Visitor *visitor) 00472 { 00473 return visitor->visit_identifier (this); 00474 } 00475 00476 // **************************************************************** 00477 00478 ETCL_Union_Value::~ETCL_Union_Value (void) 00479 { 00480 delete this->string_; 00481 delete this->integer_; 00482 } 00483 00484 int 00485 ETCL_Union_Value::accept (ETCL_Constraint_Visitor *visitor) 00486 { 00487 return visitor->visit_union_value (this); 00488 } 00489 00490 // **************************************************************** 00491 00492 ETCL_Union_Pos::~ETCL_Union_Pos (void) 00493 { 00494 delete this->component_; 00495 delete this->union_value_; 00496 } 00497 00498 int 00499 ETCL_Union_Pos::accept (ETCL_Constraint_Visitor *visitor) 00500 { 00501 return visitor->visit_union_pos (this); 00502 } 00503 00504 // **************************************************************** 00505 00506 ETCL_Component_Pos::~ETCL_Component_Pos (void) 00507 { 00508 delete this->component_; 00509 delete this->integer_; 00510 } 00511 00512 int 00513 ETCL_Component_Pos::accept (ETCL_Constraint_Visitor *visitor) 00514 { 00515 return visitor->visit_component_pos (this); 00516 } 00517 00518 // **************************************************************** 00519 00520 ETCL_Component_Assoc::~ETCL_Component_Assoc (void) 00521 { 00522 delete this->component_; 00523 delete this->identifier_; 00524 } 00525 00526 int 00527 ETCL_Component_Assoc::accept (ETCL_Constraint_Visitor *visitor) 00528 { 00529 return visitor->visit_component_assoc (this); 00530 } 00531 00532 // **************************************************************** 00533 00534 ETCL_Component_Array::~ETCL_Component_Array (void) 00535 { 00536 delete this->component_; 00537 delete this->integer_; 00538 } 00539 00540 int 00541 ETCL_Component_Array::accept (ETCL_Constraint_Visitor *visitor) 00542 { 00543 return visitor->visit_component_array (this); 00544 } 00545 00546 // **************************************************************** 00547 00548 ETCL_Special::~ETCL_Special (void) 00549 {} 00550 00551 int 00552 ETCL_Special::accept (ETCL_Constraint_Visitor *visitor) 00553 { 00554 return visitor->visit_special (this); 00555 } 00556 00557 // **************************************************************** 00558 00559 ETCL_Component::~ETCL_Component (void) 00560 { 00561 delete this->component_; 00562 delete this->identifier_; 00563 } 00564 00565 int 00566 ETCL_Component::accept (ETCL_Constraint_Visitor *visitor) 00567 { 00568 return visitor->visit_component (this); 00569 } 00570 00571 // **************************************************************** 00572 00573 ETCL_Dot::~ETCL_Dot (void) 00574 { 00575 delete this->component_; 00576 } 00577 00578 int 00579 ETCL_Dot::accept (ETCL_Constraint_Visitor *visitor) 00580 { 00581 return visitor->visit_dot (this); 00582 } 00583 00584 // **************************************************************** 00585 00586 ETCL_Eval::~ETCL_Eval (void) 00587 { 00588 delete this->component_; 00589 } 00590 00591 int 00592 ETCL_Eval::accept (ETCL_Constraint_Visitor *visitor) 00593 { 00594 return visitor->visit_eval (this); 00595 } 00596 00597 // **************************************************************** 00598 00599 ETCL_Default::~ETCL_Default (void) 00600 { 00601 delete this->component_; 00602 } 00603 00604 int 00605 ETCL_Default::accept (ETCL_Constraint_Visitor *visitor) 00606 { 00607 return visitor->visit_default (this); 00608 } 00609 00610 // **************************************************************** 00611 00612 ETCL_Exist::~ETCL_Exist (void) 00613 { 00614 delete this->component_; 00615 } 00616 00617 int 00618 ETCL_Exist::accept (ETCL_Constraint_Visitor *visitor) 00619 { 00620 return visitor->visit_exist (this); 00621 } 00622 00623 // **************************************************************** 00624 00625 ETCL_Unary_Expr::~ETCL_Unary_Expr (void) 00626 { 00627 delete this->subexpr_; 00628 } 00629 00630 int 00631 ETCL_Unary_Expr::accept (ETCL_Constraint_Visitor *visitor) 00632 { 00633 return visitor->visit_unary_expr (this); 00634 } 00635 00636 // **************************************************************** 00637 00638 ETCL_Binary_Expr::~ETCL_Binary_Expr (void) 00639 { 00640 delete this->lhs_; 00641 delete this->rhs_; 00642 } 00643 00644 int 00645 ETCL_Binary_Expr::accept (ETCL_Constraint_Visitor *visitor) 00646 { 00647 return visitor->visit_binary_expr (this); 00648 } 00649 00650 // **************************************************************** 00651 00652 ETCL_Preference::~ETCL_Preference (void) 00653 { 00654 delete this->subexpr_; 00655 } 00656 00657 int 00658 ETCL_Preference::accept (ETCL_Constraint_Visitor *visitor) 00659 { 00660 return visitor->visit_preference (this); 00661 } 00662 00663 ACE_END_VERSIONED_NAMESPACE_DECL