SatelliteIdentifier.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 <cstdint>
#include <string>
#include <vector>
#include <nlohmann/json.hpp>
using json = nlohmann::json; 
#include <fmt/format.h>
 
#include "SatelliteSystem.hpp"
#include "Frequency.hpp"
#include "Code.hpp"
 
#include "util/Container/STL.hpp"
 
namespace NAV
{

struct SatId
{
    SatId(SatelliteSystem satSys, uint16_t satNum)
        : satSys(satSys), satNum(satNum) {}

    SatId() = default;
 
    SatelliteSystem satSys = SatSys_None; 
    uint16_t satNum = 0;                  

    constexpr bool operator==(const SatId& rhs) const { return satSys == rhs.satSys && satNum == rhs.satNum; }

    constexpr bool operator<(const SatId& rhs) const
    {
        return satSys == rhs.satSys ? satNum < rhs.satNum
                                    : satSys < rhs.satSys;
    }

    [[nodiscard]] bool isGeo() const;
};

struct SatSigId
{
    SatSigId(Code code, uint16_t satNum)
        : code(code), satNum(satNum) {}

    SatSigId() = default;
 
    Code code = Code::None; 
    uint16_t satNum = 0;    

    bool operator==(const SatSigId& rhs) const { return code == rhs.code && satNum == rhs.satNum; }

    bool operator<(const SatSigId& rhs) const
    {
        if (toSatId().satSys == rhs.toSatId().satSys)
        {
            if (satNum == rhs.satNum)
            {
                return Code::Set(code) < Code::Set(rhs.code);
            }
            return satNum < rhs.satNum;
        }
        return toSatId().satSys < rhs.toSatId().satSys;
    }

    [[nodiscard]] SatId toSatId() const
    {
        return { code.getFrequency().getSatSys(), satNum };
    }

    [[nodiscard]] Frequency freq() const
    {
        return code.getFrequency();
    }
};

bool lessCompareSatSigId(const std::string& lhs, const std::string& rhs);

void to_json(json& j, const SatId& data);
void from_json(const json& j, SatId& data);

void to_json(json& j, const SatSigId& data);
void from_json(const json& j, SatSigId& data);

bool ShowSatelliteSelector(const char* label, std::vector<SatId>& satellites, SatelliteSystem filterSys = SatSys_All, bool displayOnlyNumber = false);

bool ShowSatelliteSelector(const char* label, SatId& satellite, SatelliteSystem filterSys = SatSys_All, bool displayOnlyNumber = false);
 
} // namespace NAV

std::ostream& operator<<(std::ostream& os, const NAV::SatId& obj);

std::ostream& operator<<(std::ostream& os, const NAV::SatSigId& obj);
 
#ifndef DOXYGEN_IGNORE

template<>
struct fmt::formatter<NAV::SatId>
{
    static constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin())
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const NAV::SatId& satId, FormatContext& ctx) const -> decltype(ctx.out())
    {
        return fmt::format_to(ctx.out(), "{0}{1:02d}", char(satId.satSys), satId.satNum);
    }
};

template<>
struct fmt::formatter<NAV::SatSigId>
{
    static constexpr auto parse(format_parse_context& ctx) -> decltype(ctx.begin())
    {
        return ctx.begin();
    }

    template<typename FormatContext>
    auto format(const NAV::SatSigId& satSigId, FormatContext& ctx) const
    {
        return fmt::format_to(ctx.out(), "{0}-{1:02d}", satSigId.code, satSigId.satNum);
    }
};
 
#endif
 
namespace std
{
template<>
struct hash<NAV::SatId>
{
    std::size_t operator()(const NAV::SatId& f) const
    {
        auto hash1 = std::hash<NAV::SatelliteSystem_>{}(NAV::SatelliteSystem_(f.satSys));
        auto hash2 = static_cast<size_t>(f.satNum);
 
        return hash1 | (hash2 << 10);
    }
};

template<>
struct hash<NAV::SatSigId>
{
    std::size_t operator()(const NAV::SatSigId& f) const
    {
        auto hash1 = static_cast<size_t>(f.code.getEnumValue());
        auto hash2 = static_cast<size_t>(f.satNum);
 
        return hash1 | (hash2 << 8);
    }
};
} // namespace std