UUID.cpp

/*
** libutil++
** $Id: UUID.cpp 1911 2017-09-02 17:37:35Z 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: UUID.cpp 1911 2017-09-02 17:37:35Z sella $";

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

using namespace sella::variant;

UUID::UUID() throw () : Nullable(std::make_shared<sella::util::UUID>()) { }

UUID::UUID(const std::string &value) throw (TypeCastException) : Nullable() {
        if (value.empty()) {
                this->value = std::make_shared<sella::util::UUID>();
        } else {
                if (LIKELY(boost::regex_match(value.c_str(), UUID::Pattern()))) {
                        try {
                                this->value = std::make_shared<sella::util::UUID>(value);
                        } catch (sella::util::UUIDException &e) {
                                THROW(TypeCastException, "unable to cast '%s' to a UUID value: %s", value.c_str(), e.what());
                        }
                } else {
                        THROW(TypeCastException, "unable to cast '%s' to a UUID value", value.c_str());
                }
        }
}

UUID::UUID(std::string &&value) throw (TypeCastException) : Nullable() {
        if (value.empty()) {
                this->value = std::make_shared<sella::util::UUID>();
        } else {
                if (LIKELY(boost::regex_match(value.c_str(), UUID::Pattern()))) {
                        try {
                                this->value = std::make_shared<sella::util::UUID>(std::move(value));
                        } catch (sella::util::UUIDException &e) {
                                THROW(TypeCastException, "unable to cast '%s' to a UUID value: %s", value.c_str(), e.what());
                        }
                } else {
                        THROW(TypeCastException, "unable to cast '%s' to a UUID value", value.c_str());
                }
        }
}

UUID::UUID(const char *value) throw (TypeCastException) : Nullable() {
        if (value == NULL) {
                this->value = std::make_shared<sella::util::UUID>();
        } else {
                if (LIKELY(boost::regex_match(value, UUID::Pattern()))) {
                        this->value = std::make_shared<sella::util::UUID>(value);
                } else {
                        THROW(TypeCastException, "unable to cast '%s' to a UUID value", value);
                }
        }
}

UUID::UUID(uuid_t &value) throw () : Nullable() {
        this->value = std::make_shared<sella::util::UUID>(value);
}

UUID::UUID(const sella::util::UUID &value) throw () : Nullable(std::make_shared<sella::util::UUID>(value)) { }

UUID::UUID(sella::util::UUID &&value) throw () : Nullable(std::make_shared<sella::util::UUID>(std::move(value))) { }

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

UUID::UUID(UUID &&other) throw () : Nullable() {
        if (LIKELY(!other.isNull())) {
                this->value = std::move(other.value);
        }
}

UUID::~UUID() throw () { }

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

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

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

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

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

        return *this;
}

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

        return *this;
}

const sella::util::UUID& UUID::get() const throw () {
        return *std::static_pointer_cast<sella::util::UUID>(this->value);
}

sella::util::UUID& UUID::get() throw () {
        return *std::static_pointer_cast<sella::util::UUID>(this->value);
}

void UUID::clear() throw() {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<sella::util::UUID>();
        } else {
                std::static_pointer_cast<sella::util::UUID>(this->value)->clear();
        }
}

void UUID::shrink_to_fit() throw () {
        auto &u = *std::static_pointer_cast<sella::util::UUID>(this->value);

        u.shrink_to_fit();
}

void UUID::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<sella::util::UUID>(this->value)->str()); 
        }

        offset += c;

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

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

                return;
        }

        size += 5 + 36;
}

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

        return this->get().str();
}

bool UUID::isType(const char *value, size_t size) throw () {
        return (size == 36 && boost::regex_match(std::string(value, size), Pattern()));
}

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