RepositoryInfo.h

/* miktex/PackageManager/RepositoryInfo.h:              -*- C++ -*-
 
   Copyright (C) 2001-2022 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(AE9D0FE238A0478AB880D039796623E3)
#define AE9D0FE238A0478AB880D039796623E3
 
#include "config.h"
 
#include <ctime>
 
#include <ostream>
#include <string>
 
#include "definitions.h"
 
MIKTEX_PACKAGES_BEGIN_NAMESPACE;

enum class PackageLevel
{
  None = 0,
  Essential = 10,
  Basic = 1000,
  Advanced = 100000,
  Complete = 1000000000,
};
 
inline std::string PackageLevelToString(PackageLevel packageLevel)
{
  switch (packageLevel)
  {
    case PackageLevel::None:
      return "none";
    case PackageLevel::Essential:
      return "essential";
    case PackageLevel::Basic:
      return "basic";
    case PackageLevel::Advanced:
      return "advanced";
    case PackageLevel::Complete:
      return "complete";
    default:
      return "?";
  }
}
 
inline std::ostream& operator<<(std::ostream& os, const PackageLevel packageLevel)
{
  return os << PackageLevelToString(packageLevel);
}

enum class RepositoryType
{
  Unknown,
  MiKTeXDirect,
  Local,
  Remote,
  MiKTeXInstallation
};
 
inline std::string RepositoryTypeToString(RepositoryType repositoryType)
{
  switch (repositoryType)
  {
    case RepositoryType::Unknown:
      return "unknown";
    case RepositoryType::MiKTeXDirect:
      return "miktexdirect";
    case RepositoryType::Local:
      return "local";
    case RepositoryType::Remote:
      return "remote";
    case RepositoryType::MiKTeXInstallation:
      return "miktexinstallation";
    default:
      return "?";
  }  
}
 
inline std::ostream& operator<<(std::ostream& os, const RepositoryType repositoryType)
{
  return os << RepositoryTypeToString(repositoryType);
}

enum class RepositoryStatus
{
  Unknown,
  Online,
  Offline,
};
 
inline std::string RepositoryStatusToString(RepositoryStatus repositoryStatus)
{
  switch (repositoryStatus)
  {
    case RepositoryStatus::Unknown:
      return "unknown";
    case RepositoryStatus::Online:
      return "online";
    case RepositoryStatus::Offline:
      return "offline";
    default:
      return "?";
  }  
}
 
inline std::ostream& operator<<(std::ostream& os, const RepositoryStatus repositoryStatus)
{
  return os << RepositoryStatusToString(repositoryStatus);
}

enum class RepositoryIntegrity
{
  Unknown,
  Intact,
  Corrupted,
};
 
inline std::string RepositoryIntegrityToString(RepositoryIntegrity repositoryIntegrity)
{
  switch (repositoryIntegrity)
  {
    case RepositoryIntegrity::Unknown:
      return "unknown";
    case RepositoryIntegrity::Intact:
      return "intact";
    case RepositoryIntegrity::Corrupted:
      return "corrupted";
    default:
      return "?";
  }  
}
 
inline std::ostream& operator<<(std::ostream& os, const RepositoryIntegrity repositoryIntegrity)
{
  return os << RepositoryIntegrityToString(repositoryIntegrity);
}

enum class RepositoryReleaseState
{
  Unknown,
  Stable,
  Next,
};
 
inline std::string RepositoryReleaseStateToString(RepositoryReleaseState repositoryReleaseState)
{
  switch (repositoryReleaseState)
  {
    case RepositoryReleaseState::Unknown:
      return "unknown";
    case RepositoryReleaseState::Stable:
      return "stable";
    case RepositoryReleaseState::Next:
      return "next";
    default:
      return "?";
  }  
}
 
inline std::ostream& operator<<(std::ostream& os, const RepositoryReleaseState repositoryReleaseState)
{
  return os << RepositoryReleaseStateToString(repositoryReleaseState);
}

struct RepositoryInfo
{
  RepositoryType type;
  std::string url;
  std::string description;
  std::string country;
  std::string town;
  PackageLevel packageLevel = PackageLevel::None;
  unsigned int version = 0;
  std::time_t timeDate = InvalidTimeT;
  RepositoryStatus status = RepositoryStatus::Unknown;
  RepositoryIntegrity integrity = RepositoryIntegrity::Unknown;
  unsigned delay = 0;
  unsigned relativeDelay = 0;
  RepositoryReleaseState releaseState = RepositoryReleaseState::Unknown;
  unsigned ranking = 0;
  double dataTransferRate = 0.0;
  std::time_t lastCheckTime = InvalidTimeT;
  std::time_t lastVisitTime = InvalidTimeT;
};
 
inline bool operator==(const RepositoryInfo& lhs, const RepositoryInfo& rhs)
{
  return lhs.type == rhs.type && lhs.url == rhs.url;
}
 
inline bool operator!=(const RepositoryInfo& lhs, const RepositoryInfo& rhs)
{
  return !(lhs == rhs);
}
 
MIKTEX_PACKAGES_END_NAMESPACE;
 
#endif