UUID.cpp

/*
** libutil++
** $Id: UUID.cpp 1703 2016-08-16 00:16:40Z 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 1703 2016-08-16 00:16:40Z sella $";

#include "UUID.h"
#include "String.h"

#include <string.h>

#define BUFFER_SIZE     64
#define HASH_ALGO_DJB2

using namespace sella::util;

UUID::UUID() throw () : scache(), bcache(), bcache_std(false), hcache(0) {
        uuid_generate(this->uuid);
}

UUID::UUID(uuid_t &uuid) throw () : scache(), bcache(), bcache_std(false), hcache(0) {
        uuid_copy(this->uuid, uuid);
}

UUID::UUID(const std::string &uuid) throw (UUIDException) : scache(), bcache(), bcache_std(false), hcache(0) {
        if (uuid_parse(uuid.c_str(), this->uuid) != 0) {
                THROW(UUIDException, "Improperly formatted UUID '%s' provided", uuid.c_str());
        }
}

UUID::UUID(const char *uuid) throw (UUIDException) : scache(), bcache(), bcache_std(false), hcache(0) {
        if (uuid_parse(uuid, this->uuid) != 0) {
                THROW(UUIDException, "Improperly formatted UUID '%s' provided", uuid);
        }
}

UUID::UUID(const UUID &other) :
        scache(other.scache),
        bcache(other.bcache),
        bcache_std(other.bcache_std),
        hcache(other.hcache)
{
        uuid_copy(this->uuid, other.uuid);
}

UUID::UUID(const UUID &&other) :
        scache(std::move(other.scache)),
        bcache(std::move(other.bcache)),
        bcache_std(other.bcache_std),
        hcache(other.hcache)
{
        uuid_copy(this->uuid, other.uuid);
}

UUID::~UUID() {
        clear();
}

UUID& UUID::operator=(const UUID &other) throw () {
        if (this != &other) {
                uuid_copy(this->uuid, other.uuid);
                this->scache = other.scache;
                this->bcache = other.bcache;
                this->bcache_std = other.bcache_std;
                this->hcache = other.hcache;
        }

        return *this;
}

UUID& UUID::operator=(const UUID &&other) throw () {
        if (this != &other) {
                uuid_copy(this->uuid, other.uuid);
                this->scache = std::move(other.scache);
                this->bcache = std::move(other.bcache);
                this->bcache_std = other.bcache_std;
                this->hcache = other.hcache;
        }

        return *this;
}

UUID& UUID::operator=(const std::string &uuid) throw (UUIDException) {
        this->scache.clear();
        this->bcache.clear();
        this->bcache_std = false;
        this->hcache = 0;

        if (uuid_parse(uuid.c_str(), this->uuid) != 0) {
                THROW(UUIDException, "Improperly formatted UUID '%s' provided", uuid.c_str());
        }

        return *this;
}

UUID& UUID::operator=(const char *uuid) throw (UUIDException) {
        this->scache.clear();
        this->bcache.clear();
        this->bcache_std = false;
        this->hcache = 0;

        if (uuid_parse(uuid, this->uuid) != 0) {
                THROW(UUIDException, "Improperly formatted UUID '%s' provided", uuid);
        }

        return *this;
}

bool UUID::operator==(const UUID &other) const throw () {
        return (uuid_compare(this->uuid, other.uuid) == 0);
}

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

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

        return (*this > other);
}

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

        return (*this < other);
}

bool UUID::operator>(const UUID &other) const throw () {
        return uuid_compare(this->uuid, other.uuid) > 0;
}

bool UUID::operator<(const UUID &other) const throw () {
        return uuid_compare(this->uuid, other.uuid) < 0;
}

void UUID::set(uuid_t &uuid) throw () {
        scache.clear();
        bcache.clear();
        bcache_std = false;
        hcache = 0;

        uuid_copy(this->uuid, uuid);
}

const uuid_t& UUID::get(void) const throw () {
        return this->uuid;
}

void UUID::generate(void) throw () {
        this->scache.clear();
        this->bcache.clear();
        this->bcache_std = false;
        this->hcache = 0;

        uuid_generate(this->uuid);
}

void UUID::clear(void) throw () {
        this->scache.clear();
        this->bcache.clear();
        this->bcache_std = false;
        this->hcache = 0;

        uuid_clear(this->uuid);
}

bool UUID::isNull(void) const throw () {
        return uuid_is_null(this->uuid);
}

void UUID::shrink_to_fit(void) throw () {
        std::string(scache.begin(), scache.end()).swap(scache);
        std::string(bcache.begin(), bcache.end()).swap(bcache);
}

const std::string& UUID::str(void) const throw () {
        if (scache.empty()) {
                char buffer[BUFFER_SIZE];

                uuid_unparse(this->uuid, buffer);

                scache = buffer;
        }

        return scache;
}

const std::string& UUID::base64(bool standard) const throw () {
        if (bcache.empty() || bcache_std != standard) {
                bcache = String::base64_encode((unsigned char const*) this->uuid, sizeof(this->uuid), standard);
                bcache_std = standard;
        }

        return bcache;
}

const char* UUID::c_str(void) const throw () {
        return str().c_str();
}

const char* UUID::c_base64(bool standard) const throw () {
        return base64(standard).c_str();
}

const UUID::shared UUID::shared_ptr(void) throw () {
        return std::make_shared<UUID>();
}

const UUID::shared UUID::shared_ptr(uuid_t &uuid) throw () {
        return std::make_shared<UUID>(uuid);
}

uint32_t UUID::getU32(void) const throw () {
        const uint32_t *a = (const uint32_t *) this->uuid;

        return (a[0] ^ a[1] ^ a[2] ^ a[3]);
}

uint32_t UUID::getHash(void) const throw () {
        if (hcache != 0) {
                return hcache;
        }

#if defined HASH_ALGO_INT1 /* Fast. Nibble swap. */
        uint32_t k = getU32();

        hcache = ((k & 0xF0F0F0F0) >> 4) | ((k & 0x0F0F0F0F) << 4);
#elif defined HASH_ALGO_INT2
        uint32_t k = getU32();

        hcache = (k<<16)^(k>>16)^k; /* Fast. Mix by XOR shifting.. */
#elif defined HASH_ALGO_INT3 /* Very fast, but not good. */
        hcache = getU32();
#elif defined HASH_ALGO_DJB2 /* This is a Dan Bernstein hash algo. Excellent hash for english characters. */
        uint32_t i;
        hcache = 5381;

        for (i = 0; i < sizeof(uuid_t); ++i) {
                hcache = ((hcache << 5) + hcache) + uuid[i]; /* h * 33 + i */
        }
#elif defined HASH_ALGO_SDBM /* This is the SDBM hash algo. Good general string hash. */
        uint32_t i;
        hcache = 0;

        for (i = 0; i < sizeof(uuid_t); ++i) {
                hcache = uuid[i] + (hcache << 6) + (hcache << 16) - hcache;
        }
#else
        #error No hash algo selected.
#endif

        return hcache;
}

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