CUTimestamp.h

//
//  CUTimestamp.h
//  Cornell University Game Library (CUGL)
//
//  This module simplifies timestamp support a bit.  Accurate timestamp support
//  is necessary for touch and mouse support, but timestamps requires some
//  really arcane C++11.
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 2/10/15
//
#ifndef __CU_TIMESTAMP_H__
#define __CU_TIMESTAMP_H__
#include <chrono>
#include "../base/CUBase.h"
#include "CUDebug.h"

#pragma mark -
#pragma mark Clock Data Types

typedef std::chrono::steady_clock cuclock_t;
typedef cuclock_t::time_point   timestamp_t;

namespace cugl {

#pragma mark -
#pragma mark TimeStamp Class

class Timestamp {
protected:
    timestamp_t _time;

#pragma mark Constructors
public:
    Timestamp() { mark(); }
    
    Timestamp(const Timestamp& stamp) { set(stamp); }

    const Timestamp& operator=(const Timestamp& stamp) {
        return set(stamp);
    }

    const Timestamp& set(const Timestamp& stamp) {
        _time = stamp.getTime();
        return *this;
    }
    
    void mark() {
        _time = cuclock_t::now();
    }
    
#pragma mark Reading Time

    timestamp_t getTime() const { return _time; }

    static Uint64 ellapsedMillis(const Timestamp& start, const Timestamp& end) {
        auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end.getTime()-start.getTime());
        return (Uint64)elapsed.count();
    }

    Uint64 ellapsedMillis(const Timestamp& stamp) const  {
        return Timestamp::ellapsedMillis(stamp,*this);
    }
    
    static Uint64 ellapsedMicros(const Timestamp& start, const Timestamp& end)  {
        auto elapsed = std::chrono::duration_cast<std::chrono::microseconds>(end.getTime()-start.getTime());
        return (Uint64)elapsed.count();
    }
    
    Uint64 ellapsedMicros(const Timestamp& stamp) const  {
        return Timestamp::ellapsedMicros(stamp,*this);
    }

    static Uint64 ellapsedNanos(const Timestamp& start, const Timestamp& end) {
        auto elapsed = std::chrono::duration_cast<std::chrono::nanoseconds>(end.getTime()-start.getTime());
        return (Uint64)elapsed.count();
    }
    
    long ellapsedNanos(const Timestamp& stamp) {
        return Timestamp::ellapsedNanos(stamp,*this);
    }
    
#pragma mark Operators

    Timestamp& operator+=(Uint32 millis) {
        _time += std::chrono::milliseconds(millis);
        return *this;
    }

    Timestamp& operator-=(Uint32 millis) {
        _time -= std::chrono::milliseconds(millis);
        return *this;
    }

    const Timestamp operator+(Uint32 millis) const {
        return Timestamp(*this) += millis;
    }
    
    const Timestamp operator-(Uint32 millis) const {
        return Timestamp(*this) -= millis;
    }

};

}
#endif /* __CU_TIMESTAMP_H__ */