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 dataFolder);      
    
    static bool stopNow();                          
    static void setStopNow();
    static void clearStopNow();
};


// safe malloc using new operator; zeroes memory after testing pointer
// used like: SAFE_MALLOC(mSampleBuffer, sample, mWindowSize);

#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, ...);

// 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);


float fRand(void);                          
float fRand2(void);                         
float fRand3(float minV, float maxV);       
float fRand4(float base, float range);      
float fRand5(float base, float range);      
float fRand6(float val);                    

// same with descriptive names

float fRandZ(void);                         
float fRand1(void);                         
float fRandM(float minV, float maxV);       
float fRandR(float base, float range);      
float fRandB(float base, float range);      
float fRandV(float val);                    

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


class Observer;                             


class Model {
public:
    Model() : mHasObservers(false) { };     
    ~Model() { };                           
    
    void attachObserver(Observer *);        
    void detachObserver(Observer *);
    
    void changed(void * argument);          

private:
    std::vector <Observer *> mObservers;    
    bool mHasObservers;                     
};


class Observer {
public:
    Observer() { };                         
    virtual ~Observer() { };                


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

} // end of namespace

#endif