AtomicFileWriter.hpp

// SPDX-FileCopyrightText: 2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <span>
#include <string_view>
 
// Project includes
#include "EnumString.hpp"
#include "FileSystem.hpp"
#include "Log.hpp"
#include "PrivateState.hpp"
#include "Utility.hpp"
 
namespace dfx::Utils
{
class AtomicFileWriter
{
    DFX_PRIVATE_STATE(AtomicFileWriter, DFX_UTILITIES_LOGGER())
 
public:
    enum class State
    {
        Open,       
        Discarded,  
        Published,  
        Durable,    
    };

    enum class Backend
    {
        TmpFile, 
        Mktemp,  
    };

    struct Options
    {
        mode_t mode = 0644;

        bool fsyncFile = true;

        bool fsyncDir = true;

        Backend backend = Backend::TmpFile;
    };
 
public:
    explicit AtomicFileWriter(fs::path p);
    AtomicFileWriter(fs::path p, Options options);
    DFX_PRIVATE_STATE_DECLARE_RULE_OF_5(AtomicFileWriter);

    fs::path const & path() const noexcept;

    State state() const noexcept;
    bool isOpen() const noexcept      { return state() == State::Open; }
    bool isDiscarded() const noexcept { return state() == State::Discarded; }
    bool isPublished() const noexcept { return isOneOf(state(), { State::Published, State::Durable }); }
    bool isDurable() const noexcept   { return state() == State::Durable; }
 
public:
    void write(std::byte const * data, std::size_t len)
    { write(std::string_view(reinterpret_cast<std::string_view::value_type const *>(data), len)); }
 

    void write(std::span<std::byte const> data)
    { write(data.data(), data.size()); }
 

    void write(std::string_view data);
 
public:
    void commit();

    void discard() noexcept;
};
} // !namespace dfx::Utils
 
DFX_DECLARE_ENUM_STRING_FUNCTIONS(dfx::Utils::AtomicFileWriter::State);