include/util/timestamp.hpp

Go to the documentation of this file.

// This file is part of SPart, Spatially Located Workload Partitioner.

// Copyright (C) 2011, The Ohio State University
// SPart developed by Erdeniz O. Bas, Erik Saule and Umit V. Catalyurek 

// For questions, comments, suggestions, bugs please send e-mail to: 
// Umit V. Catalyurek   catalyurek.1@osu.edu

// SPart 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 2 or (at your option) any later
// version.

// SPart 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 SPart; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

// As a special exception, if other files instantiate templates or use
// macros or inline functions from this file, or you compile this file
// and link it with other works to produce a work based on this file,
// this file does not by itself cause the resulting work to be covered by
// the GNU General Public License. However the source code for this file
// must still be made available in accordance with section (3) of the GNU
// General Public License.

// This exception does not invalidate any other reasons why a work based
// on this file might be covered by the GNU General Public License.

// The full text of the GPL license version 2 is available in "gpl.txt".

#ifndef TIMESTAMP_ERIK_H__
#define TIMESTAMP_ERIK_H__

#include <sys/time.h>
#include <iostream>
#include <stdio.h>

namespace util{class timestamp;}

static std::ostream& operator<< (std::ostream&, const util::timestamp&);

namespace util
{
  class timestamp
  {
    int seconds;
    int microseconds; //< 1000000

    void fixme()
    {
      if (microseconds < 0)
        {
          seconds --;
          microseconds += 1000000;
        }
      else if (microseconds > 1000000)
        {
          seconds ++;
          microseconds -= 1000000;
        }    
    }

  public:

    timestamp()
    {
      struct timeval tv;
      gettimeofday (&tv, NULL); //should check return code
      seconds = tv.tv_sec;
      microseconds = tv.tv_usec;
    }

    timestamp(int s, int us)
      :seconds(s), microseconds(us)
    {}


    timestamp operator+ (const timestamp& b)
    {
      timestamp ret (this->seconds + b.seconds,
                     this->microseconds+b.microseconds);
      ret.fixme();
      return ret;
    }

    timestamp operator- (const timestamp& b)
    {
      timestamp ret (this->seconds - b.seconds,
                     this->microseconds - b.microseconds);
      ret.fixme();
      return ret;
    }

    const timestamp& operator += (const timestamp& b)
    {
      this->seconds += b.seconds;
      this->microseconds += b.microseconds;

      this->fixme();
      return *this;
    }

    const timestamp& operator -= (const timestamp& b)
    {
      this->seconds -= b.seconds;
      this->microseconds -= b.microseconds;

      this->fixme();
      return *this;
    }

    friend std::ostream& ::operator<< (std::ostream&, const util::timestamp&);
  };

}

static std::ostream& operator<< (std::ostream& out, const util::timestamp& t)
{
  char microsecval[7];

  out<<t.seconds<<'.';

  sprintf(microsecval, "%06d", t.microseconds);

  out<<microsecval;

  return out;
}


#endif