types.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/core/types.hh
 *
 * @brief Miscellaneous typedefs and aliases
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <string>
#include <vector>
 
#include <nix/eval-cache.hh>
#include <nix/flake/flake.hh>
#include <nix/ref.hh>
 
#include <nlohmann/json.hpp>
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox {
 
/* -------------------------------------------------------------------------- */
 
using AttrPath = std::vector<std::string>;
 
using AttrPathGlob = std::vector<std::optional<std::string>>;
 
using MaybeCursor = std::shared_ptr<nix::eval_cache::AttrCursor>;
 
using Cursor = nix::ref<nix::eval_cache::AttrCursor>;
 
 
/* -------------------------------------------------------------------------- */
 
// TODO: Make this a real type/enum.
using System = std::string;
 
 
/* -------------------------------------------------------------------------- */
 
enum subtree_type { ST_NONE = 0, ST_LEGACY = 1, ST_PACKAGES = 2 };
 
/* Generate `to_json' and `from_json' for enum. */
NLOHMANN_JSON_SERIALIZE_ENUM( subtree_type,
                              { { ST_NONE, nullptr },
                                { ST_LEGACY, "legacyPackages" },
                                { ST_PACKAGES, "packages" } } )
 
 
struct Subtree
{
 
  subtree_type subtree = ST_NONE;
 
  constexpr Subtree() = default;
 
  // NOLINTNEXTLINE
  constexpr Subtree( subtree_type subtree ) : subtree( subtree ) {}
 
  constexpr explicit Subtree( std::string_view str ) noexcept
    : subtree( ( str == "legacyPackages" ) ? ST_LEGACY
               : ( str == "packages" )     ? ST_PACKAGES
                                           : ST_NONE )
  {}
 
 
  [[nodiscard]] static Subtree
  parseSubtree( std::string_view str )
  {
    return Subtree { ( str == "legacyPackages" ) ? ST_LEGACY
                     : ( str == "packages" )
                       ? ST_PACKAGES
                       : throw std::invalid_argument(
                         "Invalid subtree '" + std::string( str ) + "'" ) };
  }
 
 
  [[nodiscard]] friend constexpr std::string_view
  to_string( const Subtree & subtree )
  {
    switch ( subtree.subtree )
      {
        case ST_LEGACY: return "legacyPackages";
        case ST_PACKAGES: return "packages";
        default: return "ST_NONE";
      }
  }
 
  constexpr explicit
  operator std::string_view() const
  {
    return to_string( *this );
  }
 
  // NOLINTNEXTLINE
  constexpr
  operator subtree_type() const
  {
    return this->subtree;
  }
 
  [[nodiscard]] constexpr bool
  operator==( const Subtree & other ) const
    = default;
 
  [[nodiscard]] constexpr bool
  operator!=( const Subtree & other ) const
    = default;
 
  [[nodiscard]] constexpr bool
  operator==( const subtree_type & other ) const
  {
    return this->subtree == other;
  }
 
  [[nodiscard]] constexpr bool
  operator!=( const subtree_type & other ) const
  {
    return this->subtree != other;
  }
 
}; /* End struct `Subtree' */
 
 
/* -------------------------------------------------------------------------- */
 
inline void
from_json( const nlohmann::json & jfrom, Subtree & subtree )
{
  jfrom.get_to( subtree.subtree );
}
 
inline void
to_json( nlohmann::json & jto, const Subtree & subtree )
{
  to_json( jto, subtree.subtree );
}
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */