libmetro.h

#ifndef LIBMETRO_H
#define LIBMETRO_H

#include <chrono>
#include <stdexcept>
#include <string>
#include <vector>

// forward declare the private implementation of Metronome
namespace metro_private {
class MetronomePrivate;
};

namespace metro {


const float SampleRateHz = 48000.0;

class MetroException : public std::runtime_error {
public:
    MetroException(std::string msg)
        : std::runtime_error(msg){};
};


class Note {
public:
    enum Timbre {
        Sine, 
        Drum, 
    };


    Note()
        : frames(std::vector<float>(2 * SampleRateHz)){};


    Note(Timbre timbre, float frequency, float volume);

    //
    // Parses a string in the format timbre,freq,vol
    // e.g. sine,440.0,50.0
    //
    Note(std::string triplet);

    float& operator[](size_t index) { return frames[index]; };

    const float& operator[](size_t index) const { return frames[index]; };

    std::vector<float>& get_frames() { return frames; };

    size_t size() { return frames.size(); };

    Note operator+(const Note& other)
    {
        metro::Note ret;
        for (size_t i = 0; i < ret.size(); ++i)
            ret[i] = (*this)[i] + other[i];
        return ret;
    }

private:
    std::vector<float> frames;
};


class Measure {
public:
    enum FileFormat {
        One, 
        Two, 
    };


    Measure(int num_notes)
        : notes(num_notes){};


    Measure(const char* path, FileFormat file_format);

    Note& operator[](size_t index) { return notes[index]; };

    const Note& operator[](size_t index) const { return notes[index]; };

    std::vector<Note>& get_notes() { return notes; };

    size_t size() { return notes.size(); };

private:
    std::vector<Note> notes;
};


class Metronome {
public:

    Metronome(int bpm);

    ~Metronome();


    void add_measure(Measure& measure);


    void start();

    void start_and_loop();

private:
    metro_private::MetronomePrivate*
        p_impl; // https://en.cppreference.com/w/cpp/language/pimpl
};
}; // namespace metro

#endif /* LIBMETRO_H */