/Users/ljp/code/gamma/trunk/Gamma/Sync.h

#ifndef GAMMA_SYNC_H_INC
#define GAMMA_SYNC_H_INC

/*  Gamma - Generic processing library
    See COPYRIGHT file for authors and license information */

#include "Gamma/Node.h"

namespace gam{

class Sync;


class Synced1{
public:

    virtual ~Synced1(){}

    double spu() const { return 1.; }       
    double ups() const { return 1.; }       


    virtual void onResync(double ratioSPU){}
    
    void spu(double val){}          
    void ups(double val){}          

protected:
    void initSynced(){ onResync(1); }
};




class Synced : public Node2<Synced> {
public:

    Synced();
    
    
    Synced(const Synced& rhs);

    virtual ~Synced(){}

    double scaleSPU() const;    
    double spu() const;         
    double ups() const;         
    const Sync * sync() const;  

    
    virtual void onResync(double ratioSPU){}

    void scaleSPU(double v);    
    void scaleUPS(double v);    
    void spu(double v);         
    void sync(Sync& src);       
    void ups(double v);         

    Synced& operator= (const Synced& rhs);

protected:
    void initSynced(); 

private:
    friend class Sync;
    Synced(bool zeroLinks, Sync& src);

    Sync * mSync;   // Reference to my Sync
    double mSPU;    // Local samples/unit
    double mUPS;    // Local units/sample
};





class Sync{
public:

    Sync();

    Sync(double spu);

    ~Sync();

    Sync& operator<< (Synced& synced);  
    void notifySynceds(double r);       
    void spu(double v);                 
    void ups(double v);                 

    bool hasBeenSet() const;            
    double spu() const;                 
    double ups() const;                 

    static Sync& master(){
        static Sync * s = new Sync;
        return *s;
    }

protected:
    double mSPU, mUPS;
    Synced mHeadSynced;     // Head of Synced doubly-linked list.
    bool mHasBeenSet;

friend class Synced;
    void addSynced(Synced& synced);
};




// Implementation_______________________________________________________________

// Sync

inline bool Sync::hasBeenSet() const { return mHasBeenSet; }
inline double Sync::spu() const { return mSPU; }
inline double Sync::ups() const { return mUPS; }


// Synced

#define SYNCED_INIT mSync(0), mSPU(1), mUPS(1)

inline Synced::Synced()
:   Node2<Synced>(), SYNCED_INIT
{
    //printf("Synced::Synced() - %p\n", this);
    sync(Sync::master());
}

// This ctor is used to create the head Synced in a Sync
inline Synced::Synced(bool zeroLinks, Sync& src)
:   Node2<Synced>(zeroLinks), SYNCED_INIT
{
    sync(src);
}

inline Synced::Synced(const Synced& rhs)
:   Node2<Synced>(), SYNCED_INIT
{
    //printf("Synced::Synced(const Synced&) - %p\n", this);
    Sync& s = rhs.mSync ? *rhs.mSync : Sync::master();
    sync(s);
}

inline void Synced::initSynced(){ if(sync()) spu(sync()->spu()); }
inline double Synced::scaleSPU() const { return sync() ? spu() / sync()->spu() : 1; }
inline void Synced::spu(double v){ scaleSPU(v * ups()); }
inline void Synced::ups(double v){ scaleUPS(v * spu()); }
inline double Synced::spu() const { return mSPU; }
inline double Synced::ups() const { return mUPS; }

inline const Sync * Synced::sync() const { return mSync; }

} // gam::

#endif