RhythmPattern.h

#ifndef MCC_RHYTHM_RHYTHM_PATTERN_H
#define MCC_RHYTHM_RHYTHM_PATTERN_H
 
#include <stddef.h>
#include <stdint.h>
 
#include <MCC_BuildSettings.h>
 
#include <Foundation/Containers/BitVector.h>
 
namespace MCC {

class RhythmPattern {
public:
    static constexpr uint16_t MaximumSteps = 0xFFFFu;

    static constexpr size_t BytesFor(uint32_t steps) noexcept {
        return Foundation::Containers::BitVector::BytesFor(steps);
    }

    RhythmPattern() noexcept : _steps() {}

    explicit RhythmPattern(int32_t steps) noexcept;

    RhythmPattern(uint8_t* buffer, size_t bytes) noexcept : _steps(buffer, bytes) {}
 
    // Copy, move and destruction follow Foundation::Containers::BitVector:
    // a copy owns exactly its steps; copy assignment, and move assignment
    // into an attached pattern, copy into the existing storage; a move
    // otherwise takes the storage; owned storage is freed on destruction.

    static RhythmPattern Invalid() noexcept { return RhythmPattern(); }

    static RhythmPattern FromMask(uint32_t onsets, int32_t steps) noexcept;

    static RhythmPattern FromString(const char* text) noexcept;

    static RhythmPattern FromIntervals(const char* text) noexcept;

    bool Attach(uint8_t* buffer, size_t bytes) noexcept { return _steps.Attach(buffer, bytes); }

    void Release() noexcept { _steps.Release(); }

    bool OwnsStorage() const noexcept { return _steps.OwnsStorage(); }

    bool Parse(const char* text) noexcept;

    bool ParseIntervals(const char* text) noexcept;

    bool IsValid() const noexcept { return !_steps.IsEmpty(); }

    uint16_t StepCount() const noexcept { return static_cast<uint16_t>(_steps.GetCount()); }

    uint16_t Capacity() const noexcept;

    uint16_t OnsetCount() const noexcept;

    bool IsOnset(int32_t step) const noexcept;

    int32_t OnsetStep(int32_t index) const noexcept;

    int32_t InteronsetInterval(int32_t index) const noexcept;

    bool SetOnset(int32_t step, bool onset = true) noexcept;

    bool Resize(int32_t steps) noexcept;

    bool Reserve(int32_t steps) noexcept;

    bool Append(bool onset = false) noexcept;

    bool Append(const RhythmPattern& other) noexcept;

    bool ShrinkToFit() noexcept;

    bool Rotate(int32_t steps) noexcept;

    bool Invert() noexcept;

    RhythmPattern Rotated(int32_t steps) const noexcept;

    bool IsRotationOf(const RhythmPattern& other) const noexcept;

    RhythmPattern Complement() const noexcept;

    RhythmPattern Concatenated(const RhythmPattern& other) const noexcept;

    friend bool operator==(const RhythmPattern& a, const RhythmPattern& b) noexcept {
        return a._steps == b._steps;
    }

    friend bool operator!=(const RhythmPattern& a, const RhythmPattern& b) noexcept {
        return a._steps != b._steps;
    }
 
private:
    // Bit i is step i; bits past the step count are always zero.
    Foundation::Containers::BitVector _steps;
 
    bool Bit(uint16_t step) const noexcept { return _steps.Get(step); }
    void ReverseSteps(uint16_t first, uint16_t last) noexcept;
};
 
} // namespace MCC
 
#endif // MCC_RHYTHM_RHYTHM_PATTERN_H