edoRepairerDispatcher.h

/*
The Evolving Distribution Objects framework (EDO) is a template-based,
ANSI-C++ evolutionary computation library which helps you to write your
own estimation of distribution algorithms.

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.1 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

Copyright (C) 2011 Thales group
*/
/*
Authors:
    Johann Dréo <johann.dreo@thalesgroup.com>
    Pierre Savéant <pierre.saveant@thalesgroup.com>
*/

#ifndef _edoRepairerDispatcher_h
#define _edoRepairerDispatcher_h

#include <vector>
#include <utility>

#include "edoRepairer.h"

template < typename EOT, typename ICT = std::vector<unsigned int> >
class edoRepairerDispatcher 
    : public edoRepairer<EOT>, 
             std::vector< 
                  std::pair< ICT, edoRepairer< EOT >* > 
             >
{
public:

    edoRepairerDispatcher() : 
        std::vector< 
            std::pair< std::vector< unsigned int >, edoRepairer< EOT >* > 
        >()
    {}

    edoRepairerDispatcher( ICT idx, edoRepairer<EOT>* op ) :
        std::vector< 
            std::pair< std::vector< unsigned int >, edoRepairer< EOT >* > 
        >() 
    {
        this->add( idx, op );
    }

    void add( ICT idx, edoRepairer<EOT>* op )
    {
        //assert( idx.size() > 0 );
#ifndef NDEBUG
        eo::log << eo::warnings << "A repairer is added to the dispatcher while having an empty index list, nothing will be repaired" << std::endl;
#endif
        assert( op != NULL );

        this->push_back( std::make_pair(idx, op) );
    }

    virtual void operator()( EOT& sol )
    {
//        std::cout << "in dispatcher, sol = " << sol << std::endl;

        // iterate over { indexe, repairer }
        // ipair is an iterator that points on a pair of <indexes,repairer>
        for( typename edoRepairerDispatcher<EOT>::iterator ipair = this->begin(); ipair != this->end(); ++ipair ) {

            assert( ipair->first.size() <= sol.size() ); // assert there is less indexes than items in the whole solution

            // a partial copy of the sol
            EOT partsol;

//            std::cout << "\tusing indexes = ";
//
            // iterate over indexes
            // j is an iterator that points on an uint
            for( std::vector< unsigned int >::iterator j = ipair->first.begin(); j != ipair->first.end(); ++j ) {

//                std::cout << *j << " ";
//                std::cout.flush();

                partsol.push_back( sol.at(*j) );
            } // for j
//            std::cout << std::endl;
//            std::cout << "\tpartial sol = " << partsol << std::endl;

            if( partsol.size() == 0 ) {
                continue;
            }
            assert( partsol.size() > 0 );

            // apply the repairer on the partial copy
            // the repairer is a functor, thus second is callable
            (*(ipair->second))( partsol );

            { // copy back the repaired partial solution to sol
                // browse partsol with uint k, and the idx set with an iterator (std::vector is an associative tab)
                unsigned int k=0;
                for( std::vector< unsigned int >::iterator j = ipair->first.begin(); j != ipair->first.end(); ++j ) {
                    sol[ *j ] = partsol[ k ];
                    k++;
                } // for j
            } // context for k
        } // for ipair

        sol.invalidate();
    }
};

#endif // !_edoRepairerDispatcher_h