SatelliteSystem.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 <vector>
#include <fmt/format.h>
 
#include <nlohmann/json.hpp>
using json = nlohmann::json; 
 
#include "Navigation/Time/TimeSystem.hpp"
 
namespace NAV
{
 
enum SatelliteSystem_ : uint64_t
{ // clang-format off
    SatSys_None = 0x0000'0000'0000'0000, 
    GPS         = 0x0000'0000'0000'00FF, 
    GAL         = 0x0000'0000'0000'FF00, 
    GLO         = 0x0000'0000'00FF'0000, 
    BDS         = 0x0000'0000'FF00'0000, 
    QZSS        = 0x0000'00FF'0000'0000, 
    IRNSS       = 0x0000'FF00'0000'0000, 
    SBAS        = 0x00FF'0000'0000'0000, 
}; // clang-format on
 
struct SatelliteSystem
{
    enum Enum : size_t
    {
        Enum_GPS,   
        Enum_GAL,   
        Enum_GLO,   
        Enum_BDS,   
        Enum_QZSS,  
        Enum_IRNSS, 
        Enum_SBAS,  
        Enum_COUNT, 
        Enum_None,  
    };
 
    constexpr SatelliteSystem() = default;
 
    constexpr SatelliteSystem(SatelliteSystem_ type) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
        : value(type)
    {}
 
    SatelliteSystem(Enum enumeration) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
        : value(SatelliteSystem::fromEnum(enumeration))
    {}
 
    static SatelliteSystem fromString(const std::string& typeString);
 
    static SatelliteSystem fromChar(char typeChar);
 
    static SatelliteSystem fromEnum(Enum enumeration);
 
    constexpr SatelliteSystem& operator=(SatelliteSystem_ v)
    {
        value = v;
        return *this;
    }
 
    friend constexpr bool operator==(const SatelliteSystem& lhs, const SatelliteSystem& rhs);
 
    constexpr bool operator<(const SatelliteSystem& rhs) const { return value < rhs.value; }
 
    constexpr explicit operator SatelliteSystem_() const { return value; }
    constexpr explicit operator bool() = delete;
 
    constexpr explicit operator uint64_t() const { return uint64_t(value); }
 
    explicit operator std::string() const;
 
    explicit operator char() const;
 
    static TimeSystem GetTimeSystemForSatelliteSystem(SatelliteSystem satSys);
 
    [[nodiscard]] TimeSystem getTimeSystem() const;
 
    static std::vector<uint16_t> GetSatellitesForSatelliteSystem(SatelliteSystem satSys);
 
    [[nodiscard]] std::vector<uint16_t> getSatellites() const;
 
    static Enum ToEnumeration(SatelliteSystem satSys);
 
    [[nodiscard]] Enum toEnumeration() const;
 
    static char ToChar(SatelliteSystem satSys);
 
    [[nodiscard]] char toChar() const;
 
    static std::vector<SatelliteSystem> ToVector(SatelliteSystem satSys);
 
    [[nodiscard]] std::vector<SatelliteSystem> toVector() const;
 
    static std::vector<SatelliteSystem> GetAll();
 
  private:
    SatelliteSystem_ value = SatelliteSystem_::SatSys_None;
};
 
// #########################################################################################################################################
 
void to_json(json& j, const SatelliteSystem& data);
void from_json(const json& j, SatelliteSystem& data);
 
// #########################################################################################################################################
 
constexpr SatelliteSystem_ operator|(SatelliteSystem_ lhs, SatelliteSystem_ rhs)
{
    return SatelliteSystem_(uint64_t(lhs) | uint64_t(rhs));
}
constexpr SatelliteSystem_ operator|(SatelliteSystem lhs, SatelliteSystem rhs)
{
    return SatelliteSystem_(lhs) | SatelliteSystem_(rhs);
}
constexpr SatelliteSystem_ operator|(SatelliteSystem_ lhs, SatelliteSystem rhs)
{
    return lhs | SatelliteSystem_(rhs);
}
constexpr SatelliteSystem_ operator|(SatelliteSystem lhs, SatelliteSystem_ rhs)
{
    return SatelliteSystem_(lhs) | rhs;
}
 
constexpr SatelliteSystem_& operator|=(SatelliteSystem_& lhs, const SatelliteSystem_& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
constexpr SatelliteSystem& operator|=(SatelliteSystem& lhs, const SatelliteSystem& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
constexpr SatelliteSystem_& operator|=(SatelliteSystem_& lhs, const SatelliteSystem& rhs)
{
    lhs = lhs | SatelliteSystem_(rhs);
    return lhs;
}
constexpr SatelliteSystem& operator|=(SatelliteSystem& lhs, const SatelliteSystem_& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
 
constexpr SatelliteSystem_ operator&(SatelliteSystem_ lhs, SatelliteSystem_ rhs)
{
    return SatelliteSystem_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr SatelliteSystem operator&(SatelliteSystem lhs, SatelliteSystem rhs)
{
    return SatelliteSystem_(lhs) & SatelliteSystem_(rhs);
}
constexpr SatelliteSystem_ operator&(SatelliteSystem lhs, SatelliteSystem_ rhs)
{
    return SatelliteSystem_(lhs) & rhs;
}
constexpr SatelliteSystem_ operator&(SatelliteSystem_ lhs, SatelliteSystem rhs)
{
    return lhs & SatelliteSystem_(rhs);
}
 
constexpr SatelliteSystem_& operator&=(SatelliteSystem_& lhs, const SatelliteSystem_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
constexpr SatelliteSystem& operator&=(SatelliteSystem& lhs, const SatelliteSystem& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
constexpr SatelliteSystem_& operator&=(SatelliteSystem_& lhs, const SatelliteSystem& rhs)
{
    lhs = lhs & SatelliteSystem_(rhs);
    return lhs;
}
constexpr SatelliteSystem& operator&=(SatelliteSystem& lhs, const SatelliteSystem_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr SatelliteSystem_ operator~(SatelliteSystem_ rhs)
{
    return SatelliteSystem_(~uint64_t(rhs));
}
constexpr SatelliteSystem_ operator~(SatelliteSystem rhs)
{
    return SatelliteSystem_(~uint64_t(rhs));
}
 
// #########################################################################################################################################
 
constexpr bool operator==(const SatelliteSystem& lhs, const SatelliteSystem& rhs) { return lhs.value == rhs.value; }
constexpr bool operator==(const SatelliteSystem& lhs, const SatelliteSystem_& rhs) { return lhs == SatelliteSystem(rhs); }
constexpr bool operator==(const SatelliteSystem_& lhs, const SatelliteSystem& rhs) { return SatelliteSystem(lhs) == rhs; }
 
constexpr bool operator!=(const SatelliteSystem& lhs, const SatelliteSystem& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const SatelliteSystem& lhs, const SatelliteSystem_& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const SatelliteSystem_& lhs, const SatelliteSystem& rhs) { return !(lhs == rhs); }
 
std::ostream& operator<<(std::ostream& os, const SatelliteSystem& satSys);
 
constexpr SatelliteSystem_ SatSys_All = GPS | GAL | GLO | BDS | QZSS | IRNSS | SBAS;
 
} // namespace NAV
 
namespace std
{
template<>
struct hash<NAV::SatelliteSystem_>
{
    std::size_t operator()(const NAV::SatelliteSystem_& satSys) const
    {
        using namespace NAV; // NOLINT(google-build-using-namespace)
        switch (satSys)
        {
        case SatSys_None:
            return 1;
        case GPS:
            return 100;
        case GAL:
            return 200;
        case GLO:
            return 300;
        case BDS:
            return 400;
        case QZSS:
            return 500;
        case IRNSS:
            return 600;
        case SBAS:
            return 700;
        }
        return 0;
    }
};
template<>
struct hash<NAV::SatelliteSystem>
{
    std::size_t operator()(const NAV::SatelliteSystem& satSys) const
    {
        return std::hash<NAV::SatelliteSystem_>()(NAV::SatelliteSystem_(satSys));
    }
};
} // namespace std
 
#ifndef DOXYGEN_IGNORE
 
template<>
struct fmt::formatter<NAV::SatelliteSystem> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::SatelliteSystem& satSys, FormatContext& ctx)
    {
        return fmt::formatter<std::string>::format(std::string(satSys), ctx);
    }
};
 
#endif