Time.h

/******************************************************************************
* Copyright (c) ATTX LLC 2024. All Rights Reserved.
*
* This software and associated documentation (the "Software") are the 
* proprietary and confidential information of ATTX, LLC. The Software is 
* furnished under a license agreement between ATTX and the user organization 
* and may be used or copied only in accordance with the terms of the agreement.
* Refer to 'license/attx_license.adoc' for standard license terms.
*
* EXPORT CONTROL NOTICE: THIS SOFTWARE MAY INCLUDE CONTENT CONTROLLED UNDER THE
* INTERNATIONAL TRAFFIC IN ARMS REGULATIONS (ITAR) OR THE EXPORT ADMINISTRATION 
* REGULATIONS (EAR99). No part of the Software may be used, reproduced, or 
* transmitted in any form or by any means, for any purpose, without the express 
* written permission of ATTX, LLC.
******************************************************************************/
/*
Time class header file
 
Author: Alex Reynolds
*/
#ifndef TIME_CLASS_H
#define TIME_CLASS_H
 
#include <time.h>
#include <string>
 
#include "data_management/GraphTreeObject.h"
#include "logging/SimLogger.h"
 
/// Constants for this class
#define NSEC_PER_SEC_D 1000000000.0
#define MSEC_PER_SEC_I 1000
#define NSEC_PER_MSEC_I 1000000
#define NSEC_PER_SEC_I 1000000000
#define NSEC_MAX 999999999
 
namespace clockwerk {
 
    /// @brief  Wrapper to manage and convert time as timespce
    //
    /// The time class is a simple wrapper class designed to make
    /// working with time simple. It wraps around a struct timespec
    /// as its core, and contains functions to perform time math 
    /// and conversions into various formats.
    class Time : public GraphTreeObject {
    public:
        /// Default, copy constructors and default destructor
        Time() {_tspec.tv_sec = 0; _tspec.tv_nsec = 0; _loggable=true;}
        Time(const struct timespec &t) {_tspec = t; _loggable=true;}
        Time(long unsigned int sec, long unsigned int nsec=0) {_tspec.tv_sec=sec; _tspec.tv_nsec=nsec; _loggable=true;}
        ~Time() {};
 
        /// @brief   Function to set the time in the time object
        /// @param   t   Timespec to set the time to11  
        void setTime(const struct timespec &t) {_tspec = t;}
 
        /// @brief   Function to step time forward by a set amount of nanoseconds
        /// @param   nsec    Number of nanoseconds to step by
        void stepTime(const unsigned long long &nsec);
 
        /// Functions to return various time formats
        const timespec& asTimespec() const {return _tspec;}
        double asDouble() const {return (double)_tspec.tv_sec + ((double)_tspec.tv_nsec)/NSEC_PER_SEC_D;}
        unsigned long long asMilliseconds() const {return _tspec.tv_sec*MSEC_PER_SEC_I + _tspec.tv_nsec/NSEC_PER_MSEC_I;}
        std::string asString() const {return std::to_string(_tspec.tv_sec) + ":" + std::to_string(_tspec.tv_nsec);}
 
        /// @brief   Function to set a time object from a frequency, in Hz
        /// @param   rate_hz     The rate to be converted to time
        void fromFrequency(unsigned int rate_hz);
        /// @brief   Function to set a time object from double
        /// @param   val     The double value to set time from
        void fromDouble(double val);
 
        /// @brief   Function to log data from our Time class
        /// @param   logger  Pointer to the logger to write to
        /// @note    Overwrites virtual function
        int log(void* logger) {
            SimLogger* log_ptr = (SimLogger*)logger;
            log_ptr->writeToBuffer(asDouble());
            return NO_ERROR;
        }
 
        /// @brief   Function to write header data from our Time class
        /// @note    Overwrites virtual function
        std::vector<std::string> header_info() const {
            return {""};
        }
 
        /// @brief   Function to add two times together a + b
        /// @param   b   Time to add
        /// @param   res     Result of the addition operation
        /// @return  Error code corresponding to success/failure
        int add(const Time &a, Time &res) const;
 
        /// @brief   Function to subtract a - b = res
        /// @param   b   Time to subtract
        /// @param   res     Result of the subtraction operation
        /// @return  Error code corresponding to success/failure
        int subtract(const Time &b, Time &res) const;
 
        /// @brief   Function to get half of a struct timespec
        /// @return  timespec corresponding to 
        int divide(unsigned int d, Time &res) const;
 
        /// @brief   Overloaded operator to compare two time objects
        /// @return  True/false corresponding to greater than calculation
        bool operator>=(const Time& B) const;
 
        /// @brief   Overloaded operator to compare two time objects
        /// @return  True/false corresponding to greater than calculation
        bool operator<=(const Time& B) const;
 
        /// @brief   Overloaded operator to compare two time objects
        /// @return  True/false corresponding to greater than calculation
        bool operator>(const Time& B) const;
 
        /// @brief   Overloaded operator to compare two time objects
        /// @return  True/false corresponding to greater than calculation
        bool operator<(const Time& B) const;
 
        /// @brief   Overloaded operator to compare two time objects
        /// @return  True/false corresponding to equals calculation
        bool operator==(const Time& B) const;
    protected:
        struct timespec _tspec;
    };
 
}
 
#endif