PO.h

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

//-----------------------------------------------------------------------------
// PO.h
// (c) OPAC 2007
/*
    Contact: paradiseo-help@lists.gforge.inria.fr
 */
//-----------------------------------------------------------------------------

#ifndef PO_H
#define PO_H

//-----------------------------------------------------------------------------
#include <stdexcept>
#include <EO.h>
//-----------------------------------------------------------------------------

template < class F > class PO:public EO < F >
{

public:

    typedef typename PO < F >::Fitness Fitness;

    PO ():repFitness (Fitness ()), invalidFitness (true),
            bestFitness (Fitness()){}


    Fitness fitness () const
    {
        if (invalid ())
            throw std::runtime_error ("invalid fitness in PO.h");
        return repFitness;
    }


    void fitness (const Fitness & _fitness)
    {
        repFitness = _fitness;
        invalidFitness = false;
    }

    Fitness best () const
    {
        if (invalid ())
            throw std::runtime_error ("invalid best fitness in PO.h");
        return bestFitness;
    }


    void best (const Fitness & _bestFitness)
    {
        bestFitness = _bestFitness;
        invalidBestFitness = false;
    }


    bool invalid () const
    {
        return invalidFitness;
    }

    void invalidate ()
    {
        invalidFitness = true;
    }

    bool invalidBest () const
    {
        return invalidBestFitness;
    }

    void invalidateBest ()
    {
        invalidBestFitness = true;
    }

    virtual std::string className () const
    {
        return "PO";
    }

    bool operator< (const PO & _po2) const { return fitness () < _po2.fitness ();}
    bool operator> (const PO & _po2) const { return !(fitness () <= _po2.fitness ());}

    virtual void printOn(std::ostream& _os) const {


        // the latest version of the code. Very similar to the old code
        if (invalid()) {
            _os << "INVALID ";
        }
        else
        {
            _os << repFitness  << ' ' ;
        }

        if (invalidBest()) {
            _os << "INVALID BEST";
        }
        else
        {
            _os << "best: " << bestFitness  ;
        }

    }

    virtual void readFrom(std::istream& _is) {

        // the new version of the reafFrom function.
        // It can distinguish between valid and invalid fitness values.
        std::string fitness_str;
        int pos = _is.tellg();
        _is >> fitness_str;

        if (fitness_str == "INVALID")
        {
            invalidFitness = true;
        }
        else
        {
            invalidFitness = false;
            _is.seekg(pos); // rewind
            _is >> repFitness;
        }
    }

private:
    Fitness repFitness;         // value of fitness for this particle
    bool invalidFitness;                // true if the value of the fitness is invalid

    Fitness bestFitness;                // value of the best fitness found for the particle
    bool invalidBestFitness;    // true if the value of the best fitness is invalid

};

//-----------------------------------------------------------------------------

#endif /*PO_H */

---