libcore/include/sirikata/core/task/Time.hpp

Go to the documentation of this file.

/*  Sirikata Kernel -- Task scheduling system
 *  Time.hpp
 *
 *  Copyright (c) 2008, Patrick Reiter Horn
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of Sirikata nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef SIRIKATA_Time_HPP__
#define SIRIKATA_Time_HPP__

namespace Sirikata {

namespace Task {


class SIRIKATA_EXPORT DeltaTime {
    int64 mDeltaTime;

    explicit DeltaTime(int64 us)
        : mDeltaTime(us)
    {
    }
public:
    DeltaTime()
        : mDeltaTime(0)
    {
    }

    inline double operator/ (const DeltaTime&other)const {
        return (double)(mDeltaTime/other.mDeltaTime)+(double)(mDeltaTime%other.mDeltaTime)/(double)other.mDeltaTime;
    }

    inline DeltaTime operator/(float32 rhs) const {
        return DeltaTime((int64)((float64)mDeltaTime / (float64)rhs));
    }
    inline void operator/=(float32 rhs) {
        mDeltaTime = (int64)((float64)mDeltaTime / (float64)rhs);
    }
    inline DeltaTime operator/(float64 rhs) const {
        return DeltaTime((int64)((float64)mDeltaTime / (float64)rhs));
    }
    inline void operator/=(float64 rhs) {
        mDeltaTime = (int64)((float64)mDeltaTime / (float64)rhs);
    }
    inline DeltaTime operator/(int32 rhs) const {
        return (*this)/(float64)rhs;
    }
    inline void operator/=(int32 rhs) {
        (*this) /= (float64)rhs;
    }
    inline DeltaTime operator/(uint32 rhs) const {
        return (*this)/(float64)rhs;
    }
    inline void operator/=(uint32 rhs) {
        (*this) /= (float64)rhs;
    }
    inline DeltaTime operator/(int64 rhs) const {
        return (*this)/(float64)rhs;
    }
    inline void operator/=(int64 rhs) {
        (*this) /= (float64)rhs;
    }
    inline DeltaTime operator/(uint64 rhs) const {
        return (*this)/(float64)rhs;
    }
    inline void operator/=(uint64 rhs) {
        (*this) /= (float64)rhs;
    }

    inline DeltaTime operator*(float32 rhs) const {
        return DeltaTime((int64)((float64)mDeltaTime * (float64)rhs));
    }
    inline void operator*=(float32 rhs) {
        mDeltaTime = (int64)((float64)mDeltaTime * (float64)rhs);
    }
    inline DeltaTime operator*(float64 rhs) const {
        return DeltaTime((int64)((float64)mDeltaTime * (float64)rhs));
    }
    inline void operator*=(float64 rhs) {
        mDeltaTime = (int64)((float64)mDeltaTime * (float64)rhs);
    }
    inline DeltaTime operator*(int32 rhs) const {
        return (*this) * (float64)rhs;
    }
    inline void operator*=(int32 rhs) {
        (*this) *= (float64)rhs;
    }
    inline DeltaTime operator*(uint32 rhs) const {
        return (*this) * (float64)rhs;
    }
    inline void operator*=(uint32 rhs) {
        (*this) *= (float64)rhs;
    }
    inline DeltaTime operator*(int64 rhs) const {
        return (*this) * (float64)rhs;
    }
    inline void operator*=(int64 rhs) {
        (*this) *= (float64)rhs;
    }
    inline DeltaTime operator*(uint64 rhs) const {
        return (*this) * (float64)rhs;
    }
    inline void operator*=(uint64 rhs) {
        (*this) *= (float64)rhs;
    }

    static DeltaTime hours(double s) {
        return minutes(s*60);
    }
    static DeltaTime minutes(double s) {
        return seconds(s*60);
    }
    static DeltaTime seconds(double s) {
        return DeltaTime((int64)(s*1000000.));
    }
    static DeltaTime milliseconds(double ms) {
        return DeltaTime((int64)(ms*1000.));
    }
    static DeltaTime milliseconds(int64 ms) {
        return DeltaTime(ms*1000);
    }
    static DeltaTime milliseconds(uint64 ms) {
        return DeltaTime(ms*1000);
    }
    static DeltaTime milliseconds(int32 ms) {
        return DeltaTime(((int64)ms)*1000);
    }
    static DeltaTime milliseconds(uint32 ms) {
        return DeltaTime(((int64)ms)*1000);
    }
    static DeltaTime microseconds(double us) {
        return DeltaTime((int64)us);
    }
    static DeltaTime microseconds(int64 us) {
        return DeltaTime(us);
    }
    static DeltaTime microseconds(uint64 us) {
        return DeltaTime(us);
    }
    static DeltaTime microseconds(int32 us) {
        return DeltaTime((int64)us);
    }
    static DeltaTime microseconds(uint32 us) {
        return DeltaTime((int64)us);
    }
    static DeltaTime nanoseconds(int64 ns) {
        return DeltaTime(ns/1000);
    }
    static DeltaTime nanoseconds(uint64 ns) {
        return DeltaTime(ns/1000);
    }
    static DeltaTime nanoseconds(int32 ns) {
        return DeltaTime(((int64)ns)/1000);
    }
    static DeltaTime nanoseconds(uint32 ns) {
        return DeltaTime(((int64)ns)/1000);
    }

    static DeltaTime zero() {
        return DeltaTime::nanoseconds(0);
    }

    class LocalTime fromNow() const;

    inline DeltaTime operator- (const DeltaTime &other) const {
        return DeltaTime(mDeltaTime - other.mDeltaTime);
    }
    inline DeltaTime operator+ (const DeltaTime &other) const {
        return DeltaTime(mDeltaTime + other.mDeltaTime);
    }
    inline DeltaTime operator+= (const DeltaTime &other) {
        return DeltaTime(mDeltaTime += other.mDeltaTime);
    }
    inline DeltaTime operator-= (const DeltaTime &other) {
        return DeltaTime(mDeltaTime -= other.mDeltaTime);
    }
    inline DeltaTime operator- () const {
        return DeltaTime(-mDeltaTime);
    }
    double toSeconds () const {
        return mDeltaTime/1000000.;
    }
    double seconds() const {
        return toSeconds();
    }
    int64 toMilliseconds() const {
        return mDeltaTime/1000;
    }
        int64 milliseconds() const {
            return toMilliseconds();
        }
    int64 toMicroseconds() const {
        return mDeltaTime;
    }
        int64 microseconds() const {
            return toMicroseconds();
        }
    int64 toMicro() const {
        return toMicroseconds();
    }

    inline bool operator== (const DeltaTime &other) const {
        return (mDeltaTime == other.mDeltaTime);
    }
        inline bool operator!= (const DeltaTime& other) const {
            return (mDeltaTime != other.mDeltaTime);
        }
    inline bool operator< (const DeltaTime &other) const {
        return (mDeltaTime < other.mDeltaTime);
    }
    inline bool operator<= (const DeltaTime &other) const {
        return (mDeltaTime <= other.mDeltaTime);
    }
    inline bool operator> (const DeltaTime &other) const {
        return (mDeltaTime > other.mDeltaTime);
    }
    inline bool operator>= (const DeltaTime &other) const {
        return (mDeltaTime >= other.mDeltaTime);
    }

        String toString() const;
};

class SIRIKATA_EXPORT LocalTime {

    uint64 mTime;
protected:
    explicit LocalTime(uint64 t) {
        this->mTime = t;
    }

public:
    LocalTime()
        : mTime(0)
    {}

    uint64 raw() const {
        return mTime;
    }

    inline bool operator== (const LocalTime &other) const {
        return (mTime == other.mTime);
    }
    inline bool operator!= (const LocalTime& other) const {
        return (mTime != other.mTime);
    }

    inline bool operator< (const LocalTime &other) const {
        return (mTime < other.mTime);
    }
    inline bool operator<= (const LocalTime &other) const {
        return (mTime <= other.mTime);
    }
    inline bool operator> (const LocalTime &other) const {
        return (mTime > other.mTime);
    }
    inline bool operator>= (const LocalTime &other) const {
        return (mTime >= other.mTime);
    }

    inline DeltaTime operator- (const LocalTime &other) const {
        return DeltaTime::microseconds((int64)mTime - (int64)other.mTime);
    }
    inline LocalTime operator+ (const DeltaTime &otherDelta) const {
        return LocalTime(mTime + otherDelta.toMicro());
    }
    inline LocalTime operator- (const DeltaTime &otherDelta) const {
        return (*this) + (-otherDelta);
    }
    inline void operator+= (const DeltaTime &otherDelta) {
        mTime += otherDelta.toMicro();
    }
    inline void operator-= (const DeltaTime &otherDelta) {
        (*this) += (-otherDelta);
    }

    static LocalTime microseconds(int64 abstime){
        return LocalTime(abstime);
    }

    static LocalTime now(); // Only way to generate an LocalTime for now...

    static LocalTime epoch() { return LocalTime(0); }

    static LocalTime null() { return LocalTime(0); }


};

SIRIKATA_EXPORT std::ostream& operator<<(std::ostream& os, const DeltaTime& rhs);
SIRIKATA_EXPORT std::istream& operator>>(std::istream& is, DeltaTime& rhs);
inline LocalTime DeltaTime::fromNow() const {
    return LocalTime::now() + (*this);
}

}
}

#endif