Time.cc

// Copyright 2008 Michael Marsh, University of Maryland.
//
// This file is part of pydtn.
//
// pydtn is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// pydtn 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 pydtn.  If not, see <http://www.gnu.org/licenses/>.
//
// The views and conclusions contained in the software and documentation
// are those of the authors and should not be interpreted as representing
// official policies, either expressed or implied, of the University
// of Maryland.
//
// pydtn extends and embeds the Python interpreter, which is
// Copyright 2001-2006 Python Software Foundation, All Rights Reserved,
// and is released under the PSF License Agreement.
//
// RANLUX random number generation uses the Boost library,
// Copyright 1994-2006 by various authors (details in individual files),
// which is released under the Boost Software License, Version 1.0.

#include "Time.h"
#include <ostream>

const long Time::MILLION = 1000000;

Time::Time( const struct timeval& t )
{
   tv.tv_sec  = t.tv_sec;
   tv.tv_usec = t.tv_usec;
   fix();
}

Time::Time( long sec, long usec )
{
   tv.tv_sec  = sec;
   tv.tv_usec = usec;
   fix();
}

Time::Time( const Time& t )
{
   tv.tv_sec  = t.tv.tv_sec;
   tv.tv_usec = t.tv.tv_usec;
}

void
Time::operator=( const Time& t )
{
   if ( &t == this ) return;
   tv.tv_sec  = t.tv.tv_sec;
   tv.tv_usec = t.tv.tv_usec;
}

Time
Time::operator+(const Time& t) const
{
   return Time( tv.tv_sec + t.tv.tv_sec , tv.tv_usec + t.tv.tv_usec );
}

Time
Time::operator-(const Time& t) const
{
   return Time( tv.tv_sec - t.tv.tv_sec , tv.tv_usec - t.tv.tv_usec );
}

Time
Time::operator*(long s) const
{
   return Time( tv.tv_sec * s , tv.tv_usec * s );
}

Time
Time::operator/(long s) const
{
   // This requires carrying the remainder of the seconds to the microseconds
   return Time( tv.tv_sec / s ,
                ( MILLION * ( tv.tv_sec % s ) + tv.tv_usec ) / s );
}

Time&
Time::operator+=(const Time& t)
{
   tv.tv_sec += t.tv.tv_sec;
   tv.tv_usec += t.tv.tv_usec;
   fix();
   return *this;
}

Time&
Time::operator-=(const Time& t)
{
   tv.tv_sec -= t.tv.tv_sec;
   tv.tv_usec -= t.tv.tv_usec;
   fix();
   return *this;
}

Time&
Time::operator*=(long s)
{
   tv.tv_sec *= s;
   tv.tv_usec *= s;
   fix();
   return *this;
}

bool
Time::operator==(const Time& t) const
{
   if ( tv.tv_sec != t.tv.tv_sec ) return false;
   if ( tv.tv_usec != t.tv.tv_usec ) return false;
   return true;
}

bool
Time::operator<(const Time& t) const
{
   if ( tv.tv_sec < t.tv.tv_sec ) return true;
   if ( tv.tv_sec > t.tv.tv_sec ) return false;
   if ( tv.tv_usec < t.tv.tv_usec ) return true;
   return false;
}

bool
Time::operator>(const Time& t) const
{
   if ( tv.tv_sec > t.tv.tv_sec ) return true;
   if ( tv.tv_sec < t.tv.tv_sec ) return false;
   if ( tv.tv_usec > t.tv.tv_usec ) return true;
   return false;
}

bool
Time::operator<=(const Time& t) const
{
   return ! operator>(t);
}

bool
Time::operator>=(const Time& t) const
{
   return ! operator<(t);
}


void
Time::fix()
{
   if ( ( tv.tv_usec > MILLION ) || ( tv.tv_usec < -MILLION ) )
   {
      // This works regardless of sign
      tv.tv_sec += ( tv.tv_usec / MILLION );
      tv.tv_usec %= MILLION;
   }
   if ( tv.tv_sec >= 0 && tv.tv_usec < 0 )
   {
      tv.tv_usec += MILLION;
      tv.tv_sec -= 1;
   }
   else if ( tv.tv_sec < 0 && tv.tv_usec > 0 )
   {
      tv.tv_usec -= MILLION;
      tv.tv_sec += 1;
   }
}

Time
operator+(const struct timeval& a, const Time& b)
{
   return Time( a.tv_sec + b.tv.tv_sec , a.tv_usec + b.tv.tv_usec );
}

Time
operator-(const struct timeval& a, const Time& b)
{
   return Time( a.tv_sec - b.tv.tv_sec , a.tv_usec - b.tv.tv_usec );
}

Time
operator*(long a, const Time& b)
{
   return Time( a * b.tv.tv_sec , a * b.tv.tv_usec );
}

bool
operator==(const struct timeval& a, const Time& b)
{
   if ( a.tv_sec != b.tv.tv_sec ) return false;
   if ( a.tv_usec != b.tv.tv_usec ) return false;
   return true;
}

bool
operator<(const struct timeval& a, const Time& b)
{
   if ( a.tv_sec < b.tv.tv_sec ) return true;
   if ( a.tv_sec > b.tv.tv_sec ) return false;
   if ( a.tv_usec < b.tv.tv_usec ) return true;
   return false;
}

bool
operator>(const struct timeval& a, const Time& b)
{
   if ( a.tv_sec > b.tv.tv_sec ) return true;
   if ( a.tv_sec < b.tv.tv_sec ) return false;
   if ( a.tv_usec > b.tv.tv_usec ) return true;
   return false;
}

std::ostream& operator<<(std::ostream& stream, const Time& t)
{
   stream << "{" << t.tv.tv_sec << "," << t.tv.tv_usec << "}";
   return stream;
}

---