document_session.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/timeline/command.hpp>
#include <pulp/timeline/journal.hpp>
#include <pulp/timeline/undo.hpp>
 
#include <atomic>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <memory>
#include <optional>
#include <type_traits>
 
namespace pulp::timeline {

 
namespace detail {
class DocumentSessionPreviewAccess;
class WriterTokenTestAccess;
} // namespace detail

struct SessionLimits {
    JournalLimits journal;
    UndoLimits undo;
    std::size_t max_writers = 32;
    std::size_t max_cached_results = 256;
};

enum class CommandClass : std::uint8_t {
    Clip,
    Note,
    Automation,
    Track,
    Take,
    Scene,
    Sequence,
    Device,
    Annotation,
    Timing,
    Asset,
};

inline constexpr std::size_t kCommandClassCount = 11;

enum class CommandIntent : std::uint8_t {
    Create,
    Modify,
    Remove,
};

inline constexpr std::size_t kCommandIntentCount = 3;

struct CommandAuthority {
    CommandClass command_class = CommandClass::Clip;
    CommandIntent intent = CommandIntent::Modify;
 
    constexpr bool operator==(const CommandAuthority&) const noexcept = default;
};
 
namespace detail {
template <class> inline constexpr bool unclassified_command_v = false;
} // namespace detail

template <class T> constexpr CommandAuthority command_authority_of() noexcept {
    using Class = CommandClass;
    using Intent = CommandIntent;
    if constexpr (std::is_same_v<T, InsertClip>)
        return {Class::Clip, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveClip>)
        return {Class::Clip, Intent::Remove};
    else if constexpr (std::is_same_v<T, MoveClip>)
        return {Class::Clip, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetClipPlaybackProperties>)
        return {Class::Clip, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetClipSequenceRef>)
        return {Class::Clip, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertNotes>)
        return {Class::Note, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveNotes>)
        return {Class::Note, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetNoteVelocity>)
        return {Class::Note, Intent::Modify};
    else if constexpr (std::is_same_v<T, ReplaceNoteContent>)
        return {Class::Note, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetNoteEvents>)
        return {Class::Note, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertMidiExpressionLane>)
        return {Class::Note, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveMidiExpressionLane>)
        return {Class::Note, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetMidiExpressionLanePoints>)
        return {Class::Note, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertAutomationLane>)
        return {Class::Automation, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveAutomationLane>)
        return {Class::Automation, Intent::Remove};
    else if constexpr (std::is_same_v<T, InsertTrack>)
        return {Class::Track, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveTrack>)
        return {Class::Track, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetTrackName>)
        return {Class::Track, Intent::Modify};
    else if constexpr (std::is_same_v<T, MoveTrack>)
        return {Class::Track, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetTrackMixer>)
        return {Class::Track, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetRecordArm>)
        return {Class::Track, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetTrackFreeze>)
        return {Class::Track, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertTakeLane>)
        return {Class::Take, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveTakeLane>)
        return {Class::Take, Intent::Remove};
    else if constexpr (std::is_same_v<T, InsertTake>)
        return {Class::Take, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveTake>)
        return {Class::Take, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetActiveTakeLane>)
        return {Class::Take, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetTakeComp>)
        return {Class::Take, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertScene>)
        return {Class::Scene, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveScene>)
        return {Class::Scene, Intent::Remove};
    else if constexpr (std::is_same_v<T, InsertSlot>)
        return {Class::Scene, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveSlot>)
        return {Class::Scene, Intent::Remove};
    else if constexpr (std::is_same_v<T, InsertSequence>)
        return {Class::Sequence, Intent::Create};
    else if constexpr (std::is_same_v<T, CloneSequence>)
        return {Class::Sequence, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveSequence>)
        return {Class::Sequence, Intent::Remove};
    else if constexpr (std::is_same_v<T, InsertDevice>)
        return {Class::Device, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveDevice>)
        return {Class::Device, Intent::Remove};
    else if constexpr (std::is_same_v<T, MoveDevice>)
        return {Class::Device, Intent::Modify};
    else if constexpr (std::is_same_v<T, RetargetDevice>)
        return {Class::Device, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetDeviceState>)
        return {Class::Device, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertMarker>)
        return {Class::Annotation, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveMarker>)
        return {Class::Annotation, Intent::Remove};
    else if constexpr (std::is_same_v<T, InsertRegion>)
        return {Class::Annotation, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveRegion>)
        return {Class::Annotation, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetChordScaleLane>)
        return {Class::Annotation, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetGroove>)
        return {Class::Annotation, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetDynamicsLane>)
        return {Class::Annotation, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetRegion>)
        return {Class::Annotation, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetTempoMap>)
        return {Class::Timing, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetMeterMap>)
        return {Class::Timing, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetProjectTuning>)
        return {Class::Timing, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetTrackTuning>)
        return {Class::Timing, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertModulator>)
        return {Class::Automation, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveModulator>)
        return {Class::Automation, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetModulator>)
        return {Class::Automation, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertMacro>)
        return {Class::Automation, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveMacro>)
        return {Class::Automation, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetMacro>)
        return {Class::Automation, Intent::Modify};
    else if constexpr (std::is_same_v<T, SetMacroValue>)
        return {Class::Automation, Intent::Modify};
    else if constexpr (std::is_same_v<T, InsertModulationRoute>)
        return {Class::Automation, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveModulationRoute>)
        return {Class::Automation, Intent::Remove};
    else if constexpr (std::is_same_v<T, SetModulationRoute>)
        return {Class::Automation, Intent::Modify};
    else if constexpr (std::is_same_v<T, CreateAsset>)
        return {Class::Asset, Intent::Create};
    else if constexpr (std::is_same_v<T, RemoveAsset>)
        return {Class::Asset, Intent::Remove};
    else
        static_assert(detail::unclassified_command_v<T>,
                      "every Command alternative needs a CommandAuthority");
}

CommandAuthority command_authority(const Command& command) noexcept;

constexpr std::uint64_t capability_bit(CommandAuthority authority) noexcept {
    return std::uint64_t{1} << (static_cast<std::size_t>(authority.command_class) *
                                    kCommandIntentCount +
                                static_cast<std::size_t>(authority.intent));
}

inline constexpr std::uint64_t kAllCommandAuthorities =
    (std::uint64_t{1} << (kCommandClassCount * kCommandIntentCount)) - 1;
static_assert(kCommandClassCount * kCommandIntentCount < 64,
              "writer capability pairs must fit in the mask");

struct WriterCapabilityMask {
    std::uint64_t allowed = [] {
        auto value = kAllCommandAuthorities;
        for (std::size_t index = 0; index < kCommandClassCount; ++index)
            value &= ~capability_bit(
                {static_cast<CommandClass>(index), CommandIntent::Remove});
        return value;
    }();

    std::size_t max_transaction_retained_bytes = std::numeric_limits<std::size_t>::max();
    std::size_t max_session_retained_bytes = std::numeric_limits<std::size_t>::max();
};

constexpr bool allows(const WriterCapabilityMask& mask, CommandAuthority authority) noexcept {
    return (mask.allowed & capability_bit(authority)) != 0;
}

constexpr WriterCapabilityMask deny(WriterCapabilityMask mask, CommandClass command_class,
                                    CommandIntent intent) noexcept {
    mask.allowed &= ~capability_bit({command_class, intent});
    return mask;
}

constexpr WriterCapabilityMask allow(WriterCapabilityMask mask, CommandClass command_class,
                                     CommandIntent intent) noexcept {
    mask.allowed |= capability_bit({command_class, intent});
    return mask;
}

constexpr WriterCapabilityMask unrestricted_capabilities() noexcept {
    WriterCapabilityMask mask;
    mask.allowed = kAllCommandAuthorities;
    return mask;
}

constexpr WriterCapabilityMask non_destructive_capabilities() noexcept {
    return WriterCapabilityMask{};
}

class WriterToken {
  public:
    class Provenance {
      public:
        constexpr Provenance() noexcept = default;

        constexpr bool valid() const noexcept {
            return writer_.valid() && owner_nonce_ != 0;
        }

        constexpr bool operator==(const Provenance&) const noexcept = default;
 
      private:
        friend class WriterToken;
        friend class DocumentSession;
        constexpr Provenance(WriterId writer, std::uint64_t owner_nonce) noexcept
            : writer_(writer), owner_nonce_(owner_nonce) {}
 
        WriterId writer_;
        std::uint64_t owner_nonce_ = 0;
    };

    WriterToken() = default;
    WriterToken(const WriterToken&) = delete;
    WriterToken& operator=(const WriterToken&) = delete;
    WriterToken(WriterToken&& other) noexcept;
    WriterToken& operator=(WriterToken&& other) noexcept;

    WriterId id() const noexcept {
        return id_;
    }

    [[nodiscard]] Provenance provenance() const noexcept {
        return Provenance(id_, owner_nonce_);
    }

    TransactionId allocate_transaction_id() noexcept;
    CommandId allocate_command_id() noexcept;
    UndoGroupId allocate_undo_group_id() noexcept;
 
  private:
    friend class DocumentSession;
    friend class detail::WriterTokenTestAccess;
    WriterId id_;
    std::uint64_t owner_nonce_ = 0;
    std::atomic<std::uint64_t> next_transaction_{1};
    std::atomic<std::uint64_t> next_command_{1};
    std::atomic<std::uint64_t> next_undo_group_{1};
};

struct DocumentView {
    std::shared_ptr<const Project> snapshot;
    DocumentRevision revision;
};

class DocumentSession {
  public:
    static runtime::Result<std::unique_ptr<DocumentSession>, TransactionError>
    create(Project initial, SessionLimits limits = {});
    static runtime::Result<std::unique_ptr<DocumentSession>, TransactionError>
    create(Project initial, SessionLimits limits, std::shared_ptr<JournalSink> journal_sink);
    static runtime::Result<std::unique_ptr<DocumentSession>, TransactionError>
    restore(Project checkpoint, DocumentRevision checkpoint_revision, SessionLimits limits,
            std::shared_ptr<JournalSink> journal_sink);
    ~DocumentSession();
 
    DocumentSession(const DocumentSession&) = delete;
    DocumentSession& operator=(const DocumentSession&) = delete;

    runtime::Result<WriterToken, TransactionError> register_writer();
    runtime::Result<WriterToken, TransactionError> register_writer(WriterCapabilityMask mask);
    std::optional<WriterCapabilityMask>
    writer_capabilities(WriterToken::Provenance provenance) const noexcept;
    DocumentView current() const noexcept;
    std::shared_ptr<const Project> snapshot() const noexcept;
    DocumentRevision revision() const noexcept;
    bool is_current_publication(const CommitResult& result) const noexcept;
    bool is_gesture_open(WriterToken::Provenance provenance, UndoGroupId group) const noexcept;
    runtime::Result<CommitResult, TransactionError> submit(WriterToken& writer,
                                                           Transaction transaction);
    runtime::Result<CommitResult, TransactionError> undo(WriterToken& writer);
    runtime::Result<CommitResult, TransactionError> redo(WriterToken& writer);
    bool can_undo() const noexcept;
    bool can_redo() const noexcept;
    CommandJournal journal() const;
    bool checkpoint(DocumentRevision durable_revision);
 
  private:
    friend class detail::DocumentSessionPreviewAccess;
    enum class SinkAttachment : std::uint8_t { Initialize, Restore };
 
    static runtime::Result<std::unique_ptr<DocumentSession>, TransactionError>
    create_impl(Project checkpoint, DocumentRevision checkpoint_revision, SessionLimits limits,
                std::shared_ptr<JournalSink> journal_sink, SinkAttachment attachment);
 
    struct Impl;
    explicit DocumentSession(std::unique_ptr<Impl> impl);
    std::unique_ptr<Impl> impl_;
};

 
} // namespace pulp::timeline