PackageManager.h

/* miktex/PackageManager/PackageManager.h:              -*- C++ -*-
 
   Copyright (C) 2001-2020 Christian Schenk
 
   This file is part of MiKTeX Package Manager.
 
   MiKTeX Package Manager is free software; you can redistribute it
   and/or modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2, or
   (at your option) any later version.
 
   MiKTeX Package Manager is distributed in the hope that it will be
   useful, but WITHOUT ANY WARRANTY; without even the implied warranty
   of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with MiKTeX Package Manager; if not, write to the Free
   Software Foundation, 59 Temple Place - Suite 330, Boston, MA
   02111-1307, USA. */
 
#pragma once
 
#if !defined(D5760AC70396FF41BBDD7DD560BDBBBC)
#define D5760AC70396FF41BBDD7DD560BDBBBC
 
#include "config.h"
 
#include <ctime>
 
#include <memory>
#include <string>
#include <vector>
 
#include <miktex/Core/Cfg>
#include <miktex/Util/PathName>
 
#include <miktex/Trace/TraceCallback>
#include <miktex/Trace/TraceStream>
 
#include "PackageInfo.h"
#include "PackageInstaller.h"
#include "PackageIterator.h"
#include "RepositoryInfo.h"
 
MIKTEX_PACKAGES_BEGIN_NAMESPACE;
 
struct ProxySettings
{
  bool useProxy = false;
  std::string proxy;
  int port = 0;
  bool authenticationRequired = false;
  std::string user;
  std::string password;
};
 
struct InstallationSummary
{
  std::time_t lastUpdateCheck = InvalidTimeT;
  std::time_t lastUpdate = InvalidTimeT;
  std::time_t lastUpdateDb = InvalidTimeT;
  std::size_t packageCount = 0;
};
 
class MIKTEXNOVTABLE PackageManager
{
public:
  virtual MIKTEXTHISCALL ~PackageManager() noexcept = 0;
 
public:
  virtual std::unique_ptr<class PackageInstaller> MIKTEXTHISCALL CreateInstaller(const PackageInstaller::InitInfo& initInfo) = 0;
 
public:
  virtual std::unique_ptr<class PackageInstaller> MIKTEXTHISCALL CreateInstaller() = 0;
 
public:
  virtual std::unique_ptr<class PackageIterator> MIKTEXTHISCALL CreateIterator() = 0;
 
public:
  virtual void MIKTEXTHISCALL CreateMpmFndb() = 0;
 
public:
  virtual PackageInfo MIKTEXTHISCALL GetPackageInfo(const std::string& packageId) = 0;
 
public:
  virtual void MIKTEXTHISCALL LoadDatabase(const MiKTeX::Util::PathName& path, bool isArchive) = 0;
 
public:
  virtual void MIKTEXTHISCALL UnloadDatabase() = 0;
 
public:
  virtual RepositoryReleaseState MIKTEXTHISCALL GetRepositoryReleaseState() = 0;
 
public:
  virtual void MIKTEXTHISCALL SetRepositoryReleaseState(RepositoryReleaseState repositoryReleaseState) = 0;
 
public:
  virtual void MIKTEXTHISCALL DownloadRepositoryList() = 0;
 
public:
  virtual std::vector<RepositoryInfo> MIKTEXTHISCALL GetRepositories() = 0;
  
public:
  virtual std::string MIKTEXTHISCALL PickRepositoryUrl() = 0;
 
public:
  virtual bool MIKTEXTHISCALL TryGetPackageInfo(const std::string& packageId, PackageInfo& packageInfo) = 0;
 
public:
  virtual bool MIKTEXTHISCALL TryGetRepositoryInfo(const std::string& url, RepositoryInfo& repositoryInfo) = 0;
 
public:
  virtual RepositoryInfo MIKTEXTHISCALL CheckPackageRepository(const std::string& url) = 0;
 
public:
  virtual RepositoryInfo MIKTEXTHISCALL VerifyPackageRepository(const std::string& url) = 0;
 
public:
  virtual bool MIKTEXTHISCALL TryVerifyInstalledPackage(const std::string& packageId) = 0;
 
public:
  virtual std::string MIKTEXTHISCALL GetContainerPath(const std::string& packageId, bool useDisplayNames) = 0;
 
public:
  virtual InstallationSummary MIKTEXTHISCALL GetInstallationSummary(bool userScope) = 0;
 
public:
  struct InitInfo
  {
    InitInfo() = default;
    InitInfo(const InitInfo& other) = default;
    InitInfo& operator=(const InitInfo& other) = default;
    InitInfo(InitInfo&& other) = default;
    InitInfo& operator=(InitInfo&& other) = default;
    ~InitInfo() = default;
    InitInfo(MiKTeX::Trace::TraceCallback* traceCallback) :
      traceCallback(traceCallback)
    {
    }
    MiKTeX::Trace::TraceCallback* traceCallback = nullptr;
  };
 
public:
  static MIKTEXMPMCEEAPI(std::shared_ptr<PackageManager>) Create(const InitInfo& initInfo);
 
public:
  static std::shared_ptr<PackageManager> Create()
  {
    return Create(InitInfo());
  }
 
public:
  static MIKTEXMPMCEEAPI(std::string) GetRemotePackageRepository(RepositoryReleaseState& repositoryReleaseState);
 
public:
  static std::string GetRemotePackageRepository()
  {
    RepositoryReleaseState unusedRepositoryReleaseState;
    return GetRemotePackageRepository(unusedRepositoryReleaseState);
  }
 
public:
  static MIKTEXMPMCEEAPI(bool) TryGetRemotePackageRepository(std::string& url, RepositoryReleaseState& repositoryReleaseState);
 
public:
  static bool TryGetRemotePackageRepository(std::string& url)
  {
    RepositoryReleaseState unusedRepositoryReleaseState;
    return TryGetRemotePackageRepository(url, unusedRepositoryReleaseState);
  }
 
public:
  static MIKTEXMPMCEEAPI(MiKTeX::Util::PathName) GetLocalPackageRepository();
 
public:
  static MIKTEXMPMCEEAPI(bool) TryGetLocalPackageRepository(MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXMPMCEEAPI(MiKTeX::Util::PathName) GetMiKTeXDirectRoot();
 
public:
  static MIKTEXMPMCEEAPI(bool) TryGetMiKTeXDirectRoot(MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXMPMCEEAPI(RepositoryInfo) GetDefaultPackageRepository();
 
public:
  static MIKTEXMPMCEEAPI(bool) TryGetDefaultPackageRepository(RepositoryType& repositoryType, RepositoryReleaseState& repositoryReleaseState, std::string& urlOrPath);
 
public:
  static bool TryGetDefaultPackageRepository(RepositoryType& repositoryType, std::string& urlOrPath)
  {
    RepositoryReleaseState unusedRepositoryReleaseState;
    return TryGetDefaultPackageRepository(repositoryType, unusedRepositoryReleaseState, urlOrPath);
  }
 
public:
  static MIKTEXMPMCEEAPI(void) SetDefaultPackageRepository(const RepositoryInfo& repository);
 
public:
  static MIKTEXMPMCEEAPI(void) SetDefaultPackageRepository(RepositoryType repositoryType, RepositoryReleaseState repositoryReleaseState, const std::string& urlOrPath);
 
public:
  static void SetDefaultPackageRepository(RepositoryType repositoryType, const std::string& urlOrPath)
  {
    SetDefaultPackageRepository(repositoryType, RepositoryReleaseState::Unknown, urlOrPath);
  }
 
public:
  static MIKTEXMPMCEEAPI(bool) IsLocalPackageRepository(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXMPMCEEAPI(void) SetRemotePackageRepository(const std::string& url, RepositoryReleaseState repositoryReleaseState);
 
public:
  static void SetRemotePackageRepository(const std::string& url)
  {
    SetRemotePackageRepository(url, RepositoryReleaseState::Unknown);
  }
 
public:
  static MIKTEXMPMCEEAPI(void) SetLocalPackageRepository(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXMPMCEEAPI(void) SetMiKTeXDirectRoot(const MiKTeX::Util::PathName& path);
 
public:
  static MIKTEXMPMCEEAPI(PackageInfo) ReadPackageManifestFile(const MiKTeX::Util::PathName& path, const std::string& texmfPrefix);
 
public:
  static MIKTEXMPMCEEAPI(void) WritePackageManifestFile(const MiKTeX::Util::PathName& path, const PackageInfo& packageInfo, std::time_t timePackaged);
 
public:
  static MIKTEXMPMCEEAPI(void) PutPackageManifest(MiKTeX::Core::Cfg& cfg, const PackageInfo& packageInfo, std::time_t timePackaged);
 
public:
  static MIKTEXMPMCEEAPI(PackageInfo) GetPackageManifest(const MiKTeX::Core::Cfg& cfg, const std::string& packageId, const std::string& texmfPrefix);
 
public:
  static MIKTEXMPMCEEAPI(bool) StripTeXMFPrefix(const std::string& str, std::string& result);
 
public:
  static MIKTEXMPMCEEAPI(bool) TryGetProxy(const std::string& url, ProxySettings& proxySettings);
 
public:
  static MIKTEXMPMCEEAPI(bool) TryGetProxy(ProxySettings& proxySettings);
 
public:
  static MIKTEXMPMCEEAPI(void) SetProxy(const ProxySettings& proxySettings);
};
 
MIKTEX_PACKAGES_END_NAMESPACE;
 
#endif