nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge from rc2.0

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@2713 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
quemy 2012-07-19 09:53:26 +00:00
commit 409a1b21b8
1731 changed files with 104909 additions and 64375 deletions
Download patch file Download diff file Expand all files Collapse all files

221
trunk/eo/src/eoCounter.h Normal file
View file

@ -0,0 +1,221 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoCounter.h
// (c) Maarten Keijzer 2000
/*
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; either
version 2 of the License, or (at your option) any later version.
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: todos@geneura.ugr.es, http://geneura.ugr.es
mak@dhi.dk
*/
//-----------------------------------------------------------------------------
#ifndef _eoCounter_h
#define _eoCounter_h
#include <eoFunctor.h>
#include <eoFunctorStore.h>
#include <utils/eoParam.h>
/**
Generic counter class that counts the number of times
a procedure is used. Add a procedure through its ctor and
use this class instead of it.
It is derived from eoValueParam so you can add it to a monitor.
@ingroup Utilities
*/
template <class Procedure>
class eoProcedureCounter : public Procedure, public eoValueParam<unsigned long>
{
public:
eoProcedureCounter(Procedure& _proc, std::string _name = "proc_counter")
: eoValueParam<unsigned long>(0, _name), proc(_proc) {}
/** Calls the embedded function and increments the counter
Note for MSVC users, if this code does not compile, you are quite
likely trying to count a function that has a non-void return type.
Don't look at us, look at the MSVC builders. Code like "return void;"
is perfectly legal according to the ANSI standard, but the guys at
Microsoft didn't get to implementing it yet.
We had two choices: assuming (and compiling ) code that returns void or code that returns non-void.
Given that in EO most functors return void, it was chosen to support void.
But also please let me know if you have a compiler that defines _MSC_VER (lot's of windows compilers do), but is quite
capable of compiling return void; type of code. We'll try to change the signature then.
You happy GNU (and other compiler) users will not have a problem with this..
*/
typename Procedure::result_type operator()(void)
{
value()++;
#ifdef _MSC_VER
proc();
#else
return proc();
#endif
}
private :
Procedure& proc;
};
/**
Generic counter class that counts the number of times
a unary function is used. Add a unary function through its ctor and
use this class instead of it.
It is derived from eoValueParam so you can add it to a monitor.
Example: suppose you have an eoEvalFunc called myeval, to count the
number of evaluations, just define:
eoUnaryFunctorCounter<void, EoType> evalCounter(myeval);
and use evalCounter now instead of myeval.
*/
template <class UnaryFunctor>
class eoUnaryFunctorCounter : public UnaryFunctor, public eoValueParam<unsigned long>
{
public:
eoUnaryFunctorCounter(UnaryFunctor& _func, std::string _name = "uf_counter")
: eoValueParam<unsigned long>(0, _name), func(_func) {}
/** Calls the embedded function and increments the counter
Note for MSVC users, if this code does not compile, you are quite
likely trying to count a function that has a non-void return type.
Don't look at us, look at the MSVC builders. Code like "return void;"
is perfectly legal according to the ANSI standard, but the guys at
Microsoft didn't get to implementing it yet.
We had two choices: assuming (and compiling ) code that returns void or code that returns non-void.
Given that in EO most functors return void, it was chosen to support void.
But also please let me know if you have a compiler that defines _MSC_VER (lot's of windows compilers do), but is quite
capable of compiling return void; type of code. We'll try to change the signature then.
You happy GNU (and other compiler) users will not have a problem with this.
*/
typename UnaryFunctor::result_type operator()
(typename UnaryFunctor::first_argument_type _arg1)
{
value()++;
#ifdef _MSC_VER
func(_arg1);
#else
return func(_arg1);
#endif
}
private :
UnaryFunctor& func;
};
/**
Generic counter class that counts the number of times
a binary function is used. Add a binary function through its ctor and
use this class instead of it.
It is derived from eoValueParam so you can add it to a monitor.
*/
template <class BinaryFunctor>
class eoBinaryFunctorCounter : public BinaryFunctor, public eoValueParam<unsigned long>
{
public:
eoBinaryFunctorCounter(BinaryFunctor& _func, std::string _name = "proc_counter")
: eoValueParam<unsigned long>(0, _name), func(_func) {}
/** Calls the embedded function and increments the counter
Note for MSVC users, if this code does not compile, you are quite
likely trying to count a function that has a non-void return type.
Don't look at us, look at the MSVC builders. Code like "return void;"
is perfectly legal according to the ANSI standard, but the guys at
Microsoft didn't get to implementing it yet.
We had two choices: assuming (and compiling ) code that returns void or code that returns non-void.
Given that in EO most functors return void, it was chosen to support void.
But also please let me know if you have a compiler that defines _MSC_VER (lot's of windows compilers do), but is quite
capable of compiling return void; type of code. We'll try to change the signature then.
You happy GNU (and other compiler) users will not have a problem with this.
*/
typename BinaryFunctor::result_type operator()
(typename BinaryFunctor::first_argument_type _arg1,
typename BinaryFunctor::second_argument_type _arg2)
{
value()++;
#ifdef _MSC_VER
func(_arg1, _arg2);
#else
return func(_arg1, _arg2);
#endif
}
private :
BinaryFunctor& func;
};
/** make_counter: overloaded function to make a counter out of a function
how it works...
by using the xxx_function_tag structure defined in eoFunctionBase, you
can easily create a counter from a general class (say eoEval<EOT>), by
simply stating:
eoEval<EOT>& myCounted = make_counter(functor_category(myEval), myEval, store)
@see eoFunctorBase, functor_category, eoFunctorStore
*/
template <class Procedure>
eoProcedureCounter<Procedure>& make_counter(eoFunctorBase::procedure_tag, Procedure& _proc, eoFunctorStore& store, std::string _name = "proc_counter")
{
eoProcedureCounter<Procedure>* result = new eoProcedureCounter<Procedure>(_proc, _name);
store.storeFunctor(result);
return *result;
}
template <class UnaryFunctor>
eoUnaryFunctorCounter<UnaryFunctor>& make_counter(eoFunctorBase::unary_function_tag, UnaryFunctor& _proc, eoFunctorStore& store, std::string _name = "uf_counter")
{
eoUnaryFunctorCounter<UnaryFunctor>* result = new eoUnaryFunctorCounter<UnaryFunctor>(_proc, _name);
store.storeFunctor(result);
return *result;
}
template <class BinaryFunctor>
eoBinaryFunctorCounter<BinaryFunctor>& make_counter(eoFunctorBase::binary_function_tag, BinaryFunctor& _proc, eoFunctorStore& store, std::string _name = "uf_counter")
{
eoBinaryFunctorCounter<BinaryFunctor>* result = new eoBinaryFunctorCounter<BinaryFunctor>(_proc, _name);
store.storeFunctor(result);
return *result;
}
#endif