manifest-raw.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/resolver/manifest-raw.hh
 *
 * @brief An abstract description of an environment in its unresolved state.
 *        This representation is intended for serialization and deserialization.
 *        For the _real_ representation, see
 *        [flox/resolver/manifest.hh](./manifest.hh).
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <algorithm>
#include <optional>
#include <string>
#include <string_view>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <nlohmann/json.hpp>
 
#include "compat/concepts.hh"
#include "flox/core/exceptions.hh"
#include "flox/core/types.hh"
#include "flox/pkgdb/pkg-query.hh"
#include "flox/registry.hh"
#include "flox/resolver/descriptor.hh"  // IWYU pragma: keep
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox::resolver {
 
/* -------------------------------------------------------------------------- */
 
/* Forward Declarations */
 
struct GlobalManifestRaw;
struct ManifestRaw;
struct GlobalManifestRawGA;
struct ManifestRawGA;
 
 
/* -------------------------------------------------------------------------- */
 
FLOX_DEFINE_EXCEPTION( InvalidManifestFileException,
                       EC_INVALID_MANIFEST_FILE,
                       "invalid manifest file" )
/* -------------------------------------------------------------------------- */
 
 
using InstallID = std::string;
 
 
/* -------------------------------------------------------------------------- */
 
struct Options
{
 
  std::optional<std::vector<System>> systems;
 
  struct Allows
  {
    std::optional<bool>                     unfree;
    std::optional<bool>                     broken;
    std::optional<std::vector<std::string>> licenses;
  }; /* End struct `Allows' */
  std::optional<Allows> allow;
 
  struct Semver
  {
    std::optional<bool> preferPreReleases;
  }; /* End struct `Semver' */
  std::optional<Semver> semver;
 
  std::optional<std::string> packageGroupingStrategy;
  std::optional<std::string> activationStrategy;
  // TODO: Other options
 
 
  void
  merge( const Options & overrides );
 
  explicit operator pkgdb::PkgQueryArgs() const;
 
 
}; /* End struct `Options' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, Options & opts );
 
void
to_json( nlohmann::json & jto, const Options & opts );
 
 
/* -------------------------------------------------------------------------- */
 
struct GlobalManifestRaw
{
  std::optional<RegistryRaw> registry;
 
  std::optional<Options> options;
 
 
  virtual ~GlobalManifestRaw()                   = default;
  GlobalManifestRaw()                            = default;
  GlobalManifestRaw( const GlobalManifestRaw & ) = default;
  GlobalManifestRaw( GlobalManifestRaw && )      = default;
 
  explicit GlobalManifestRaw( std::optional<RegistryRaw> registry,
                              std::optional<Options> options = std::nullopt )
    : registry( std::move( registry ) ), options( std::move( options ) )
  {}
 
  explicit GlobalManifestRaw( std::optional<Options> options )
    : options( std::move( options ) )
  {}
 
  GlobalManifestRaw &
  operator=( const GlobalManifestRaw & )
    = default;
  GlobalManifestRaw &
  operator=( GlobalManifestRaw && )
    = default;
 
  virtual void
  check() const
  {}
 
  virtual void
  clear()
  {
    this->registry = std::nullopt;
    this->options  = std::nullopt;
  }
 
  explicit operator GlobalManifestRawGA() const;
 
 
}; /* End struct `GlobalManifestRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, GlobalManifestRaw & manifest );
 
void
to_json( nlohmann::json & jto, const GlobalManifestRaw & manifest );
 
 
/* -------------------------------------------------------------------------- */
 
struct EnvBaseRaw
{
  std::optional<std::string> floxhub;
 
  std::optional<std::string> dir;
 
 
  void
  check() const;
 
  void
  clear()
  {
    this->floxhub = std::nullopt;
    this->dir     = std::nullopt;
  }
 
 
}; /* End struct `EnvBaseRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
struct HookRaw
{
  std::optional<std::string> script;
 
  std::optional<std::string> file;
 
 
  void
  check() const;
 
 
}; /* End struct `HookRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
struct ManifestRaw : public GlobalManifestRaw
{
 
  std::optional<EnvBaseRaw> envBase;
 
  std::optional<
    std::unordered_map<InstallID, std::optional<ManifestDescriptorRaw>>>
    install;
 
  std::optional<std::unordered_map<std::string, std::string>> vars;
 
  std::optional<HookRaw> hook;
 
 
  ~ManifestRaw() override            = default;
  ManifestRaw()                      = default;
  ManifestRaw( const ManifestRaw & ) = default;
  ManifestRaw( ManifestRaw && )      = default;
 
  explicit ManifestRaw( const GlobalManifestRaw & globalManifestRaw )
    : GlobalManifestRaw( globalManifestRaw )
  {}
 
  explicit ManifestRaw( GlobalManifestRaw && globalManifestRaw )
    : GlobalManifestRaw( globalManifestRaw )
  {}
 
  ManifestRaw &
  operator=( const ManifestRaw & )
    = default;
 
  ManifestRaw &
  operator=( ManifestRaw && )
    = default;
 
  ManifestRaw &
  operator=( const GlobalManifestRaw & globalManifestRaw )
  {
    GlobalManifestRaw::operator=( globalManifestRaw );
    return *this;
  }
 
  ManifestRaw &
  operator=( GlobalManifestRaw && globalManifestRaw )
  {
    GlobalManifestRaw::operator=( globalManifestRaw );
    return *this;
  }
 
  void
  check() const override;
 
  void
  clear() override
  {
    /* From `GlobalManifestRaw' */
    this->options  = std::nullopt;
    this->registry = std::nullopt;
    /* From `ManifestRaw' */
    this->envBase = std::nullopt;
    this->install = std::nullopt;
    this->vars    = std::nullopt;
    this->hook    = std::nullopt;
  }
 
  nlohmann::json
  diff( const ManifestRaw & old ) const;
 
  explicit operator ManifestRawGA() const;
 
 
}; /* End struct `ManifestRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, ManifestRaw & manifest );
 
void
to_json( nlohmann::json & jto, const ManifestRaw & manifest );
 
 
/* -------------------------------------------------------------------------- */
 
struct GlobalManifestRawGA
{
 
  std::optional<Options> options;
 
 
  virtual ~GlobalManifestRawGA()                     = default;
  GlobalManifestRawGA()                              = default;
  GlobalManifestRawGA( const GlobalManifestRawGA & ) = default;
  GlobalManifestRawGA( GlobalManifestRawGA && )      = default;
 
  explicit GlobalManifestRawGA( std::optional<Options> options )
    : options( std::move( options ) )
  {}
 
  GlobalManifestRawGA &
  operator=( const GlobalManifestRawGA & )
    = default;
 
  GlobalManifestRawGA &
  operator=( GlobalManifestRawGA && )
    = default;
 
  virtual void
  check() const
  {}
 
  virtual void
  clear()
  {
    this->options = std::nullopt;
  }
 
  explicit operator GlobalManifestRaw() const
  {
    return GlobalManifestRaw( getGARegistry(), this->options );
  }
 
  explicit operator ManifestRaw() const
  {
    return ManifestRaw( static_cast<GlobalManifestRaw>( *this ) );
  }
 
 
}; /* End struct `GlobalManifestRawGA' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, GlobalManifestRawGA & manifest );
 
void
to_json( nlohmann::json & jto, const GlobalManifestRawGA & manifest );
 
 
/* -------------------------------------------------------------------------- */
 
struct ManifestRawGA : public GlobalManifestRawGA
{
 
  std::optional<
    std::unordered_map<InstallID, std::optional<ManifestDescriptorRaw>>>
    install;
 
  std::optional<std::unordered_map<std::string, std::string>> vars;
 
  std::optional<HookRaw> hook;
 
 
  ~ManifestRawGA() override              = default;
  ManifestRawGA()                        = default;
  ManifestRawGA( const ManifestRawGA & ) = default;
  ManifestRawGA( ManifestRawGA && )      = default;
 
  explicit ManifestRawGA( const GlobalManifestRawGA & globalManifestRawGA )
    : GlobalManifestRawGA( globalManifestRawGA )
  {}
 
  explicit ManifestRawGA( GlobalManifestRawGA && globalManifestRawGA )
    : GlobalManifestRawGA( globalManifestRawGA )
  {}
 
  ManifestRawGA &
  operator=( const ManifestRawGA & )
    = default;
 
  ManifestRawGA &
  operator=( ManifestRawGA && )
    = default;
 
  ManifestRawGA &
  operator=( const GlobalManifestRawGA & globalManifestRawGA )
  {
    GlobalManifestRawGA::operator=( globalManifestRawGA );
    return *this;
  }
 
  ManifestRawGA &
  operator=( GlobalManifestRawGA && globalManifestRawGA )
  {
    GlobalManifestRawGA::operator=( globalManifestRawGA );
    return *this;
  }
 
  void
  check() const override;
 
  void
  clear() override
  {
    /* From `GlobalManifestRawGA' */
    this->options = std::nullopt;
    /* From `ManifestRawGA' */
    this->install = std::nullopt;
    this->vars    = std::nullopt;
    this->hook    = std::nullopt;
  }
 
  nlohmann::json
  diff( const ManifestRawGA & old ) const;
 
  explicit operator ManifestRaw() const
  {
    ManifestRaw raw;
    raw.registry = getGARegistry();
    raw.options  = this->options;
    raw.install  = this->install;
    raw.vars     = this->vars;
    raw.hook     = this->hook;
    return raw;
  }
 
 
}; /* End struct `ManifestRawGA' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, ManifestRawGA & manifest );
 
void
to_json( nlohmann::json & jto, const ManifestRawGA & manifest );
 
 
/* -------------------------------------------------------------------------- */
 
template<typename RawType>
concept manifest_raw_type = std::derived_from<RawType, GlobalManifestRaw>
                            || std::derived_from<RawType, GlobalManifestRawGA>;
 
static_assert( manifest_raw_type<GlobalManifestRaw> );
static_assert( manifest_raw_type<GlobalManifestRawGA> );
static_assert( manifest_raw_type<ManifestRaw> );
static_assert( manifest_raw_type<ManifestRawGA> );
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox::resolver
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */