PackageInfo.h

Go to the documentation of this file.

 
#pragma once
 
#include "config.h"
 
#include <cstddef>
#include <ctime>
 
#include <string>
#include <vector>
 
#include <miktex/Core/MD5>
#include <miktex/Core/Session>
 
#include "definitions.h"
#include "RepositoryInfo.h"
 
MIKTEX_PACKAGES_BEGIN_NAMESPACE;
 
struct PackageInfo
{
    std::size_t archiveFileSize = 0;
 
    std::string copyrightOwner;
 
    std::string copyrightYear;
 
    std::string creator;
 
    std::string ctanPath;
 
    std::string description;
 
    MiKTeX::Core::MD5 digest;
 
    std::string displayName;
 
    std::string id;
 
    bool isObsolete = false;
 
    bool isRemovable = false;
 
    std::vector<std::string> docFiles;
 
    std::string licenseType;
 
    std::string minTargetSystemVersion;
 
    RepositoryReleaseState releaseState = RepositoryReleaseState::Unknown;
 
    std::vector<std::string> requiredBy;
 
    std::vector<std::string> requiredPackages;
 
    std::vector<std::string> runFiles;
 
    std::size_t sizeDocFiles = 0;
 
    std::size_t sizeSourceFiles = 0;
 
    std::size_t sizeRunFiles = 0;
 
    std::vector<std::string> sourceFiles;
 
    std::string targetSystem;
 
    std::time_t timeInstalledCommon = InvalidTimeT;
 
    std::time_t timeInstalledUser = InvalidTimeT;
 
    std::time_t timePackaged = InvalidTimeT;
 
    std::string title;
 
    std::string version;
 
    std::string versionDate;
 
    unsigned long GetRefCount() const
    {
        return static_cast<unsigned long>(requiredBy.size());
    }
 
    unsigned long GetNumFiles() const
    {
        return static_cast<unsigned long>(runFiles.size() + docFiles.size() + sourceFiles.size());
    }
 
    std::size_t GetSize() const
    {
        return sizeRunFiles + sizeDocFiles + sizeSourceFiles;
    }
 
    std::time_t GetTimeInstalled() const
    {
        return IsValidTimeT(timeInstalledUser) ? timeInstalledUser : timeInstalledCommon;
    }
 
    bool IsContained() const
    {
        return GetRefCount() > 0;
    }
 
    bool IsContainer() const
    {
        return !requiredPackages.empty();
    }
 
    bool IsInstalled() const
    {
        return IsValidTimeT(timeInstalledUser) || IsValidTimeT(timeInstalledCommon);
    }
 
    bool IsInstalled(MiKTeX::Core::ConfigurationScope scope) const
    {
        switch (scope)
        {
        case MiKTeX::Core::ConfigurationScope::User:
            return IsValidTimeT(timeInstalledUser);
        case MiKTeX::Core::ConfigurationScope::Common:
            return IsValidTimeT(timeInstalledCommon);
        default:
            MIKTEX_UNEXPECTED();
        }
    }
 
    bool IsPureContainer() const
    {
        return IsContainer() && GetNumFiles() <= 1;
    }
 
    void SetTimeInstalled(std::time_t timeInstalled, MiKTeX::Core::ConfigurationScope scope)
    {
        switch (scope)
        {
        case MiKTeX::Core::ConfigurationScope::User:
            timeInstalledUser = timeInstalled;
            break;
        case MiKTeX::Core::ConfigurationScope::Common:
            timeInstalledCommon = timeInstalled;
            break;
        default:
            MIKTEX_UNEXPECTED();
        }
    }
};
 
inline bool operator==(const PackageInfo& lhs, const PackageInfo& rhs)
{
    return true
        && lhs.copyrightOwner == rhs.copyrightOwner
        && lhs.copyrightYear == rhs.copyrightYear
        && lhs.creator == rhs.creator
        && lhs.ctanPath == rhs.ctanPath
        && lhs.description == rhs.description
        && lhs.digest == rhs.digest
        && lhs.displayName == rhs.displayName
        && lhs.id == rhs.id
        && lhs.licenseType == rhs.licenseType
        && lhs.requiredPackages == rhs.requiredPackages
        && lhs.sizeDocFiles == rhs.sizeDocFiles
        && lhs.sizeSourceFiles == rhs.sizeSourceFiles
        && lhs.targetSystem == rhs.targetSystem
        && lhs.timePackaged == rhs.timePackaged
        && lhs.title == rhs.title
        && lhs.version == rhs.version
        && lhs.versionDate == rhs.versionDate
#if 0
        // there was a time when the calculation of sizeRunFiles was broken
        // maybe due to .tpm file treatment
        && lhs.sizeRunFiles == rhs.sizeRunFiles
#endif
        ;
}
 
MIKTEX_PACKAGES_END_NAMESPACE;