Nullable.cpp

/*
** libutil++
** $Id: Nullable.cpp 1653 2016-02-28 19:54:59Z 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: Nullable.cpp 1653 2016-02-28 19:54:59Z sella $";

#include "Nullable.h"
#include "../util/CommonMacro.h"

using namespace sella::variant;

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

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

Nullable::Nullable(std::shared_ptr<void> &&value) throw () :
        value(std::move(value))
{ }

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

void Nullable::shrink_to_fit() throw () {
}

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 (UNLIKELY(!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(), end = data.end(); it != 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 && end == std::next(it)) {
                                        tokens.push_back(std::string(begin, end));
                                }
                }

                if (esc) {
                        esc = false;
                }
        }

        return tokens;
}

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