types.hh

Go to the documentation of this file.

#pragma once
 
#include <list>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <map>
#include <vector>
#include <span>
#include <stdint.h> // IWYU pragma: keep (this is used literally everywhere)
 
namespace nix {
 
typedef std::list<std::string> Strings;
typedef std::set<std::string> StringSet;
typedef std::map<std::string, std::string> StringMap;
typedef std::map<std::string, std::string> StringPairs;
 
// TODO this should be a std::byte span, but too much of the
// current codebase predates std::byte and uses char instead
using Bytes = std::span<const char>;

typedef std::string Path;
typedef std::string_view PathView;
typedef std::list<Path> Paths;
typedef std::set<Path> PathSet;
 
typedef std::vector<std::pair<std::string, std::string>> Headers;

template<typename T>
struct Explicit {
    T t;
 
    bool operator ==(const Explicit<T> & other) const
    {
        return t == other.t;
    }
};

template <class T>
const typename T::mapped_type * get(const T & map, const typename T::key_type & key)
{
    auto i = map.find(key);
    if (i == map.end()) return nullptr;
    return &i->second;
}
 
template <class T>
typename T::mapped_type * get(T & map, const typename T::key_type & key)
{
    auto i = map.find(key);
    if (i == map.end()) return nullptr;
    return &i->second;
}

template<class T>
const typename T::mapped_type & getOr(
    T & map [[clang::lifetimebound]],
    const typename T::key_type & key,
    const typename T::mapped_type & defaultValue [[clang::lifetimebound]]
)
{
    auto i = map.find(key);
    if (i == map.end()) {
        /* FIXME(Raito): `[[clang::lifetimebound]]` has no effect on `defaultValue` warning. */
        // NOLINTNEXTLINE(bugprone-return-const-ref-from-parameter)
        return defaultValue;
    }
    return i->second;
}

template <class T>
std::optional<typename T::value_type> remove_begin(T & c)
{
    auto i = c.begin();
    if (i == c.end()) return {};
    auto v = std::move(*i);
    c.erase(i);
    return v;
}
 

template <class T>
std::optional<typename T::value_type> pop(T & c)
{
    if (c.empty()) return {};
    auto v = std::move(c.front());
    c.pop();
    return v;
}
 

template<typename T>
struct MaintainCount
{
    T & counter;
    long delta;
    MaintainCount(T & counter, long delta = 1) : counter(counter), delta(delta) { counter += delta; }
    ~MaintainCount() { counter -= delta; }
};
 

template <typename T,
          typename TIter = decltype(std::begin(std::declval<T>())),
          typename = decltype(std::end(std::declval<T>()))>
constexpr auto enumerate(T && iterable)
{
    struct iterator
    {
        size_t i;
        TIter iter;
        constexpr bool operator != (const iterator & other) const { return iter != other.iter; }
        constexpr void operator ++ () { ++i; ++iter; }
        constexpr auto operator * () { return std::tie(i, *iter); }
    };
 
    struct iterable_wrapper
    {
        T iterable;
        constexpr auto begin() { return iterator{ 0, std::begin(iterable) }; }
        constexpr auto end() { return iterator{ 0, std::end(iterable) }; }
    };
 
    return iterable_wrapper{ std::forward<T>(iterable) };
}
 

template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

struct NeverAsync {};

constexpr inline NeverAsync always_progresses;
 
}