grabber.impl.hpp

template<class T, size_t N>
dataGrabber<T,N>::dataGrabber(Param* param, Caminfo* ci)
  :   mCurr(0)               ,
      mSend(N-1)             ,
      mRun(true)             ,
      mLogin(param->login)   ,
      mPass(param->pass)     ,
      mIp(param->ip)         ,
      mPort(param->port)
{
  // Le buffer :  - courant est 0 (le premier)
  //              - a lire est le dernier (juste avant le premier)
  
  
  // Le generator
  // N -> pour le nb d'elements (pour rendre le containeur circulaire)
  // fill_data -> le foncteur (methode 'threadée')
  macq = new acq<T, N, fill_data<T> >
    ( &mBuffers[0]   ,   // Les buffers
      &mLock[0]      ,   // Les mutexes
      &mCurr         ,   // Le pointeur sur le buffer courant
      &mSend         ,   // Le pointeur sur le buffer a rendre
      &mRun          ,   // Le pointeur sur le booleen pour stopper
      &ready         , 
      param          ,
      ci
      );
  
  // Le thread
  // Lance le generator
  mThread    = new boost::thread(*macq);
  
}


template<class T, size_t N>
dataGrabber<T,N>::~dataGrabber()
{
  stop();
  
  mThread->join();
  
  // Si le generator existe
  if(macq)
    delete macq;    // On le delete
  
  // Si le thread existe
  if(mThread)
    delete mThread; // On le delete
}


template<class T, size_t N>
buffer_t& dataGrabber<T,N>::getData()
{
  // On lock le mutex
  boost::mutex::scoped_lock lock(mLock[mSend]);
  
  // On retourne le dernier buffer remplit
  return  mBuffers[mSend];
}


template<class T, size_t N>
size_t dataGrabber<T,N>::size()
{
  // On lock le mutex
  boost::mutex::scoped_lock lock(mLock[mSend]);
  
  // On renvoi la taille du dernier buffer remplit
  return  mBuffers[mSend].size();
}


template<class T, size_t N>
bool dataGrabber<T,N>::isready() const
{
  //std::cout <<  "grabber : " <<  macq->isready() <<  std::endl; 
  return ready;
}


template<class T, size_t N>
void dataGrabber<T,N>::stop()
{
  // Le thread s'arretera a la prochaine boucle du while
  mRun = false;
}

---