/builddir/build/BUILD/libutil++-1.4.0/src/sella/variant/Boolean.cpp

/*
** libutil++
** $Id: Boolean.cpp 1197 2014-10-14 22:26:11Z sella $
** Copyright (c) 2011-2014 Digital Genesis, LLC. All Rights Reserved.
** Released under the LGPL Version 2.1 License.
** http://www.digitalgenesis.com
*/

static const char rcsid[] __attribute__((used)) = "$Id: Boolean.cpp 1197 2014-10-14 22:26:11Z sella $";

#include "Boolean.h"

#include <ctype.h>

using namespace sella::variant;

const boost::regex Boolean::Pattern("^(?:true|false)$", boost::regex::icase);

Boolean::Boolean() throw () : Nullable() { }

Boolean::Boolean(const std::string &value) throw (TypeCastException) : Nullable() {
        if (boost::regex_match(value, Boolean::Pattern)) {
                this->value = std::make_shared<bool>(tolower(value[0]) == 't');
        } else {
                THROW(TypeCastException, "unable to cast '%s' to a boolean value", value.c_str());
        }
}

Boolean::Boolean(bool value) throw () : Nullable(std::make_shared<bool>(value)) { }

Boolean::Boolean(const Boolean &other) throw () : Nullable(other) {
        if (!other.isNull()) {
                this->value = std::make_shared<bool>(*other.getBoolean());
        }
}

Boolean::~Boolean() throw () { }

bool Boolean::operator==(const Boolean &other) const throw () {
        return (*std::static_pointer_cast<bool>(this->value) == *std::static_pointer_cast<bool>(other.value));
}

bool Boolean::operator!=(const Boolean &other) const throw () {
        return !(*this == other);
}

bool Boolean::operator>(const Boolean &other) const throw () {
        return (*std::static_pointer_cast<bool>(this->value) > *std::static_pointer_cast<bool>(other.value));
}

bool Boolean::operator<(const Boolean &other) const throw () {
        return (*std::static_pointer_cast<bool>(this->value) < *std::static_pointer_cast<bool>(other.value));
}

bool Boolean::operator!() throw () {
        return !(*std::static_pointer_cast<bool>(this->value));
}

Boolean& Boolean::operator=(const Boolean &other) throw () {
        if (this != &other) {
                Nullable::operator=(other);
                if (!other.isNull()) {
                        this->value = std::make_shared<bool>(*other.getBoolean());
                }
        }

        return *this;
}

Boolean& Boolean::operator+=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) += value;

        return *this;
}

Boolean& Boolean::operator-=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) -= value;

        return *this;
}

Boolean& Boolean::operator*=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) *= value;

        return *this;
}

Boolean& Boolean::operator/=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) /= value;

        return *this;
}

Boolean& Boolean::operator^=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) = pow((*std::static_pointer_cast<bool>(this->value)), value);

        return *this;
}

Boolean& Boolean::operator%=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) %= value;

        return *this;
}

Boolean& Boolean::operator&=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) &= value;

        return *this;
}

Boolean& Boolean::operator|=(bool value) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) |= value;

        return *this;
}

Boolean& Boolean::operator<<=(int bits) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) <<= bits;

        return *this;
}

Boolean& Boolean::operator>>=(int bits) throw () {
        cache.clear();
        (*std::static_pointer_cast<bool>(this->value)) >>= bits;

        return *this;
}

const bool* Boolean::getBoolean() const throw (UnsupportedOperatorException) {
        if (isNull()) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

        return &(*std::static_pointer_cast<bool>(this->value));
}

const std::string& Boolean::str() const throw () {
        if (cache.empty()) {
                if (this->isNull()) {
                        cache = "null";
                } else { 
                        if (*getBoolean()) {
                                cache = "true";
                        } else {
                                cache = "false";
                        }
                }
        }

        return cache;
}

/*
** vim: noet ts=3 sw=3
*/

---