eoPopulator.h

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

//-----------------------------------------------------------------------------
// eoPopulator.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: mkeijzer@dhi.dk
             Marc.Schoenauer@polytechnique.fr
 */
//-----------------------------------------------------------------------------

#ifndef _eoPopulator_H
#define _eoPopulator_H

#include <eoPop.h>
#include <eoSelectOne.h>

template <class EOT>
class eoPopulator
{
public :

  eoPopulator(const eoPop<EOT>& _src, eoPop<EOT>& _dest) : dest(_dest), current(dest.end()), src(_src)
  {
    dest.reserve(src.size()); // we don't know this, but wth.
    current = dest.end();
  }

    virtual ~eoPopulator() {};

  struct OutOfIndividuals {};

  EOT& operator*(void)
  {
    if (current == dest.end())
      get_next(); // get a new individual

    return *current;
  }

  eoPopulator& operator++()
  {
    if (current == dest.end())
      { // keep the pointer there
        return *this;
      }
    // else
    ++current;
    return *this;
  }

  void insert(const EOT& _eo)
  { /* not really efficient, but its nice to have */
    current = dest.insert(current, _eo);
  }

  void reserve(int how_many)
  {
    size_t sz = current - dest.begin();
    if (dest.capacity() < dest.size() + how_many)
    {
      dest.reserve(dest.size() + how_many);
    }

    current = dest.begin() + sz;
  }

  const eoPop<EOT>& source(void) { return src; }

  eoPop<EOT>& offspring(void)    { return dest; }

  typedef unsigned position_type;

  position_type tellp()         { return current - dest.begin(); }
  void seekp(position_type pos) { current = dest.begin() + pos; }
  bool exhausted(void)          { return current == dest.end(); }

  virtual const EOT& select() = 0;

protected:
    eoPop<EOT>& dest;
    typename eoPop<EOT>::iterator current;
    const eoPop<EOT>& src;

private:

  void get_next() {
    if(current == dest.end())
      { // get new individual from derived class select()
        dest.push_back(select());
        current = dest.end();
        --current;
        return;
      }
    // else
    ++current;
    return;
  }

};


template <class EOT>
class eoSeqPopulator : public eoPopulator<EOT>
{
public:

    using eoPopulator< EOT >::src;

    eoSeqPopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest) :
        eoPopulator<EOT>(_pop, _dest), current(0) {}

    const EOT& select(void) {
        if(current >= eoPopulator< EOT >::src.size()) {
            throw OutOfIndividuals();
        }

        const EOT& res = src[current++];
        return res;
    }


private:

    struct OutOfIndividuals {};

    unsigned current;
};


template <class EOT>
class eoSelectivePopulator : public eoPopulator<EOT>
{
public :

    using eoPopulator< EOT >::src;

    eoSelectivePopulator(const eoPop<EOT>& _pop, eoPop<EOT>& _dest, eoSelectOne<EOT>& _sel)
        : eoPopulator<EOT>(_pop, _dest), sel(_sel)
        { sel.setup(_pop); };

    const EOT& select() {
        return sel(src);
    }


private:

    eoSelectOne<EOT>& sel;
};

#endif