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