eoCounter.h

// -*- 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>

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) {}

        typename Procedure::result_type operator()(void)
        {
            value()++;
#ifdef _MSC_VER
            proc();
#else
            return proc();
#endif
        }

    private :

        Procedure& proc;
};

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) {}

        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;
};

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) {}

        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;
};

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