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

/*
** libutil++
** $Id: UUID.cpp 645 2013-05-04 21:21:45Z 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: UUID.cpp 645 2013-05-04 21:21:45Z sella $";

#include "UUID.h"

using namespace sella::variant;

const boost::regex UUID::Pattern("^[0-9a-f]{8}-?(?:[0-9a-f]{4}-?){3}[0-9a-f]{12}$", boost::regex::icase);

UUID::UUID() throw () : Nullable() { }

UUID::UUID(const std::string &value) throw (TypeCastException) : Nullable() {
        if (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(const char *value) throw (TypeCastException) : Nullable() {
        if (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(const UUID &other) throw () : Nullable(other) {
        if (!other.isNull()) {
                this->value = std::make_shared<sella::util::UUID>(*other.getUUID());
        }
}

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 (this != &other) {
                Nullable::operator=(other);
                if (!other.isNull()) {
                        this->value = std::make_shared<sella::util::UUID>(*other.getUUID());
                }
        }

        return *this;
}

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

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

        u.shrink_to_fit();
        std::string(cache.begin(), cache.end()).swap(cache);
}

const std::string& UUID::str() const throw () {
        if (cache.empty()) {
                if (this->isNull()) {
                        cache = "null";
                } else { 
                        cache = this->getUUID()->str();
                }
        }

        return cache;
}

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

---