Unsigned.cpp

/*
** libutil++
** $Id: Unsigned.cpp 1702 2016-08-13 23:26:06Z sella $
** Copyright (c) 2011-2016 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: Unsigned.cpp 1702 2016-08-13 23:26:06Z sella $";

#include "Unsigned.h"
#include "../util/CommonMacro.h"

using namespace sella::variant;

Unsigned::Unsigned() throw () : Nullable(std::make_shared<uint64_t>(0)) { }

Unsigned::Unsigned(const std::string &value) throw (TypeCastException) : Nullable() {
        try {
                this->value = std::make_shared<uint64_t>(std::stoull(value));
        } catch (std::invalid_argument &e) {
                THROW(TypeCastException, "unable to cast '%s' to an unsigned value (invalid string)", value.c_str());
        } catch (std::out_of_range &e) {
                THROW(TypeCastException, "unable to cast '%s' to an unsigned value (overflow/underflow)", value.c_str());
        }
}

Unsigned::Unsigned(uint64_t value) throw () : Nullable(std::make_shared<uint64_t>(value)) { }

Unsigned::Unsigned(const Unsigned &other) throw () : Nullable() {
        if (LIKELY(this != &other)) {
                if (LIKELY(!other.isNull())) {
                        if (UNLIKELY(isNull())) {
                                this->value = std::make_shared<uint64_t>(other.get());
                        } else {
                                *std::static_pointer_cast<uint64_t>(this->value) = *std::static_pointer_cast<uint64_t>(other.value);
                        }
                } else {
                        this->value.reset();
                }
        }
}

Unsigned::~Unsigned() throw () { }

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

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

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

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

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

Unsigned& Unsigned::operator=(const Unsigned &other) throw () {
        if (LIKELY(this != &other)) {
                if (LIKELY(!other.isNull())) {
                        if (UNLIKELY(isNull())) {
                                this->value = std::make_shared<uint64_t>(other.get());
                        } else {
                                *std::static_pointer_cast<uint64_t>(this->value) = *std::static_pointer_cast<uint64_t>(other.value);
                        }
                } else {
                        this->value.reset();
                }
        }

        return *this;
}

Unsigned& Unsigned::operator=(uint64_t other) throw () {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<uint64_t>(other);
        } else {
                *std::static_pointer_cast<uint64_t>(this->value) = other;
        }

        return *this;
}

Unsigned& Unsigned::operator++() throw () {
        ++(*std::static_pointer_cast<uint64_t>(this->value));

        return *this;
}

Unsigned& Unsigned::operator--() throw () {
        --(*std::static_pointer_cast<uint64_t>(this->value));

        return *this;
}

Unsigned& Unsigned::operator+=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) += value;

        return *this;
}

Unsigned& Unsigned::operator-=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) -= value;

        return *this;
}

Unsigned& Unsigned::operator*=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) *= value;

        return *this;
}

Unsigned& Unsigned::operator/=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) /= value;

        return *this;
}

Unsigned& Unsigned::operator^=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) = pow((*std::static_pointer_cast<uint64_t>(this->value)), value);

        return *this;
}

Unsigned& Unsigned::operator%=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) %= value;

        return *this;
}

Unsigned& Unsigned::operator&=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) &= value;

        return *this;
}

Unsigned& Unsigned::operator|=(uint64_t value) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) |= value;

        return *this;
}

Unsigned& Unsigned::operator<<=(int bits) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) <<= bits;

        return *this;
}

Unsigned& Unsigned::operator>>=(int bits) throw () {
        (*std::static_pointer_cast<uint64_t>(this->value)) >>= bits;

        return *this;
}

uint64_t Unsigned::get() const throw (UnsupportedOperatorException) {
        if (UNLIKELY(isNull())) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

void Unsigned::msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException) {
        uint32_t c;

        if (UNLIKELY(isNull())) {
                c = mpack.append(offset);
        } else {
                c = mpack.append(offset, *std::static_pointer_cast<uint64_t>(this->value));
        }

        offset += c;

        if (UNLIKELY(c == 0)) {
                THROW(TypeCastException, "Failed to append unsigned '%s' at offset %d (buffer length: %d)", str(JSON).c_str(), offset, mpack.length());
        }
}

void Unsigned::msgpackBufferSize(size_t &size) const throw () {
        if (UNLIKELY(isNull())) {
                size += 1;

                return;
        }

        size += 9;
}

std::string Unsigned::str(int type) const throw () {
        if (UNLIKELY(isNull())) {
                return "null";
        }

        return std::to_string(*std::static_pointer_cast<uint64_t>(this->value));
}

bool Unsigned::isType(const char *value, size_t size) throw () {
        for (size_t i = (value[0] == '+') ? 1 : 0; i < size; i++) {
                if (!::isdigit(value[i]) != 0) {
                        return false;
                }
        }

        return true;
}

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