eoGenOp.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

//-----------------------------------------------------------------------------
// eoGenOp.h
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
    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: mak@dhi.dk
             Marc.Schoenauer@polytechnique.fr
 */
//-----------------------------------------------------------------------------

#ifndef _eoGenOp_H
#define _eoGenOp_H

#include <eoOp.h>
#include <eoPopulator.h>
#include <eoFunctorStore.h>
#include <assert.h>


template <class EOT>
class eoGenOp : public eoOp<EOT>, public eoUF<eoPopulator<EOT> &, void>
{
  public :
  eoGenOp(): eoOp<EOT>( eoOp<EOT>::general ) {}

    virtual unsigned max_production(void) = 0;

    virtual std::string className() const = 0;

    void operator()(eoPopulator<EOT>& _pop)
    {
        _pop.reserve( max_production() );
        apply(_pop);
    }

    //protected :
    virtual void apply(eoPopulator<EOT>& _pop) = 0;
};
template <class EOT>
class eoMonGenOp : public eoGenOp<EOT>
{
   public:
    eoMonGenOp(eoMonOp<EOT>& _op) : op(_op) {}

    unsigned max_production(void) { return 1; }

    void apply(eoPopulator<EOT>& _it)
    {
      if (op(*_it))
        (*_it).invalidate();  // look how simple

    }
  virtual std::string className() const {return op.className();}
   private :
    eoMonOp<EOT>& op;
};

template <class EOT>
class eoBinGenOp : public eoGenOp<EOT>
{
   public:
    eoBinGenOp(eoBinOp<EOT>& _op) : op(_op) {}

    unsigned max_production(void) { return 1; }

    void apply(eoPopulator<EOT>& _pop)
    {
      EOT& a = *_pop;
      const EOT& b = _pop.select();

      if (op(a, b))
        a.invalidate();
    }
  virtual std::string className() const {return op.className();}

   private :
    eoBinOp<EOT>& op;
};

template <class EOT>
class eoSelBinGenOp : public eoGenOp<EOT>
{
   public:
    eoSelBinGenOp(eoBinOp<EOT>& _op, eoSelectOne<EOT>& _sel) :
      op(_op), sel(_sel) {}

    unsigned max_production(void) { return 1; }

    void apply(eoPopulator<EOT>& _pop)
    { // _pop.source() gets the original population, an eoVecOp can make use of this as well
      if (op(*_pop, sel(_pop.source())))
        (*_pop).invalidate();
    }
  virtual std::string className() const {return op.className();}

   private :
    eoBinOp<EOT>& op;
    eoSelectOne<EOT>& sel;
};


template <class EOT>
class eoQuadGenOp : public eoGenOp<EOT>
{
   public:
    eoQuadGenOp(eoQuadOp<EOT>& _op) : op(_op) {}

    unsigned max_production(void) { return 2; }

    void apply(eoPopulator<EOT>& _pop)
    {
      EOT& a = *_pop;
      EOT& b = *++_pop;


      if(op(a, b))
      {
        a.invalidate();
        b.invalidate();
      }

   }
  virtual std::string className() const {return op.className();}

   private :
    eoQuadOp<EOT>& op;
};

    template <class EOT>
    eoGenOp<EOT>& wrap_op(eoOp<EOT>& _op, eoFunctorStore& _store)
    {
      switch(_op.getType())
      {
        case eoOp<EOT>::unary     : return _store.storeFunctor(new eoMonGenOp<EOT>(static_cast<eoMonOp<EOT>&>(_op)));
        case eoOp<EOT>::binary    : return _store.storeFunctor(new eoBinGenOp<EOT>(static_cast<eoBinOp<EOT>&>(_op)));
        case eoOp<EOT>::quadratic : return _store.storeFunctor(new eoQuadGenOp<EOT>(static_cast<eoQuadOp<EOT>&>(_op)));
        case eoOp<EOT>::general   : return static_cast<eoGenOp<EOT>&>(_op);
      }

      assert(false);
      return static_cast<eoGenOp<EOT>&>(_op);
    }

#endif