Time.hpp

Go to the documentation of this file.

#ifndef FW_TIME_HPP
#define FW_TIME_HPP

#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Time/TimeComparisonEnumAc.hpp>
#include <Fw/Time/TimeValueSerializableAc.hpp>
#include <Fw/Types/Assert.hpp>
#include <Fw/Types/Serializable.hpp>
#include <config/TimeBaseEnumAc.hpp>

namespace Fw {
class Time : public Serializable {
    friend class TimeTester;

  public:
    enum { SERIALIZED_SIZE = sizeof(FwTimeBaseStoreType) + sizeof(FwTimeContextStoreType) + sizeof(U32) + sizeof(U32) };

    Time();                                              // !< Default constructor
    Time(const Time& other);                             // !< Copy constructor
    Time(U32 seconds, U32 useconds);                     // !< Constructor with member values as arguments
    Time(TimeBase timeBase, U32 seconds, U32 useconds);  // !< Constructor with member values as arguments
    Time(TimeBase timeBase,
         FwTimeContextStoreType context,
         U32 seconds,
         U32 useconds);  // !< Constructor with member values as arguments

    explicit Time(F64 seconds);

    virtual ~Time();                                         // !< Destructor
    void set(U32 seconds, U32 useconds);                     // !< Sets value of time stored
    void set(TimeBase timeBase, U32 seconds, U32 useconds);  // !< Sets value of time stored
    void set(TimeBase timeBase,
             FwTimeContextStoreType context,
             U32 seconds,
             U32 useconds);  // !< Sets value of time stored

    void set(F64 seconds);

    void setTimeBase(TimeBase timeBase);
    void setTimeContext(FwTimeContextStoreType context);
    U32 getSeconds() const;   // !< Gets seconds part of time
    U32 getUSeconds() const;  // !< Gets microseconds part of time
    TimeBase getTimeBase()
        const;  // !< Time base of time. This is project specific and is meant for indicating different sources of time
    FwTimeContextStoreType getContext() const;  // !< get the context value
    SerializeStatus serializeTo(SerialBufferBase& buffer,
                                Fw::Endianness mode = Fw::Endianness::BIG) const override;  // !< Serialize method
    SerializeStatus deserializeFrom(SerialBufferBase& buffer,
                                    Fw::Endianness mode = Fw::Endianness::BIG) override;  // !< Deserialize method
    bool operator==(const Time& other) const;
    bool operator!=(const Time& other) const;
    bool operator>(const Time& other) const;
    bool operator<(const Time& other) const;
    bool operator>=(const Time& other) const;
    bool operator<=(const Time& other) const;
    Time& operator=(const Time& other);

    Time& operator=(F64 seconds);

    Time& operator+=(F64 seconds);

    operator F64() const;

    TimeValue asTimeValue() const;

    // Static methods:

    static Time zero(TimeBase timeBase = TimeBase::TB_NONE);

    static TimeComparison compare(const Time& time1,  
                                  const Time& time2   
    );

    static Time add(const Time& a,  
                    const Time& b   
    );

    static Time sub(const Time& minuend,    
                    const Time& subtrahend  
    );

    static U32 parseSeconds(F64 seconds);

    static U32 parseUSeconds(F64 seconds);

    // add seconds and microseconds to existing time
    void add(U32 seconds, U32 mseconds);

    void add(F64 seconds);

#ifdef BUILD_UT  // Stream operators to support Googletest
    friend std::ostream& operator<<(std::ostream& os, const Time& val);
#endif
  private:
    TimeValue m_val;  // !< Time value
};
extern const Time ZERO_TIME;

}  // namespace Fw

#endif