Binary.cpp

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

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

using namespace sella::variant;

Binary::Binary() throw () : Nullable(std::make_shared<std::vector<uint8_t>>()) { }

Binary::Binary(const std::string &value) throw (TypeCastException) : Nullable() {
        if (boost::regex_match(value, Binary::Pattern())) {
                short unsigned int v;
                char buf[3] = { 0, 0, 0 };
                this->value = std::make_shared<std::vector<uint8_t>>();

                for (auto it = value.begin() + 2, end = value.end(); it != end; ++it, ++it) {
                        buf[0] = *(it + 0);
                        buf[1] = *(it + 1);

                        sscanf(buf, "%hx", &v);

                        (*std::static_pointer_cast<std::vector<uint8_t>>(this->value)).push_back((uint8_t) v);
                }
        } else {
                THROW(TypeCastException, "unable to cast '%s' to a binary value", value.c_str());
        }
}

Binary::Binary(const std::vector<uint8_t> &value) throw () : Nullable(std::make_shared<std::vector<uint8_t>>(value)) { }

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

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

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

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

        return *this;
}

Binary::~Binary() throw () { }

const std::vector<uint8_t>& Binary::get() const throw (UnsupportedOperatorException) {
        if (isNull()) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

std::vector<uint8_t>& Binary::get() throw (UnsupportedOperatorException) {
        if (isNull()) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

size_t Binary::size() const throw () {
        if (isNull()) {
                return 0;
        }

        return get().size();
}

bool Binary::empty() const throw () {
        if (isNull()) {
                return true;
        }

        return get().empty();
}

void Binary::clear() throw() {
        if (isNull()) {
                this->value = std::make_shared<std::vector<uint8_t>>();
        } else {
                std::static_pointer_cast<std::vector<uint8_t>>(this->value)->clear();
        }
}

#if 1
void Binary::msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException) {
        uint32_t c;

        if (UNLIKELY(isNull())) {
                c = mpack.append(offset);

                offset += c;

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

                c = mpack.append_vector(offset, vector.size());

                offset += c;

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

                for (auto v = vector.begin(), end = vector.end(); v != end; ++v) {
                        c = mpack.append(offset, (uint64_t) *v);

                        offset += c;

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

#else
uint32_t Binary::msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException) {
        uint32_t c, o = offset;

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

                offset += c;
        } else {
                auto &vector = this->get();

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

                offset += c;

                for (auto v = vector.begin(), end = vector.end(); v != end; ++v) {
                        if (UNLIKELY((c = mpack.append(offset, (uint64_t) *v)) == 0)) {
                                THROW(TypeCastException, "Failed to append '%s' at offset %d (buffer length: %d)", str(JSON).c_str(), offset, mpack.length());
                        }

                        offset += c;
                }
        }

        return (offset - o);
}
#endif

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

                return;
        }

        size += 5 + std::static_pointer_cast<std::vector<uint8_t>>(this->value)->size();
}

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

        char buffer[32];
        std::string output("0x");
        const std::vector<uint8_t> &data = this->get();

        for (auto it = data.begin(), end = data.end(); it != end; ++it) {
                snprintf(buffer, sizeof(buffer), "%02x", *it);
                output.append(buffer);
        }

        return output;
}

bool Binary::isType(const char *value, size_t size) throw () {
        if (size < 2 || value[0] != '0' || value[1] != 'x' || size % 2 != 0) { /* Starts with 0x and must be even. */
                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
*/