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

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

#include "Nullable.h"

using namespace sella::variant;

Nullable::Nullable() throw () :
        value(),
        cache()
{ }

Nullable::Nullable(std::shared_ptr<void> value) throw () :
        value(value),
        cache()
{ }

Nullable::Nullable(const Nullable &other) throw () :
        value(), /* Skip shallow copy. */
        cache(other.cache)
{ }

Nullable::~Nullable() throw () { }

Nullable& Nullable::operator=(const Nullable &other) throw () {
        if (this != &other) {
                this->value.reset(); /* Skip shallow copy. */
                this->cache = other.cache;
        }

        return *this;
}

const std::shared_ptr<void> Nullable::get() const throw () {
        return this->value;
}

std::shared_ptr<void> Nullable::get() throw () {
        return this->value;
}

void Nullable::shrink_to_fit() throw () {
        std::string(cache.begin(), cache.end()).swap(cache);
}

const char* Nullable::c_str() const throw () {
        return str().c_str();
}

bool Nullable::isNull() const throw () {
        return (this->value == NULL);
}

std::vector<std::string> Nullable::tokenize(const std::string &value, const boost::regex &pattern) const throw (TypeCastException) {
        std::vector<std::string>        tokens;
        boost::smatch                                   match;

        if (!boost::regex_match(value, match, pattern)) {
                if (value.at(0) == '[') {
                        THROW(TypeCastException, "unable to tokenize vector '%s'", value.c_str());
                } else if (value.at(0) == '{') {
                        THROW(TypeCastException, "unable to tokenize object '%s'", value.c_str());
                } else {
                        THROW(TypeCastException, "unable to tokenize '%s'", value.c_str());
                }
        }

        const std::string       &data = match[1].str();

        auto                                    begin = data.begin();

        bool                                    str = false;
        bool                                    esc = false;

        for (auto it = data.begin(); it != data.end(); ++it) {
                switch (*it) {
                        case '\\':
                                if (!esc) {
                                        esc = true;

                                        continue;
                                }
                                break;

                        case '"':
                                if (str && !esc) {
                                        tokens.push_back(std::string(begin, it + 1));
                                        begin = it + 1;

                                        str = false;
                                } else if (!esc) {
                                        begin = it;

                                        str = true;
                                }
                                break;

                        case ' ': case '\t': case '\r': case '\n': case '\f':
                                if (!str) {
                                        if (begin != it) {
                                                tokens.push_back(std::string(begin, it));
                                        }
                                        begin = it + 1;
                                }
                                break;

                        case '[': case ']': case '{': case '}': case ',': case ':':
                                if (!str) {
                                        if (begin != it) {
                                                tokens.push_back(std::string(begin, it));
                                        }
                                        tokens.push_back(std::string(1, *it));
                                        begin = it + 1;
                                }
                                break;

                        default:
                                if (!str && data.end() == std::next(it)) {
                                        tokens.push_back(std::string(begin, data.end()));
                                }
                }


                if (esc) {
                        esc = false;
                }
        }

        return tokens;
}

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

---