Pointer.cpp

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

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

using namespace sella::variant;

Pointer::Pointer() throw () : Nullable(std::make_shared<void*>((void*) NULL)) { }

Pointer::Pointer(const std::string &value) throw (TypeCastException) : Nullable() {
        if (boost::regex_match(value, Pointer::Pattern())) {
                void* v = 0;

                if (scanf(value.c_str(), "%p", &v) < 1) {
                        THROW(TypeCastException, "unable to cast '%s' to a pointer value", value.c_str());
                }

                this->value = std::make_shared<void*>(v);
        } else {
                THROW(TypeCastException, "unable to cast '%s' to a pointer value", value.c_str());
        }
}

Pointer::Pointer(void* value) throw () : Nullable(std::make_shared<void*>(value)) { }

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

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

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

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

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

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

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

        return *this;
}

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

        return *this;
}

Pointer::~Pointer() throw () { }

const void*& Pointer::get() const throw (UnsupportedOperatorException) {
        if (isNull()) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

void*& Pointer::get() throw (UnsupportedOperatorException) {
        if (isNull()) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

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

        if (this->isNull()) {
                if ((c = mpack.append(offset)) == 0) {
                        THROW(TypeCastException, "Failed to append '%s' at offset %d (buffer length: %d)", str(JSON).c_str(), offset, mpack.length());
                }
        } else {
                if ((c = mpack.append(offset, (uint64_t) this->get())) == 0) {
                        THROW(TypeCastException, "Failed to append '%s' at offset %d (buffer length: %d)", str(JSON).c_str(), offset, mpack.length());
                }
        }

        offset += c;
}

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

                return;
        }

        size += 9;
}

std::string Pointer::str(int type) const throw () {
        if (this->isNull()) {
                return "null";
        }

        char buffer[4096];

        snprintf(buffer, sizeof(buffer), "%p", this->get());

        return buffer;
}

bool Pointer::isType(const char *value, size_t size) throw () {
        if (size < 2 || value[0] != '0' || value[1] != 'x' || (size - 2) % 8 != 0) { /* Starts with 0x and must be divisible by 8 (minus 0x) */
                return false;
        }

        for (size_t i = 2; i < size; i += 2) {
                if (!::isxdigit(value[i]) != 0 || !::isxdigit(value[i + 1]) != 0) {
                        return false;
                }
        }

        return true;
}

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