registry.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/registry.hh
 *
 * @brief A set of user inputs used to set input preferences during search
 *        and resolution.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <algorithm>
#include <functional>
#include <map>
#include <vector>
 
#include <nix/fetchers.hh>
#include <nix/flake/flakeref.hh>
#include <nlohmann/json.hpp>
 
#include "compat/concepts.hh"
#include "flox/core/exceptions.hh"
#include "flox/core/types.hh"
#include "flox/core/util.hh"
#include "flox/flox-flake.hh"
#include "flox/pkgdb/pkg-query.hh"
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox {
 
/* -------------------------------------------------------------------------- */
 
struct InputPreferences
{
 
  std::optional<std::vector<Subtree>> subtrees;
 
  /* Base class boilerplate */
  virtual ~InputPreferences()                  = default;
  InputPreferences()                           = default;
  InputPreferences( const InputPreferences & ) = default;
  InputPreferences( InputPreferences && )      = default;
 
  InputPreferences &
  operator=( const InputPreferences & )
    = default;
  InputPreferences &
  operator=( InputPreferences && )
    = default;
 
  explicit InputPreferences(
    const std::optional<std::vector<Subtree>> & subtrees )
    : subtrees( subtrees )
  {}
 
  virtual void
  clear();
 
  pkgdb::PkgQueryArgs &
  fillPkgQueryArgs( pkgdb::PkgQueryArgs & pqa ) const;
 
  void
  merge( const InputPreferences & overrides );
 
  [[nodiscard]] bool
  operator==( const InputPreferences & other ) const
  {
    return this->subtrees == other.subtrees;
  }
 
  [[nodiscard]] bool
  operator!=( const InputPreferences & other ) const
  {
    return ! ( ( *this ) == other );
  }
 
 
}; /* End struct `InputPreferences' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, InputPreferences & prefs );
 
void
to_json( nlohmann::json & jto, const InputPreferences & prefs );
 
 
/* -------------------------------------------------------------------------- */
 
template<typename T>
concept input_preferences_typename
  = std::is_base_of<InputPreferences, T>::value && requires( T obj ) {
      {
        obj.getFlakeRef()
      } -> std::convertible_to<nix::ref<nix::FlakeRef>>;
    };
 
 
/* -------------------------------------------------------------------------- */
 
struct RegistryInput : public InputPreferences
{
 
  /* From `InputPreferences':
   *   std::optional<std::vector<Subtree>> subtrees;
   */
 
  std::shared_ptr<nix::FlakeRef> from; 
  RegistryInput() = default;
 
  RegistryInput( const std::optional<std::vector<Subtree>> & subtrees,
                 const nix::FlakeRef &                       from )
    : InputPreferences( subtrees )
    , from( std::make_shared<nix::FlakeRef>( from ) )
  {}
 
  explicit RegistryInput( const nix::FlakeRef & from )
    : from( std::make_shared<nix::FlakeRef>( from ) )
  {}
 
 
  [[nodiscard]] nix::ref<nix::FlakeRef>
  getFlakeRef() const
  {
    return static_cast<nix::ref<nix::FlakeRef>>( this->from );
  };
 
  [[nodiscard]] bool
  operator==( const RegistryInput & other ) const
  {
    if ( static_cast<InputPreferences>( *this )
         != static_cast<InputPreferences>( other ) )
      {
        return false;
      }
 
    if ( this->from == other.from ) { return true; }
 
    if ( ( this->from == nullptr ) || ( other.from == nullptr ) )
      {
        return false;
      }
 
    return ( *this->from ) == ( *other.from );
  }
 
  [[nodiscard]] bool
  operator!=( const RegistryInput & other ) const
  {
    return ! ( ( *this ) == other );
  }
 
 
}; /* End struct `RegistryInput' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, RegistryInput & rip );
 
void
to_json( nlohmann::json & jto, const RegistryInput & rip );
 
 
/* -------------------------------------------------------------------------- */
 
template<typename T>
concept registry_input_factory =
  /* Must have a `using input_type = <TYPENAME>;' definition. */
  requires { typename T::input_type; } &&
  /* `input_type' must satisfy `input_preferences_typesname' concept. */
  input_preferences_typename<typename T::input_type> &&
  /* Must provide a function, `mkInput' that constructs an `input_type'. */
  requires( T ref, const std::string & name, const RegistryInput & rip ) {
    {
      ref.mkInput( name, rip )
    } -> std::convertible_to<std::shared_ptr<typename T::input_type>>;
  };
 
 
/* -------------------------------------------------------------------------- */
 
class RegistryInputFactory
{
 
public:
 
  using input_type = RegistryInput;
 
  [[nodiscard]] static std::shared_ptr<RegistryInput>
  mkInput( const std::string & /* unused */, const RegistryInput & input )
  {
    return std::make_shared<RegistryInput>( input );
  }
 
 
}; /* End class `RegistryInputFactory' */
 
static_assert( registry_input_factory<RegistryInputFactory> );
 
 
/* -------------------------------------------------------------------------- */
 
struct RegistryRaw
{
 
  std::map<std::string, RegistryInput> inputs;
 
  InputPreferences defaults;
 
  std::vector<std::string> priority;
 
 
  /* Base class boilerplate. */
  virtual ~RegistryRaw()             = default;
  RegistryRaw()                      = default;
  RegistryRaw( const RegistryRaw & ) = default;
  RegistryRaw( RegistryRaw && )      = default;
 
  RegistryRaw &
  operator=( const RegistryRaw & )
    = default;
  RegistryRaw &
  operator=( RegistryRaw && )
    = default;
 
  explicit RegistryRaw( std::map<std::string, RegistryInput> inputs,
                        InputPreferences                     defaults = {},
                        std::vector<std::string>             priority = {} )
    : inputs( std::move( inputs ) )
    , defaults( std::move( defaults ) )
    , priority( std::move( priority ) )
  {}
 
  explicit RegistryRaw( std::map<std::string, RegistryInput> inputs,
                        std::vector<std::string>             priority = {} )
    : RegistryRaw( std::move( inputs ),
                   InputPreferences {},
                   std::move( priority ) )
  {}
 
  [[nodiscard]] virtual std::vector<std::reference_wrapper<const std::string>>
  getOrder() const;
 
  virtual void
  clear();
 
  pkgdb::PkgQueryArgs &
  fillPkgQueryArgs( const std::string &   input,
                    pkgdb::PkgQueryArgs & pqa ) const;
 
  void
  merge( const RegistryRaw & overrides );
 
  [[nodiscard]] bool
  operator==( const RegistryRaw & other ) const;
 
  [[nodiscard]] bool
  operator!=( const RegistryRaw & other ) const
  {
    return ! ( *this == other );
  }
 
 
}; /* End struct `RegistryRaw' */
 
 
/* -------------------------------------------------------------------------- */
 
void
from_json( const nlohmann::json & jfrom, RegistryRaw & reg );
 
void
to_json( nlohmann::json & jto, const RegistryRaw & reg );
 
/* -------------------------------------------------------------------------- */
 
FLOX_DEFINE_EXCEPTION( InvalidRegistryException,
                       EC_INVALID_REGISTRY,
                       "invalid registry" )
/* -------------------------------------------------------------------------- */
 
 
template<registry_input_factory FactoryType>
class Registry
{
 
private:
 
  RegistryRaw registryRaw;
 
  std::vector<
    std::pair<std::string, std::shared_ptr<typename FactoryType::input_type>>>
    inputs;
 
 
public:
 
  using input_type = typename FactoryType::input_type;
 
 
  explicit Registry( RegistryRaw registry, FactoryType & factory )
    : registryRaw( std::move( registry ) )
  {
    for ( const std::reference_wrapper<const std::string> & _name :
          this->registryRaw.getOrder() )
      {
        const auto & pair = std::find_if(
          this->registryRaw.inputs.begin(),
          this->registryRaw.inputs.end(),
          [&]( const auto & pair ) { return pair.first == _name.get(); } );
 
        /* Throw an exception if a registry input is an indirect reference. */
        if ( pair->second.getFlakeRef()->input.getType() == "indirect" )
          {
            throw InvalidRegistryException(
              "registry contained an indirect reference" );
          }
 
        /* Fill default/fallback values if none are defined. */
        RegistryInput input = pair->second;
        if ( ! input.subtrees.has_value() )
          {
            input.subtrees = this->registryRaw.defaults.subtrees;
          }
 
        /* Construct the input */
        this->inputs.emplace_back(
          std::make_pair( pair->first,
                          factory.mkInput( pair->first, input ) ) );
      }
  }
 
  [[nodiscard]] std::shared_ptr<typename FactoryType::input_type>
  get( const std::string & name ) const noexcept
  {
    const auto maybeInput
      = std::find_if( this->inputs.begin(),
                      this->inputs.end(),
                      [&]( const auto & pair ) { return pair.first == name; } );
    if ( maybeInput == this->inputs.end() ) { return nullptr; }
    return maybeInput->second;
  }
 
  [[nodiscard]] std::shared_ptr<typename FactoryType::input_type>
  at( const std::string & name ) const
  {
    const std::shared_ptr<typename FactoryType::input_type> maybeInput
      = this->get( name );
    if ( maybeInput == nullptr )
      {
        throw std::out_of_range( "No such input '" + name + "'" );
      }
    return maybeInput;
  }
 
  [[nodiscard]] const RegistryRaw &
  getRaw() const
  {
    return this->registryRaw;
  }
 
  /* Forwarded container functions. */
 
  [[nodiscard]] auto
  size() const
  {
    return this->inputs.size();
  }
 
  [[nodiscard]] auto
  empty() const
  {
    return this->inputs.empty();
  }
 
  [[nodiscard]] auto
  begin()
  {
    return this->inputs.begin();
  }
 
  [[nodiscard]] auto
  end()
  {
    return this->inputs.end();
  }
 
  [[nodiscard]] auto
  begin() const
  {
    return this->inputs.cbegin();
  }
 
  [[nodiscard]] auto
  end() const
  {
    return this->inputs.cend();
  }
 
  [[nodiscard]] auto
  cbegin() const
  {
    return this->inputs.cbegin();
  }
 
  [[nodiscard]] auto
  cend() const
  {
    return this->inputs.cend();
  }
 
 
}; /* End class `Registry' */
 
 
/* -------------------------------------------------------------------------- */
 
class FloxFlakeInput : public RegistryInput
{
 
  /* From `RegistryInput':
   *   public:
   *     std::optional<std::vector<Subtree>>     subtrees;
   *     std::shared_ptr<nix::FlakeRef>          from;
   */
 
private:
 
  nix::ref<nix::Store>       store; 
  std::shared_ptr<FloxFlake> flake; 
  std::optional<std::vector<Subtree>> enabledSubtrees;
 
 
public:
 
  FloxFlakeInput( const nix::ref<nix::Store> & store,
                  const RegistryInput &        input )
    : RegistryInput( input ), store( store )
  {}
 
 
  [[nodiscard]] nix::ref<FloxFlake>
  getFlake();
 
 
  [[nodiscard]] const std::vector<Subtree> &
  getSubtrees();
 
 
  [[nodiscard]] RegistryInput
  getLockedInput();
 
 
}; /* End struct `FloxFlakeInput' */
 
 
/* -------------------------------------------------------------------------- */
 
class FloxFlakeInputFactory : NixStoreMixin
{
 
public:
 
  using input_type = FloxFlakeInput;
 
  FloxFlakeInputFactory() = default;
 
  explicit FloxFlakeInputFactory( const nix::ref<nix::Store> & store )
    : NixStoreMixin( store )
  {}
 
  [[nodiscard]] std::shared_ptr<FloxFlakeInput>
  mkInput( const std::string & /* unused */, const RegistryInput & input )
  {
    return std::make_shared<FloxFlakeInput>( this->getStore(), input );
  }
 
 
}; /* End class `FloxFlakeInputFactory' */
 
 
static_assert( registry_input_factory<FloxFlakeInputFactory> );
 
 
/* -------------------------------------------------------------------------- */
 
class FlakeRegistry : public Registry<FloxFlakeInputFactory>
{
 
public:
 
  FlakeRegistry( RegistryRaw registryRaw, FloxFlakeInputFactory & factory )
    : Registry<FloxFlakeInputFactory>( std::move( registryRaw ), factory )
  {}
 
  [[nodiscard]] std::map<std::string, RegistryInput>
  getLockedInputs();
 
 
}; /* End class `FlakeRegistry' */
 
 
/* -------------------------------------------------------------------------- */
 
RegistryRaw
lockRegistry( const RegistryRaw &          unlocked,
              const nix::ref<nix::Store> & store = NixStoreMixin().getStore() );
 
 
/* -------------------------------------------------------------------------- */
 
RegistryRaw
getGARegistry();
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */