CMemCopier.hpp

/* This file is part of sUtil, a random collection of utilities.

sUtil is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 3 of the License, or (at your option) any later version.

Alternatively, you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License, or (at your option) any later version.

sUtil is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License and a copy of the GNU General Public License along with
sUtil. If not, see <http://www.gnu.org/licenses/>.
 */
/* \file CMemCopier.hpp
 *
 *  Created on: Jun 28, 2010
 *
 *  Copyright (C) 2010, Samir Menon <smenon@stanford.edu>
 */

#ifndef CMEMCOPIER_HPP_
#define CMEMCOPIER_HPP_

#include <vector>
#include <string.h>

namespace sutil
{

  template <typename T>
  class CMemCopier
  {
  private:
    const T* mem_;

    std::vector<T*> buf_;

    bool initialized_;

  public:
    CMemCopier();
    virtual ~CMemCopier(){}

    bool init(const T* arg_mem);

    bool addBuf(T* arg_buf);

    T* removeBuf(T* arg_buf);

    bool copy();
  };

  template <typename T>
  CMemCopier<T>::CMemCopier()
  {
    mem_ = NULL;
    initialized_ = false;
  }

  template <typename T>
  bool CMemCopier<T>::init(const T* arg_mem)
  {
    if(NULL == arg_mem)
    { return false; }
    else
    {
      mem_ = arg_mem;

      //Set init variable
      if(buf_.size() > 0)
      { initialized_ = true; }

      return true;
    }
  }

  template <typename T>
  bool CMemCopier<T>::addBuf(T* arg_buf)
  {
    if(NULL!= arg_buf)
    {
      //Check if the buffer is already there.
      typename std::vector<T*>::iterator it, ite;
      ite = buf_.end();
      for(it= buf_.begin(); it!=ite; ++it)
      {
        //In case the pointed to memory has been
        //deallocated.
        if(arg_buf == (*it))
        {
          return false;
        }
      }

      //Add the buffer (new) to the vector
      buf_.push_back(arg_buf);

      if(NULL != mem_)
      { initialized_ = true; }

      return true;
    }
    else
    { return false; }
  }

  template <typename T>
  T* CMemCopier<T>::removeBuf(T* arg_buf)
  {
    typename std::vector<T*>::iterator it, ite;
    ite = buf_.end();
    for(it= buf_.begin(); it!=ite; ++it)
    {
      //In case the pointed to memory has been
      //deallocated.
      if(arg_buf == (*it))
      {
        buf_.erase(it);

        //Set init variable
        if(buf_.size() <= 0)
        { initialized_ = false; }

        return arg_buf;
      }
    }
    return NULL;
  }

  template <typename T>
  bool CMemCopier<T>::copy()
  {
    if(!initialized_)
    { return false; }
    else
    {
      bool flag = true;
      typename std::vector<T*>::iterator it, ite;
      ite = buf_.end();
      for(it= buf_.begin(); it!=ite; ++it)
      {
        //In case the pointed to memory has been
        //deallocated.
        if(NULL == (*it))
        { flag = false; continue; }
        else
        { memcpy((void*)(*it),mem_,sizeof(T));  }
      }
      return flag;
    }
  }

}

#endif /* CMEMCOPIER_HPP_ */