mixins.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/resolver/mixins.hh
 *
 * @brief State blobs for flox commands.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <filesystem>
#include <optional>
#include <string_view>
 
#include "flox/core/exceptions.hh"
#include "flox/resolver/environment.hh"
#include "flox/resolver/lockfile.hh"
#include "flox/resolver/manifest.hh"
 
 
/* -------------------------------------------------------------------------- */
 
/* Forward Declarations */
 
namespace argparse {
 
class Argument;
class ArgumentParser;
 
}  // namespace argparse
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox::resolver {
 
/* -------------------------------------------------------------------------- */
 
FLOX_DEFINE_EXCEPTION( EnvironmentMixinException,
                       EC_ENVIRONMENT_MIXIN,
                       "error handling manifest or lockfile" )
/* -------------------------------------------------------------------------- */
 
 
class EnvironmentMixin
{
 
private:
 
  /* All member variables are calculated lazily using `std::optional' and
   * `get<MEMBER>' accessors.
   * Even for internal access you should use the `get<MEMBER>' accessors to
   * lazily initialize. */
 
  /* ------------------------------ arguments ------------------------------- */
 
 
  std::optional<std::filesystem::path> manifestPath;
 
  /* ----------------------------- lazy fields ------------------------------ */
 
 
  std::optional<GlobalManifest> globalManifest;
 
  std::optional<ManifestRaw> manifestRaw;
 
  std::optional<EnvironmentManifest> manifest;
 
  std::optional<GlobalManifestRaw> globalManifestRaw;
 
  std::optional<LockfileRaw> lockfileRaw;
 
  std::optional<Lockfile> lockfile;
 
  std::optional<Environment> environment;
 
 
protected:
 
  void
  setGlobalManifestRaw( std::optional<std::filesystem::path> maybePath );
 
  void
  setGlobalManifestRaw( std::optional<GlobalManifestRaw> maybeRaw );
 
 
  [[nodiscard]] virtual GlobalManifest
  initGlobalManifest( GlobalManifestRaw manifestRaw );
 
  void
  setManifestRaw( std::optional<std::filesystem::path> maybePath );
 
  void
  setManifestRaw( std::optional<ManifestRaw> maybeRaw );
 
 
  [[nodiscard]] virtual EnvironmentManifest
  initManifest( ManifestRaw manifestRaw );
 
  virtual void
  setLockfileRaw( std::filesystem::path path );
 
  virtual void
  setLockfileRaw( LockfileRaw lockfileRaw );
 
  [[nodiscard]] virtual Lockfile
  initLockfile( LockfileRaw lockfileRaw );
 
 
  [[nodiscard]] const std::optional<LockfileRaw> &
  getLockfileRaw()
  {
    return this->lockfileRaw;
  }
 
 
public:
 
  [[nodiscard]] const std::optional<GlobalManifestRaw> &
  getGlobalManifestRaw()
  {
    return this->globalManifestRaw;
  }
 
 
  [[nodiscard]] const std::optional<GlobalManifest>
  getGlobalManifest();
 
  [[nodiscard]] const std::optional<ManifestRaw> &
  getManifestRaw() const
  {
    return this->manifestRaw;
  }
 
  [[nodiscard]] const EnvironmentManifest &
  getManifest();
 
  [[nodiscard]] const std::optional<Lockfile> &
  getLockfile();
 
  [[nodiscard]] Environment &
  getEnvironment();
 
  /* -------------------------- argument parsers ---------------------------- */
 
  argparse::Argument &
  addGlobalManifestFileOption( argparse::ArgumentParser & parser );
 
  argparse::Argument &
  addManifestFileOption( argparse::ArgumentParser & parser );
 
  argparse::Argument &
  addManifestFileArg( argparse::ArgumentParser & parser, bool required = true );
 
  argparse::Argument &
  addLockfileOption( argparse::ArgumentParser & parser );
 
  argparse::Argument &
  addFloxDirectoryOption( argparse::ArgumentParser & parser );
 
 
}; /* End class `EnvironmentMixin' */
 
 
/* -------------------------------------------------------------------------- */
 
class GAEnvironmentMixin : public EnvironmentMixin
{
 
private:
 
  bool gaRegistry = false;
 
 
protected:
 
  [[nodiscard]] GlobalManifest
  initGlobalManifest( GlobalManifestRaw manifestRaw ) override;
 
  [[nodiscard]] EnvironmentManifest
  initManifest( ManifestRaw manifestRaw ) override;
 
 
public:
 
  argparse::Argument &
  addGARegistryOption( argparse::ArgumentParser & parser );
 
}; /* End class `GAEnvironmentMixin' */
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox::resolver
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */