D:/Projekt/ECF_trunk/ECF/Genotype.h

#ifndef Genotype_h
#define Genotype_h

#include<string>

// forward declarations of genotype operators
class CrossoverOp;
typedef boost::shared_ptr<CrossoverOp> CrossoverOpP;
class MutationOp;
typedef boost::shared_ptr<MutationOp> MutationOpP;

// forward declaration of State class
class State;
typedef boost::shared_ptr<State> StateP;

class Genotype
{
protected:

public:
    Genotype()
    {   }
    virtual ~Genotype()
    {   }

    virtual bool initialize(StateP state) = 0;

    virtual Genotype* copy() = 0;

    virtual std::vector<CrossoverOpP> getCrossoverOp()
    {
        std::vector<CrossoverOpP> empty;
        return empty;
    }

    virtual std::vector<MutationOpP> getMutationOp()
    {
        std::vector<MutationOpP> empty;
        return empty;
    }

    virtual void registerParameters(StateP) {}

    bool registerParameter(StateP state, std::string name, voidP value, enum ECF::type T, std::string description = ""); 

    voidP getParameterValue(StateP state, std::string name);    

    bool setParameterValue(StateP state, std::string name, voidP value);    

    bool isParameterDefined(StateP state, std::string name);    

    virtual void read(XMLNode&) = 0;

    virtual void write(XMLNode&) = 0;

    virtual uint getGenomeSize()
    {   return 0;   }

    std::string getName()
    {   return name_;   }

    uint getGenotypeId()
    {   return genotypeId_; }

    void setGenotypeId(uint id)
    {   genotypeId_ = id;   }

    std::string toString()
    {
        XMLNode xGene;
        write(xGene);
        char *s = xGene.createXMLString();
        std::string out(s);
        freeXMLString(s);
        return out;
    }

protected:
    std::string name_;  
    uint genotypeId_;   
};
typedef boost::shared_ptr<Genotype>  GenotypeP;

#endif // Genotype_h