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

Go to the documentation of this file.

/*  Sirikata
 *  Time.hpp
 *
 *  Copyright (c) 2009, Daniel 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.
 */

#include <sstream>

#ifndef _SIRIKATA_TIME_HPP_
#define _SIRIKATA_TIME_HPP_
#include "../task/Time.hpp"
namespace Sirikata {
class Time : private Task::LocalTime{

    Time (const LocalTime &local):LocalTime(local) {

    }
  public:
    Time ()
     : LocalTime()
    {}

    Time (uint64 raw) :LocalTime(raw){}
    
    uint64 raw() const {
        return static_cast<const LocalTime*>(this)->raw();
    }
    inline bool operator== (const Time &other) const {
        return *static_cast<const LocalTime*>(this)==other;
    }
    inline bool operator!= (const Time& other) const {
        return *static_cast<const LocalTime*>(this)!=other;
    }


    inline bool operator< (const Time &other) const {
        return *static_cast<const LocalTime*>(this)<other;
    }
    inline bool operator<= (const Time &other) const {
        return *static_cast<const LocalTime*>(this)<=other;
    }
    inline bool operator> (const Time &other) const {
        return *static_cast<const LocalTime*>(this)>other;
    }
    inline bool operator>= (const Time &other) const {
        return *static_cast<const LocalTime*>(this)>=other;
    }

    inline Duration operator- (const Time &other) const {
        return *static_cast<const LocalTime*>(this)-other;
    }
    inline Time operator+ (const Duration &otherDelta) const {
        return *static_cast<const LocalTime*>(this)+otherDelta;
    }
    inline Time operator- (const Duration &otherDelta) const {
        return *static_cast<const LocalTime*>(this)-otherDelta;
    }
    inline void operator+= (const Duration &otherDelta) {
        return *static_cast<LocalTime*>(this)+=otherDelta;
    }
    inline void operator-= (const Duration &otherDelta) {
        return *static_cast<LocalTime*>(this)-=otherDelta;
    }

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

    static Time now(const Duration&spaceDurationOffset){
        return Time(LocalTime::now()+spaceDurationOffset);
    }

    static Time local() {
        return now(Duration::zero());
    }

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

    static Time null() { return Time(0); }
    static Time convertFrom(const LocalTime&lt, const Duration&serverOffset){
        return Time(lt)+serverOffset;
    }
};
}
#endif