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

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

#include "Interval.h"

using namespace sella::variant;

const boost::regex Interval::Pattern("^(-?[0-9]+)([dhmsu])$");

Interval::Interval() throw () : Nullable() { }

Interval::Interval(const std::string &value) throw (TypeCastException) : Nullable() {
        boost::smatch   matcher;

        if (boost::regex_match(value, matcher, Interval::Pattern)) {
                int64_t usec;

                try {
                        usec = std::stoll(matcher[1].str().c_str());
                } catch (std::invalid_argument &e) {
                        THROW(TypeCastException, "unable to cast '%s' to an interval value (invalid string)", value.c_str());
                } catch (std::out_of_range &e) {
                        THROW(TypeCastException, "unable to cast '%s' to an interval value (overflow/underflow)", value.c_str());
                }

                switch (matcher[2].str().c_str()[0]) {
                        case 'd':
                                usec *= 86400000000LL;
                                break;

                        case 'h':
                                usec *= 3600000000LL;
                                break;

                        case 'm':
                                usec *= 60000000LL;
                                break;

                        case 's':
                                usec *= 1000000LL;
                                break;

                        case 'u':
                                break;

                        default:
                                THROW(TypeCastException, "unable to cast '%s' to an interval value", value.c_str());
                }

                this->value = std::make_shared<uint64_t>(usec);
        } else {
                THROW(TypeCastException, "unable to cast '%s' to an interval value", value.c_str());
        }
}

Interval::Interval(int64_t value) throw () : Nullable(std::make_shared<int64_t>(value)) { }

Interval::Interval(const Interval &other) throw () : Nullable(other) {
        if (!other.isNull()) {
                this->value = std::make_shared<int64_t>(*other.getUsec());
        }
}

Interval::~Interval() throw () { }

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

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

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

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

Interval& Interval::operator=(const Interval &other) throw () {
        if (this != &other) {
                Nullable::operator=(other);
                if (!other.isNull()) {
                        this->value = std::make_shared<int64_t>(*other.getUsec());
                }
        }

        return *this;
}

Interval& Interval::operator+=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) += value;

        return *this;
}

Interval& Interval::operator-=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) -= value;

        return *this;
}

Interval& Interval::operator*=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) *= value;

        return *this;
}

Interval& Interval::operator/=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) /= value;

        return *this;
}

Interval& Interval::operator^=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) = pow((*std::static_pointer_cast<int64_t>(this->value)), value);

        return *this;
}

Interval& Interval::operator%=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) %= value;

        return *this;
}

Interval& Interval::operator&=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) &= value;

        return *this;
}

Interval& Interval::operator|=(int64_t value) throw () {
        cache.clear();
        (*std::static_pointer_cast<int64_t>(this->value)) |= value;

        return *this;
}

const int64_t* Interval::getUsec() const throw (UnsupportedOperatorException) {
        if (isNull()) {
                THROW(UnsupportedOperatorException, "unable to take reference of null value");
        }

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

const std::string& Interval::str() const throw () {
        if (cache.empty()) {
                if (this->isNull()) {
                        cache = "null";
                } else { 
                        char            buffer[4096];
                        int64_t usec = *(this->getUsec());

                        if ((usec % 3600000000LL) == 0) {
                                snprintf(buffer, sizeof(buffer), "%lldh", usec % 3600000000LL);
                        } else if ((usec % 60000000LL) == 0) {
                                snprintf(buffer, sizeof(buffer), "%lldm", usec % 60000000LL);
                        } else if ((usec % 1000000LL) == 0) {
                                snprintf(buffer, sizeof(buffer), "%llds", usec % 1000000LL);
                        } else {
                                snprintf(buffer, sizeof(buffer), "%" PRId64 "u", usec);
                        }

                        cache = buffer;
                }
        }

        return cache;
}

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

---