more comments ; header

eo/src/eoEvalCounterThrowException.h

@@ -0,0 +1,85 @@
+/* 
+(c) Thales group, 2010
+
+    This library 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;
+    version 2 of the License.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+Contact: http://eodev.sourceforge.net
+
+Authors: 
+Johann Dréo <johann.dreo@thalesgroup.com>
+Caner Candan <caner.candan@thalesgroup.com>
+
+*/
+
+#ifndef __eoEvalCounterThrowException_h__
+#define __eoEvalCounterThrowException_h__
+
+#include <eoEvalFunc.h>
+#include <utils/eoParam.h>
+#include <eoExceptions.h>
+
+/*!
+Wrap an evaluation function so that an exception may be thrown when the
+algorithm have reached a maximum number of evaluations.
+
+This may be useful if you want to check this kind of stopping criterion
+at each _evaluation_, instead of using continuators at each _iteration_.
+
+The class first call the evaluation function, then check the number of
+times it has been called. If the maximum number of evaluation has been
+reached, it throw an eoMaxEvalException. You can catch this exception
+from your main function, so as to stop everything properly.
+*/
+template < typename EOT >
+class eoEvalCounterThrowException : public eoEvalFuncCounter< EOT >
+{
+public :
+    eoEvalCounterThrowException( eoEvalFunc<EOT>& func, unsigned long max_evals, std::string name = "Eval. ")
+	: eoEvalFuncCounter< EOT >( func, name ), _threshold( max_evals )
+    {}
+
+    using eoEvalFuncCounter< EOT >::value;
+
+    //! Evaluate the individual, then throw an exception if it exceed the max number of evals.
+    virtual void operator()(EOT& eo)
+    {
+        // bypass already evaluated individuals
+        if (eo.invalid()) {
+
+            // increment the value of the self parameter 
+            // (eoEvalFuncCounter inherits from @see eoValueParam) 
+            value()++;
+
+            // if we have reached the maximum
+            if ( value() >= _threshold ) {
+
+                // go back through the stack until catched
+                throw eoMaxEvalException(_threshold);
+            }
+
+            // evaluate
+            func(eo);
+
+        } // if invalid
+    }
+
+    virtual std::string className() const {return "eoEvalCounterThrowException";}
+
+private :
+    unsigned long _threshold;
+};
+
+#endif // __eoEvalCounterThrowException_h__
+