CGestalt.h

Go to the documentation of this file.

#ifndef CSL_Gestalt_H
#define CSL_Gestalt_H

#include "CSL_Types.h"      // The system default values are defined there

#include <stdarg.h>         // for va_arg, vaList, etc.
#include <string>

namespace csl {


class CGestalt {                        

public:                                             // Accessor (getter/setter) methods

    static unsigned frameRate();                    
    static void setFrameRate(unsigned frameRate);
    static sample framePeriod();                    

    static unsigned numInChannels();                
    static void setNumInChannels(unsigned numChannels);

    static unsigned numOutChannels();               
    static void setNumOutChannels(unsigned numChannels);

    static unsigned blockSize();                    
    static void setBlockSize(unsigned blockSize);

    static unsigned maxBufferFrames();              
    static void setMaxBufferFrames(unsigned numFrames);

    static unsigned maxSndFileFrames();             
    static void setMaxSndFileFrames(unsigned numFrames);

    static unsigned verbosity();                    
    static void setVerbosity(unsigned verbosity);   // (0 = only fatal errors, 1 = warnings, 
                                                    // 2 = most msgs, 3 = include info msgs)

    static unsigned loggingPeriod();                
    static void setLoggingPeriod(unsigned loggingPeriod);

    static unsigned outPort();                      
    static void setOutPort(unsigned outPort);

    static std::string dataFolder();                
    static void setDataFolder(std::string dFolder); 
    
    static bool stopNow();                          
    static void setStopNow();
    static void clearStopNow();
    
    static std::string initFileText(char key);      
    static void storeToInitFile(char key, std::string data);
    
    static std::string sndFileName();               

};



#define SAFE_MALLOC(ptr, type, len)                     \
    ptr = new type[len];                                \
    if ((char *) ptr == NULL)                           \
        throw MemoryError("can't allocate buffer");     \
    memset(ptr, 0, len * sizeof(ptr))

#define SAFE_FREE(ptr)                                  \
    if (ptr)                                            \
        delete[] ptr


#ifdef CSL_ENUMS
typedef enum {                  
    kLogInfo,                   
    kLogWarning,
    kLogError,
    kLogFatal
} LogLevel;
#else
    #define kLogInfo 0
    #define kLogWarning 1
    #define kLogError 2
    #define kLogFatal 3
    typedef int LogLevel;
#endif


void logMsg(char * format, ...);            
void logMsg(LogLevel level, char* format, ...);

void logLine();                             
void logURL();                              

// These two are private -- for handling var-args

void vlogMsg(char * format, va_list args);
void vlogMsg(LogLevel level, char * format, va_list args);



bool sleepUsec(float dur);                  
bool sleepMsec(float dur);
bool sleepSec(float dur);

Timestamp timeNow();                        
float fTimeNow();                           



float fRandZ(void);                         
float fRand1(void);                         
float fRandV(float val);                    

float fRandM(float minV, float maxV);       
float fRandR(float base, float range);      
float fRandB(float base, float range);      


int iRandV(int val);                        
int iRandM(int minV, int maxV);             
int iRandB(int base, int range);            

// Bool coin-toss rands

bool coin();                                
bool coin(float bias);                      


// MIDI Conversions


float keyToFreq(unsigned midiKey);


unsigned freqToKey(float frequency);



class Observer;                             
typedef std::vector <Observer *> ObserverVector;


class Model {
public:
    Model() : mHasObservers(false), mHasObserverMap(false), mUpdateTime(0), mPeriod(0) { }; 
    ~Model() { };                           
    
    void attachObserver(Observer *);        
    void detachObserver(Observer *);
    
    void changed(void * argument);          



    virtual int evaluate(void * argument) { return 0; };
    
private:
    ObserverVector mObservers;              
    std::map<int, ObserverVector> mObsMap;  
    bool mHasObservers;                     
    bool mHasObserverMap;                   
    float mUpdateTime;                      
    float mPeriod;                          
};


class Observer {
public:
    Observer() { mPeriod = 0; mKey = 0; };  
    virtual ~Observer() { };                

    float mPeriod;                          
    int mKey;                               

    virtual void update(void * arg) = 0;    
};

} // end of namespace

#endif

---