guido.h

/*

  Copyright (C) 2003  Grame

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  Grame Research Laboratory, 9 rue du Garet, 69001 Lyon - France
  grame@grame.fr

*/

#ifndef __guido__
#define __guido__

#include "exports.h"
#include "smartpointer.h"
#include "guidovisitor.h"

#include <vector>
#include <iostream>
#include <sstream>
#include <string>

using namespace std;

class guidovisitor;
class guidoelement;
class guidoparam;
typedef SMARTP<guidoelement>    Sguidoelement;
typedef SMARTP<guidoparam>      Sguidoparam;

VEXP ostream& operator<< (ostream& os, const Sguidoelement& elt);

class VEXP guidoparam : public smartable, public guidovisitable {
    public:
        VEXP friend SMARTP<guidoparam> new_guidoparam(string value, bool quote=true);
        VEXP friend SMARTP<guidoparam> new_guidoparam(long value, bool quote=true);

        void set (string value, bool quote=true);
        void set (long value, bool quote=true);
        string get () const                         { return fValue; }
        bool   quote () const                       { return fQuote; }
        
        void accept(guidovisitor& visitor);

    protected:
        guidoparam(string value, bool quote) : fValue(value), fQuote(quote) {}
        guidoparam(long value, bool quote)   { set(value, quote); }
        virtual ~guidoparam () {}
        
    private:
        string  fValue;
        bool    fQuote;
};

class VEXP guidoelement : public smartable, public guidovisitable {
    public:
        VEXP friend SMARTP<guidoelement> new_guidoelement(string name, string sep=" ");
        
        long add (Sguidoelement& elt);
        long add (Sguidoparam& param);
#ifndef WIN32
        long add (Sguidoparam param);
#endif
        void print (ostream& os);

        void    setName (string name)           { fName = name; }
        string  getName () const                { return fName; }
        string  getStart () const               { return fStartList; }
        string  getEnd () const                 { return fEndList; }
        string  getSep () const                 { return fSep; }
        const vector<Sguidoelement>& elements() const   { return fElements; }
        const vector<Sguidoparam>& parameters() const   { return fParams; }
        
        bool empty () const { return fElements.empty(); }

        virtual void accept(guidovisitor& visitor);

    protected:
        guidoelement(string name, string sep=" ") : fName(name), fSep(sep) {}
        virtual ~guidoelement() {}

        string  fName;
        string  fStartList;
        string  fEndList;
        string  fSep;
        vector<Sguidoelement>   fElements;
        vector<Sguidoparam> fParams;        
};

class VEXP guidonoteduration {
    public:
        guidonoteduration(long num, long denom, long dots=0) 
            { set (num, denom, dots); }
        virtual ~guidonoteduration() {}
        
        void set (long num, long denom, long dots=0) 
            { fNum=num; fDenom=denom; fDots=dots; }
        guidonoteduration& operator= (const guidonoteduration& dur) 
            { fNum=dur.fNum; fDenom=dur.fDenom; fDots=dur.fDots; return *this; }
        bool operator!= (const guidonoteduration& dur) const    
            { return (fNum!=dur.fNum) || (fDenom!=dur.fDenom) || (fDots!=dur.fDots); }

        long    fNum;
        long    fDenom;
        long    fDots;
};

class VEXP guidonote : public guidoelement {
    public:
        VEXP friend SMARTP<guidonote> new_guidonote(unsigned short voice, string name, char octave,
                                                guidonoteduration& dur, string acc="");
        
        void set (unsigned short voice, string name, char octave, 
                    guidonoteduration& dur, string acc);

        void accept(guidovisitor& visitor);

        const char *    name() const        { return fNote.c_str(); }
        const char *    accidental() const  { return fAccidental.c_str(); }
        char            octave() const      { return fOctave; }
        const guidonoteduration& duration() const { return fDuration; }

    protected:
        guidonote(unsigned short voice, string name, char octave, 
                    guidonoteduration& dur, string acc="") 
            : guidoelement(""), fDuration(1,4) { set(voice, name, octave, dur, acc); }
        virtual ~guidonote() {}
    
    string  fNote;
    string  fAccidental;
    char    fOctave;
    guidonoteduration fDuration;

};
typedef SMARTP<guidonote> Sguidonote;

class VEXP guidonotestatus {
    public:
        enum { kMaxInstances=128 };
        
        static guidonotestatus* get(unsigned short voice);
        static void resetall();

        enum { defoctave=1, defnum=1, defdenom=4 };
        
        void reset()    { fOctave=defoctave; fDur.set(defnum, defdenom, 0); }
        guidonotestatus& operator= (const guidonoteduration& dur)   { fDur = dur; return *this; }
        bool operator!= (const guidonoteduration& dur) const        { return fDur!= dur; }
            
        char                fOctave;
        guidonoteduration   fDur;
//      char                fBeat;

    protected:
        guidonotestatus() : fOctave(defoctave), fDur(defnum, defdenom, 0) {}
    private:
        static guidonotestatus * fInstances[kMaxInstances];
};

class VEXP guidoseq : public guidoelement {
    public:
        VEXP friend SMARTP<guidoseq> new_guidoseq();
        void accept(guidovisitor& visitor);
    protected:
        guidoseq() : guidoelement("") { fStartList="["; fEndList=" ]"; }
        virtual ~guidoseq() {}
};
typedef SMARTP<guidoseq> Sguidoseq;

class VEXP guidochord : public guidoelement {
    public:
        VEXP friend SMARTP<guidochord> new_guidochord();
        void accept(guidovisitor& visitor);
    protected:
        guidochord () : guidoelement("", ", ") { fStartList="{"; fEndList=" }"; }
        virtual ~guidochord() {}
};
typedef SMARTP<guidochord> Sguidochord;

class VEXP guidotag : public guidoelement {
    public:
        VEXP friend SMARTP<guidotag> new_guidotag(string name);
        void accept(guidovisitor& visitor);
    protected:
        guidotag(string name) : guidoelement("\\"+name) { fStartList="("; fEndList=")"; }
        virtual ~guidotag() {}
};
typedef SMARTP<guidotag> Sguidotag;
#endif

---