CveShaMap.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <algorithm>
#include <filesystem>
#include <set>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
#include "../helpers/String.h"
 
namespace SlCVEs {

class CveShaMap {
public:
    using CveShaMapTy = std::unordered_multimap<std::string, std::string,
          SlHelpers::String::Hash, SlHelpers::String::Eq>;
    using ShaCveMapTy = std::unordered_map<std::string, std::string,
          SlHelpers::String::Hash, SlHelpers::String::Eq>;

    enum struct ShaSize {
        Long,
        Short
    };
 
    CveShaMap() = delete;
 
    CveShaMap(const CveShaMap &) = delete;
    CveShaMap &operator=(const CveShaMap &) = delete;

    CveShaMap(CveShaMap &&) = default;
    CveShaMap &operator=(CveShaMap &&) = default;

    CveShaMap(const std::filesystem::path &vsource = {},
          ShaSize shaSize = ShaSize::Long,
          const std::string &branch = "origin/master",
          unsigned year = 0,
          bool rejected = false);

    std::string_view getCve(std::string_view shaCommit) const {
        const auto it = m_shaCveMap.find(shaCommit);
        if (it != m_shaCveMap.cend())
            return it->second;
 
        return {};
    }

    std::vector<std::string> getShas(std::string_view cveNumber) const { //requires (S == ShaSize::Long)
        std::vector<std::string> ret;
        const auto range = m_cveShaMap.equal_range(cveNumber);
        std::transform(range.first, range.second, std::back_inserter(ret),
                   [](const auto &p) { return p.second; });
        return ret;
    }

    std::set<std::string> getAllCves() const { //requires (S == ShaSize::Long)
        std::set<std::string> ret;
        std::transform(m_cveShaMap.cbegin(), m_cveShaMap.cend(),
                   std::inserter(ret, ret.end()),
                   [](const auto &p) { return p.first; });
        return ret;
    }
 
private:
    CveShaMapTy m_cveShaMap;
    ShaCveMapTy m_shaCveMap;
};
 
}