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

move paradiseo/eo to deprecated/ before merge with eodev

Browse source
This commit is contained in:
Johann Dreo 2012-10-05 15:12:12 +02:00
commit 0c5120f675
717 changed files with 0 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

184
deprecated/eo/src/eoFunctor.h Normal file
View file

@ -0,0 +1,184 @@
// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
//-----------------------------------------------------------------------------
// eoFunctor.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
CVS Info: $Date: 2004-12-01 09:22:48 $ $Header: /home/nojhan/dev/eodev/eodev_cvs/eo/src/eoFunctor.h,v 1.7 2004-12-01 09:22:48 evomarc Exp $ $Author: evomarc $
*/
//-----------------------------------------------------------------------------
#ifndef _eoFunctor_h
#define _eoFunctor_h
#include <functional>
/** @addtogroup Core
* @{
*/
/** Base class for functors to get a nice hierarchy diagram
That's actually quite an understatement as it does quite a bit more than
just that. By having all functors derive from the same base class, we can
do some memory management that would otherwise be very hard.
The memory management base class is called eoFunctorStore, and it supports
a member add() to add a pointer to a functor. When the functorStore is
destroyed, it will delete all those pointers. So beware: do not delete
the functorStore before you are done with anything that might have been allocated.
@see eoFunctorStore
*/
class eoFunctorBase
{
public :
/// virtual dtor here so there is no need to define it in derived classes
virtual ~eoFunctorBase() {}
/// tag to identify a procedure in compile time function selection @see functor_category
struct procedure_tag {};
/// tag to identify a unary function in compile time function selection @see functor_category
struct unary_function_tag {};
/// tag to identify a binary function in compile time function selection @see functor_category
struct binary_function_tag {};
};
/** @example t-eoFunctor.cpp
*/
/**
Basic Function. Derive from this class when defining
any procedure. It defines a result_type that can be used
to determine the return type
Argument and result types can be any type including void for
result_type
**/
template <class R>
class eoF : public eoFunctorBase
{
public :
/// virtual dtor here so there is no need to define it in derived classes
virtual ~eoF() {}
/// the return type - probably useless ....
typedef R result_type;
/// The pure virtual function that needs to be implemented by the subclass
virtual R operator()() = 0;
/// tag to identify a procedure in compile time function selection @see functor_category
static eoFunctorBase::procedure_tag functor_category()
{
return eoFunctorBase::procedure_tag();
}
};
/**
Overloaded function that can help in the compile time detection
of the type of functor we are dealing with
@see eoCounter, make_counter
*/
template<class R>
eoFunctorBase::procedure_tag functor_category(const eoF<R>&)
{
return eoFunctorBase::procedure_tag();
}
/**
Basic Unary Functor. Derive from this class when defining
any unary function. First template argument is the first_argument_type,
second result_type.
Argument and result types can be any type including void for
result_type
**/
template <class A1, class R>
class eoUF : public eoFunctorBase, public std::unary_function<A1, R>
{
public :
/// virtual dtor here so there is no need to define it in derived classes
virtual ~eoUF() {}
/// The pure virtual function that needs to be implemented by the subclass
virtual R operator()(A1) = 0;
/// tag to identify a procedure in compile time function selection @see functor_category
static eoFunctorBase::unary_function_tag functor_category()
{
return eoFunctorBase::unary_function_tag();
}
};
/**
Overloaded function that can help in the compile time detection
of the type of functor we are dealing with
@see eoCounter, make_counter
*/
template<class R, class A1>
eoFunctorBase::unary_function_tag functor_category(const eoUF<A1, R>&)
{
return eoFunctorBase::unary_function_tag();
}
/**
Basic Binary Functor. Derive from this class when defining
any binary function. First template argument is result_type, second
is first_argument_type, third is second_argument_type.
Argument and result types can be any type including void for
result_type
**/
template <class A1, class A2, class R>
class eoBF : public eoFunctorBase, public std::binary_function<A1, A2, R>
{
public :
/// virtual dtor here so there is no need to define it in derived classes
virtual ~eoBF() {}
//typedef R result_type;
//typedef A1 first_argument_type;
//typedef A2 second_argument_type;
/// The pure virtual function that needs to be implemented by the subclass
virtual R operator()(A1, A2) = 0;
/// tag to identify a procedure in compile time function selection @see functor_category
static eoFunctorBase::binary_function_tag functor_category()
{
return eoFunctorBase::binary_function_tag();
}
};
/**
Overloaded function that can help in the compile time detection
of the type of functor we are dealing with
@see eoCounter, make_counter
*/
template<class R, class A1, class A2>
eoFunctorBase::binary_function_tag functor_category(const eoBF<A1, A2, R>&)
{
return eoFunctorBase::binary_function_tag();
}
/** @} */
#endif