TimeSystem.hpp

Go to the documentation of this file.

// This file is part of INSTINCT, the INS Toolkit for Integrated
// Navigation Concepts and Training by the Institute of Navigation of
// the University of Stuttgart, Germany.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <string>
#include <fmt/format.h>
 
#include <nlohmann/json.hpp>
using json = nlohmann::json; 
 
namespace NAV
{
enum TimeSystem_
{
    TimeSys_None = 0x00, 
    UTC = 0x01,          
    GPST = 0x02,         
    GLNT = 0x04,         
    GST = 0x08,          
    BDT = 0x10,          
    QZSST = 0x20,        
    IRNSST = 0x40,       
};
 
class TimeSystem
{
  public:
    constexpr TimeSystem() = default;
 
    constexpr TimeSystem(TimeSystem_ type) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
        : value(type)
    {}
 
    static TimeSystem fromString(const std::string& typeString)
    {
        if (typeString == "UTC")
        {
            return UTC;
        }
        if (typeString == "GPST" || typeString == "GPS")
        {
            return GPST;
        }
        if (typeString == "GLNT" || typeString == "GLO")
        {
            return GLNT;
        }
        if (typeString == "GST" || typeString == "GAL")
        {
            return GST;
        }
        if (typeString == "BDT")
        {
            return BDT;
        }
        if (typeString == "QZSST" || typeString == "QZS")
        {
            return QZSST;
        }
        if (typeString == "IRNSST" || typeString == "IRN")
        {
            return IRNSST;
        }
 
        return TimeSys_None;
    }
 
    constexpr TimeSystem& operator=(TimeSystem_ v)
    {
        value = v;
        return *this;
    }
 
    friend constexpr bool operator==(const TimeSystem& lhs, const TimeSystem& rhs);
 
    constexpr explicit operator TimeSystem_() const { return value; }
    constexpr explicit operator bool() = delete;
 
    constexpr explicit operator int() const { return int(value); }
 
    explicit operator std::string() const { return toString(); }
 
    [[nodiscard]] constexpr const char* toString() const
    {
        switch (value)
        {
        case UTC:
            return "UTC";
        case GPST:
            return "GPST";
        case GLNT:
            return "GLNT";
        case GST:
            return "GST";
        case BDT:
            return "BDT";
        case QZSST:
            return "QZSST";
        case IRNSST:
            return "IRNSST";
        case TimeSys_None:
            return "None";
        }
 
        return "None";
    }
 
    enum class TimeSystemEnum
    {
        TimeSys_None, 
        UTC,          
        GPST,         
        GLNT,         
        GST,          
        BDT,          
        QZSST,        
        IRNSST,       
        COUNT,        
    };
 
    static TimeSystemEnum GetTimeSystemEnumValue(TimeSystem timeSystem);
 
    [[nodiscard]] TimeSystemEnum getEnumValue() const;
 
    constexpr TimeSystem(TimeSystemEnum timeSystem) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
    {
        switch (timeSystem)
        {
        case TimeSystemEnum::UTC:
            value = UTC;
            break;
        case TimeSystemEnum::GPST:
            value = GPST;
            break;
        case TimeSystemEnum::GLNT:
            value = GLNT;
            break;
        case TimeSystemEnum::GST:
            value = GST;
            break;
        case TimeSystemEnum::BDT:
            value = BDT;
            break;
        case TimeSystemEnum::QZSST:
            value = QZSST;
            break;
        case TimeSystemEnum::IRNSST:
            value = IRNSST;
            break;
        default:
            value = TimeSys_None;
            break;
        }
    }
 
  private:
    TimeSystem_ value = TimeSystem_::TimeSys_None;
};
 
bool ComboTimeSystem(const char* label, TimeSystem& timeSystem);
 
const char* to_string(TimeSystem::TimeSystemEnum timeSystem);
 
constexpr TimeSystem_ operator|(TimeSystem_ lhs, TimeSystem_ rhs)
{
    return TimeSystem_(int(lhs) | int(rhs));
}
constexpr TimeSystem operator|(TimeSystem lhs, TimeSystem rhs)
{
    return { TimeSystem_(lhs) | TimeSystem_(rhs) };
}
constexpr TimeSystem operator|(TimeSystem_ lhs, TimeSystem rhs)
{
    return { lhs | TimeSystem_(rhs) };
}
constexpr TimeSystem operator|(TimeSystem lhs, TimeSystem_ rhs)
{
    return { TimeSystem_(lhs) | rhs };
}
 
constexpr TimeSystem_& operator|=(TimeSystem_& lhs, const TimeSystem_& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
constexpr TimeSystem& operator|=(TimeSystem& lhs, const TimeSystem& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
constexpr TimeSystem_& operator|=(TimeSystem_& lhs, const TimeSystem& rhs)
{
    lhs = lhs | TimeSystem_(rhs);
    return lhs;
}
constexpr TimeSystem& operator|=(TimeSystem& lhs, const TimeSystem_& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
 
constexpr TimeSystem_ operator&(TimeSystem_ lhs, TimeSystem_ rhs)
{
    return TimeSystem_(int(lhs) & int(rhs));
}
constexpr TimeSystem operator&(TimeSystem lhs, TimeSystem rhs)
{
    return { TimeSystem_(lhs) & TimeSystem_(rhs) };
}
constexpr TimeSystem operator&(TimeSystem lhs, TimeSystem_ rhs)
{
    return { TimeSystem_(lhs) & rhs };
}
constexpr TimeSystem operator&(TimeSystem_ lhs, TimeSystem rhs)
{
    return { lhs & TimeSystem_(rhs) };
}
 
constexpr TimeSystem_& operator&=(TimeSystem_& lhs, const TimeSystem_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
constexpr TimeSystem& operator&=(TimeSystem& lhs, const TimeSystem& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
constexpr TimeSystem_& operator&=(TimeSystem_& lhs, const TimeSystem& rhs)
{
    lhs = lhs & TimeSystem_(rhs);
    return lhs;
}
constexpr TimeSystem& operator&=(TimeSystem& lhs, const TimeSystem_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr TimeSystem operator~(TimeSystem_ rhs)
{
    return { TimeSystem_(~int(rhs)) };
}
constexpr TimeSystem operator~(TimeSystem rhs)
{
    return { TimeSystem_(~int(rhs)) };
}
 
constexpr bool operator==(const TimeSystem& lhs, const TimeSystem& rhs) { return lhs.value == rhs.value; }
constexpr bool operator==(const TimeSystem& lhs, const TimeSystem_& rhs) { return lhs == TimeSystem(rhs); }
constexpr bool operator==(const TimeSystem_& lhs, const TimeSystem& rhs) { return TimeSystem(lhs) == rhs; }
 
constexpr bool operator!=(const TimeSystem& lhs, const TimeSystem& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const TimeSystem& lhs, const TimeSystem_& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const TimeSystem_& lhs, const TimeSystem& rhs) { return !(lhs == rhs); }
 
void to_json(json& j, const TimeSystem& timeSystem);
void from_json(const json& j, TimeSystem& timeSystem);
 
} // namespace NAV
 
namespace std
{
template<>
struct hash<NAV::TimeSystem>
{
    std::size_t operator()(const NAV::TimeSystem& f) const
    {
        return std::hash<NAV::TimeSystem_>{}(NAV::TimeSystem_(f));
    }
};
} // namespace std
 
#ifndef DOXYGEN_IGNORE
 
template<>
struct fmt::formatter<NAV::TimeSystem> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::TimeSystem& timeSys, FormatContext& ctx)
    {
        return fmt::formatter<std::string>::format(std::string(timeSys), ctx);
    }
};
 
#endif
 
std::ostream& operator<<(std::ostream& os, const NAV::TimeSystem& obj);