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

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

#include "Object.h"
#include "Variant.h"

#include <stack>

using namespace sella::variant;

const boost::regex Object::Pattern("^\\{(.*)\\}$");

Object::Object() throw () : Nullable() { }

Object::Object(const std::string &value) throw (TypeCastException) : Nullable() {
        std::vector<std::string>        token = this->tokenize(value, Object::Pattern);

        parse(token);
        this->it = std::static_pointer_cast<std::map<std::string, Variant>>(this->value)->begin();
}

Object::Object(const std::vector<std::string> &token) throw (TypeCastException) : Nullable() {
        parse(token);
        this->it = std::static_pointer_cast<std::map<std::string, Variant>>(this->value)->begin();
}

Object::Object(const std::map<std::string, Variant> &value) throw () : Nullable() {
        this->value = std::make_shared<std::map<std::string, Variant>>(value);
        this->it = std::static_pointer_cast<std::map<std::string, Variant>>(this->value)->begin();
}

Object::Object(const Object &other) throw () : Nullable(other) {
        if (!other.isNull()) {
                this->value = std::make_shared<std::map<std::string, Variant>>(*other.getObject());
        }
        this->it = other.it;
}

Object::~Object() throw () { }

std::map<std::string, Variant>::iterator Object::begin() throw () {
        return getRef().begin();
}

std::map<std::string, Variant>::iterator Object::end() throw () {
        return getRef().end();
}

std::map<std::string, Variant>::const_iterator Object::cbegin() const throw () {
        return getRef().cbegin();
}

std::map<std::string, Variant>::const_iterator Object::cend() const throw () {
        return getRef().cend();
}

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

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

Object& Object::operator=(const Object &other) throw () {
        if (this != &other) {
                Nullable::operator=(other);
                if (!other.isNull()) {
                        this->value = std::make_shared<std::map<std::string, Variant>>(*other.getObject());
                }
                it = other.it;
        }

        return *this;
}

Object& Object::operator+=(const Variant &other) throw () {
        if (isNull()) {
                this->value = std::make_shared<std::map<std::string, Variant>>();
        }

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

                return *this;
        }

        cache.clear();

        auto &o = *std::static_pointer_cast<std::map<std::string, Variant>>(this->value);
        auto &o2 = *(other.get<Object>().getObject());
        
        o.insert(o2.begin(), o2.end());

        return *this;
}

const Variant& Object::operator[](const std::string &key) const throw () {
        const static Variant n;

        if (isNull()) {
                return n;
        }

        auto &o = *std::static_pointer_cast<std::map<std::string, Variant>>(this->value);

        return o[key];
}

Variant& Object::operator[](const std::string &key) throw () {
        if (isNull()) {
                this->value = std::make_shared<std::map<std::string, Variant>>();
        }

        cache.clear();

        auto &o = *std::static_pointer_cast<std::map<std::string, Variant>>(this->value);

        return o[key];
}

const std::map<std::string, Variant>* Object::getObject() const throw (UnsupportedOperatorException) {
        if (isNull()) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

        return &(*std::static_pointer_cast<std::map<std::string, Variant>>(this->value));
}

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

        return getObject()->size();
}

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

        return getObject()->empty();
}

bool Object::erase(const Variant &value) throw () {
        auto &o = *std::static_pointer_cast<std::map<std::string, Variant>>(this->value);

        cache.clear();
        it = o.begin();

        return (o.erase(value.str()) > 0);
}

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

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

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

        return cache;
}

std::map<std::string, Variant>& Object::getRef() throw () {
        return *std::static_pointer_cast<std::map<std::string, Variant>>(this->value);
}

const std::map<std::string, Variant>& Object::getRef() const throw () {
        return *std::static_pointer_cast<std::map<std::string, Variant>>(this->value);
}

void Object::parse(const std::vector<std::string> &token) throw (TypeCastException) {
        auto                                    t = token.begin();
        std::string                     label;
        std::stack<int> type;
        std::shared_ptr<std::map<std::string, Variant>> m = std::make_shared<std::map<std::string, 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()) {
                                        m->insert(std::make_pair(label, Variant(std::vector<std::string>(t, it))));
                                        label.clear();
                                }
                                break;

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

                                if (type.empty()) {
                                        m->insert(std::make_pair(label, Variant(std::vector<std::string>(t, it))));
                                        label.clear();
                                }
                                break;
        
                        case ':':
                        case ',':
                                break;

                        case '"':
                                if (type.empty()) {
                                        if (label.empty()) {
                                                label = std::string(it->begin() + 1, it->end() - 1);
                                        } else {
                                                m->insert(std::make_pair(label, Variant(std::string(it->begin() + 1, it->end() - 1), Variant::TypeString)));
                                                label.clear();
                                        }
                                }
                                break;

                        default:
                                if (type.empty()) {
                                        m->insert(std::make_pair(label, Variant(*it, Variant::TypeAuto)));
                                        label.clear();
                                }
                }
        }

        this->value = m;
}

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

---