lockfile.hh

Go to the documentation of this file.

#pragma once
 
#include "lix/libexpr/flake/flakeref.hh"
#include "lix/libutil/json-fwd.hh"
 
namespace nix {
class Store;
class StorePath;
}
 
namespace nix::flake {
 
typedef std::vector<FlakeId> InputPath;
 
struct LockedNode;

struct Node : std::enable_shared_from_this<Node>
{
    typedef std::variant<ref<LockedNode>, InputPath> Edge;
 
    std::map<FlakeId, Edge> inputs;
 
    virtual ~Node() { }
};

struct LockedNode : Node
{
    FlakeRef lockedRef, originalRef;
    bool isFlake = true;
 
    LockedNode(
        const FlakeRef & lockedRef,
        const FlakeRef & originalRef,
        bool isFlake = true)
        : lockedRef(lockedRef), originalRef(originalRef), isFlake(isFlake)
    { }
 
    LockedNode(const JSON & json);
 
    StorePath computeStorePath(Store & store) const;
};
 
struct LockFile
{
    ref<Node> root = make_ref<Node>();
 
    LockFile() {};
    LockFile(const JSON & json, const Path & path);
 
    typedef std::map<ref<const Node>, std::string> KeyMap;
 
    JSON toJSON() const;
 
    std::string to_string() const;
 
    static LockFile read(const Path & path);
 
    void write(const Path & path) const;

    std::optional<FlakeRef> isUnlocked() const;
 
    bool operator ==(const LockFile & other) const;
    // Needed for old gcc versions that don't synthesize it (like gcc 8.2.2
    // that is still the default on aarch64-linux)
    bool operator !=(const LockFile & other) const;
 
    std::shared_ptr<Node> findInput(const InputPath & path);
 
    std::map<InputPath, Node::Edge> getAllInputs() const;
 
    static std::string diff(const LockFile & oldLocks, const LockFile & newLocks);

    void check();
};
 
std::ostream & operator <<(std::ostream & stream, const LockFile & lockFile);
 
InputPath parseInputPath(std::string_view s);
 
std::string printInputPath(const InputPath & path);
 
}