libplumbing/time_value.cc

Go to the documentation of this file.

//
// plumbing - C++ wrapper facades for Berkeley sockets
// Copyright (C) 2009, 2010 Peter Miller
//
// This program is free software; you can redistribute it and/or modify it
// under the terms of the GNU General Public License, version 3, as published
// by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
// more details.
//
// You should have received a copy of the GNU General Public License along with
// this program. If not, see <http://www.gnu.org/licenses/>.
//

#include <libplumbing/config.h>
#include <cstdio>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <libexplain/gettimeofday.h>

#include <libplumbing/logging.h>
#include <libplumbing/time_value.h>


plumbing::time_value::time_value(long sec, long usec)
{
    if (usec >= 1000000)
    {
        ldiv_t q = ldiv(usec, 1000000);
        tv_sec = sec + q.quot;
        tv_usec = q.rem;
    }
    else if (usec < 0)
    {
        //
        // The ldiv function rounds towards zero (it doesn't round down,
        // which is what we need) so we have to be careful when using it
        // for negative numbers.
        //
        ldiv_t q = ldiv(-usec, 1000000);
        tv_sec = sec - q.quot;
        if (q.rem)
        {
            tv_sec--;
            tv_usec = 1000000 - q.rem;
        }
        else
            tv_usec = 0;
    }
    else
    {
        tv_sec = sec;
        tv_usec = usec;
    }
    assert(in_normal_form());
}


plumbing::time_value::time_value(double sec)
{
    long long usec = (long long)floor(sec * 1e6 + 0.5);
    tv_sec = usec / 1000000;
    tv_usec = usec - tv_sec * 1000000;
    if (tv_usec < 0)
    {
        //
        // In the case where sec is negative, but not a whole multiple
        // of seconds, the tv_sec calculation will truncate towards
        // zero.  This results in the tv_usec value being negative
        // (-1..-999999), which is not normal form.  The value is
        // adjusted so that the tv_usec field is positive, and the
        // tv_sec field adjusted down to compensate.
        //
        // For example: time_value(-1.5) yields
        //     usec = -1500000
        //     tv_sec = -1
        //     tv_usec = -500000
        // but this is not normal form, so it is adjusted to
        //     tv_sec = -2
        //     tv_usec = 500000
        //
        tv_sec--;
        tv_usec += 1000000;
    }
    assert(in_normal_form());
}


plumbing::time_value::time_value(const time_value &rhs)
{
    assert(rhs.in_normal_form());
    tv_sec = rhs.tv_sec;
    tv_usec = rhs.tv_usec;
}


plumbing::time_value::time_value(const char *str)
{
    double n = strtod(str, 0);
    *this = time_value(n);
}


plumbing::time_value &
plumbing::time_value::operator=(double sec)
{
    double usec = floor(sec * 1e6 + 0.5);
    tv_sec = long(floor(usec * 1e-6));
    tv_usec = long(usec - tv_sec * 1e6);
    assert(in_normal_form());
    return *this;
}


plumbing::time_value::operator double()
    const
{
    return (tv_sec + tv_usec * 1e-6);
}


plumbing::time_value &
plumbing::time_value::operator+=(const time_value &rhs)
{
    assert(in_normal_form());
    assert(rhs.in_normal_form());
    tv_sec += rhs.tv_sec;
    tv_usec += rhs.tv_usec;
    if (tv_usec >= 1000000)
    {
        tv_sec++;
        tv_usec -= 1000000;
    }
    assert(in_normal_form());
    return *this;
}


plumbing::time_value
plumbing::time_value::operator+(const time_value &rhs)
    const
{
    time_value result(*this);
    result += rhs;
    return result;
}


plumbing::time_value &
plumbing::time_value::operator-=(const time_value &rhs)
{
    assert(in_normal_form());
    assert(rhs.in_normal_form());
    tv_sec -= rhs.tv_sec;
    tv_usec -= rhs.tv_usec;
    if (tv_usec < 0)
    {
        tv_sec--;
        tv_usec += 1000000;
    }
    assert(in_normal_form());
    return *this;
}


plumbing::time_value
plumbing::time_value::operator-(const time_value &rhs)
    const
{
    time_value result(*this);
    result -= rhs;
    return result;
}


bool
plumbing::time_value::operator==(const time_value &rhs)
    const
{
    return (tv_sec == rhs.tv_sec && tv_usec == rhs.tv_usec);
}


bool
plumbing::time_value::operator!=(const time_value &rhs)
    const
{
    return (tv_sec != rhs.tv_sec || tv_usec != rhs.tv_usec);
}


bool
plumbing::time_value::operator<(const time_value &rhs)
    const
{
    if (tv_sec == rhs.tv_sec)
        return (tv_usec < rhs.tv_usec);
    return (tv_sec < rhs.tv_sec);
}


bool
plumbing::time_value::operator<=(const time_value &rhs)
    const
{
    if (tv_sec == rhs.tv_sec)
        return (tv_usec <= rhs.tv_usec);
    return (tv_sec < rhs.tv_sec);
}


bool
plumbing::time_value::operator>(const time_value &rhs)
    const
{
    if (tv_sec == rhs.tv_sec)
        return (tv_usec > rhs.tv_usec);
    return (tv_sec > rhs.tv_sec);
}


bool
plumbing::time_value::operator>=(const time_value &rhs)
    const
{
    if (tv_sec == rhs.tv_sec)
        return (tv_usec >= rhs.tv_usec);
    return (tv_sec > rhs.tv_sec);
}


plumbing::time_value &
plumbing::time_value::operator*=(double x)
{
    *this = x * double(*this);
    return *this;
}


plumbing::time_value
plumbing::time_value::operator*(double x)
    const
{
    return time_value(x * double(*this));
}


plumbing::time_value &
plumbing::time_value::operator*=(long x)
{
    *this = x * double(*this);
    return *this;
}


plumbing::time_value
plumbing::time_value::operator*(long x)
    const
{
    return time_value(x * double(*this));
}


plumbing::time_value
plumbing::time_value::operator-()
    const
{
    assert(in_normal_form());
    if (tv_usec == 0)
        return time_value(-tv_sec);
    time_value result(-tv_sec - 1, 1000000 - tv_usec);
    return result;
}


int
plumbing::time_value::get_time_of_day()
{
    if (gettimeofday(this, 0) < 0)
        return -1;
    assert(in_normal_form());
    return 0;
}


plumbing::time_value
plumbing::time_value::now()
{
    time_value result;
    if (result.get_time_of_day() < 0)
        log().fatal_error("%s", explain_gettimeofday(&result, 0));
    return result;
}


std::string
plumbing::time_value::representation()
    const
{
    char buffer[20];
    snprintf(buffer, sizeof(buffer), "%8.6f", double(*this));
    return buffer;
}


// vim: set ts=4 et

---