b2time.H

//------------------------------------------------------------------------
// b2time.H --
//
//
// written by Mathias Doreille
//
// Copyright (c) 2004-2012 SMR Engineering & Development SA
//                         2502 Bienne, Switzerland
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef B2TIME_H_
#define B2TIME_H_
 
#include <chrono>
#include <iomanip>
#include <ostream>
#include <sstream>
#include <string>
 
#include "b2ppconfig.h"
 
namespace b2000 {
 
class Time;
class DiffTime;
 
class Time {
public:
    Time() {
        t = std::chrono::high_resolution_clock::now();
        t_sys = std::chrono::system_clock::now();
    }
 
    void reinit() {
        t = std::chrono::high_resolution_clock::now();
        t_sys = std::chrono::system_clock::now();
    }
 
    Time(const Time& time_) { t = time_.t; }
 
    std::string time() { return time_formats("%X"); }
 
    std::string date() { return time_formats("%c"); }
 
    std::string time_formats(const char* format) const {
        char time_buffer[256];
        std::time_t t_c = std::chrono::system_clock::to_time_t(t_sys);
        strftime(time_buffer, 256, format, std::localtime(&t_c));
        return time_buffer;
    }
 
    friend DiffTime operator-(const Time& t1, const Time& t2);
 
private:
    friend class DiffTime;
    std::chrono::time_point<std::chrono::high_resolution_clock> t;
    std::chrono::time_point<std::chrono::system_clock> t_sys;
};
 
class DiffTime {
public:
    DiffTime() { t = std::chrono::duration<double>(0.0); }
 
    DiffTime(const DiffTime& dt) : t(dt.t) {}
 
    bool operator<(const DiffTime& dt) const { return t < dt.t; }
 
    std::string time() {
        long tt = long(std::chrono::floor<std::chrono::seconds>(t).count());
        int sec = int(tt % 60);
        tt /= 60;
        int min = tt % 60;
        tt /= 60;
        std::ostringstream o;
        if (tt > 0) { o << tt << "h"; }
        o << min << "m" << sec << "s";
        return o.str();
    }
 
    friend DiffTime operator-(const Time& t1, const Time& t2) {
        DiffTime tmp;
        tmp.t = std::chrono::duration_cast<std::chrono::duration<double>>(t1.t - t2.t);
        return tmp;
    }
 
    operator double() { return t.count(); }
 
private:
    std::chrono::duration<double> t;
};
 
}  // namespace b2000
 
#endif  // B2TIME_H_