organism.h

//---------------------------------------------------------------------
//  Algorithmic Conjurings @ http://www.coyotegulch.com
//  Evocosm -- An Object-Oriented Framework for Evolutionary Algorithms
//
//  organism.h
//---------------------------------------------------------------------
//
//  Copyright 1996, 1999, 2002, 2003, 2004, 2005, 2007 Scott Robert Ladd
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//  
//  This program 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 General Public License for more details.
//  
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the
//      Free Software Foundation, Inc.
//      59 Temple Place - Suite 330
//      Boston, MA 02111-1307, USA.
//
//-----------------------------------------------------------------------
//
//  For more information on this software package, please visit
//  Scott's web site, Coyote Gulch Productions, at:
//
//      http://www.coyotegulch.com
//  
//-----------------------------------------------------------------------

#if !defined(LIBEVOCOSM_ORGANISM_H)
#define LIBEVOCOSM_ORGANISM_H

// Standard C++ Library
#include <cstddef>

// libevocosm
#include "evocommon.h"

namespace libevocosm
{
    using std::vector;


    template <typename Genotype>
    class organism : protected globals
    {
    protected:
        double m_fitness;

        Genotype m_genes;

    public:

        organism()
            : m_fitness(0.0),
              m_genes()
        {
            // nada
        }


        organism(const Genotype & a_value)
            : m_fitness(0.0),
              m_genes(a_value)
        {
            // nada
        }


        organism(const organism & a_source)
            : m_fitness(a_source.m_fitness),
              m_genes(a_source.m_genes)
        {
            // nada
        }


        organism(const organism & a_parent1, const organism & a_parent2)
            : m_fitness(a_parent1.m_fitness),
              m_genes(a_parent1.m_genes,a_parent2.m_genes)
        {
            // nada
        }


        virtual ~organism()
        {
            // nada
        }


        organism & operator = (const organism & a_source)
        {
            m_fitness = a_source.m_fitness;
            m_genes   = a_source.m_genes;
            return *this;
        }


        virtual bool operator < (const organism & a_right) const
        {
            return (m_fitness > a_right.m_fitness);
        }
        

        virtual void reset_all()
        {
            m_fitness = 0.0;
        }
    

        double & fitness()
        {
            return m_fitness;
        }


        double fitness() const
        {
            return m_fitness;
        }


        Genotype & genes()
        {
            return m_genes;
        }


        const Genotype & genes() const
        {
            return m_genes;
        }
    };

};

#endif