00001
00002
00003
00004
00005
00006
00007
00008
00009 static const char rcsid[] __attribute__((used)) = "$Id: Operators.cpp 1197 2014-10-14 22:26:11Z sella $";
00010
00011 #include "Variant.h"
00012
00013 using namespace sella::variant;
00014
00015 bool Variant::operator!() throw (UnsupportedOperatorException) {
00016 switch (getType()) {
00017 case TypeBoolean:
00018 return !get<Boolean>();
00019
00020 case TypeSigned:
00021 return !get<Signed>();
00022
00023 case TypeUnsigned:
00024 return !get<Unsigned>();
00025
00026 case TypeDouble:
00027 return !get<Double>();
00028
00029 default:
00030 THROW(UnsupportedOperatorException, "Unable to perform operator! on %s value", getTypeName());
00031 }
00032 }
00033
00034 Variant& Variant::operator++() throw (UnsupportedOperatorException) {
00035 switch (getType()) {
00036 case TypeBoolean:
00037 get<Boolean>() = !get<Boolean>();
00038
00039 break;
00040
00041 case TypeSigned:
00042 ++get<Signed>();
00043
00044 break;
00045
00046 case TypeUnsigned:
00047 ++get<Unsigned>();
00048
00049 break;
00050
00051 case TypeDouble:
00052 ++get<Double>();
00053
00054 break;
00055
00056 default:
00057 THROW(UnsupportedOperatorException, "Unable to perform operator++ on %s value", getTypeName());
00058 }
00059
00060 this->cache.clear();
00061
00062 return *this;
00063 }
00064
00065 Variant Variant::operator++(int) throw (UnsupportedOperatorException) {
00066 Variant tmp = *this;
00067
00068 switch (getType()) {
00069 case TypeBoolean:
00070 get<Boolean>() = !get<Boolean>();
00071
00072 break;
00073
00074 case TypeSigned:
00075 ++get<Signed>();
00076
00077 break;
00078
00079 case TypeUnsigned:
00080 ++get<Unsigned>();
00081
00082 break;
00083
00084 case TypeDouble:
00085 ++get<Double>();
00086
00087 break;
00088
00089 default:
00090 THROW(UnsupportedOperatorException, "Unable to perform operator++ on %s value", getTypeName());
00091 }
00092
00093 this->cache.clear();
00094
00095 return tmp;
00096 }
00097
00098 const Variant& Variant::operator[](const char* key) const throw () {
00099 const static Variant n;
00100 const Object &o = get<Object>();
00101
00102 if (getType() != TypeObject || o.getObject()->find(key) == o.getObject()->end()) {
00103 return n;
00104 }
00105
00106 return o[key];
00107 }
00108
00109 const Variant& Variant::operator[](const std::string &key) const throw () {
00110 const static Variant n;
00111 const Object &o = get<Object>();
00112
00113 if (getType() != TypeObject || o.getObject()->find(key) == o.getObject()->end()) {
00114 return n;
00115 }
00116
00117 return o[key];
00118 }
00119
00120 Variant& Variant::operator[](const char* key) throw () {
00121 this->cache.clear();
00122
00123 if (getType() != TypeObject) {
00124 this->value = std::make_shared<Object>();
00125 this->type = TypeObject;
00126 }
00127
00128 return get<Object>()[key];
00129 }
00130
00131 Variant& Variant::operator[](const std::string &key) throw () {
00132 this->cache.clear();
00133
00134 if (getType() != TypeObject) {
00135 this->value = std::make_shared<Object>();
00136 this->type = TypeObject;
00137 }
00138
00139 return get<Object>()[key];
00140 }
00141
00142 const Variant& Variant::operator[](int index) const throw (UnsupportedOperatorException) {
00143 const static Variant n;
00144 const Vector &v = get<Vector>();
00145
00146 if (index < 0) {
00147 THROW(UnsupportedOperatorException, "index is less than 0");
00148 } else if ((size_t) index > v.getVector()->max_size()) {
00149 THROW(UnsupportedOperatorException, "index is larger than max size");
00150 }
00151
00152 if (getType() != TypeVector || (size_t) index > v.size()) {
00153 return n;
00154 }
00155
00156 return v[index];
00157 }
00158
00159 Variant& Variant::operator[](int index) throw (UnsupportedOperatorException) {
00160 if (index < 0) {
00161 THROW(UnsupportedOperatorException, "index is less than 0");
00162
00163
00164 }
00165
00166 this->cache.clear();
00167
00168 if (getType() != TypeVector) {
00169 this->value = std::make_shared<Vector>();
00170 this->type = TypeVector;
00171 }
00172
00173 return get<Vector>()[index];
00174 }
00175
00176 Variant& Variant::operator=(const Variant &other) throw () {
00177 if (this != &other) {
00178 this->type = other.type;
00179 this->cache = other.cache;
00180
00181 switch (this->type) {
00182 case TypeNull:
00183 this->value = std::make_shared<Null>();
00184
00185 break;
00186
00187 case TypeBoolean:
00188 this->value = std::make_shared<Boolean>(other.get<Boolean>());
00189
00190 break;
00191
00192 case TypeSigned:
00193 this->value = std::make_shared<Signed>(other.get<Signed>());
00194
00195 break;
00196
00197 case TypeUnsigned:
00198 this->value = std::make_shared<Unsigned>(other.get<Unsigned>());
00199
00200 break;
00201
00202 case TypeDouble:
00203 this->value = std::make_shared<Double>(other.get<Double>());
00204
00205 break;
00206
00207 case TypeString:
00208 this->value = std::make_shared<String>(other.get<String>());
00209
00210 break;
00211
00212 case TypeUUID:
00213 this->value = std::make_shared<UUID>(other.get<UUID>());
00214
00215 break;
00216
00217 case TypeBinary:
00218 this->value = std::make_shared<Binary>(other.get<Binary>());
00219
00220 break;
00221
00222 case TypePointer:
00223 this->value = std::make_shared<Pointer>(other.get<Pointer>());
00224
00225 break;
00226
00227 case TypeIPAddress:
00228 this->value = std::make_shared<IPAddress>(other.get<IPAddress>());
00229
00230 break;
00231
00232 case TypeIPPrefix:
00233 this->value = std::make_shared<IPPrefix>(other.get<IPPrefix>());
00234
00235 break;
00236
00237 case TypeInterval:
00238 this->value = std::make_shared<Interval>(other.get<Interval>());
00239
00240 break;
00241
00242 case TypeTime:
00243 this->value = std::make_shared<Time>(other.get<Time>());
00244
00245 break;
00246
00247 case TypeDate:
00248 this->value = std::make_shared<Date>(other.get<Date>());
00249
00250 break;
00251
00252 case TypeTimeStamp:
00253 this->value = std::make_shared<TimeStamp>(other.get<TimeStamp>());
00254
00255 break;
00256 case TypeVector:
00257 this->value = std::make_shared<Vector>(other.get<Vector>());
00258
00259 break;
00260
00261 case TypeObject:
00262 this->value = std::make_shared<Object>(other.get<Object>());
00263
00264 break;
00265
00266 default:
00267 fprintf(stderr, "DEBUG: Missing Type in switch statements.\n");
00268 abort();
00269 }
00270 }
00271
00272 return *this;
00273 }
00274
00275 Variant& Variant::operator=(const Variant &&other) throw () {
00276 if (this != &other) {
00277 this->value = std::move(other.value);
00278 this->type = other.type;
00279 this->cache = std::move(other.cache);
00280 }
00281
00282 return *this;
00283 }
00284
00285 Variant& Variant::operator=(const std::string &value) throw () {
00286 this->value = std::make_shared<String>(value);
00287 this->type = TypeString;
00288 this->cache.clear();
00289
00290
00291 return *this;
00292 }
00293
00294 Variant& Variant::operator=(const char *value) throw () {
00295 this->value = std::make_shared<String>(value);
00296 this->type = TypeString;
00297 this->cache.clear();
00298
00299 return *this;
00300 }
00301
00302 Variant& Variant::operator=(const sella::util::UUID &value) throw () {
00303 this->value = std::make_shared<UUID>(value);
00304 this->type = TypeUUID;
00305 this->cache.clear();
00306
00307 return *this;
00308 }
00309
00310 Variant& Variant::operator=(uuid_t &value) throw () {
00311 this->value = std::make_shared<UUID>(value);
00312 this->type = TypeUUID;
00313 this->cache.clear();
00314
00315 return *this;
00316 }
00317
00318 Variant& Variant::operator=(void *ptr) throw () {
00319 this->value = std::make_shared<Pointer>(ptr);
00320 this->type = TypePointer;
00321 this->cache.clear();
00322
00323 return *this;
00324 }
00325
00326 Variant& Variant::operator=(bool value) throw () {
00327 this->value = std::make_shared<Boolean>(value);
00328 this->type = TypeBoolean;
00329 this->cache.clear();
00330
00331 return *this;
00332 }
00333
00334 Variant& Variant::operator=(uint8_t value) throw () {
00335 return operator=((uint64_t) value);
00336 }
00337
00338 Variant& Variant::operator=(uint16_t value) throw () {
00339 return operator=((uint64_t) value);
00340 }
00341
00342 Variant& Variant::operator=(uint32_t value) throw () {
00343 return operator=((uint64_t) value);
00344 }
00345
00346 Variant& Variant::operator=(uint64_t value) throw () {
00347 this->value = std::make_shared<Unsigned>(value);
00348 this->type = TypeUnsigned;
00349 this->cache.clear();
00350
00351 return *this;
00352 }
00353
00354 Variant& Variant::operator=(int8_t value) throw () {
00355 return operator=((int64_t) value);
00356 }
00357
00358 Variant& Variant::operator=(int16_t value) throw () {
00359 return operator=((int64_t) value);
00360 }
00361
00362 Variant& Variant::operator=(int32_t value) throw () {
00363 return operator=((int64_t) value);
00364 }
00365
00366 Variant& Variant::operator=(int64_t value) throw () {
00367 this->value = std::make_shared<Signed>(value);
00368 this->type = TypeSigned;
00369 this->cache.clear();
00370
00371 return *this;
00372 }
00373
00374 Variant& Variant::operator=(float value) throw () {
00375 return operator=((double) value);
00376 }
00377
00378 Variant& Variant::operator=(double value) throw () {
00379 this->value = std::make_shared<Double>(value);
00380 this->type = TypeDouble;
00381 this->cache.clear();
00382
00383 return *this;
00384 }
00385
00386
00387 #ifdef __LP64__
00388 Variant& Variant::operator=(unsigned long long value) throw () {
00389 return operator=((uint64_t) value);
00390 }
00391
00392 Variant& Variant::operator=(long long value) throw () {
00393 return operator=((int64_t) value);
00394 }
00395 #else
00396 Variant& Variant::operator=(unsigned long value) throw () {
00397 return operator=((uint64_t) value);
00398 }
00399
00400 Variant& Variant::operator=(long value) throw () {
00401 return operator=((int64_t) value);
00402 }
00403 #endif
00404
00405 Variant::operator const char*() const throw (TypeCastException) {
00406 return this->cast<const char*>();
00407 }
00408
00409 Variant::operator const std::string&() const throw (TypeCastException) {
00410 return this->cast<const std::string&>();
00411 }
00412
00413 Variant::operator sella::util::UUID() const throw (TypeCastException) {
00414 return this->cast<const sella::util::UUID>();
00415 }
00416
00417 Variant::operator bool() const throw (TypeCastException) {
00418 return this->cast<bool>();
00419 }
00420
00421 Variant::operator uint8_t() const throw (TypeCastException) {
00422 return this->cast<uint8_t>();
00423 }
00424
00425 Variant::operator uint16_t() const throw (TypeCastException) {
00426 return this->cast<uint16_t>();
00427 }
00428
00429 Variant::operator uint32_t() const throw (TypeCastException) {
00430 return this->cast<uint32_t>();
00431 }
00432
00433 Variant::operator uint64_t() const throw (TypeCastException) {
00434 return this->cast<uint64_t>();
00435 }
00436
00437 Variant::operator int8_t() const throw (TypeCastException) {
00438 return this->cast<int8_t>();
00439 }
00440
00441 Variant::operator int16_t() const throw (TypeCastException) {
00442 return this->cast<int16_t>();
00443 }
00444
00445 Variant::operator int32_t() const throw (TypeCastException) {
00446 return this->cast<int32_t>();
00447 }
00448
00449 Variant::operator int64_t() const throw (TypeCastException) {
00450 return this->cast<int64_t>();
00451 }
00452
00453 Variant::operator float() const throw (TypeCastException) {
00454 return this->cast<float>();
00455 }
00456
00457 Variant::operator double() const throw (TypeCastException) {
00458 return this->cast<double>();
00459 }
00460
00461 #ifdef __LP64__
00462 Variant::operator unsigned long long() const throw (TypeCastException) {
00463 return this->cast<uint64_t>();
00464 }
00465
00466 Variant::operator long long() const throw (TypeCastException) {
00467 return this->cast<int64_t>();
00468 }
00469 #else
00470 Variant::operator unsigned long() const throw (TypeCastException) {
00471 return this->cast<uint64_t>();
00472 }
00473
00474 Variant::operator long() const throw (TypeCastException) {
00475 return this->cast<int64_t>();
00476 }
00477 #endif
00478
00479 namespace sella {
00480 namespace variant {
00481 bool operator==(const Variant &a, const Variant &b) throw () {
00482 if (a.getType() != b.getType()) {
00483 return false;
00484 } else if (a.isNull()) {
00485 return true;
00486 }
00487
00488 switch (a.getType()) {
00489 case Variant::TypeBoolean:
00490 return (a.get<Boolean>() == b.get<Boolean>());
00491
00492 case Variant::TypeSigned:
00493 return (a.get<Signed>() == b.get<Signed>());
00494
00495 case Variant::TypeUnsigned:
00496 return (a.get<Unsigned>() == b.get<Unsigned>());
00497
00498 case Variant::TypeDouble:
00499 return (a.get<Double>() == b.get<Double>());
00500
00501 case Variant::TypeString:
00502 return (a.get<String>() == b.get<String>());
00503
00504 case Variant::TypeUUID:
00505 return (a.get<UUID>() == b.get<UUID>());
00506
00507 case Variant::TypeBinary:
00508 return (a.get<Binary>() == b.get<Binary>());
00509
00510 case Variant::TypePointer:
00511 return (a.get<Pointer>() == b.get<Pointer>());
00512
00513 case Variant::TypeIPAddress:
00514 return (a.get<IPAddress>() == b.get<IPAddress>());
00515
00516 case Variant::TypeIPPrefix:
00517 return (a.get<IPPrefix>() == b.get<IPPrefix>());
00518
00519 case Variant::TypeInterval:
00520 return (a.get<Interval>() == b.get<Interval>());
00521
00522 case Variant::TypeTime:
00523 return (a.get<Time>() == b.get<Time>());
00524
00525 case Variant::TypeDate:
00526 return (a.get<Date>() == b.get<Date>());
00527
00528 case Variant::TypeTimeStamp:
00529 return (a.get<TimeStamp>() == b.get<TimeStamp>());
00530
00531 case Variant::TypeVector:
00532 return (a.get<Vector>() == b.get<Vector>());
00533
00534 case Variant::TypeObject:
00535 return (a.get<Object>() == b.get<Object>());
00536 }
00537
00538 fprintf(stderr, "DEBUG: Missing Type in switch statements.\n");
00539 abort();
00540 }
00541
00542 bool operator!=(const Variant &a, const Variant &b) throw () {
00543 return !(a == b);
00544 }
00545
00546 bool operator>(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00547 if (a.getType() != b.getType()) {
00548 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value for source %s value", a.getTypeName(), b.getTypeName());
00549 } else if (a.isNull()) {
00550 return false;
00551 }
00552
00553 switch (a.getType()) {
00554 case Variant::TypeBoolean:
00555 return (a.get<Boolean>() > b.get<Boolean>());
00556
00557 case Variant::TypeSigned:
00558 return (a.get<Signed>() > b.get<Signed>());
00559
00560 case Variant::TypeUnsigned:
00561 return (a.get<Unsigned>() > b.get<Unsigned>());
00562
00563 case Variant::TypeDouble:
00564 return (a.get<Double>() > b.get<Double>());
00565
00566 case Variant::TypeString:
00567 return (a.get<String>() > b.get<String>());
00568
00569 case Variant::TypeUUID:
00570 return (a.get<UUID>() > b.get<UUID>());
00571
00572 case Variant::TypeBinary:
00573 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value", a.getTypeName());
00574
00575 case Variant::TypePointer:
00576 return (a.get<Pointer>() > b.get<Pointer>());
00577
00578 case Variant::TypeIPAddress:
00579 return (a.get<IPAddress>() > b.get<IPAddress>());
00580
00581 case Variant::TypeIPPrefix:
00582 return (a.get<IPPrefix>() > b.get<IPPrefix>());
00583
00584 case Variant::TypeInterval:
00585 return (a.get<Interval>() > b.get<Interval>());
00586
00587 case Variant::TypeTime:
00588 return (a.get<Time>() > b.get<Time>());
00589
00590 case Variant::TypeDate:
00591 return (a.get<Date>() > b.get<Date>());
00592
00593 case Variant::TypeTimeStamp:
00594 return (a.get<TimeStamp>() > b.get<TimeStamp>());
00595
00596 case Variant::TypeVector:
00597 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value", a.getTypeName());
00598
00599 case Variant::TypeObject:
00600 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value", a.getTypeName());
00601 }
00602
00603 fprintf(stderr, "DEBUG: Missing Type in switch statements.\n");
00604 abort();
00605 }
00606
00607 bool operator<(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00608 if (a.getType() != b.getType()) {
00609 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value for source %s value", a.getTypeName(), b.getTypeName());
00610 } else if (a.isNull()) {
00611 return false;
00612 }
00613
00614 switch (a.getType()) {
00615 case Variant::TypeBoolean:
00616 return (a.get<Boolean>() < b.get<Boolean>());
00617
00618 case Variant::TypeSigned:
00619 return (a.get<Signed>() < b.get<Signed>());
00620
00621 case Variant::TypeUnsigned:
00622 return (a.get<Unsigned>() < b.get<Unsigned>());
00623
00624 case Variant::TypeDouble:
00625 return (a.get<Double>() < b.get<Double>());
00626
00627 case Variant::TypeString:
00628 return (a.get<String>() < b.get<String>());
00629
00630 case Variant::TypeUUID:
00631 return (a.get<UUID>() < b.get<UUID>());
00632
00633 case Variant::TypeBinary:
00634 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value", a.getTypeName());
00635
00636 case Variant::TypePointer:
00637 return (a.get<Pointer>() < b.get<Pointer>());
00638
00639 case Variant::TypeIPAddress:
00640 return (a.get<IPAddress>() < b.get<IPAddress>());
00641
00642 case Variant::TypeIPPrefix:
00643 return (a.get<IPPrefix>() < b.get<IPPrefix>());
00644
00645 case Variant::TypeInterval:
00646 return (a.get<Interval>() < b.get<Interval>());
00647
00648 case Variant::TypeTime:
00649 return (a.get<Time>() < b.get<Time>());
00650
00651 case Variant::TypeDate:
00652 return (a.get<Date>() < b.get<Date>());
00653
00654 case Variant::TypeTimeStamp:
00655 return (a.get<TimeStamp>() < b.get<TimeStamp>());
00656
00657 case Variant::TypeVector:
00658 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value", a.getTypeName());
00659
00660 case Variant::TypeObject:
00661 THROW(UnsupportedOperatorException, "Unable to perform operator> on %s value", a.getTypeName());
00662 }
00663
00664 fprintf(stderr, "DEBUG: Missing Type in switch statements.\n");
00665 abort();
00666 }
00667
00668 bool operator>=(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00669 if (a == b) {
00670 return true;
00671 }
00672
00673 return (a > b);
00674 }
00675
00676 bool operator<=(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00677 if (a == b) {
00678 return true;
00679 }
00680
00681 return (a < b);
00682 }
00683
00684 Variant& operator+=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00685 try {
00686 switch (a.getType()) {
00687 case Variant::TypeNull:
00688 a = b;
00689 break;
00690
00691 case Variant::TypeBoolean:
00692 a.get<Boolean>() += (bool) b;
00693
00694 break;
00695
00696 case Variant::TypeSigned:
00697 a.get<Signed>() += (int64_t) b;
00698
00699 break;
00700
00701 case Variant::TypeUnsigned:
00702 a.get<Unsigned>() += (uint64_t) b;
00703
00704 break;
00705
00706 case Variant::TypeDouble:
00707 a.get<Double>() += (double) b;
00708
00709 break;
00710
00711 case Variant::TypeString:
00712 a.get<String>() += (const std::string&) b;
00713
00714 break;
00715
00716 case Variant::TypeInterval:
00717 a.get<Interval>() += (int64_t) b;
00718
00719 break;
00720
00721 case Variant::TypeTime:
00722 a.get<Time>() += (int64_t) b;
00723
00724 break;
00725
00726 case Variant::TypeDate:
00727 a.get<Date>() += (int64_t) b;
00728
00729 break;
00730
00731 case Variant::TypeTimeStamp:
00732 a.get<TimeStamp>() += (int64_t) b;
00733
00734 break;
00735
00736 case Variant::TypeVector:
00737 a.get<Vector>() += b;
00738
00739 break;
00740
00741 case Variant::TypeObject:
00742 if (b.getType() == Variant::TypeObject) {
00743 a.get<Object>() += b;
00744
00745 break;
00746 }
00747
00748 default:
00749 THROW(UnsupportedOperatorException, "Unable to perform operator+= on %s value for source %s value", a.getTypeName(), b.getTypeName());
00750 }
00751 } catch (TypeCastException &e) {
00752 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
00753 }
00754
00755 a.cache.clear();
00756
00757 return a;
00758 }
00759
00760 Variant& operator-=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00761 try {
00762 switch (a.getType()) {
00763 case Variant::TypeBoolean:
00764 a.get<Boolean>() -= (bool) b;
00765
00766 break;
00767
00768 case Variant::TypeSigned:
00769 a.get<Signed>() -= (int64_t) b;
00770
00771 break;
00772
00773 case Variant::TypeUnsigned:
00774 a.get<Unsigned>() -= (uint64_t) b;
00775
00776 break;
00777
00778 case Variant::TypeDouble:
00779 a.get<Double>() -= (double) b;
00780
00781 break;
00782
00783 case Variant::TypeInterval:
00784 a.get<Interval>() -= (int64_t) b;
00785
00786 break;
00787
00788 case Variant::TypeTime:
00789 a.get<Time>() -= (int64_t) b;
00790
00791 break;
00792
00793 case Variant::TypeDate:
00794 a.get<Date>() -= (int64_t) b;
00795
00796 break;
00797
00798 case Variant::TypeTimeStamp:
00799 a.get<TimeStamp>() -= (int64_t) b;
00800
00801 break;
00802
00803 default:
00804 THROW(UnsupportedOperatorException, "Unable to perform operator-= on %s value for source %s value", a.getTypeName(), b.getTypeName());
00805 }
00806 } catch (TypeCastException &e) {
00807 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
00808 }
00809
00810 a.cache.clear();
00811
00812 return a;
00813 }
00814
00815 Variant& operator*=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00816 try {
00817 switch (a.getType()) {
00818 case Variant::TypeBoolean:
00819 a.get<Boolean>() *= (bool) b;
00820
00821 break;
00822
00823 case Variant::TypeSigned:
00824 a.get<Signed>() *= (int64_t) b;
00825
00826 break;
00827
00828 case Variant::TypeUnsigned:
00829 a.get<Unsigned>() *= (uint64_t) b;
00830
00831 break;
00832
00833 case Variant::TypeDouble:
00834 a.get<Double>() *= (double) b;
00835
00836 break;
00837
00838 case Variant::TypeInterval:
00839 a.get<Interval>() *= (int64_t) b;
00840
00841 break;
00842
00843 case Variant::TypeTime:
00844 a.get<Time>() *= (int64_t) b;
00845
00846 break;
00847
00848 case Variant::TypeDate:
00849 a.get<Date>() *= (int64_t) b;
00850
00851 break;
00852
00853 case Variant::TypeTimeStamp:
00854 a.get<TimeStamp>() *= (int64_t) b;
00855
00856 break;
00857
00858 default:
00859 THROW(UnsupportedOperatorException, "Unable to perform operator*= on %s value for source %s value", a.getTypeName(), b.getTypeName());
00860 }
00861 } catch (TypeCastException &e) {
00862 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
00863 }
00864
00865 a.cache.clear();
00866
00867 return a;
00868 }
00869
00870 Variant& operator/=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00871 try {
00872 switch (a.getType()) {
00873 case Variant::TypeBoolean:
00874 a.get<Boolean>() /= (bool) b;
00875
00876 break;
00877
00878 case Variant::TypeSigned:
00879 a.get<Signed>() /= (int64_t) b;
00880
00881 break;
00882
00883 case Variant::TypeUnsigned:
00884 a.get<Unsigned>() /= (uint64_t) b;
00885
00886 break;
00887
00888 case Variant::TypeDouble:
00889 a.get<Double>() /= (double) b;
00890
00891 break;
00892
00893 case Variant::TypeInterval:
00894 a.get<Interval>() /= (int64_t) b;
00895
00896 break;
00897
00898 case Variant::TypeTime:
00899 a.get<Time>() /= (int64_t) b;
00900
00901 break;
00902
00903 case Variant::TypeDate:
00904 a.get<Date>() /= (int64_t) b;
00905
00906 break;
00907
00908 case Variant::TypeTimeStamp:
00909 a.get<TimeStamp>() /= (int64_t) b;
00910
00911 break;
00912
00913 default:
00914 THROW(UnsupportedOperatorException, "Unable to perform operator/= on %s value for source %s value", a.getTypeName(), b.getTypeName());
00915 }
00916 } catch (TypeCastException &e) {
00917 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
00918 }
00919
00920 a.cache.clear();
00921
00922 return a;
00923 }
00924
00925 Variant& operator^=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00926 try {
00927 switch (a.getType()) {
00928 case Variant::TypeBoolean:
00929 a.get<Boolean>() ^= (bool) b;
00930
00931 break;
00932
00933 case Variant::TypeSigned:
00934 a.get<Signed>() ^= (int64_t) b;
00935
00936 break;
00937
00938 case Variant::TypeUnsigned:
00939 a.get<Unsigned>() ^= (uint64_t) b;
00940
00941 break;
00942
00943 case Variant::TypeDouble:
00944 a.get<Double>() ^= (double) b;
00945
00946 break;
00947
00948 case Variant::TypeInterval:
00949 a.get<Interval>() ^= (int64_t) b;
00950
00951 break;
00952
00953 case Variant::TypeTime:
00954 a.get<Time>() ^= (int64_t) b;
00955
00956 break;
00957
00958 case Variant::TypeDate:
00959 a.get<Date>() ^= (int64_t) b;
00960
00961 break;
00962
00963 case Variant::TypeTimeStamp:
00964 a.get<TimeStamp>() ^= (int64_t) b;
00965
00966 break;
00967
00968 default:
00969 THROW(UnsupportedOperatorException, "Unable to perform operator^= on %s value for source %s value", a.getTypeName(), b.getTypeName());
00970 }
00971 } catch (TypeCastException &e) {
00972 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
00973 }
00974
00975 a.cache.clear();
00976
00977 return a;
00978 }
00979
00980 Variant& operator%=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
00981 try {
00982 switch (a.getType()) {
00983 case Variant::TypeBoolean:
00984 a.get<Boolean>() %= (bool) b;
00985
00986 break;
00987
00988 case Variant::TypeSigned:
00989 a.get<Signed>() %= (int64_t) b;
00990
00991 break;
00992
00993 case Variant::TypeUnsigned:
00994 a.get<Unsigned>() %= (uint64_t) b;
00995
00996 break;
00997
00998 case Variant::TypeInterval:
00999 a.get<Interval>() %= (int64_t) b;
01000
01001 break;
01002
01003 case Variant::TypeTime:
01004 a.get<Time>() %= (int64_t) b;
01005
01006 break;
01007
01008 case Variant::TypeDate:
01009 a.get<Date>() %= (int64_t) b;
01010
01011 break;
01012
01013 case Variant::TypeTimeStamp:
01014 a.get<TimeStamp>() %= (int64_t) b;
01015
01016 break;
01017
01018 default:
01019 THROW(UnsupportedOperatorException, "Unable to perform operator%= on %s value for source %s value", a.getTypeName(), b.getTypeName());
01020 }
01021 } catch (TypeCastException &e) {
01022 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
01023 }
01024
01025 a.cache.clear();
01026
01027 return a;
01028 }
01029
01030 Variant& operator&=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01031 try {
01032 switch (a.getType()) {
01033 case Variant::TypeBoolean:
01034 a.get<Boolean>() &= (bool) b;
01035
01036 break;
01037
01038 case Variant::TypeSigned:
01039 a.get<Signed>() &= (int64_t) b;
01040
01041 break;
01042
01043 case Variant::TypeUnsigned:
01044 a.get<Unsigned>() &= (uint64_t) b;
01045
01046 break;
01047
01048 case Variant::TypeInterval:
01049 a.get<Interval>() &= (int64_t) b;
01050
01051 break;
01052
01053 case Variant::TypeTime:
01054 a.get<Time>() &= (int64_t) b;
01055
01056 break;
01057
01058 case Variant::TypeDate:
01059 a.get<Date>() &= (int64_t) b;
01060
01061 break;
01062
01063 case Variant::TypeTimeStamp:
01064 a.get<TimeStamp>() &= (int64_t) b;
01065
01066 break;
01067
01068 default:
01069 THROW(UnsupportedOperatorException, "Unable to perform operator&= on %s value for source %s value", a.getTypeName(), b.getTypeName());
01070 }
01071 } catch (TypeCastException &e) {
01072 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
01073 }
01074
01075 a.cache.clear();
01076
01077 return a;
01078 }
01079
01080 Variant& operator|=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01081 try {
01082 switch (a.getType()) {
01083 case Variant::TypeBoolean:
01084 a.get<Boolean>() |= (bool) b;
01085
01086 break;
01087
01088 case Variant::TypeSigned:
01089 a.get<Signed>() |= (int64_t) b;
01090
01091 break;
01092
01093 case Variant::TypeUnsigned:
01094 a.get<Unsigned>() |= (uint64_t) b;
01095
01096 break;
01097
01098 case Variant::TypeInterval:
01099 a.get<Interval>() |= (int64_t) b;
01100
01101 break;
01102
01103 case Variant::TypeTime:
01104 a.get<Time>() |= (int64_t) b;
01105
01106 break;
01107
01108 case Variant::TypeDate:
01109 a.get<Date>() |= (int64_t) b;
01110
01111 break;
01112
01113 case Variant::TypeTimeStamp:
01114 a.get<TimeStamp>() |= (int64_t) b;
01115
01116 break;
01117
01118 default:
01119 THROW(UnsupportedOperatorException, "Unable to perform operator|= on %s value for source %s value", a.getTypeName(), b.getTypeName());
01120 }
01121 } catch (TypeCastException &e) {
01122 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
01123 }
01124
01125 a.cache.clear();
01126
01127 return a;
01128 }
01129
01130 Variant& operator<<=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01131 try {
01132 switch (a.getType()) {
01133 case Variant::TypeBoolean:
01134 a.get<Boolean>() <<= (int) b;
01135
01136 break;
01137
01138 case Variant::TypeSigned:
01139 a.get<Signed>() <<= (int) b;
01140
01141 break;
01142
01143 case Variant::TypeUnsigned:
01144 a.get<Unsigned>() <<= (int) b;
01145
01146 break;
01147
01148 default:
01149 THROW(UnsupportedOperatorException, "Unable to perform operator<<= on %s value for source %s value", a.getTypeName(), b.getTypeName());
01150 }
01151 } catch (TypeCastException &e) {
01152 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
01153 }
01154
01155 a.cache.clear();
01156
01157 return a;
01158 }
01159
01160 Variant& operator>>=(Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01161 try {
01162 switch (a.getType()) {
01163 case Variant::TypeBoolean:
01164 a.get<Boolean>() >>= (int) b;
01165
01166 break;
01167
01168 case Variant::TypeSigned:
01169 a.get<Signed>() >>= (int) b;
01170
01171 break;
01172
01173 case Variant::TypeUnsigned:
01174 a.get<Unsigned>() >>= (int) b;
01175
01176 break;
01177
01178 default:
01179 THROW(UnsupportedOperatorException, "Unable to perform operator>>= on %s value for source %s value", a.getTypeName(), b.getTypeName());
01180 }
01181 } catch (TypeCastException &e) {
01182 THROW(UnsupportedOperatorException, "Unsupported operation: %s", e.what());
01183 }
01184
01185 a.cache.clear();
01186
01187 return a;
01188 }
01189
01190 Variant operator+(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01191 Variant v = a;
01192
01193 v += b;
01194
01195 return v;
01196 }
01197
01198 Variant operator-(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01199 Variant v = a;
01200
01201 v -= b;
01202
01203 return v;
01204 }
01205
01206 Variant operator*(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01207 Variant v = a;
01208
01209 v *= b;
01210
01211 return v;
01212 }
01213
01214 Variant operator/(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01215 Variant v = a;
01216
01217 v /= b;
01218
01219 return v;
01220 }
01221
01222 Variant operator^(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01223 Variant v = a;
01224
01225 v ^= b;
01226
01227 return v;
01228 }
01229
01230 Variant operator%(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01231 Variant v = a;
01232
01233 v %= b;
01234
01235 return v;
01236 }
01237
01238 Variant operator&(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01239 Variant v = a;
01240
01241 v &= b;
01242
01243 return v;
01244 }
01245
01246 Variant operator|(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01247 Variant v = a;
01248
01249 v |= b;
01250
01251 return v;
01252 }
01253
01254 Variant operator<<(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01255 Variant v = a;
01256
01257 v <<= b;
01258
01259 return v;
01260 }
01261
01262 Variant operator>>(const Variant &a, const Variant &b) throw (UnsupportedOperatorException) {
01263 Variant v = a;
01264
01265 v >>= b;
01266
01267 return v;
01268 }
01269
01270 std::istream& operator>>(std::istream &is, Variant &value) throw (TypeCastException) {
01271 std::string buf;
01272
01273 is >> buf;
01274 value.parse(buf, Variant::TypeAuto);
01275
01276 return is;
01277 }
01278
01279 std::ostream& operator<<(std::ostream &os, const Variant &value) throw (TypeCastException) {
01280 os << value.c_str();
01281
01282 return os;
01283 }
01284
01285 }
01286 }
01287
01288
01289
01290
