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

/*
** libutil++
** $Id: Binary.cpp 1197 2014-10-14 22:26:11Z 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: Binary.cpp 1197 2014-10-14 22:26:11Z sella $";

#include "Binary.h"

using namespace sella::variant;

const boost::regex Binary::Pattern("^0x([0-9A-Fa-f]{2})*$");

Binary::Binary() throw () : Nullable() { }

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; it != value.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(other) {
        if (!other.isNull()) {
                this->value = std::make_shared<std::vector<uint8_t>>(*other.getBinary());
        }
}

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

        return *this;
}

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

const std::vector<uint8_t>* Binary::getBinary() 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));
}

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

        return getBinary()->size();
}

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

        return getBinary()->empty();
}

const std::string& Binary::str() const throw () {
        if (cache.empty()) {
                if (this->isNull()) {
                        cache = "null";
                } else { 
                        char    buffer[32];

                        cache = "0x";
                        const std::vector<uint8_t> *data = this->getBinary();

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

        return cache;
}

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

---