Music.hpp

Go to the documentation of this file.

#ifndef MUSIC_HPP_INCLUDED
#define MUSIC_HPP_INCLUDED

#define BOOST

#include <map>
#include <vector>
#include <climits>
#include <iostream>
#include <stdexcept>
#include <cassert>
#include <functional>
#ifdef BOOST
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wall"
#pragma GCC diagnostic ignored "-Wextra"
#pragma GCC diagnostic ignored "-Wconversion"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wsign-conversion"
#pragma GCC diagnostic ignored "-Wsuggest-attribute=const"
#pragma GCC diagnostic ignored "-Wsuggest-attribute=pure"
#pragma GCC diagnostic ignored "-Wstrict-overflow"
#pragma GCC diagnostic ignored "-Weffc++"
#include <boost/rational.hpp>
#pragma GCC diagnostic pop
#endif

enum class NoteName{C,D,E,F,G,A,B};

std::ostream& operator <<(std::ostream& o, NoteName n);

std::istream& operator >>(std::istream& i, NoteName& n);

enum class Accidental
{
    Flat,
    Sharp,
    None
};

std::ostream& operator <<(std::ostream& o, Accidental a);

std::istream& operator >>(std::istream& i, Accidental& a);

using Octave = unsigned;
#ifdef BOOST
using Fraction = boost::rational<int>;
#else
#warning "Not using boost is a problem"
using Fraction = float;
#endif

struct CompleteNoteName
{
    NoteName m_name; 
    Accidental m_modifier;

    CompleteNoteName(NoteName n=NoteName::C, Accidental mod=Accidental::None);
    bool operator==(const CompleteNoteName& o) const __attribute__((pure));
    bool operator!=(const CompleteNoteName& o) const __attribute__((pure));
};

std::ostream& operator <<(std::ostream& o, const CompleteNoteName& n);

std::istream& operator >>(std::istream& i, CompleteNoteName& n);

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Weffc++"

struct Pitch : public CompleteNoteName
{
    Octave m_octave; 

    Pitch(const CompleteNoteName& n, Octave o = 4);
    Pitch(NoteName n = NoteName::C, Accidental mod=Accidental::None, Octave o = 4);
    Pitch& operator+=(int nb);
    Pitch operator+(int nb) const __attribute__((pure));
    Pitch& operator-=(int nb);
    Pitch operator-(int nb) const __attribute__((pure));
    bool operator==(const Pitch& o) const __attribute__((pure));
    bool operator!=(const Pitch& o) const __attribute__((pure));
    CompleteNoteName getNoteName() const __attribute__((pure));
};

std::ostream& operator <<(std::ostream& o, const Pitch& n);

std::istream& operator >>(std::istream& i, Pitch& n);

struct Note : public Pitch
{
    Fraction m_duration; 

    Note(const Pitch& n = Pitch(), const Fraction& duration = 1);
    Note(NoteName n, Accidental mod=Accidental::None, Octave o = 4, const Fraction& duration = Fraction(1));
    bool operator==(const Note& o) const __attribute__((pure));
    bool operator!=(const Note& o) const __attribute__((pure));
    static unsigned noteToHalfTone(const CompleteNoteName& n) __attribute__((const));
};

#pragma GCC diagnostic pop

std::ostream& operator <<(std::ostream& o, const Note& n);

std::istream& operator >>(std::istream& i, Note& n);

class Measure
{
public :
    //Constructor must verify Measure invariants

    using Position = Fraction;
    using ConstIterator = std::map<Position, Note>::const_iterator;

    //Constructor

    Measure(bool binary = true, unsigned duration = 4);

    ConstIterator begin() const __attribute__((pure));
    ConstIterator end() const __attribute__((pure));
    unsigned getDuration() const __attribute__((pure));

    void changeDuration(unsigned d);
    bool isBinary() const __attribute__((pure));

    void setBinary(bool b);



    ConstIterator getNoteBeingPlayedAt(const Position& p) const __attribute__((pure));

    void addNote(const Position& p, const Note& n);

    bool operator==(const Measure& o) const __attribute__((pure));

    bool operator!=(const Measure& o) const __attribute__((pure));
private :

    std::map<Position, Note> m_starts; 
    unsigned m_duration; 
    bool m_binary;


};

std::ostream& operator <<(std::ostream& o, const Measure& m);

std::istream& operator >>(std::istream& i, Measure& m);

struct Key
{
    CompleteNoteName m_base; 
    NoteName m_mode; 

    Key(const CompleteNoteName& base=CompleteNoteName(), const NoteName& mode = NoteName::C);

    std::vector<CompleteNoteName> getNotes() const;

    void normalize(CompleteNoteName& c) const;
    bool operator==(const Key& k) const __attribute__((pure));

    bool operator!=(const Key& k) const __attribute__((pure));
    //What about == and != operators ?
};

std::ostream& operator <<(std::ostream& o, const Key& k);

Key readKey(const std::string& str);

struct Chord
{
    enum class ChordType
    {
        Minor, 
        Major, 
        Sus4, 
        Sus2,
        Dim, 
        Aug 
        };
    Fraction m_duration;
    CompleteNoteName m_base; 

    enum class SeventhType
    {
        Major,
        Minor,
        Dim,
        None
        };
    SeventhType m_seventh; 
    ChordType m_type; 

    std::vector<CompleteNoteName> getNotes() const __attribute__((pure));

    Chord(Fraction d = 4, const CompleteNoteName& b= CompleteNoteName(), const SeventhType& s = SeventhType::None, const ChordType& c = ChordType::Major);

    bool operator==(const Chord& o) const __attribute__((pure));
    bool operator!=(const Chord& o) const __attribute__((pure));
    
    using ChordID = unsigned;
    explicit Chord(ChordID id);
    explicit operator ChordID() const;
    static const unsigned nbChords = 6*4*12;
    static const std::vector<CompleteNoteName>& getNotes(ChordID c);

};

std::ostream& operator <<(std::ostream& o, const Chord& c);

Chord readChord(const std::string& s);

using ChordProgression = std::vector<Chord>;

std::ostream& operator <<(std::ostream& o, const ChordProgression& c);

ChordProgression readChordProgression(const std::string& str);

ChordProgression moveCP(const ChordProgression& cp, int i, const Key& k);

class Melody
{
public:

    using ConstIterator = std::vector<Measure>::const_iterator;
    //Constructor

    Melody(const std::vector<Measure>& v,Key k, unsigned tempo = 120);

    Melody(const Key& k = Key(NoteName::C));


    std::vector<Measure> convertToMeasures() const __attribute__((pure));

    const Key& getKey() const __attribute__((pure));

    // Set_functions


    ConstIterator begin() const __attribute__((pure));
    ConstIterator end() const __attribute__((pure));
    unsigned size() const;

    Melody transpose(const Key& k) const;

    bool isBinary() const;

    bool operator==(const Melody& o) const __attribute__((pure));
    bool operator!=(const Melody& o) const __attribute__((pure));
    
    std::ostream& createABCChordFile(std::ostream& out, const ChordProgression& chords) const;
    
    unsigned m_BPM;
private:
    std::vector<Measure> m_measures;
    Key m_k; 
};

std::ostream& operator <<(std::ostream& o, const Melody& m);

Melody readMelody(const std::string& str);

#endif // MUSIC_HPP_INCLUDED