content-address.hh

Go to the documentation of this file.

#pragma once
 
#include <variant>
#include "lix/libutil/hash.hh"
#include "lix/libstore/path.hh"
#include "lix/libutil/comparator.hh"
#include "lix/libutil/variant-wrapper.hh"
 
namespace nix {
 
/*
 * Content addressing method
 */
 
/* We only have one way to hash text with references, so this is a single-value
   type, mainly useful with std::variant.
*/

struct TextIngestionMethod : std::monostate { };

enum struct FileIngestionMethod : uint8_t {
    Flat = false,
    Recursive = true
};

std::string makeFileIngestionPrefix(FileIngestionMethod m);

struct ContentAddressMethod
{
    typedef std::variant<
        TextIngestionMethod,
        FileIngestionMethod
    > Raw;
 
    Raw raw;
 
    GENERATE_CMP(ContentAddressMethod, me->raw);
 
    MAKE_WRAPPER_CONSTRUCTOR(ContentAddressMethod);

    static ContentAddressMethod parsePrefix(std::string_view & m);

    std::string renderPrefix() const;

    static std::pair<ContentAddressMethod, HashType> parse(std::string_view rawCaMethod);

    std::string render(HashType ht) const;
};
 
 
/*
 * Mini content address
 */

struct ContentAddress
{
    ContentAddressMethod method;

    Hash hash;
 
    GENERATE_CMP(ContentAddress, me->method, me->hash);

    std::string render() const;
 
    static ContentAddress parse(std::string_view rawCa);
 
    static std::optional<ContentAddress> parseOpt(std::string_view rawCaOpt);
 
    std::string printMethodAlgo() const;
};

std::string renderContentAddress(std::optional<ContentAddress> ca);
 
 
/*
 * Full content address
 *
 * See the schema for store paths in store-api.cc
 */

struct StoreReferences
{
    StorePathSet others;

    bool self = false;

    bool empty() const;

    size_t size() const;
 
    GENERATE_CMP(StoreReferences, me->self, me->others);
};
 
// This matches the additional info that we need for makeTextPath
struct TextInfo
{
    Hash hash;

    StorePathSet references;
 
    GENERATE_CMP(TextInfo, me->hash, me->references);
};
 
struct FixedOutputInfo
{
    FileIngestionMethod method;

    Hash hash;

    StoreReferences references;
 
    GENERATE_CMP(FixedOutputInfo, me->hash, me->references);
};

struct ContentAddressWithReferences
{
    typedef std::variant<
        TextInfo,
        FixedOutputInfo
    > Raw;
 
    Raw raw;
 
    GENERATE_CMP(ContentAddressWithReferences, me->raw);
 
    MAKE_WRAPPER_CONSTRUCTOR(ContentAddressWithReferences);

    static ContentAddressWithReferences withoutRefs(const ContentAddress &);

    static std::optional<ContentAddressWithReferences> fromPartsOpt(
        ContentAddressMethod method, Hash hash, StoreReferences refs);
 
    ContentAddressMethod getMethod() const;
 
    Hash getHash() const;
};
 
}