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

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

#include "Vector.h"
#include "Variant.h"

#include <stack>
#include <algorithm>

using namespace sella::variant;

const boost::regex Vector::Pattern("^\\[(.*)\\]$");

Vector::Vector() throw () : Nullable() { }

Vector::Vector(const std::string &value) throw (TypeCastException) : Nullable() {
        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() {
        parse(token);
        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(const Vector &other) throw () : Nullable(other) {
        if (!other.isNull()) {
                this->value = std::make_shared<std::vector<Variant>>(*other.getVector());
        }
        this->it = other.it;
}

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

        return *this;
}

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

        cache.clear();

        if (this == &(other.get<Vector>())) {
                fprintf(stderr, "DEBUG: Attempt to append vector to itself\n");

                return *this;
        }

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

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

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

        return *this;
}

const Variant& Vector::operator[](int index) const throw (std::out_of_range) {
        const static Variant n;

        if (isNull()) {
                return n;
        }

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

        if ((size_t) index >= v.size()) {
                return n;
        }

        return v[index];
}

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

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

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

        return v[index];
}

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

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

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

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

const std::vector<Variant>* Vector::getVector() const throw (UnsupportedOperatorException) {
        if (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 (isNull()) {
                return -1;
        }

        return getVector()->size();
}

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

        return getVector()->empty();
}

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(int 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();

                cache.clear();
                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(cache.begin(), cache.end()).swap(cache);
}

const std::string& Vector::str() const throw () {
        if (cache.empty()) {
                if (this->isNull()) {
                        cache = "null";
                } else { 
                        const std::vector<Variant>      *data = this->getVector();

                        if (data->empty()) {
                                cache = std::string("[ ]");
                        } else {
                                std::string     buffer("[ ");

                                for (auto it = data->begin(); it != data->end(); ++it) {
                                        if (!it->isScalar() || it->isNumeric() || it->isBoolean() || it->isNull()) {
                                                buffer.append(it->str()).append(", ");
                                        } else {
                                                buffer.append("\"").append(it->str()).append("\", ");
                                        }
                                }
                                buffer.erase(buffer.size() - 2);
                                cache = buffer.append(" ]");
                        }
                }
        }

        return cache;
}

std::vector<Variant>& Vector::getRef() throw () {
        return *std::static_pointer_cast<std::vector<Variant>>(this->value);
}

const std::vector<Variant>& Vector::getRef() const throw () {
        return *std::static_pointer_cast<std::vector<Variant>>(this->value);
}

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(); it != token.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 (type.empty() || (type.top() != 'v')) {
                                        THROW(TypeCastException, "mismatched vector [ ... ] in text (%s)", "TODO");
                                }
                                type.pop();

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

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

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

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

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

        this->value = v;
}

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

---