AGPFunction.h

/*  This file is part of Victor.

    Victor 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 3 of the License, or
    (at your option) any later version.

    Victor 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 Victor.  If not, see <http://www.gnu.org/licenses/>.
 */
#ifndef __AGPFunction_H__
#define __AGPFunction_H__

#include <GapFunction.h>

namespace Victor { namespace Align2{

    class AGPFunction : public GapFunction {
    public:

        // CONSTRUCTORS:


        AGPFunction() : o(12.00), e(3.00) {
        }


        AGPFunction(double o, double e) : o(o), e(e) {
        }


        AGPFunction(const AGPFunction &orig) : GapFunction(orig) {
            copy(orig);
        }


        virtual ~AGPFunction() {
        }


        // OPERATORS:

        AGPFunction& operator =(const AGPFunction &orig);


        // PREDICATES:

        virtual double getOpenPenalty(int p);

        virtual double getExtensionPenalty(int p);


        // MODIFIERS:

        virtual void copy(const AGPFunction &orig);

        virtual AGPFunction* newCopy();

        virtual void setOpenPenalty(double pen);

        virtual void setExtensionPenalty(double pen);


    protected:


    private:

        // ATTRIBUTES:

        double o; 
        double e; 

    };

    // -----------------------------------------------------------------------------
    //                                 AGPFunction
    // -----------------------------------------------------------------------------

    // OPERATORS:

    inline AGPFunction&
            AGPFunction::operator =(const AGPFunction &orig) {
        if (&orig != this)
            copy(orig);
        POSTCOND((orig == *this), exception);
        return *this;
    }


    // PREDICATES:

    inline double
    AGPFunction::getOpenPenalty(int p) {
        return o;
    }

    inline double
    AGPFunction::getExtensionPenalty(int p) {
        return e;
    }


    // MODIFIERS:

    inline void
    AGPFunction::copy(const AGPFunction &orig) {
        GapFunction::copy(orig);
        o = orig.o;
        e = orig.e;
    }

    inline AGPFunction*
    AGPFunction::newCopy() {
        AGPFunction *tmp = new AGPFunction(*this);
        return tmp;
    }

    inline void
    AGPFunction::setOpenPenalty(double pen) {
        o = pen;
    }

    inline void
    AGPFunction::setExtensionPenalty(double pen) {
        e = pen;
    }

}} // namespace

#endif