Time.cpp

/*
** libutil++
** $Id: Time.cpp 1911 2017-09-02 17:37:35Z 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: Time.cpp 1911 2017-09-02 17:37:35Z sella $";

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

using namespace sella::variant;

Time::Time() throw () : Nullable(std::make_shared<int64_t>(0)) { }

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

        if (boost::regex_match(value, matcher, Time::Pattern())) {
                int64_t usec = (strtol(matcher[1].str().c_str(), NULL, 10) * 3600000000LL);
        
                usec += (strtol(matcher[4].str().c_str(), NULL, 10) * 60000000LL);
                usec += ((matcher.length(6) > 0) ? (strtol(matcher[6].str().c_str(), NULL, 10) * 1000000LL) : 0);

                switch (matcher.length(8)) {
                        case 0:
                                break;

                        case 1:
                                usec += (strtol(matcher[8].str().c_str(), NULL, 10) * 100000LL);
                                break;

                        case 2:
                                usec += (strtol(matcher[8].str().c_str(), NULL, 10) * 10000LL);
                                break;

                        case 3:
                                usec += (strtol(matcher[8].str().c_str(), NULL, 10) * 1000LL);
                                break;

                        case 4:
                                usec += (strtol(matcher[8].str().c_str(), NULL, 10) * 100LL);
                                break;

                        case 5:
                                usec += (strtol(matcher[8].str().c_str(), NULL, 10) * 10LL);
                                break;

                        case 6:
                                usec += (strtol(matcher[8].str().c_str(), NULL, 10));
                                break;
                }

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

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

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

Time::~Time() throw () { }

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

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

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

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

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

        return *this;
}

Time& Time::operator+=(int64_t value) throw () {
        (*std::static_pointer_cast<int64_t>(this->value)) += value;

        return *this;
}

Time& Time::operator-=(int64_t value) throw () {
        (*std::static_pointer_cast<int64_t>(this->value)) -= value;

        return *this;
}

Time& Time::operator*=(int64_t value) throw () {
        (*std::static_pointer_cast<int64_t>(this->value)) *= value;

        return *this;
}

Time& Time::operator/=(int64_t value) throw () {
        (*std::static_pointer_cast<int64_t>(this->value)) /= value;

        return *this;
}

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

        return *this;
}

Time& Time::operator%=(int64_t value) throw () {
        (*std::static_pointer_cast<int64_t>(this->value)) %= value;

        return *this;
}

Time& Time::operator&=(int64_t value) throw () {
        (*std::static_pointer_cast<int64_t>(this->value)) &= value;

        return *this;
}

Time& Time::operator|=(int64_t value) throw () {
        (*std::static_pointer_cast<int64_t>(this->value)) |= value;

        return *this;
}

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

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

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

        if (UNLIKELY(this->isNull())) {
                c = mpack.append(offset);
        } else {
                c = mpack.append(offset, this->str(JSON));
        }

        offset += c;

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

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

                return;
        }

        size += 9;
}

std::string Time::str(int type) const throw () {
        if (UNLIKELY(this->isNull())) {
                return "null";
        }

        char                    buffer[4096];   
        time_t          epoch = this->getUsec() / 1000000LL;
        struct tm       human;
        
        gmtime_r(&epoch, &human);
        snprintf(buffer, sizeof(buffer), "%02d:%02d:%02d.%06lld", human.tm_hour, human.tm_min, human.tm_sec, this->getUsec() % 1000000LL);

        return buffer;
}

bool Time::isType(const char *value, size_t size) throw () {
        return (size > 7 && value[2] == ':' && value [5] == ':' && boost::regex_match(std::string(value, size), Pattern()));
}

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