std_headers.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2008 by Kutumov Alexey                                  *
 *   ru.pixel@gmail.com                                                    *
 *                                                                         *
 *   This program is free software; 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.                                   *
 *                                                                         *
 *   This program 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 General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef __std_headers__header__
#define __std_headers__header__

#ifdef __BORLANDC__
#define __STD_ALGORITHM
#endif

#if defined(GCC_VISIBILITY)

#   pragma GCC visibility push(default)
#endif

#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <cstdarg>
#include <cmath>

// STL containers
#include <vector>
#include <map>
#include <string>
#include <set>
#include <list>
#include <deque>
#include <queue>
#include <bitset>

//STL exception
#include <exception>

// STL algorithms & functions
#include <algorithm>
#include <functional>
#include <limits>

// C++ Stream stuff
#include <fstream>
#include <iostream>
#include <iomanip>
#include <iterator>
#include <sstream>

#ifdef __BORLANDC__

#endif

extern "C" {

#include <sys/types.h>
#include <sys/stat.h>

}

#if PLATFORM == PLATFORM_WIN32
#undef min
#undef max
#if defined( __MINGW32__ )
#include <unistd.h>
#endif
#endif

#if PLATFORM == PLATFORM_LINUX
extern "C" {

#include <unistd.h>
#include <dlfcn.h>

}
#endif

#if PLATFORM == PLATFORM_APPLE
extern "C" {

#include <unistd.h>
#include <sys/param.h>
#include <CoreFoundation/CoreFoundation.h>

}
#endif


#if defined(GCC_VISIBILITY)
#pragma GCC visibility pop
#endif




namespace gpucalc
{
 template <typename T> inline bool addToContainer(const T & what, std::list<T> & Container)
 {
  typename std::list<T>::iterator i = std::find(Container.begin(), Container.end(), what);
  if (i != Container.end())
  {
   return false;
  }
  else
  {
   Container.push_back(what);
   return true;
  }
 }


 template <typename T> inline bool removeFromContainer(const T & what, std::list<T> & Container)
 {
  typename std::list<T>::iterator i = std::find(Container.begin(), Container.end(), what);
  if (i != Container.end())
  {
   Container.erase(i);
   return true;
  }
  else
  {
   return false;
  }
 }

 
 template <typename T> inline void clearContainer(std::list<T> & Container)
 {
  for (typename std::list<T>::iterator i = Container.begin(); i != Container.end(); ++i)
  {
   delete (*i);
  }
  Container.clear();
 }
 

 template <typename T> inline bool addToContainer(const T & what, std::vector<T> & Container)
 {
  typename std::vector<T>::iterator i = std::find(Container.begin(), Container.end(), what);
  if (i != Container.end())
  {
   return false;
  }
  else
  {
   Container.push_back(what);
   return true;
  }
 }


 template <typename T> inline bool removeFromContainer(const T & what, std::vector<T> & Container)
 {
  typename std::vector<T>::iterator i = std::find(Container.begin(), Container.end(), what);
  if (i != Container.end())
  {
   Container.erase(i);
   return true;
  }
  else
  {
   return false;
  }
 }

 
 template <typename T> inline void clearContainer(std::vector<T> & Container)
 {
  for (typename std::vector<T>::iterator i = Container.begin(); i != Container.end(); ++i)
  {
   delete (*i);
  }
  Container.clear();
 }


 template <typename T, typename Y> inline bool addToContainer(const T & what, const Y & where, std::map<Y, T> & Container)
 {
  typename std::map<Y, T>::iterator i = Container.find(where);
  if (i != Container.end())
  {
   return false;
  }
  else
  {
   Container.insert(std::make_pair(where, what));
   return true;
  }
 }


 template <typename T, typename Y> inline bool removeFromContainer(const Y & where, std::map<Y, T> & Container)
 {
  typename std::map<Y, T>::iterator i = Container.find(where);
  if (i != Container.end())
  {
   Container.erase(i);
   return true;
  }
  else
  {
   return false;
  }
 }


 template <typename T, typename Y> inline void clearContainer(std::map<Y, T> & Container)
 {
  for (typename std::map<Y, T>::iterator i = Container.begin(); i != Container.end(); ++i)
  {
   delete (i->second);
  }
  Container.clear();
 }


 
}


#endif