String.cpp

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

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

using namespace sella::variant;

String::String() throw () : Nullable(std::make_shared<std::string>()) { }

String::String(const std::string &value) throw () : Nullable(std::make_shared<std::string>(value)) { }

String::String(std::string &&value) throw () : Nullable(std::make_shared<std::string>(std::move(value))) { }

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

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

String::~String() throw () { }

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

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

bool String::operator>(const String &other) const throw () {
        return (*std::static_pointer_cast<std::string>(this->value) > *std::static_pointer_cast<std::string>(other.value));
}

bool String::operator<(const String &other) const throw () {
        return (*std::static_pointer_cast<std::string>(this->value) < *std::static_pointer_cast<std::string>(other.value));
}

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

        return *this;
}

String& String::operator=(String &&other) throw () {
        if (LIKELY(this != &other)) {
                this->value = std::move(other.value);
        }

        return *this;
}

String& String::operator=(const std::string &other) throw () {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<std::string>(other);
        } else {
                *std::static_pointer_cast<std::string>(this->value) = other;
        }

        return *this;
}

String& String::operator=(const char *other) throw () {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<std::string>(other);
        } else {
                *std::static_pointer_cast<std::string>(this->value) = other;
        }

        return *this;
}

String& String::operator+=(const std::string &value) throw () {
        (*std::static_pointer_cast<std::string>(this->value)) += value;

        return *this;
}

const std::string& String::get() const throw (UnsupportedOperatorException) {
        if (UNLIKELY(isNull())) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

std::string& String::get() throw (UnsupportedOperatorException) {
        if (UNLIKELY(isNull())) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

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

        return get().size();
}

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

        return get().empty();
}

void String::clear() throw() {
        if (UNLIKELY(isNull())) {
                this->value = std::make_shared<std::string>();
        } else {
                std::static_pointer_cast<std::string>(this->value)->clear();
        }
}

void String::shrink_to_fit() throw () {
        if (LIKELY(!isNull())) {
                auto &s = *std::static_pointer_cast<std::string>(this->value);

                std::string(s.begin(), s.end()).swap(s);
        }
}

void String::msgpack(sella::util::MessagePack &mpack, uint32_t &offset) const throw (TypeCastException) {
        uint32_t c;

        if (UNLIKELY(isNull())) {
                c = mpack.append(offset);
        } else {
                c = mpack.append(offset, *std::static_pointer_cast<std::string>(this->value));
        }

        offset += c;

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

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

                return;
        }

        size += 5 + std::static_pointer_cast<std::string>(this->value)->size();
}

std::string String::str(int type) const throw () {
        if (UNLIKELY(isNull())) {
                return "null";
        }

        return this->get();
}

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

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