# ParadisEO-MOMovingObjects: moSimpleMoveTabuList.h Source File

# moSimpleMoveTabuList.h

    00001 /*
    00002   <moSimpleMoveTabuList.h>
    00003   Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008
    00004   (C) OPAC Team, LIFL, 2002-2008
    00005
    00006   Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
    00007
    00008   This software is governed by the CeCILL license under French law and
    00009   abiding by the rules of distribution of free software.  You can  use,
    00010   modify and/ or redistribute the software under the terms of the CeCILL
    00011   license as circulated by CEA, CNRS and INRIA at the following URL
    00012   "http://www.cecill.info".
    00013
    00014   As a counterpart to the access to the source code and  rights to copy,
    00015   modify and redistribute granted by the license, users are provided only
    00016   with a limited warranty  and the software's author,  the holder of the
    00017   economic rights,  and the successive licensors  have only  limited liability.
    00018
    00019   In this respect, the user's attention is drawn to the risks associated
    00020   with loading,  using,  modifying and/or developing or reproducing the
    00021   software by the user in light of its specific status of free software,
    00022   that may mean  that it is complicated to manipulate,  and  that  also
    00023   therefore means  that it is reserved for developers  and  experienced
    00024   professionals having in-depth computer knowledge. Users are therefore
    00025   encouraged to load and test the software's suitability as regards their
    00026   requirements in conditions enabling the security of their systems and/or
    00027   data to be ensured and,  more generally, to use and operate it in the
    00028   same conditions as regards security.
    00029   The fact that you are presently reading this means that you have had
    00030   knowledge of the CeCILL license and that you accept its terms.
    00031
    00032   ParadisEO WebSite : http://paradiseo.gforge.inria.fr
    00033   Contact: paradiseo-help@lists.gforge.inria.fr
    00034 */
    00035
    00036 #ifndef _moSimpleMoveTabuList_h
    00037 #define _moSimpleMoveTabuList_h
    00038
    00039 #include <list>
    00040 #include <iterator>
    00041
    00042 #include <moTabuList.h>
    00043
    00045 template <class M>
    00046 class moSimpleMoveTabuList: public moTabuList < M >
    00047 {
    00048  public:
    00049
    00051   typedef typename M::EOType EOT;
    00052
    00054   typedef typename std::list<M>::iterator moveIterator;
    00055
    00057   /*
    00058     \param _size The maximum size of the move tabu list.
    00059   */
    00060  moSimpleMoveTabuList(unsigned int _memory_maximum_size): memory_maximum_size(_memory_maximum_size), memory_size(0)
    00061     {}
    00062
    00064
    00069   bool operator () (const M & _move, const EOT & _solution)
    00070   {
    00071     moveIterator it;
    00072     //code only used to avoid warning because _solution is not used in this function.
    00073     EOT solution=(EOT)_solution;
    00074
    00075     it=tabuList.begin();
    00076     // The code is !(*it)==_move instead of (*it)!=_move because people designing their specific move representation
    00077     // will write the "==" operator (I hope) but not necessary the "!=" operator.
    00078     while ( it!=tabuList.end() && !((*it)==_move) )
    00079       {
    00080         it++;
    00081       }
    00082
    00083     return it!=tabuList.end();
    00084   }
    00085
    00086   void add(const M & _move, const EOT & _solution)
    00087   {
    00088     //code only used to avoid warning because _solution is not used in this function.
    00089     EOT solution=(EOT)_solution;
    00090
    00091     if (memory_size!=0)
    00092       {
    00093         // Useful in the case of a move has been kept thanks to the moAspirCrit.
    00094         // In this case, the move can already be in the tabuList.
    00095         removeMove(_move);
    00096       }
    00097
    00098     tabuList.push_back(_move);
    00099
    00100     if (memory_size == memory_maximum_size)
    00101       {
    00102         tabuList.erase(tabuList.begin());
    00103       }
    00104     else
    00105       {
    00106         memory_size++;
    00107       }
    00108   }
    00109
    00110   void update ()
    00111   {
    00112     //nothing to do
    00113   }
    00114
    00115   void init ()
    00116   {
    00117     //nothing to do
    00118   }
    00119
    00120  private:
    00121
    00123
    00126   void removeMove(const M & _move)
    00127   {
    00128     moveIterator it;
    00129
    00130     it=tabuList.begin();
    00131     // The code is !(*it)==_move instead of (*it)!=_move because people designing their specific move representation
    00132     // will write the "==" operator (I hope) but not necessary the "!=" operator.
    00133     while ( it!=tabuList.end() && (!((*it)==_move) ))
    00134       {
    00135         it++;
    00136       }
    00137
    00138     if (it!=tabuList.end())
    00139       {
    00140         tabuList.erase(it);
    00141       }
    00142   }
    00143
    00145   unsigned int memory_maximum_size;
    00146
    00148   unsigned int memory_size;
    00149
    00151   std::list<M> tabuList;
    00152 };
    00153
    00154 #endif