acq.impl.hpp

template<class T, size_t N, class F>
acq<T,N,F>::acq(  buffer_t*     buff  ,
                  boost::mutex* lock  ,
                  unsigned int* cur   ,
                  unsigned int* send  ,
                  bool*         run   ,
                  bool*         ready , 
                  Param*        param ,
                  Caminfo*      ci    )
  : c(NULL),mIdx(0),mBuffer(buff), mLock(lock), mCur(cur), mSend(send), mRun(run), mRun2(*run), mReady(ready), mParam(param), mCi(ci)
{ }


template<class T, size_t N, class F>
acq<T,N,F>::acq( const acq& src ) :
  c(NULL)             ,
  mIdx   (src.mIdx)   ,   // Recuperation de l'index
  mBuffer(src.mBuffer),   // Recuperation des buffers
  mLock  (src.mLock)  ,   // Recuperation des verrous
  mCur   (src.mCur)   ,   // Recuperation du ptr sur le buffer courant
  mSend  (src.mSend)  ,   // Recuperation du ptr sur le buffer a rendre
  mRun   (src.mRun)   ,   // Recuperation du booleen pour stopper le thrd
  mRun2  (src.mRun2)  ,
  mReady (src.mReady) , 
  mParam (src.mParam) ,
  mCi    (src.mCi)
{ }


template<class T, size_t N, class F>
acq<T,N,F>::~acq()
{
  if(c)
    {
      delete c;
      c=NULL;
    }
}


template<class T, size_t N, class F>
void acq<T,N,F>::operator()()
{
  
  T flux(mParam, mCi);
  
  // Tant que le booleen reste sur true
  while(*mRun && mRun2)
    {
      // Appel du foncteur avec :
      // - Le mutex a locker
      // - Le buffer a renvoyer
      // - Le flux
      mRun2=mFunc(mLock[*mCur], mBuffer[*mCur], &flux);

      // Index qui compte le nombre de buffers remplis
      mIdx++;
      
      // Pour savoir quand les N buffers sont remplis
      if(mIdx == N)
        *mReady = true;
      
      // Incrementation du pointeur sur le buffer courant et a renvoyer
      // avec un modulo pour la circularite
      *mCur  = (*mCur  + 1) % N;
      *mSend = (*mSend + 1) % N;
    }

}

---