F:/KPlato/koffice/kplato/kpttask.h

Aller à la documentation de ce fichier.

/* This file is part of the KDE project
   Copyright (C) 2001 Thomas Zander zander@kde.org
   Copyright (C) 2004 Dag Andersen <danders@get2net.dk>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#ifndef KPTTASK_H
#define KPTTASK_H

#include "kptnode.h"
#include "kptduration.h"
#include "kptresource.h"

#include <QList>

namespace KPlato
{

class DateTime;

class Task : public Node {
public:
    Task(Node *parent = 0);
    Task(Task &task, Node *parent = 0);
    ~Task();

    virtual int type() const;

    Duration *getExpectedDuration();

    Duration *getRandomDuration();

    ResourceGroupRequest *resourceGroupRequest(ResourceGroup *group) const;
    void clearResourceRequests();
    void addRequest(ResourceGroup *group, int numResources);
    void addRequest(ResourceGroupRequest *request);
    void takeRequest(ResourceGroupRequest *request);
    int units() const;
    int workUnits() const;
    void makeAppointments();
    void calcResourceOverbooked();
    
    void setConstraint(Node::ConstraintType type);

    virtual bool load(QDomElement &element, Project &project);
    virtual void save(QDomElement &element) const;
    virtual void saveAppointments(QDomElement &element, long id) const;
    virtual EffortCostMap plannedEffortCostPrDay(const QDate &start, const QDate &end) const;
    
    virtual Duration plannedEffort();
    virtual Duration plannedEffort(const QDate &date);
    virtual Duration plannedEffortTo(const QDate &date);
    
    virtual Duration actualEffort();
    virtual Duration actualEffort(const QDate &date);
    virtual Duration actualEffortTo(const QDate &date);
    
    virtual double plannedCost();
    virtual double plannedCost(const QDate &/*date*/);
    virtual double plannedCostTo(const QDate &/*date*/);
    
    virtual double actualCost();
    virtual double actualCost(const QDate &/*date*/);
    virtual double actualCostTo(const QDate &/*date*/);

    double effortPerformanceIndex(const QDate &date, bool *error=0);
    double costPerformanceIndex(const QDate &date, bool *error=0);
    
    void initiateCalculation(Schedule &sch);
    void initiateCalculationLists(QList<Node*> &startnodes, QList<Node*> &endnodes, QList<Node*> &summarytasks);
    DateTime calculateForward(int use);
    DateTime calculateBackward(int use);
    DateTime scheduleForward(const DateTime &earliest, int use);
    DateTime scheduleBackward(const DateTime &latest, int use);
    
    void adjustSummarytask();
    
    Duration calcDuration(const DateTime &time, const Duration &effort, bool backward);

    // Proxy relations are relations to/from summarytasks. 
    // These relations are distrubuted to the relevant tasks before calculation.
    void clearProxyRelations();
    void addParentProxyRelations(QList<Relation*> &list);
    void addChildProxyRelations(QList<Relation*> &list);
    void addParentProxyRelation(Node *node, const Relation *rel);
    void addChildProxyRelation(Node *node, const Relation *rel);
    
    bool isEndNode() const;
    bool isStartNode() const;
    
    virtual DateTime workStartTime() const;
    
    virtual DateTime workEndTime() const;
    
    Duration positiveFloat();
    Duration negativeFloat() { return Duration(); }
    Duration freeFloat() { return Duration(); }
    Duration startFloat() { return Duration(); }
    Duration finishFloat() { return Duration(); }
    
    virtual bool isCritical() const;
    virtual bool calcCriticalPath(bool fromEnd);
    
    virtual void setCurrentSchedule(long id);
    
    virtual bool effortMetError() const;
    
    struct Progress {
        Progress() { started = finished = false; percentFinished = 0; }
        bool operator==(struct Progress &p) {
            return started == p.started && finished == p.finished &&
                   startTime == p.startTime && finishTime == p.finishTime &&
                   percentFinished == p.percentFinished &&
                   remainingEffort == p.remainingEffort &&
                   totalPerformed == p.totalPerformed;
        }
        bool operator!=(struct Progress &p) { return !(*this == p); }
        struct Progress &operator=(struct Progress &p) {
            started = p.started; finished = p.finished;
            startTime = p.startTime; finishTime = p.finishTime;
            percentFinished = p.percentFinished;
            remainingEffort = p.remainingEffort;
            totalPerformed = p.totalPerformed;
            return *this;
        }
        bool started, finished;
        DateTime startTime, finishTime;
        int percentFinished;
        Duration remainingEffort;
        Duration totalPerformed;        
    };
    struct Progress &progress() { return m_progress; }
    
private:
    DateTime calculateSuccessors(const QList<Relation*> &list, int use);
    DateTime calculatePredeccessors(const QList<Relation*> &list, int use);
    DateTime scheduleSuccessors(const QList<Relation*> &list, int use);
    DateTime schedulePredeccessors(const QList<Relation*> &list, int use);
    
    DateTime workStartAfter(const DateTime &dt);
    DateTime workFinishBefore(const DateTime &dt);

private:
    QList<ResourceGroup*> m_resource;

    ResourceRequestCollection *m_requests;
 
    QList<Relation*> m_parentProxyRelations;
    QList<Relation*> m_childProxyRelations;
      
    struct Progress m_progress;
    
#ifndef NDEBUG
public:
    void printDebug(bool children, QByteArray indent);
#endif

};

}  //KPlato namespace

#endif

---