PackageDataStore.h

Go to the documentation of this file.

 
#pragma once
 
#include <ctime>
 
#include <memory>
#include <string>
#include <tuple>
#include <unordered_map>
 
#include <miktex/Util/PathName>
#include <miktex/Core/Session>
#include <miktex/Core/equal_icase>
#include <miktex/Core/hash_icase>
#include <miktex/Core/less_icase_dos>
 
#include <miktex/PackageManager/PackageManager>
 
#include "ComboCfg.h"
 
MPM_INTERNAL_BEGIN_NAMESPACE;

class PackageDataStore
{
    typedef std::unordered_map<std::string, MiKTeX::Packages::PackageInfo, MiKTeX::Core::hash_icase, MiKTeX::Core::equal_icase> PackageDefinitionTable;
 
public:
 
    PackageDataStore();

    void Clear();

    void DeclareObsolete(const std::string& packageId);

    unsigned long DecrementFileRefCount(const MiKTeX::Util::PathName& path);

    void DefinePackage(const MiKTeX::Packages::PackageInfo& packageinfo);

    std::size_t GetNumberOfInstalledPackages(bool userScope);

    unsigned long GetFileRefCount(const MiKTeX::Util::PathName& path);

    MiKTeX::Packages::PackageInfo GetPackage(const std::string& packageId)
    {
        return (*this)[packageId];
    }

    void IncrementFileRefCounts(const std::string& packageId);

    void LoadAllPackageManifests(const MiKTeX::Util::PathName& path, bool mustBeSigned);
 
    PackageDataStore& Load();
 
    bool LoadedAllPackageManifests() const
    {
        return loadedAllPackageManifests;
    }

    void NeedPackageManifestsIni();

    void SaveVarData();

    void SetPackage(const MiKTeX::Packages::PackageInfo& packageInfo)
    {
        (*this)[packageInfo.id] = packageInfo;
    }

    void SetReleaseState(const std::string& packageId, MiKTeX::Packages::RepositoryReleaseState releaseState);

    void SetTimeInstalled(const std::string& packageId, std::time_t timeInstalled);

    std::tuple<bool, MiKTeX::Packages::PackageInfo> TryGetPackage(const std::string& packageId);
 
    class iterator
    {
    public:
        iterator(PackageDefinitionTable::iterator it) :
            it(it)
        {
        }
        MiKTeX::Packages::PackageInfo& operator*()
        {
            return it->second;
        }
        iterator& operator++()
        {
            it++;
            return *this;
        }
        bool operator==(const iterator& rhs)
        {
            return it == rhs.it;
        }
        bool operator!=(const iterator& rhs)
        {
            return it != rhs.it;
        }
    private:
        PackageDefinitionTable::iterator it;
    };

    iterator begin();

    iterator end();
 
private:
 
    struct InstalledFileInfo
    {
        unsigned long refCount = 0;
    };
 
    typedef std::unordered_map<std::string, InstalledFileInfo, hash_path, equal_path> InstalledFileInfoTable;
 
    MiKTeX::Packages::PackageInfo& operator[](const std::string& packageId);
    MiKTeX::Packages::RepositoryReleaseState GetReleaseState(const std::string& packageId);
    bool IsObsolete(const std::string& packageId);
    bool IsRemovable(const std::string& packageId);
    std::time_t GetTimeInstalled(const std::string& packageId);
    std::time_t GetTimeInstalled(const std::string& packageId, MiKTeX::Core::ConfigurationScope scope);
    void IncrementFileRefCounts(const std::vector<std::string>& files);
    void Load(MiKTeX::Core::Cfg& cfg);
    void LoadVarData();
 
    ComboCfg comboCfg;
    InstalledFileInfoTable installedFileInfoTable;
    bool loadedAllPackageManifests = false;
    PackageDefinitionTable packageTable;
    std::shared_ptr<MiKTeX::Core::Session> session = MIKTEX_SESSION();
    std::unique_ptr<MiKTeX::Trace::TraceStream> trace_mpm;
    std::unique_ptr<MiKTeX::Trace::TraceStream> trace_stopwatch;
};
 
MPM_INTERNAL_END_NAMESPACE;