input.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/pkgdb/input.hh
 *
 * @brief A @a RegistryInput that opens a @a PkgDb associated with a flake.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <filesystem>
#include <memory>
#include <nlohmann/json_fwd.hpp>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <nix/flake/flake.hh>
#include <nix/flake/flakeref.hh>
#include <nix/ref.hh>
 
#include "flox/core/nix-state.hh"
#include "flox/core/types.hh"
#include "flox/flox-flake.hh"
#include "flox/pkgdb/pkg-query.hh"
#include "flox/pkgdb/read.hh"
#include "flox/registry.hh"
 
 
/* -------------------------------------------------------------------------- */
 
/* Forward declare */
namespace nix {
class Store;
}
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox::pkgdb {
 
/* -------------------------------------------------------------------------- */
 
/* Forward declare */
class PkgDb;
 
/* -------------------------------------------------------------------------- */
 
class PkgDbInput : public FloxFlakeInput
{
 
private:
 
  /* Provided by `FloxFlakeInput':
   *   nix::ref<nix::FlakeRef>             flakeRef
   *   nix::ref<nix::Store>                store
   *   std::shared_ptr<FloxFlake>          flake
   *   std::optional<std::vector<Subtree>> enabledSubtrees
   */
 
  std::filesystem::path dbPath;
 
  std::shared_ptr<PkgDbReadOnly> dbRO;
 
  std::shared_ptr<PkgDb> dbRW;
 
  std::optional<std::string> name;
 
 
  void
  init();
 
 
public:
 
  struct db_path_tag
  {};
 
 
  PkgDbInput( nix::ref<nix::Store> & store,
              const RegistryInput &  input,
              std::filesystem::path  dbPath,
              const db_path_tag & /* unused */
              ,
              const std::string & name = "" )
    : FloxFlakeInput( store, input )
    , dbPath( std::move( dbPath ) )
    , name( name.empty() ? std::nullopt : std::make_optional( name ) )
  {
    this->init();
  }
 
  PkgDbInput( nix::ref<nix::Store> &        store,
              const RegistryInput &         input,
              const std::filesystem::path & cacheDir = getPkgDbCachedir(),
              const std::string &           name     = "" )
    : FloxFlakeInput( store, input )
    , dbPath( genPkgDbName( this->getFlake()->lockedFlake.getFingerprint(),
                            cacheDir ) )
    , name( name.empty() ? std::nullopt : std::make_optional( name ) )
  {
    this->init();
  }
 
  [[nodiscard]] nix::ref<PkgDbReadOnly>
  getDbReadOnly() const
  {
    return static_cast<nix::ref<PkgDbReadOnly>>( this->dbRO );
  }
 
  [[nodiscard]] nix::ref<PkgDb>
  getDbReadWrite();
 
  void
  closeDbReadWrite()
  {
    this->dbRW = nullptr;
  }
 
  [[nodiscard]] std::filesystem::path
  getDbPath() const
  {
    return this->dbPath;
  }
 
  void
  scrapePrefix( const flox::AttrPath & prefix );
 
  void
  scrapeSystems( const std::vector<System> & systems );
 
  void
  setName( std::string_view name )
  {
    this->name = name;
  }
 
  [[nodiscard]] std::string
  getNameOrURL()
  {
    return this->name.value_or(
      this->getFlake()->lockedFlake.flake.lockedRef.to_string() );
  }
 
  [[nodiscard]] nlohmann::json
  getRowJSON( row_id row );
 
 
}; /* End struct `PkgDbInput' */
 
 
/* -------------------------------------------------------------------------- */
 
class PkgDbInputFactory
{
 
private:
 
  nix::ref<nix::Store>  store;    
  std::filesystem::path cacheDir; 
public:
 
  using input_type = PkgDbInput;
 
  explicit PkgDbInputFactory( nix::ref<nix::Store> & store,
                              std::filesystem::path  cacheDir
                              = getPkgDbCachedir() )
    : store( store ), cacheDir( std::move( cacheDir ) )
  {}
 
  [[nodiscard]] std::shared_ptr<PkgDbInput>
  mkInput( const std::string & name, const RegistryInput & input )
  {
    return std::make_shared<PkgDbInput>( this->store,
                                         input,
                                         this->cacheDir,
                                         name );
  }
 
 
}; /* End class `PkgDbInputFactory' */
 
 
static_assert( registry_input_factory<PkgDbInputFactory> );
 
 
/* -------------------------------------------------------------------------- */
 
class PkgDbRegistryMixin : virtual protected NixStoreMixin
{
 
private:
 
  /* From `NixStoreMixin':
   *   std::shared_ptr<nix::Store> store
   */
 
  std::shared_ptr<Registry<PkgDbInputFactory>> registry;
 
  // TODO: Implement
  bool force = false;
 
 
protected:
 
  /* From `NixStoreMixin':
   *   nix::ref<nix::Store> getStore()
   */
 
 
  void
  initRegistry();
 
  void
  scrapeIfNeeded();
 
  [[nodiscard]] virtual RegistryRaw
  getRegistryRaw()
    = 0;
 
  [[nodiscard]] virtual const std::vector<System> &
  getSystems()
    = 0;
 
 
public:
 
  [[nodiscard]] nix::ref<Registry<PkgDbInputFactory>>
  getPkgDbRegistry();
 
  [[nodiscard]] bool
  isPkgDbForced() const
  {
    return this->force;
  }
 
  void
  setPkgDbForced( bool force )
  {
    this->force = force;
  }
 
 
}; /* End class `PkgDbRegistryMixin' */
 
 
/* -------------------------------------------------------------------------- */
 
 
}  // namespace flox::pkgdb
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */