Frequency.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 "Navigation/GNSS/Core/SatelliteSystem.hpp"
 
namespace NAV
{
 
enum Frequency_ : uint64_t
{ // clang-format off
    Freq_None = 0x0000'0000'0000'0000, 
    G01       = 0x0000'0000'0000'0001, 
    G02       = 0x0000'0000'0000'0002, 
    G05       = 0x0000'0000'0000'0004, 
    E01       = 0x0000'0000'0000'0100, 
    E05       = 0x0000'0000'0000'0200, 
    E06       = 0x0000'0000'0000'0400, 
    E07       = 0x0000'0000'0000'0800, 
    E08       = 0x0000'0000'0000'1000, 
    R01       = 0x0000'0000'0001'0000, 
    R02       = 0x0000'0000'0002'0000, 
    R03       = 0x0000'0000'0004'0000, 
    R04       = 0x0000'0000'0008'0000, 
    R06       = 0x0000'0000'0010'0000, 
    B01       = 0x0000'0000'0100'0000, 
    B02       = 0x0000'0000'0200'0000, 
    B05       = 0x0000'0000'0400'0000, 
    B06       = 0x0000'0000'0800'0000, 
    B07       = 0x0000'0000'1000'0000, 
    B08       = 0x0000'0000'2000'0000, 
    J01       = 0x0000'0001'0000'0000, 
    J02       = 0x0000'0002'0000'0000, 
    J05       = 0x0000'0004'0000'0000, 
    J06       = 0x0000'0008'0000'0000, 
    I05       = 0x0000'0100'0000'0000, 
    I09       = 0x0000'0200'0000'0000, 
    S01       = 0x0001'0000'0000'0000, 
    S05       = 0x0002'0000'0000'0000, 
}; // clang-format on
 
class Frequency
{
  public:
    enum Enum : uint8_t
    {
        Enum_G01,   
        Enum_G02,   
        Enum_G05,   
        Enum_E01,   
        Enum_E05,   
        Enum_E06,   
        Enum_E07,   
        Enum_E08,   
        Enum_R01,   
        Enum_R02,   
        Enum_R03,   
        Enum_R04,   
        Enum_R06,   
        Enum_B01,   
        Enum_B02,   
        Enum_B05,   
        Enum_B06,   
        Enum_B07,   
        Enum_B08,   
        Enum_J01,   
        Enum_J02,   
        Enum_J05,   
        Enum_J06,   
        Enum_I05,   
        Enum_I09,   
        Enum_S01,   
        Enum_S05,   
        Enum_COUNT, 
        Enum_None,  
    };
 
    constexpr Frequency() = default;
 
    constexpr Frequency(Frequency_ type) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
        : value(type)
    {}
 
    Frequency(Enum enumeration) // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
        : value(Frequency::fromEnum(enumeration))
    {}
 
    static Frequency fromString(const std::string& typeString);
 
    static Frequency fromEnum(Enum enumeration);
 
    constexpr Frequency& operator=(Frequency_ v)
    {
        value = v;
        return *this;
    }
 
    friend constexpr bool operator==(const Frequency& lhs, const Frequency& rhs);
 
    constexpr bool operator<(const Frequency& rhs) const { return value < rhs.value; }
 
    constexpr explicit operator Frequency_() const { return value; }
    constexpr explicit operator bool() = delete;
 
    constexpr explicit operator uint64_t() const { return uint64_t(value); }
 
    explicit operator std::string() const;
 
    static SatelliteSystem GetSatelliteSystemForFrequency(Frequency freq);
 
    [[nodiscard]] SatelliteSystem getSatSys() const
    {
        return GetSatelliteSystemForFrequency(value);
    }
 
    static double GetFrequency(Frequency freq, int8_t num);
 
    [[nodiscard]] double getFrequency(int8_t num) const
    {
        return GetFrequency(value, num);
    }
 
    static Frequency GetL1(Frequency freq);
 
    [[nodiscard]] Frequency getL1() const
    {
        return GetL1(value);
    }
 
    [[nodiscard]] size_t count() const;
 
    constexpr static std::array<Frequency, 27> GetAll()
    {
        return { G01, G02, G05,
                 E01, E05, E06, E07, E08,
                 R01, R02, R03, R04, R06,
                 B01, B02, B05, B06, B07, B08,
                 J01, J02, J05, J06,
                 I05, I09,
                 S01, S05 };
    }
 
    static Enum ToEnumeration(Frequency freq);
 
    [[nodiscard]] Enum toEnumeration() const;
 
    static std::vector<Frequency> ToVector(Frequency freq);
 
    [[nodiscard]] std::vector<Frequency> toVector() const;
 
    static bool IsFirstFrequency(const Frequency& freq, const Frequency& filter);
 
    [[nodiscard]] bool isFirstFrequency(const Frequency& filter) const;
 
  private:
    Frequency_ value = Frequency_::Freq_None;
};
 
// #########################################################################################################################################
 
void to_json(json& j, const Frequency& data);
void from_json(const json& j, Frequency& data);
 
// #########################################################################################################################################
 
constexpr Frequency_ operator|(Frequency_ lhs, Frequency_ rhs)
{
    return Frequency_(uint64_t(lhs) | uint64_t(rhs));
}
constexpr Frequency_ operator|(Frequency lhs, Frequency rhs)
{
    return Frequency_(lhs) | Frequency_(rhs);
}
constexpr Frequency_ operator|(Frequency_ lhs, Frequency rhs)
{
    return lhs | Frequency_(rhs);
}
constexpr Frequency_ operator|(Frequency lhs, Frequency_ rhs)
{
    return Frequency_(lhs) | rhs;
}
 
constexpr Frequency_& operator|=(Frequency_& lhs, const Frequency_& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
constexpr Frequency& operator|=(Frequency& lhs, const Frequency& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
constexpr Frequency_& operator|=(Frequency_& lhs, const Frequency& rhs)
{
    lhs = lhs | Frequency_(rhs);
    return lhs;
}
constexpr Frequency& operator|=(Frequency& lhs, const Frequency_& rhs)
{
    lhs = lhs | rhs;
    return lhs;
}
 
constexpr Frequency_ operator&(Frequency_ lhs, Frequency_ rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency_ operator&(Frequency lhs, Frequency rhs)
{
    return Frequency_(lhs) & Frequency_(rhs);
}
constexpr Frequency_ operator&(Frequency lhs, Frequency_ rhs)
{
    return Frequency_(lhs) & rhs;
}
constexpr Frequency_ operator&(Frequency_ lhs, Frequency rhs)
{
    return lhs & Frequency_(rhs);
}
 
constexpr Frequency_& operator&=(Frequency_& lhs, const Frequency_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
constexpr Frequency& operator&=(Frequency& lhs, const Frequency& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
constexpr Frequency_& operator&=(Frequency_& lhs, const Frequency& rhs)
{
    lhs = lhs & Frequency_(rhs);
    return lhs;
}
constexpr Frequency& operator&=(Frequency& lhs, const Frequency_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr Frequency_ operator~(Frequency_ rhs)
{
    return Frequency_(~uint64_t(rhs));
}
constexpr Frequency_ operator~(Frequency rhs)
{
    return Frequency_(~uint64_t(rhs));
}
 
constexpr bool operator==(const Frequency& lhs, const Frequency& rhs) { return lhs.value == rhs.value; }
constexpr bool operator==(const Frequency& lhs, const Frequency_& rhs) { return lhs == Frequency(rhs); }
constexpr bool operator==(const Frequency_& lhs, const Frequency& rhs) { return Frequency(lhs) == rhs; }
 
constexpr bool operator!=(const Frequency& lhs, const Frequency& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const Frequency& lhs, const Frequency_& rhs) { return !(lhs == rhs); }
constexpr bool operator!=(const Frequency_& lhs, const Frequency& rhs) { return !(lhs == rhs); }
 
// #########################################################################################################################################
 
constexpr Frequency_ operator&(Frequency_ lhs, SatelliteSystem_ rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency_ operator&(SatelliteSystem_ lhs, Frequency_ rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency_& operator&=(Frequency_& lhs, const SatelliteSystem_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr Frequency_ operator&(Frequency_ lhs, SatelliteSystem rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency_ operator&(SatelliteSystem lhs, Frequency_ rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency_& operator&=(Frequency_& lhs, const SatelliteSystem& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr Frequency_ operator&(Frequency lhs, SatelliteSystem_ rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency_ operator&(SatelliteSystem_ lhs, Frequency rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency& operator&=(Frequency& lhs, const SatelliteSystem_& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr Frequency_ operator&(Frequency lhs, SatelliteSystem rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency_ operator&(SatelliteSystem lhs, Frequency rhs)
{
    return Frequency_(uint64_t(lhs) & uint64_t(rhs));
}
constexpr Frequency& operator&=(Frequency& lhs, const SatelliteSystem& rhs)
{
    lhs = lhs & rhs;
    return lhs;
}
 
constexpr Frequency_ Freq_All = G01 | G02 | G05
                                | E01 | E05 | E06 | E07 | E08
                                | R01 | R02 | R03 | R04 | R06
                                | B01 | B02 | B05 | B06 | B07 | B08
                                | J01 | J02 | J05 | J06
                                | I05 | I09
                                | S01 | S05;
 
bool ShowFrequencySelector(const char* label, Frequency& frequency, bool singleSelect = false);
 
} // namespace NAV
 
std::ostream& operator<<(std::ostream& os, const NAV::Frequency& obj);
 
namespace std
{
template<>
struct hash<NAV::Frequency_>
{
    std::size_t operator()(const NAV::Frequency_& f) const
    {
        using namespace NAV; // NOLINT(google-build-using-namespace)
        switch (f)
        {
        case Freq_None:
            return 2;
        case G01:
            return 101;
        case G02:
            return 102;
        case G05:
            return 103;
        case E01:
            return 201;
        case E05:
            return 202;
        case E06:
            return 203;
        case E07:
            return 204;
        case E08:
            return 205;
        case R01:
            return 301;
        case R02:
            return 302;
        case R03:
            return 303;
        case R04:
            return 304;
        case R06:
            return 305;
        case B01:
            return 401;
        case B02:
            return 402;
        case B05:
            return 403;
        case B06:
            return 404;
        case B07:
            return 405;
        case B08:
            return 406;
        case J01:
            return 501;
        case J02:
            return 502;
        case J05:
            return 503;
        case J06:
            return 504;
        case I05:
            return 601;
        case I09:
            return 602;
        case S01:
            return 701;
        case S05:
            return 702;
        }
 
        return 0;
    }
};
template<>
struct hash<NAV::Frequency>
{
    std::size_t operator()(const NAV::Frequency& f) const
    {
        return std::hash<NAV::Frequency_>()(NAV::Frequency_(f));
    }
};
} // namespace std
 
#ifndef DOXYGEN_IGNORE
 
template<>
struct fmt::formatter<NAV::Frequency> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::Frequency& freq, FormatContext& ctx) const
    {
        return fmt::formatter<std::string>::format(std::string(freq), ctx);
    }
};
 
#endif