Code.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 <bitset>
#include <fmt/format.h>
 
#include "Navigation/GNSS/Core/SatelliteSystem.hpp"
#include "Navigation/GNSS/Core/Frequency.hpp"
 
namespace NAV
{
 
class Code
{
  public:
    enum Enum
    {
        None, 
 
        G1C, 
        G1S, 
        G1L, 
        G1X, 
        G1P, 
        G1W, 
        G1Y, 
        G1M, 
        G1N, 
        G2C, 
        G2D, 
        G2S, 
        G2L, 
        G2X, 
        G2P, 
        G2W, 
        G2Y, 
        G2M, 
        G2N, 
        G5I, 
        G5Q, 
        G5X, 
 
        E1A, 
        E1B, 
        E1C, 
        E1X, 
        E1Z, 
        E5I, 
        E5Q, 
        E5X, 
        E6A, 
        E6B, 
        E6C, 
        E6X, 
        E6Z, 
        E7I, 
        E7Q, 
        E7X, 
        E8I, 
        E8Q, 
        E8X, 
 
        R1C, 
        R1P, 
        R2C, 
        R2P, 
        R3I, 
        R3Q, 
        R3X, 
        R4A, 
        R4B, 
        R4X, 
        R6A, 
        R6B, 
        R6X, 
 
        B1D, 
        B1P, 
        B1X, 
        B2I, 
        B2Q, 
        B2X, 
        B5D, 
        B5P, 
        B5X, 
        B6I, 
        B6Q, 
        B6X, 
        B6A, 
        B7I, 
        B7Q, 
        B7X, 
        B7D, 
        B7P, 
        B7Z, 
        B8D, 
        B8P, 
        B8X, 
 
        J1C, 
        J1S, 
        J1L, 
        J1X, 
        J1Z, 
        J2S, 
        J2L, 
        J2X, 
        J5I, 
        J5Q, 
        J5X, 
        J5D, 
        J5P, 
        J5Z, 
        J6S, 
        J6L, 
        J6X, 
        J6E, 
        J6Z, 
 
        I5A, 
        I5B, 
        I5C, 
        I5X, 
        I9A, 
        I9B, 
        I9C, 
        I9X, 
 
        S1C, 
        S5I, 
        S5Q, 
        S5X, 
    };
    enum
    {
        _GPS_START = G1C,   
        _GPS_END = G5X,     
        _GAL_START = E1A,   
        _GAL_END = E8X,     
        _GLO_START = R1C,   
        _GLO_END = R6X,     
        _BDS_START = B1D,   
        _BDS_END = B8X,     
        _QZSS_START = J1C,  
        _QZSS_END = J6Z,    
        _IRNSS_START = I5A, 
        _IRNSS_END = I9X,   
        _SBAS_START = S1C,  
        _SBAS_END = S5X,    
 
        _G01_START = G1C, 
        _G01_END = G1N,   
        _G02_START = G2C, 
        _G02_END = G2N,   
        _G05_START = G5I, 
        _G05_END = G5X,   
 
        _E01_START = E1A, 
        _E01_END = E1Z,   
        _E05_START = E5I, 
        _E05_END = E5X,   
        _E06_START = E6B, 
        _E06_END = E6X,   
        _E07_START = E7I, 
        _E07_END = E7X,   
        _E08_START = E8I, 
        _E08_END = E8X,   
 
        _R01_START = R1C, 
        _R01_END = R1P,   
        _R02_START = R2C, 
        _R02_END = R2P,   
        _R03_START = R3I, 
        _R03_END = R3X,   
        _R04_START = R4A, 
        _R04_END = R4X,   
        _R06_START = R6A, 
        _R06_END = R6X,   
 
        _B01_START = B1D, 
        _B01_END = B1X,   
        _B02_START = B2I, 
        _B02_END = B2X,   
        _B05_START = B5D, 
        _B05_END = B5X,   
        _B06_START = B6I, 
        _B06_END = B6A,   
        _B07_START = B7I, 
        _B07_END = B7Z,   
        _B08_START = B8D, 
        _B08_END = B8X,   
 
        _J01_START = J1C, 
        _J01_END = J1Z,   
        _J02_START = J2S, 
        _J02_END = J2X,   
        _J05_START = J5I, 
        _J05_END = J5Z,   
        _J06_START = J6S, 
        _J06_END = J6Z,   
 
        _I05_START = I5A, 
        _I05_END = I5X,   
        _I09_START = I9A, 
        _I09_END = I9X,   
 
        _S01_START = S1C, 
        _S01_END = S1C,   
        _S05_START = S5I, 
        _S05_END = S5X,   
 
        COUNT = S5X + 1 
    };
 
    using Set = std::bitset<COUNT>;
 
    constexpr Code() = default;
 
    constexpr explicit Code(const Set& set) : value(set) {}
 
    explicit Code(SatelliteSystem_ sys);
 
    explicit Code(Frequency_ freq);
 
    Code(Enum e) { value.set(e, true); } // NOLINT(hicpp-explicit-conversions, google-explicit-constructor)
 
    explicit operator bool() const { return value.any(); }
 
    constexpr explicit operator Set() const { return value; }
 
    explicit operator std::string() const;
 
    static Code fromFreqAttr(Frequency freq, char attribute);
 
    static const char* GetCodeDescription(Code code);
 
    [[nodiscard]] const char* getDescription() const;
 
    static Frequency GetCodeFequency(Code code);
 
    [[nodiscard]] Frequency getFrequency() const;
 
    static bool IsCodeCombined(Code first, Code second);
 
    static std::vector<Code> GetAll();
 
    static Enum GetCodeEnumValue(Code code);
 
    [[nodiscard]] Enum getEnumValue() const;
 
    // #####################################################################################################################################
 
    friend Code operator|(const Code& lhs, const Code& rhs);
    friend Code operator|(const Code& lhs, const Enum& rhs);
    friend Code operator|(const Enum& lhs, const Code& rhs);
 
    Code& operator|=(const Code& rhs);
    Code& operator|=(const Enum& rhs);
 
    friend Code operator&(const Code& lhs, const Code& rhs);
    friend Code operator&(const Code& lhs, const Enum& rhs);
    friend Code operator&(const Enum& lhs, const Code& rhs);
 
    Code& operator&=(const Code& rhs);
    Code& operator&=(const Enum& rhs);
 
    Code operator~() const;
 
    // #####################################################################################################################################
 
    friend bool operator==(const Code& lhs, const Code& rhs);
 
    friend bool operator==(const Code& lhs, const Enum& rhs);
 
    friend bool operator==(const Enum& lhs, const Code& rhs);
 
    friend bool operator!=(const Code& lhs, const Code& rhs);
    friend bool operator!=(const Code& lhs, const Enum& rhs);
    friend bool operator!=(const Enum& lhs, const Code& rhs);
 
    friend bool operator<(const Code& lhs, const Code& rhs);
 
    friend bool operator<(const Code& lhs, const Enum& rhs);
 
    friend bool operator<(const Enum& lhs, const Code& rhs);
 
    // #####################################################################################################################################
 
    friend Code operator&(Code lhs, SatelliteSystem_ rhs);
    friend Code operator&(SatelliteSystem_ lhs, Code rhs);
    Code& operator&=(const SatelliteSystem_& rhs);
    friend Code operator&(Code lhs, SatelliteSystem rhs);
    friend Code operator&(SatelliteSystem lhs, Code rhs);
    Code& operator&=(const SatelliteSystem& rhs);
 
    friend Code operator|(Code lhs, SatelliteSystem_ rhs);
    friend Code operator|(SatelliteSystem_ lhs, Code rhs);
    Code& operator|=(const SatelliteSystem_& rhs);
    friend Code operator|(Code lhs, SatelliteSystem rhs);
    friend Code operator|(SatelliteSystem lhs, Code rhs);
    Code& operator|=(const SatelliteSystem& rhs);
 
    // #####################################################################################################################################
 
    friend Code operator&(Code lhs, Frequency_ rhs);
    friend Code operator&(Frequency_ lhs, Code rhs);
    Code& operator&=(const Frequency_& rhs);
    friend Code operator&(Code lhs, Frequency rhs);
    friend Code operator&(Frequency lhs, Code rhs);
    Code& operator&=(const Frequency& rhs);
 
    friend Code operator|(Code lhs, Frequency_ rhs);
    friend Code operator|(Frequency_ lhs, Code rhs);
    Code& operator|=(const Frequency_& rhs);
    friend Code operator|(Code lhs, Frequency rhs);
    friend Code operator|(Frequency lhs, Code rhs);
    Code& operator|=(const Frequency& rhs);
 
    // #####################################################################################################################################
 
  private:
    Set value{};
};
 
// #########################################################################################################################################
 
void to_json(json& j, const Code& data);
void from_json(const json& j, Code& data);
 
// #########################################################################################################################################
 
Code operator|(const Code::Enum& lhs, const Code::Enum& rhs);
Code operator&(const Code::Enum& lhs, const Code::Enum& rhs);
 
const Code Code_G1S_G1L_G1X = Code::G1S | Code::G1L | Code::G1X; 
const Code Code_G2S_G2L_G2X = Code::G2S | Code::G2L | Code::G2X; 
const Code Code_G5I_G5Q_G5X = Code::G5I | Code::G5Q | Code::G5X; 
 
const Code Code_E1B_E1C_E1X = Code::E1B | Code::E1C | Code::E1X; 
const Code Code_E5I_E5Q_E5X = Code::E5I | Code::E5Q | Code::E5X; 
const Code Code_E6B_E6C_E6X = Code::E6B | Code::E6C | Code::E6X; 
const Code Code_E7I_E7Q_E7X = Code::E7I | Code::E7Q | Code::E7X; 
const Code Code_E8I_E8Q_E8X = Code::E8I | Code::E8Q | Code::E8X; 
 
const Code Code_R3I_R3Q_R3X = Code::R3I | Code::R3Q | Code::R3X; 
const Code Code_R4A_R4B_R4X = Code::R4A | Code::R4B | Code::R4X; 
const Code Code_R6A_R6B_R6X = Code::R6A | Code::R6B | Code::R6X; 
 
const Code Code_B1D_B1P_B1X = Code::B1D | Code::B1P | Code::B1X; 
const Code Code_B2I_B2Q_B2X = Code::B2I | Code::B2Q | Code::B2X; 
const Code Code_B5D_B5P_B5X = Code::B5D | Code::B5P | Code::B5X; 
const Code Code_B6I_B6Q_B6X = Code::B6I | Code::B6Q | Code::B6X; 
const Code Code_B7I_B7Q_B7X = Code::B7I | Code::B7Q | Code::B7X; 
const Code Code_B7D_B7P_B7Z = Code::B7D | Code::B7P | Code::B7Z; 
const Code Code_B8D_B8P_B8X = Code::B8D | Code::B8P | Code::B8X; 
 
const Code Code_J1S_J1L_J1X = Code::J1S | Code::J1L | Code::J1X; 
const Code Code_J2S_J2L_J2X = Code::J2S | Code::J2L | Code::J2X; 
const Code Code_J5I_J5Q_J5X = Code::J5I | Code::J5Q | Code::J5X; 
const Code Code_J5D_J5P_J5Z = Code::J5D | Code::J5P | Code::J5Z; 
const Code Code_J6S_J6L_J6X = Code::J6S | Code::J6L | Code::J6X; 
 
const Code Code_I5B_I5C_I5X = Code::I5B | Code::I5C | Code::I5X; 
const Code Code_I9B_I9C_I9X = Code::I9B | Code::I9C | Code::I9X; 
 
const Code Code_S5I_S5Q_S5X = Code::S5I | Code::S5Q | Code::S5X; 
 
const Code Code_ALL = Code(Code::Set().set()); 
const Code Code_Default = Code(Code::Set().set())
                          & ~Code(Code::G1Y)  // GPS L1 - Y-code (with decryption)
                          & ~Code(Code::G1M)  // GPS L1 - M-code
                          & ~Code(Code::G2Y)  // GPS L2 - Y-code (with decryption)
                          & ~Code(Code::G2M); // GPS L2 - M-code
 
bool ShowCodeSelector(const char* label, Code& code, const Frequency& filterFreq, bool singleSelect = false);
 
} // namespace NAV
 
std::ostream& operator<<(std::ostream& os, const NAV::Code& obj);
 
namespace std
{
 
template<>
struct hash<NAV::Code>
{
    std::size_t operator()(const NAV::Code& c) const
    {
        return static_cast<size_t>(c.getEnumValue());
    }
};
} // namespace std
 
#ifndef DOXYGEN_IGNORE
 
template<>
struct fmt::formatter<NAV::Code> : fmt::formatter<std::string>
{
    template<typename FormatContext>
    auto format(const NAV::Code& code, FormatContext& ctx)
    {
        return fmt::formatter<std::string>::format(std::string(code), ctx);
    }
};
 
#endif