Vector.cpp

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

#include "Vector.h"
#include "Variant.h"
#include "../util/String.h"
#include "../util/CommonMacro.h"

#include <stack>
#include <algorithm>

using namespace sella::variant;

Vector::Vector() throw () : Nullable(std::make_shared<std::vector<Variant>>()) { } 

Vector::Vector(const std::string &value) throw (TypeCastException) : Nullable() {
        if (value.empty()) {
                this->value = std::make_shared<std::vector<Variant>>();
        } else {
                std::vector<std::string> token = this->tokenize(value, Vector::Pattern());

                parse(token);
        }

        it = std::static_pointer_cast<std::vector<Variant>>(this->value)->begin();
}

Vector::Vector(const std::vector<std::string> &token) throw (TypeCastException) : Nullable() {
        if (token.empty()) {
                this->value = std::make_shared<std::vector<Variant>>();
        } else {
                parse(token);
        }

        it = std::static_pointer_cast<std::vector<Variant>>(this->value)->begin();
}

Vector::Vector(sella::util::MessagePack &mpack, uint32_t &offset) throw (TypeCastException) {
        unmsgpack(mpack, offset);
        it = std::static_pointer_cast<std::vector<Variant>>(this->value)->begin();
}

Vector::Vector(const std::vector<Variant> &value) throw () : Nullable() {
        this->value = std::make_shared<std::vector<Variant>>(value);
        it = std::static_pointer_cast<std::vector<Variant>>(this->value)->begin();
}

Vector::Vector(std::vector<Variant> &&value) throw () : Nullable() {
        this->value = std::make_shared<std::vector<Variant>>(std::move(value));
        it = std::static_pointer_cast<std::vector<Variant>>(this->value)->begin();
}

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

Vector::Vector(Vector &&other) throw () : Nullable() {
        if (LIKELY(!other.isNull())) {
                this->value = std::move(other.value);
                this->it = std::move(other.it);
        } else {
                this->value.reset();
        }
}

Vector::~Vector() throw () { }

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

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

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

        return *this;
}

Vector& Vector::operator=(Vector &&other) throw () {
        if (LIKELY(this != &other)) {
                if (LIKELY(!other.isNull())) {
                        this->value = std::move(other.value);
                        this->it = std::move(other.it);
                } else {
                        this->value.reset();
                }
        }

        return *this;
}

Vector& Vector::operator+=(const Variant &other) throw () {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<std::vector<Variant>>();
        }

        if (UNLIKELY(this == &(other.get<Vector>()))) {
                return *this;
        }

        auto &v = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        if (other.getType() == Variant::TypeVector) {
                auto &v2 = other.get<Vector>().get();

                v.insert(v.end(), v2.begin(), v2.end());
        } else {
                v.push_back(other);
        }

        return *this;
}

Vector& Vector::operator+=(Variant &&other) throw () {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<std::vector<Variant>>();
        }

        if (UNLIKELY(this == &(other.get<Vector>()))) {
                return *this;
        }

        auto &v = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        if (other.getType() == Variant::TypeVector) {
                auto &v2 = other.get<Vector>().get();

                std::move(v2.begin(), v2.end(), std::back_inserter(v));
        } else {
                v.push_back(std::move(other));
        }

        return *this;
}

const Variant& Vector::operator[](size_t index) const throw (RangeException) {
        if (UNLIKELY(isNull())) {
                THROW(RangeException, "index out of bounds");
        }

        std::vector<Variant> &v = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        if (UNLIKELY(index >= v.size())) {
                THROW(RangeException, "index out of bounds");
        }

        return v[index];
}

Variant& Vector::operator[](size_t index) throw () {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<std::vector<Variant>>();
        }

        std::vector<Variant> &v = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        if (index >= v.size()) { /* Expand vector, if needed. */
                v.resize(index + 1); /* Initializes empty slots with TypeNull Variant(). */
        }

        return v[index];
}

Vector::iterator Vector::begin() throw () {
        return get().begin();
}

Vector::iterator Vector::end() throw () {
        return get().end();
}

Vector::const_iterator Vector::cbegin() const throw () {
        return get().cbegin();
}

Vector::const_iterator Vector::cend() const throw () {
        return get().cend();
}

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

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

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

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

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

        return get().size();
}

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

        return get().empty();
}

void Vector::clear() throw() {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<std::vector<Variant>>();
        } else {
                this->get().clear();
        }
}

bool Vector::erase(const std::string &v, int type) throw () {
        const Variant value(v, type);

        return erase(value);
}

bool Vector::erase(const Variant &value) throw () {
        auto &v = *std::static_pointer_cast<std::vector<Variant>>(this->value);
        size_t s = v.size();

        v.erase(std::remove(v.begin(), v.end(), value), v.end());

        return (s != v.size());
}

bool Vector::erase(size_t index) throw () {
        auto &v = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        if ((size_t) index < v.size()) {
                v.erase(v.begin() + index) != v.end();

                it = v.begin();

                return true;
        }

        return false;
}

void Vector::shrink_to_fit() throw () {
        auto &v = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        std::vector<Variant>(v.begin(), v.end()).swap(v);
}

std::string Vector::str(int type) const throw () {
        std::string output;

        switch (type) {
                case JSON:
                        output = json();
                        break;

                case CJSON:
                        output = cjson();
                        break;

                case XML:
                        output = xml();
                        break;

                case CSV:
                        output = csv();
                        break;
        }

        return output;
}

#if 1
void Vector::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 vector '%s' at offset %d (buffer length: %d)", str(JSON).c_str(), offset, mpack.length());
                }
        } else {
                const std::vector<Variant>      &data = *std::static_pointer_cast<std::vector<Variant>>(this->value);
                size_t size = data.size();

                if (size > 0) {
                        PREFETCH(&data[0].value, PREFETCH_RO, PREFETCH_LOCALITY_MEDIUM);
                }

                c = mpack.append_vector(offset, size);

                offset += c;

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

                for (size_t i = 0; i < size; i++) {
                        if (i + 1 < size) {
                                PREFETCH(&data[i + 1].value, PREFETCH_RO, PREFETCH_LOCALITY_MEDIUM);
                        }

                        data[i].value->msgpack(mpack, offset);
                }
        }
}
#else
uint32_t Vector::msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException) {
        uint32_t c, o = offset;

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

                offset += c;

                return c;
        }

        const std::vector<Variant>      &data = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        if (UNLIKELY((c = mpack.append_vector(offset, data.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 it = data.begin(), end = data.end(); it != end; ++it) {
                if (UNLIKELY(isNull())) {
                        c = mpack.append(offset);

                        offset += c;
                } else {
                        int type = it->getType();

                        switch (type) {
                                case Boolean::Type:
                                        c = mpack.append(offset, it->get<Boolean>().get());
                                        break;

                                case Signed::Type:
                                        c = mpack.append(offset, it->get<Signed>().get());
                                        break;

                                case Unsigned::Type:
                                        c = mpack.append(offset, it->get<Unsigned>().get());
                                        break;

                                case Double::Type:
                                        c = mpack.append(offset, it->get<Double>().get());
                                        break;

                                case UUID::Type:
                                        c = mpack.append(offset, it->get<UUID>().get().str());
                                        break;

                                case String::Type:
                                        c = mpack.append(offset, it->get<String>().get());
                                        break;

                                case Binary::Type:
                                        c = it->get<Binary>().msgpack(mpack, offset);
                                        break;

                                case Pointer::Type:
                                        c = mpack.append(offset, (uint64_t) it->get<Pointer>().get());
                                        break;

                                case IPAddress::Type:
                                        c = mpack.append(offset, it->get<IPAddress>().get().str());
                                        break;

                                case IPPrefix::Type:
                                        c = mpack.append(offset, it->get<IPPrefix>().get().str());
                                        break;

                                case Interval::Type:
                                        c = mpack.append(offset, it->get<Interval>().str(JSON));
                                        break;

                                case Time::Type:
                                        c = mpack.append(offset, it->get<Time>().str(JSON));
                                        break;

                                case Date::Type:
                                        c = mpack.append(offset, it->get<Date>().str(JSON));
                                        break;

                                case TimeStamp::Type:
                                        c = mpack.append(offset, it->get<TimeStamp>().str(JSON));
                                        break;

                                case Vector::Type:
                                        c = it->get<Vector>().msgpack(mpack, offset);
                                        break;

                                case Object::Type:
                                        c = it->get<Object>().msgpack(mpack, offset);
                                        break;
                        }

                        if (type != Object::Type && type != Vector::Type && type != Binary::Type) {
                                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());
                }
        }

        return (offset - o);
}
#endif

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

                return;
        }

        const std::vector<Variant>      &data = *std::static_pointer_cast<std::vector<Variant>>(this->value);

        for (size_t i = 0; i < data.size(); i++) {
                data[i].value->msgpackBufferSize(size);
        }

        size += 5;
}

std::string Vector::json() const throw () {
        if (UNLIKELY(isNull())) {
                return "null";
        }

        std::string output;
        const std::vector<Variant>      &data = this->get();
        
        if (data.empty()) {
                output = "[ ]";
        } else {
                output = "[ ";

                for (auto it = data.begin(), end = data.end(); it != end; ++it) {
                        if ((!it->isScalar() && !it->isNetwork()) || it->isNumeric() || it->isBoolean() || it->isNull()) {
                                output.append(it->value->str(JSON)).append(", ");
                        } else {
                                output.append("\"").append(it->value->str(JSON)).append("\", ");
                        }
                }

                output.erase(output.size() - 2);
                output.append(" ]");
        }

        return output;
}

std::string Vector::cjson() const throw () {
        if (UNLIKELY(isNull())) {
                return "null";
        }

        std::string output;
        const std::vector<Variant>      &data = this->get();

        if (data.empty()) {
                output = "[]";
        } else {
                output = "[";

                for (auto it = data.begin(), end = data.end(); it != end; ++it) {
                        if ((!it->isScalar() && !it->isNetwork()) || it->isNumeric() || it->isBoolean() || it->isNull()) {
                                output.append(it->value->str(CJSON)).push_back(',');
                        } else {
                                output.append("\"").append(it->value->str(CJSON)).append("\",");
                        }
                }

                output.erase(output.size() - 1);
                output.push_back(']');
        }

        return output;
}

std::string Vector::xml() const throw () {
        if (UNLIKELY(isNull())) {
                return "<root null=\"true\" />";
        }

        std::string output;
        const std::vector<Variant>      &data = this->get();

        for (auto it = data.begin(), end = data.end(); it != end; ++it) {
                if (it->isNull()) {
                        output.append("<element null=\"true\" />");
                } else {
                        output.append("<element>").append(it->value->str(XML)).append("</element>");
                }
        }

        return output;
}

std::string Vector::csv() const throw () {
        if (UNLIKELY(isNull())) {
                return "\\N";
        }

        std::string output;
        const std::vector<Variant>      &data = this->get();

        if (!data.empty()) {
                for (auto it = data.begin(), end = data.end(); it != end; ++it) {
                        if (it->isNull()) {
                                output.append("\\N");
                        } else if (it->isScalar()) {
                                output.append("\"").append(sella::util::String::escape(it->value->str(CSV))).append("\"");
                        } else if (it->isObject()) {
                                if (!it->empty() && it == data.begin()) { /* Add CSV header */
                                        auto &o = it->get<Object>().get();

                                        for (auto i = o.begin(); i != o.end(); ++i) {
                                                output.append("\"").append(i->first).append("\",");
                                        }
                                        output.erase(output.size() - 1);
                                        output.append("\r\n");
                                }

                                output.append(it->value->str(CSV));
                        } else if (it->isVector()) {
                                auto &v = it->get<Vector>().get();

                                if (v.empty()) {
                                        output.append("\\N");
                                } else {
                                        for (auto i = v.begin(), end = v.end(); i != end; ++i) {
                                                if (i->isNull()) {
                                                        output.append("\\N,");
                                                } else if (i->isScalar()) {
                                                        output.append("\"").append(sella::util::String::escape(i->value->str(CSV))).append("\",");
                                                } else {
                                                        output.append("\"").append(sella::util::String::escape(i->value->str(JSON))).append("\",");
                                                }
                                        }

                                        output.erase(output.size() - 1);
                                }
                        }

                        output.append("\r\n");
                }

                output.erase(output.size() - 2);
        }

        return output;
}

void Vector::parse(const std::vector<std::string> &token) throw (TypeCastException) {
        auto t = token.begin();
        std::stack<int> type;
        std::shared_ptr<std::vector<Variant>> v = std::make_shared<std::vector<Variant>>();

        for (auto it = token.begin(), end = token.end(); it != end; ++it) {
                switch (it->at(0)) {
                        case '[':
                                if (type.empty()) {
                                        t = it;
                                }
                                type.push('v');
                                break;

                        case '{':
                                if (type.empty()) {
                                        t = it;
                                }
                                type.push('o');
                                break;

                        case ']':
                                if (UNLIKELY(type.empty() || (type.top() != 'v'))) {
                                        THROW(TypeCastException, "mismatched vector [ ... ] in text (%s)", t->c_str());
                                }
                                type.pop();

                                if (type.empty()) {
                                        v->push_back(Variant(std::vector<std::string>(t, it)));
                                }
                                break;

                        case '}':
                                if (UNLIKELY(type.empty() || (type.top() != 'o'))) {
                                        THROW(TypeCastException, "mismatched object { ... } in text (%s)", t->c_str());
                                }
                                type.pop();

                                if (type.empty()) {
                                        v->push_back(Variant(std::vector<std::string>(t, it)));
                                }
                                break;
        
                        case ':':
                        case ',':
                                break;

                        case '"':
                                if (type.empty()) {
                                        std::string value(it->begin() + 1, it->end() - 1);
                                        v->push_back(Variant(value, Variant::TypeQuoted));
                                }
                                break;

                        default:
                                if (type.empty()) {
                                        v->push_back(Variant(*it, Variant::TypeNonQuoted));
                                }
                }
        }

        this->value = v;
}

void Vector::unmsgpack(sella::util::MessagePack &mpack, uint32_t &offset) throw (TypeCastException) {
        std::shared_ptr<std::vector<Variant>> v = std::make_shared<std::vector<Variant>>();

        union {
                bool b;
                int64_t s;
                uint64_t u;
                double d;
        } u;

        try {
                v->reserve(mpack.count(offset));

                mpack.scan(offset, [this, &mpack, &v, &u](uint32_t i, uint32_t value) {
                        switch (mpack.typeof(value)) {
                                case sella::util::MessagePack::TYPE_NULL:
                                        v->push_back(std::move(Variant()));
                                        break;

                                case sella::util::MessagePack::TYPE_BOOLEAN:
                                        if (LIKELY(mpack.decode(u.b, value))) {
                                                v->push_back(std::move(Variant(u.b)));
                                        } else {
                                                THROW(TypeCastException, "Failed to decode boolean");
                                        }
                                        break;

                                case sella::util::MessagePack::TYPE_SIGNED:
                                        if (LIKELY(mpack.decode(u.s, value))) {
                                                v->push_back(std::move(Variant(u.s)));
                                        } else {
                                                THROW(TypeCastException, "Failed to decode signed");
                                        }
                                        break;

                                case sella::util::MessagePack::TYPE_UNSIGNED:
                                        if (LIKELY(mpack.decode(u.u, value))) {
                                                v->push_back(std::move(Variant(u.u)));
                                        } else {
                                                THROW(TypeCastException, "Failed to decode unsigned");
                                        }
                                        break;

                                case sella::util::MessagePack::TYPE_FLOAT:
                                        if (LIKELY(mpack.decode(u.d, value))) {
                                                v->push_back(std::move(Variant(u.d)));
                                        } else {
                                                THROW(TypeCastException, "Failed to decode double");
                                        }
                                        break;

                                case sella::util::MessagePack::TYPE_STRING: {
                                        std::string str;

                                        if (LIKELY(mpack.decode(str, value))) {
                                                v->push_back(std::move(Variant(std::move(str))));
                                        } else {
                                                THROW(TypeCastException, "Failed to decode string");
                                        }
                                        break;
                                }

                                case sella::util::MessagePack::TYPE_VECTOR:
                                        v->push_back(std::move(Variant(std::move(std::make_shared<Vector>(mpack, value)))));
                                        break;

                                case sella::util::MessagePack::TYPE_OBJECT:
                                        v->push_back(std::move(Variant(std::move(std::make_shared<Object>(mpack, value)))));
                                        break;

                                default:
                                        THROW(TypeCastException, "Unsupported type %u in input", mpack.typeof(value));
                        }

                        return true;
                });
        } catch (sella::util::MemoryException &e) {
                RETHROW(TypeCastException, e);
        } catch (TypeCastException &e) {
                RETHROW(TypeCastException, e);
        } catch (std::exception &e) {
                THROW(TypeCastException, "%s", e.what());
        }
        
        this->value = v;
}

bool Vector::isType(const char *value, size_t size) throw () {
        return (size > 1 && value[0] == '[' && value[size - 1] == ']');
}

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