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

/*
** libutil++
** $Id: TimeStamp.cpp 1230 2014-11-16 02:32:01Z 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 1230 2014-11-16 02:32:01Z sella $";

#include "TimeStamp.h"

#include <sys/time.h>
#include <stdint.h>
#include <stdlib.h>

using namespace sella::util;

TimeStamp::TimeStamp(const struct timeval &tv) throw () :
        stamp((tv.tv_sec * 1000000) + tv.tv_usec)
{ }

TimeStamp::TimeStamp(int64_t usec) throw () :
        stamp(usec)
{ }

TimeStamp::TimeStamp() throw () :
        stamp(TimeStamp::now())
{ }

TimeStamp::TimeStamp(const TimeStamp &other) throw () :
        stamp(other.stamp)
{ }

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

TimeStamp & TimeStamp::operator =  (const TimeStamp &other) throw () {
        if (this != &other) {
                this->stamp = other.stamp;
        }
        return *this;
}

TimeStamp & TimeStamp::operator =  (const struct timeval &tv) throw () {
        this->stamp = (tv.tv_sec * 1000000) + tv.tv_usec;

        return *this;
}

TimeStamp & TimeStamp::operator =  (int64_t micro) throw () {
        this->stamp = micro;

        return *this;
}

TimeStamp & TimeStamp::operator += (const TimeStamp &other) throw () {
        if (this != &other) {
                this->stamp += other.stamp;
        }
        return *this;
}

TimeStamp & TimeStamp::operator += (const struct timeval &tv) throw () {
        this->stamp += (tv.tv_sec * 1000000) + tv.tv_usec;

        return *this;
}

TimeStamp & TimeStamp::operator += (int64_t micro) throw () {
        this->stamp += micro;

        return *this;
}

TimeStamp & TimeStamp::operator -= (const TimeStamp &other) throw () {
        if (this != &other) {
                this->stamp -= other.stamp;
        }
        return *this;
}

TimeStamp & TimeStamp::operator -= (const struct timeval &tv) throw () {
        this->stamp -= (tv.tv_sec * 1000000) + tv.tv_usec;

        return *this;
}

TimeStamp & TimeStamp::operator -= (int64_t micro) throw () {
        this->stamp -= micro;

        return *this;
}

TimeStamp & TimeStamp::operator *= (const TimeStamp &other) throw () {
        if (this != &other) {
                this->stamp *= other.stamp;
        }
        return *this;
}

TimeStamp & TimeStamp::operator *= (const struct timeval &tv) throw () {
        this->stamp *= (tv.tv_sec * 1000000) + tv.tv_usec;

        return *this;
}

TimeStamp & TimeStamp::operator *= (int64_t micro) throw () {
        this->stamp *= micro;

        return *this;
}

TimeStamp & TimeStamp::operator /= (const TimeStamp &other) throw () {
        if (this != &other) {
                this->stamp /= other.stamp;
        }
        return *this;
}

TimeStamp & TimeStamp::operator /= (const struct timeval &tv) throw () {
        this->stamp /= (tv.tv_sec * 1000000) + tv.tv_usec;

        return *this;
}

TimeStamp & TimeStamp::operator /= (int64_t micro) throw () {
        this->stamp /= micro;

        return *this;
}

TimeStamp TimeStamp::operator + (const TimeStamp &other) throw () {
        return TimeStamp(this->stamp + other.stamp);
}

TimeStamp TimeStamp::operator + (const struct timeval &tv) throw () {
        return TimeStamp(this->stamp + ((tv.tv_sec * 1000000) + tv.tv_usec));
}

TimeStamp TimeStamp::operator + (int64_t micro) throw () {
        return TimeStamp(this->stamp + micro);
}

TimeStamp TimeStamp::operator - (const TimeStamp &other) throw () {
        return TimeStamp(this->stamp - other.stamp);
}

TimeStamp TimeStamp::operator - (const struct timeval &tv) throw () {
        return TimeStamp(this->stamp - ((tv.tv_sec * 1000000) + tv.tv_usec));
}

TimeStamp TimeStamp::operator - (int64_t micro) throw () {
        return TimeStamp(this->stamp - micro);
}

TimeStamp TimeStamp::operator * (const TimeStamp &other) throw () {
        return TimeStamp(this->stamp * other.stamp);
}

TimeStamp TimeStamp::operator * (const struct timeval &tv) throw () {
        return TimeStamp(this->stamp * ((tv.tv_sec * 1000000) + tv.tv_usec));
}

TimeStamp TimeStamp::operator * (int64_t micro) throw () {
        return TimeStamp(this->stamp * micro);
}

TimeStamp TimeStamp::operator / (const TimeStamp &other) throw () {
        return TimeStamp(this->stamp / other.stamp);
}

TimeStamp TimeStamp::operator / (const struct timeval &tv) throw () {
        return TimeStamp(this->stamp / ((tv.tv_sec * 1000000) + tv.tv_usec));
}

TimeStamp TimeStamp::operator / (int64_t micro) throw () {
        return TimeStamp(this->stamp / micro);
}

bool TimeStamp::operator == (const TimeStamp &other) const throw () {
        return this->stamp == other.stamp;
}

bool TimeStamp::operator != (const TimeStamp &other) const throw () {
        return this->stamp != other.stamp;
}

bool TimeStamp::operator >= (const TimeStamp &other) const throw () {
        return this->stamp >= other.stamp;
}

bool TimeStamp::operator <= (const TimeStamp &other) const throw () {
        return this->stamp <= other.stamp;
}

bool TimeStamp::operator >  (const TimeStamp &other) const throw () {
        return this->stamp > other.stamp;
}

bool TimeStamp::operator <  (const TimeStamp &other) const throw () {
        return this->stamp < other.stamp;
}

void TimeStamp::update() throw () {
        this->stamp = TimeStamp::now();
}

int64_t TimeStamp::now() throw () {
        struct timeval  tv;

        gettimeofday(&tv, NULL);

        return (tv.tv_sec * 1000000) + tv.tv_usec;
}

int64_t TimeStamp::getEpochMicroseconds() const throw () {
        return this->stamp;
}

int64_t TimeStamp::getEpochSeconds() const throw () {
        return this->stamp / 1000000;
}

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

---