RawTime.hpp

Go to the documentation of this file.

// ======================================================================
// \title Os/RawTime.hpp
// \brief common definitions for Os::RawTime
// ======================================================================
#ifndef OS_RAWTIME_HPP_
#define OS_RAWTIME_HPP_

#include <Fw/FPrimeBasicTypes.hpp>
#include <Fw/Time/TimeInterval.hpp>
#include <Fw/Types/Serializable.hpp>
#include <Os/Os.hpp>

namespace Os {

struct RawTimeHandle {};

class RawTime;  // Forward declaration

class RawTimeInterface : public Fw::Serializable {
  public:
    // Serialization size for RawTime objects, configured in config/FpConfig.h
    static const FwSizeType SERIALIZED_SIZE = FW_RAW_TIME_SERIALIZATION_MAX_SIZE;

    enum Status {
        OP_OK,           
        OP_OVERFLOW,     
        INVALID_PARAMS,  
        NOT_SUPPORTED,   
        OTHER_ERROR      
    };

    RawTimeInterface() = default;

    virtual ~RawTimeInterface() = default;

    virtual RawTimeHandle* getHandle() = 0;

    static RawTimeInterface* getDelegate(RawTimeHandleStorage& aligned_new_memory,
                                         const RawTimeInterface* to_copy = nullptr);

    // ------------------------------------------------------------------
    // RawTime operations to be implemented by an OSAL implementation
    // ------------------------------------------------------------------

    virtual Status now() = 0;

    virtual Status getTimeInterval(const Os::RawTime& other, Fw::TimeInterval& interval) const = 0;

    virtual Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
                                            Fw::Endianness mode = Fw::Endianness::BIG) const = 0;

    virtual Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
                                                Fw::Endianness mode = Fw::Endianness::BIG) = 0;

    // ------------------------------------------------------------------
    // Common virtual functions built on top of OS-specific functions
    // ------------------------------------------------------------------

    virtual Status getDiffUsec(const RawTime& other, U32& result) const;
};

class RawTime final : public RawTimeInterface {
  public:
    RawTime();         
    ~RawTime() final;  

    RawTime(const RawTime& other);

    RawTime& operator=(const RawTime& other);

    RawTimeHandle* getHandle() override;

    // ------------------------------------------------------------
    // Implementation-specific RawTime member functions
    // ------------------------------------------------------------

    Status now() override;

    Status getTimeInterval(const Os::RawTime& other, Fw::TimeInterval& interval) const override;

    Fw::SerializeStatus serializeTo(Fw::SerialBufferBase& buffer,
                                    Fw::Endianness mode = Fw::Endianness::BIG) const override;

    Fw::SerializeStatus deserializeFrom(Fw::SerialBufferBase& buffer,
                                        Fw::Endianness mode = Fw::Endianness::BIG) override;

    Status getDiffUsec(const RawTime& other, U32& result) const override;

    // ------------------------------------------------------------
    // Common functions built on top of OS-specific functions
    // ------------------------------------------------------------

    bool operator==(const RawTime& other) const;

  private:
    // This section is used to store the implementation-defined RawTime handle. To Os::RawTime and fprime, this type is
    // opaque and thus normal allocation cannot be done. Instead, we allow the implementor to store the handle in
    // the byte-array here and set `m_handle_storage` to that address for storage.
    //
    alignas(FW_HANDLE_ALIGNMENT) RawTimeHandleStorage m_handle_storage;  
    RawTimeInterface& m_delegate;                                        
};
}  // namespace Os

#endif