util.hh

Go to the documentation of this file.

/* ========================================================================== *
 *
 * @file flox/core/util.hh
 *
 * @brief Miscellaneous helper functions.
 *
 *
 * -------------------------------------------------------------------------- */
 
#pragma once
 
#include <filesystem>
#include <initializer_list>
#include <sstream>
#include <string>  // For `std::string' and `std::string_view'
#include <string_view>
#include <variant>
#include <vector>
 
#include <nix/attrs.hh>
#include <nix/flake/flakeref.hh>
#include <nlohmann/json.hpp>
 
#include "flox/core/exceptions.hh"
#include "flox/core/types.hh"
 
 
/* -------------------------------------------------------------------------- */
 
/* Backported from C++20a for C++20b compatability. */
 
template<class... Ts>
struct overloaded : Ts...
{
  using Ts::operator()...;
};
 
template<class... Ts>
overloaded( Ts... ) -> overloaded<Ts...>;
 
 
/* -------------------------------------------------------------------------- */
 
namespace nlohmann {
 
/* -------------------------------------------------------------------------- */
 
template<typename A, typename B>
struct adl_serializer<std::variant<A, B>>
{
 
  static void
  to_json( json & jto, const std::variant<A, B> & var )
  {
    if ( std::holds_alternative<A>( var ) ) { jto = std::get<A>( var ); }
    else { jto = std::get<B>( var ); }
  }
 
  static void
  from_json( const json & jfrom, std::variant<A, B> & var )
  {
    try
      {
        var = jfrom.template get<A>();
      }
    catch ( ... )
      {
        var = jfrom.template get<B>();
      }
  }
 
}; /* End struct `adl_serializer<std::variant<A, B>>' */
 
 
/* -------------------------------------------------------------------------- */
 
template<typename A, typename... Types>
struct adl_serializer<std::variant<A, Types...>>
{
 
  static void
  to_json( json & jto, const std::variant<A, Types...> & var )
  {
    /* This _unwraps_ the inner type and calls the proper `to_json'.
     * The compiler does the heavy lifting for us here <3. */
    std::visit( [&]( auto unwrapped ) -> void { jto = unwrapped; }, var );
  }
 
  static void
  from_json( const json & jfrom, std::variant<A, Types...> & var )
  {
    /* Try getting typename `A', or recur. */
    try
      {
        var = jfrom.template get<A>();
      }
    catch ( ... )
      {
        /* Strip typename `A' from variant, and call recursively. */
        using next_variant = std::variant<Types...>;
 
        /* Coerce to `next_variant' type. */
        next_variant next = jfrom.template get<next_variant>();
        std::visit( [&]( auto unwrapped ) -> void { var = unwrapped; }, next );
      }
  }
 
}; /* End struct `adl_serializer<std::variant<A, Types...>>' */
 
 
/* -------------------------------------------------------------------------- */
 
template<>
struct adl_serializer<nix::fetchers::Attrs>
{
 
  static void
  to_json( json & jto, const nix::fetchers::Attrs & attrs )
  {
    /* That was easy. */
    jto = nix::fetchers::attrsToJSON( attrs );
  }
 
  static void
  from_json( const json & jfrom, nix::fetchers::Attrs & attrs )
  {
    /* That was easy. */
    attrs = nix::fetchers::jsonToAttrs( jfrom );
  }
 
}; /* End struct `adl_serializer<nix::fetchers::Attrs>' */
 
 
/* -------------------------------------------------------------------------- */
 
template<>
struct adl_serializer<nix::FlakeRef>
{
 
  static void
  to_json( json & jto, const nix::FlakeRef & ref )
  {
    /* That was easy. */
    jto = nix::fetchers::attrsToJSON( ref.toAttrs() );
  }
 
  static nix::FlakeRef
  from_json( const json & jfrom )
  {
    if ( jfrom.is_object() )
      {
        return { nix::FlakeRef::fromAttrs(
          nix::fetchers::jsonToAttrs( jfrom ) ) };
      }
    return { nix::parseFlakeRef( jfrom.get<std::string>() ) };
  }
 
}; /* End struct `adl_serializer<nix::FlakeRef>' */
 
 
/* -------------------------------------------------------------------------- */
 
}  // namespace nlohmann
 
 
/* -------------------------------------------------------------------------- */
 
namespace flox {
 
/* -------------------------------------------------------------------------- */
 
inline static const std::vector<std::string> &
getDefaultSystems()
{
  static const std::vector<std::string> defaultSystems
    = { "x86_64-linux", "aarch64-linux", "x86_64-darwin", "aarch64-darwin" };
  return defaultSystems;
}
 
 
inline static const std::vector<std::string> &
getDefaultSubtrees()
{
  static const std::vector<std::string> defaultSubtrees
    = { "packages", "legacyPackages" };
  return defaultSubtrees;
}
 
 
/* -------------------------------------------------------------------------- */
 
bool
isSQLiteDb( const std::string & dbPath );
 
 
/* -------------------------------------------------------------------------- */
 
nix::FlakeRef
parseFlakeRef( const std::string & flakeRef );
 
 
/* -------------------------------------------------------------------------- */
 
nlohmann::json
parseOrReadJSONObject( const std::string & jsonOrPath );
 
 
/* -------------------------------------------------------------------------- */
 
nlohmann::json
tomlToJSON( std::string_view toml );
 
 
/* -------------------------------------------------------------------------- */
 
nlohmann::json
yamlToJSON( std::string_view yaml );
 
 
/* -------------------------------------------------------------------------- */
 
nlohmann::json
readAndCoerceJSON( const std::filesystem::path & path );
 
 
/* -------------------------------------------------------------------------- */
 
std::vector<std::string>
splitAttrPath( std::string_view path );
 
 
/* -------------------------------------------------------------------------- */
 
bool
isUInt( std::string_view str );
 
 
/* -------------------------------------------------------------------------- */
 
bool
hasPrefix( std::string_view prefix, std::string_view str );
 
 
/* -------------------------------------------------------------------------- */
 
std::string &
ltrim( std::string & str );
 
std::string &
rtrim( std::string & str );
 
std::string &
trim( std::string & str );
 
 
[[nodiscard]] std::string
ltrim_copy( std::string_view str );
 
[[nodiscard]] std::string
rtrim_copy( std::string_view str );
 
[[nodiscard]] std::string
trim_copy( std::string_view str );
 
 
/* -------------------------------------------------------------------------- */
 
std::string
extract_json_errmsg( nlohmann::json::exception & err );
 
/* -------------------------------------------------------------------------- */
 
template<typename Exception = FloxException>
static void
assertIsJSONObject( const nlohmann::json & value,
                    const std::string &    who = "JSON value" )
{
  if ( ! value.is_object() )
    {
      std::stringstream oss;
      oss << "expected " << who << " to be an object, but found "
          << ( value.is_array() ? "an" : "a" ) << ' ' << value.type_name()
          << '.';
      throw Exception( oss.str() );
    }
}
 
 
/* -------------------------------------------------------------------------- */
 
template<typename T>
std::vector<T>
merge_vectors( const std::vector<T> & lower, const std::vector<T> & higher )
{
  std::vector<T> merged = higher;
  for ( const auto & value : lower )
    {
      if ( std::find( merged.begin(), merged.end(), value ) == merged.end() )
        {
          merged.emplace_back( value );
        }
    }
  return merged;
}
 
 
/* -------------------------------------------------------------------------- */
 
template<typename T>
[[nodiscard]] std::vector<std::optional<T>>
vectorMapOptional( const std::vector<T> & orig )
{
  std::vector<std::optional<T>> rsl;
  for ( const T & val : orig )
    {
      rsl.emplace_back( std::make_optional<T>( val ) );
    }
  return rsl;
}
 
/* -------------------------------------------------------------------------- */
 
std::string
displayableGlobbedPath( const AttrPathGlob & attrs );
 
/* -------------------------------------------------------------------------- */
 
}  // namespace flox
 
 
/* -------------------------------------------------------------------------- *
 *
 *
 *
 * ========================================================================== */