time.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MIO_ABM_TIME_H
#define MIO_ABM_TIME_H
 
#include "memilio/config.h"
#include "memilio/io/default_serialize.h"
 
namespace mio
{
namespace abm
{
 
class TimeSpan
{
public:
    TimeSpan() = default;
 
    explicit TimeSpan(int seconds)
        : m_seconds(seconds)
    {
    }
 
    ScalarType days() const
    {
        return ScalarType(m_seconds) / (24 * 60 * 60);
    }
 
    ScalarType hours() const
    {
        return ScalarType(m_seconds) / (60 * 60);
    };
 
    int seconds() const
    {
        return m_seconds;
    }
 
    bool operator==(const TimeSpan& other) const
    {
        return m_seconds == other.m_seconds;
    }
    bool operator!=(const TimeSpan& other) const
    {
        return !(*this == other);
    }
    bool operator<(const TimeSpan& other) const
    {
        return m_seconds < other.m_seconds;
    }
    bool operator<=(const TimeSpan& other) const
    {
        return m_seconds <= other.m_seconds;
    }
    bool operator>(const TimeSpan& other) const
    {
        return m_seconds > other.m_seconds;
    }
    bool operator>=(const TimeSpan& other) const
    {
        return m_seconds >= other.m_seconds;
    }
    TimeSpan operator+(const TimeSpan& s) const
    {
        return TimeSpan{m_seconds + s.m_seconds};
    }
    TimeSpan& operator+=(const TimeSpan& s)
    {
        m_seconds += s.m_seconds;
        return *this;
    }
    TimeSpan operator-(const TimeSpan& s) const
    {
        return TimeSpan{m_seconds - s.m_seconds};
    }
    TimeSpan& operator-=(const TimeSpan& s)
    {
        m_seconds -= s.m_seconds;
        return *this;
    }
 
    TimeSpan operator*(int f) const
    {
        return TimeSpan{m_seconds * f};
    }
 
    TimeSpan multiply(double f) const
    {
        return TimeSpan{int(m_seconds * f)};
    }
 
    TimeSpan& operator*=(int f)
    {
        m_seconds *= f;
        return *this;
    }
    TimeSpan operator/(int f) const
    {
        return TimeSpan{m_seconds / f};
    }
    TimeSpan& operator/=(int f)
    {
        m_seconds /= f;
        return *this;
    }
    auto default_serialize()
    {
        return Members("TimeSpan").add("seconds", m_seconds);
    }
 
private:
    int m_seconds; 
};
 
class TimePoint
{
public:
    TimePoint() = default;
    explicit TimePoint(int seconds)
        : m_seconds(seconds)
    {
    }
 
    ScalarType days() const
    {
        return ScalarType(m_seconds) / (24 * 60 * 60);
    }
    ScalarType hours() const
    {
        return ScalarType(m_seconds) / (60 * 60);
    };
    int seconds() const
    {
        return m_seconds;
    }
 
    int day_of_week() const
    {
        return int(days()) % 7;
    }
 
    bool is_weekend() const
    {
        return (day_of_week() > 4) ? true : false;
    }
 
    int hour_of_day() const
    {
        return int(hours()) % 24;
    }
 
    TimeSpan time_since_midnight() const
    {
        return TimeSpan(seconds() - ((int)days()) * 60 * 60 * 24);
    }
 
    bool operator==(const TimePoint& other) const
    {
        return m_seconds == other.m_seconds;
    }
    bool operator!=(const TimePoint& other) const
    {
        return !(*this == other);
    }
    bool operator<(const TimePoint& other) const
    {
        return m_seconds < other.m_seconds;
    }
    bool operator<=(const TimePoint& other) const
    {
        return m_seconds <= other.m_seconds;
    }
    bool operator>(const TimePoint& other) const
    {
        return m_seconds > other.m_seconds;
    }
    bool operator>=(const TimePoint& other) const
    {
        return m_seconds >= other.m_seconds;
    }
    TimePoint operator+(const TimeSpan& s) const
    {
        return TimePoint{m_seconds + s.seconds()};
    }
    TimePoint& operator+=(const TimeSpan& s)
    {
        m_seconds += s.seconds();
        return *this;
    }
    TimePoint operator-(const TimeSpan& s) const
    {
        return TimePoint{m_seconds - s.seconds()};
    }
    TimePoint& operator-=(const TimeSpan& s)
    {
        m_seconds -= s.seconds();
        return *this;
    }
    TimeSpan operator-(const TimePoint& p2) const
    {
        return TimeSpan{m_seconds - p2.seconds()};
    }
 
    auto default_serialize()
    {
        return Members("TimePoint").add("seconds", m_seconds);
    }
 
private:
    int m_seconds; 
};
 
inline TimeSpan seconds(int seconds)
{
    return TimeSpan(seconds);
}
 
inline TimeSpan minutes(int minutes)
{
    return TimeSpan(minutes * 60);
}
 
inline TimeSpan hours(int hours)
{
    return TimeSpan(hours * 60 * 60);
}
 
inline TimeSpan days(int days)
{
    return TimeSpan(days * 24 * 60 * 60);
}
 
inline TimeSpan days(ScalarType days)
{
    return TimeSpan((int)(days * 24 * 60 * 60));
}
 
} // namespace abm
} // namespace mio
 
#endif