command.hpp

Go to the documentation of this file.

#pragma once
 
#include <pulp/timeline/midi_lane.hpp>
#include <pulp/timeline/model.hpp>
#include <pulp/timeline/modulation.hpp>
#include <pulp/timeline/tuning.hpp>
 
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
namespace pulp::timeline {


struct WriterId {
    std::uint64_t value = 0;
    constexpr bool valid() const noexcept {
        return value != 0;
    }
    constexpr auto operator<=>(const WriterId&) const = default;
};

struct CommandId {
    WriterId writer;
    std::uint64_t sequence = 0;
    constexpr bool valid() const noexcept {
        return writer.valid() && sequence != 0;
    }
    constexpr auto operator<=>(const CommandId&) const = default;
};

struct TransactionId {
    WriterId writer;
    std::uint64_t sequence = 0;
    constexpr bool valid() const noexcept {
        return writer.valid() && sequence != 0;
    }
    constexpr auto operator<=>(const TransactionId&) const = default;
};

struct DocumentRevision {
    std::uint64_t value = 0;
    constexpr auto operator<=>(const DocumentRevision&) const = default;
};

struct UndoGroupId {
    WriterId writer;
    std::uint64_t sequence = 0;
    constexpr bool valid() const noexcept {
        return writer.valid() && sequence != 0;
    }
    constexpr auto operator<=>(const UndoGroupId&) const = default;
};

enum class GesturePhase : std::uint8_t { Single, Begin, Update, End, Cancel };

struct InsertClip {
    ItemId sequence_id;
    ItemId track_id;
    Clip clip;
};

struct RemoveClip {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
};

struct InsertAutomationLane {
    ItemId sequence_id;
    ItemId track_id;
    AutomationLane lane;
};

struct RemoveAutomationLane {
    ItemId sequence_id;
    ItemId track_id;
    ItemId lane_id;
};

struct MoveClip {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    ClipTimeRange expected_range;
    ClipTimeRange replacement_range;
};

struct SetNoteVelocity {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    ItemId note_id;
    std::uint16_t expected_velocity = 0;
    std::uint16_t replacement_velocity = 0;
};

struct ReplaceNoteContent {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    std::vector<NoteEvent> expected;
    std::vector<NoteEvent> replacement;
    std::vector<NoteModifier> expected_modifiers;
    std::vector<NoteModifier> replacement_modifiers;
};

struct SetNoteEvents {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    std::vector<NoteEvent> expected;
    std::vector<NoteEvent> replacement;
};

struct InsertNotes {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    std::vector<NoteEvent> notes;
    std::vector<NoteModifier> modifiers;
};

struct RemoveNotes {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    std::vector<NoteEvent> expected;
};

struct SetClipPlaybackProperties {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    ClipPlaybackProperties expected;
    ClipPlaybackProperties replacement;
};

struct SetTempoMap {
    timebase::TempoMap expected;
    timebase::TempoMap replacement;
};

struct SetMeterMap {
    timebase::MeterMap expected;
    timebase::MeterMap replacement;
};

struct CreateAsset {
    MediaAsset asset;
};

struct RemoveAsset {
    ItemId asset_id;
};

struct InsertTakeLane {
    ItemId sequence_id;
    ItemId track_id;
    TakeLane lane;
};

struct RemoveTakeLane {
    ItemId sequence_id;
    ItemId track_id;
    ItemId lane_id;
};

struct InsertTake {
    ItemId sequence_id;
    ItemId track_id;
    ItemId lane_id;
    Take take;
};

struct RemoveTake {
    ItemId sequence_id;
    ItemId track_id;
    ItemId lane_id;
    ItemId take_id;
};

struct SetRecordArm {
    ItemId sequence_id;
    ItemId track_id;
    bool expected = false;
    bool replacement = false;
};

struct SetActiveTakeLane {
    ItemId sequence_id;
    ItemId track_id;
    ItemId expected_lane_id;
    ItemId replacement_lane_id;
};

struct SetTakeComp {
    ItemId sequence_id;
    ItemId track_id;
    ItemId lane_id;
    std::vector<TakeCompSegment> expected;
    std::vector<TakeCompSegment> replacement;
};

struct SetTrackFreeze {
    ItemId sequence_id;
    ItemId track_id;
    std::optional<TrackFreeze> expected;
    std::optional<TrackFreeze> replacement;
};

struct SetChordScaleLane {
    ItemId sequence_id;
    ChordScaleLane expected;
    ChordScaleLane replacement;
};

struct SetDynamicsLane {
    ItemId sequence_id;
    DynamicsLane expected;
    DynamicsLane replacement;
};

struct InsertMarker {
    ItemId sequence_id;
    SequenceMarker marker;
};

struct RemoveMarker {
    ItemId sequence_id;
    ItemId marker_id;
};

struct InsertRegion {
    ItemId sequence_id;
    SequenceRegion region;
};

struct RemoveRegion {
    ItemId sequence_id;
    ItemId region_id;
};

struct SetGroove {
    ItemId sequence_id;
    GrooveTemplate expected;
    GrooveTemplate replacement;
};

struct InsertScene {
    ItemId sequence_id;
    Scene scene;
    // Empty appends. An inverse names the item that originally followed the
    // removed scene so undo restores authored order exactly.
    std::optional<ItemId> before_scene_id = std::nullopt;
};

struct RemoveScene {
    ItemId sequence_id;
    ItemId scene_id;
};

struct InsertSlot {
    ItemId sequence_id;
    ItemId scene_id;
    Slot slot;
    // Empty appends. See InsertScene::before_scene_id.
    std::optional<ItemId> before_slot_id = std::nullopt;
};

struct RemoveSlot {
    ItemId sequence_id;
    ItemId scene_id;
    ItemId slot_id;
};

struct InsertSequence {
    Sequence sequence;
};

struct CloneSequence {
    ItemId source_sequence_id;
    ItemId cloned_sequence_id;
    // Complete old -> new mapping for every identity owned by the source
    // sequence. Canonical order is ascending by old id.
    std::vector<std::pair<ItemId, ItemId>> id_remap;
};

struct RemoveSequence {
    ItemId sequence_id;
};

struct SetClipSequenceRef {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    SequenceRef expected;
    SequenceRef replacement;
};

struct SetTrackMixer {
    ItemId sequence_id;
    ItemId track_id;
    TrackMixer expected;
    TrackMixer replacement;
};

struct InsertTrack {
    ItemId sequence_id;
    Track track;
    // Empty appends. See InsertScene::before_scene_id.
    std::optional<ItemId> before_track_id = std::nullopt;
};

struct RemoveTrack {
    ItemId sequence_id;
    ItemId track_id;
};

struct SetTrackName {
    ItemId sequence_id;
    ItemId track_id;
    std::string expected;
    std::string replacement;
};

struct MoveTrack {
    ItemId sequence_id;
    ItemId track_id;
    std::optional<ItemId> expected_before_track_id = std::nullopt;
    std::optional<ItemId> replacement_before_track_id = std::nullopt;
};

struct InsertDevice {
    ItemId sequence_id;
    ItemId track_id;
    DevicePlacement placement;
    std::optional<ItemId> before_device_id = std::nullopt;
};

struct RemoveDevice {
    ItemId sequence_id;
    ItemId track_id;
    ItemId device_id;
};

struct MoveDevice {
    ItemId sequence_id;
    ItemId track_id;
    ItemId device_id;
    std::optional<ItemId> expected_before_device_id = std::nullopt;
    std::optional<ItemId> replacement_before_device_id = std::nullopt;
};

struct RetargetDevice {
    ItemId sequence_id;
    ItemId track_id;
    ItemId device_id;
    DeviceConfiguration expected;
    DeviceConfiguration replacement;
};

struct SetDeviceState {
    ItemId sequence_id;
    ItemId track_id;
    ItemId device_id;
    std::optional<ContentHash> expected;
    std::optional<ContentHash> replacement;
};

struct InsertMidiExpressionLane {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    MidiExpressionLane lane;
};

struct RemoveMidiExpressionLane {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    ItemId lane_id;
};

struct SetMidiExpressionLanePoints {
    ItemId sequence_id;
    ItemId track_id;
    ItemId clip_id;
    ItemId lane_id;
    std::vector<MidiLanePoint> expected;
    std::vector<MidiLanePoint> replacement;
};

struct SetProjectTuning {
    std::optional<TuningReference> expected;
    std::optional<TuningReference> replacement;
};

struct SetTrackTuning {
    ItemId sequence_id;
    ItemId track_id;
    std::optional<TuningReference> expected;
    std::optional<TuningReference> replacement;
};

struct SetRegion {
    ItemId sequence_id;
    SequenceRegion expected;
    SequenceRegion replacement;
};

struct InsertModulator {
    ItemId sequence_id;
    ItemId track_id;
    Modulator modulator;
};

struct RemoveModulator {
    ItemId sequence_id;
    ItemId track_id;
    ItemId modulator_id;
};

struct SetModulator {
    ItemId sequence_id;
    ItemId track_id;
    ItemId modulator_id;
    Modulator expected;
    Modulator replacement;
};

struct InsertMacro {
    ItemId sequence_id;
    ItemId track_id;
    MacroControl macro;
};

struct RemoveMacro {
    ItemId sequence_id;
    ItemId track_id;
    ItemId macro_id;
};

struct SetMacro {
    ItemId sequence_id;
    ItemId track_id;
    ItemId macro_id;
    MacroControl expected;
    MacroControl replacement;
};

struct SetMacroValue {
    ItemId sequence_id;
    ItemId track_id;
    ItemId macro_id;
    float expected = 0.0f;
    float replacement = 0.0f;
};

struct InsertModulationRoute {
    ItemId sequence_id;
    ItemId track_id;
    ModulationRoute route;
};

struct RemoveModulationRoute {
    ItemId sequence_id;
    ItemId track_id;
    ItemId route_id;
};

struct SetModulationRoute {
    ItemId sequence_id;
    ItemId track_id;
    ItemId route_id;
    ModulationRoute expected;
    ModulationRoute replacement;
};

using Command = std::variant<
    InsertClip, RemoveClip, InsertAutomationLane, RemoveAutomationLane, MoveClip, SetNoteVelocity,
    ReplaceNoteContent, SetClipPlaybackProperties, SetTempoMap, SetMeterMap, CreateAsset,
    RemoveAsset, InsertTakeLane, RemoveTakeLane, SetRecordArm, InsertTake, RemoveTake,
    SetActiveTakeLane, SetTakeComp, SetTrackFreeze, InsertMarker, RemoveMarker, InsertRegion,
    RemoveRegion, SetChordScaleLane, SetGroove, InsertScene, RemoveScene, InsertSlot, RemoveSlot,
    InsertSequence, CloneSequence, RemoveSequence, SetClipSequenceRef, SetTrackMixer, InsertTrack,
    RemoveTrack, SetTrackName, MoveTrack, SetNoteEvents, InsertNotes, RemoveNotes, InsertDevice,
    RemoveDevice, MoveDevice, RetargetDevice, SetDeviceState, SetDynamicsLane,
    InsertMidiExpressionLane, RemoveMidiExpressionLane, SetMidiExpressionLanePoints,
    SetProjectTuning, SetTrackTuning, SetRegion, InsertModulator, RemoveModulator, SetModulator,
    InsertMacro, RemoveMacro, SetMacro, SetMacroValue, InsertModulationRoute, RemoveModulationRoute,
    SetModulationRoute>;

struct CommandEnvelope {
    CommandId id;
    Command command;
};

struct Transaction {
    TransactionId id;
    DocumentRevision expected_revision;
    std::optional<UndoGroupId> undo_group;
    GesturePhase gesture_phase = GesturePhase::Single;
    std::vector<CommandEnvelope> commands;
};

runtime::Result<Transaction, ModelError>
build_diverge_transaction(const Project& project, ItemLocation clip, TransactionId transaction_id,
                          DocumentRevision expected_revision, CommandId clone_command_id,
                          CommandId retarget_command_id,
                          std::optional<UndoGroupId> undo_group = std::nullopt);

bool equivalent(const ClipTimeRange& lhs, const ClipTimeRange& rhs) noexcept;
bool equivalent(const Clip& lhs, const Clip& rhs) noexcept;
bool equivalent(const AutomationLane& lhs, const AutomationLane& rhs) noexcept;
bool equivalent(const TakeLane& lhs, const TakeLane& rhs) noexcept;
bool equivalent(const Command& lhs, const Command& rhs) noexcept;
bool equivalent(const Transaction& lhs, const Transaction& rhs) noexcept;
std::size_t retained_size(const Command& command) noexcept;
std::size_t retained_size(const Transaction& transaction) noexcept;

 
} // namespace pulp::timeline