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

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

#include "TimeStamp.h"

using namespace sella::variant;

const boost::regex TimeStamp::Pattern("^([0-9]{4})-([0-9]{2})-([0-9]{2})T(([01][0-9])|(2[0-3])):([0-5][0-9])(:([0-5][0-9])(\\.([0-9]{1,6}))?)?$");

TimeStamp::TimeStamp() throw () : Nullable() { }

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

        struct tm               stamp;
        int64_t                 usec;

        if (boost::regex_match(value, matcher, TimeStamp::Pattern)) {
                memset(&stamp, 0, sizeof(stamp));

                stamp.tm_year = strtol(matcher[1].str().c_str(), NULL, 10) - 1900;
                stamp.tm_mon  = strtol(matcher[2].str().c_str(), NULL, 10) - 1;
                stamp.tm_mday = strtol(matcher[3].str().c_str(), NULL, 10);
                stamp.tm_hour = strtol(matcher[4].str().c_str(), NULL, 10);
                stamp.tm_min  = strtol(matcher[7].str().c_str(), NULL, 10);
                stamp.tm_sec  = (matcher.length(9) > 0) ? strtol(matcher[9].str().c_str(), NULL, 10) : 0;

                usec = mktime(&stamp) * 1000000LL;

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

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

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

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

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

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

                        case 6:
                                usec += (strtol(matcher[11].str().c_str(), NULL, 10));
                                break;
                }
                this->value = std::make_shared<int64_t>(usec);
        } else {
                THROW(TypeCastException, "unable to cast '%s' to a timestamp value", value.c_str());
        }
}

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

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

TimeStamp::~TimeStamp() throw () { }

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

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

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

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

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

        return *this;
}

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

        return *this;
}

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

        return *this;
}

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

        return *this;
}

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

        return *this;
}

TimeStamp& TimeStamp::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;
}

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

        return *this;
}

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

        return *this;
}

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

        return *this;
}

const int64_t* TimeStamp::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& TimeStamp::str() const throw () {
        if (cache.empty()) {
                if (this->isNull()) {
                        cache = "null";
                } else { 
                        char                    buffer[4096];   

                        time_t          epoch = *(this->getUsec()) / 1000000LL;
                        struct tm       human;

                        gmtime_r(&epoch, &human);
                        snprintf(buffer, sizeof(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%06lld", human.tm_year + 1900, human.tm_mon + 1, human.tm_mday, human.tm_hour, human.tm_min, human.tm_sec, *(this->getUsec()) % 1000000LL);
                        cache = buffer;
                }
        }

        return cache;
}

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

---