kpttask.h

/* 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 <tqptrlist.h>
 
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(TQDomElement &element, Project &project);
    virtual void save(TQDomElement &element) const;
    virtual void saveAppointments(TQDomElement &element, long id) const;
    virtual EffortCostMap plannedEffortCostPrDay(const TQDate &start, const TQDate &end) const;
    
    virtual Duration plannedEffort();
    virtual Duration plannedEffort(const TQDate &date);
    virtual Duration plannedEffortTo(const TQDate &date);
    
    virtual Duration actualEffort();
    virtual Duration actualEffort(const TQDate &date);
    virtual Duration actualEffortTo(const TQDate &date);
    
    virtual double plannedCost();
    virtual double plannedCost(const TQDate &/*date*/);
    virtual double plannedCostTo(const TQDate &/*date*/);
    
    virtual double actualCost();
    virtual double actualCost(const TQDate &/*date*/);
    virtual double actualCostTo(const TQDate &/*date*/);
 
    double effortPerformanceIndex(const TQDate &date, bool *error=0);
    double costPerformanceIndex(const TQDate &date, bool *error=0);
    
    void initiateCalculation(Schedule &sch);
    void initiateCalculationLists(TQPtrList<Node> &startnodes, TQPtrList<Node> &endnodes, TQPtrList<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(TQPtrList<Relation> &list);
    void addChildProxyRelations(TQPtrList<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();
    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 TQPtrList<Relation> &list, int use);
    DateTime calculatePredeccessors(const TQPtrList<Relation> &list, int use);
    DateTime scheduleSuccessors(const TQPtrList<Relation> &list, int use);
    DateTime schedulePredeccessors(const TQPtrList<Relation> &list, int use);
    
    DateTime workStartAfter(const DateTime &dt);
    DateTime workFinishBefore(const DateTime &dt);
 
private:
    TQPtrList<ResourceGroup> m_resource;
 
    ResourceRequestCollection *m_requests;
 
    TQPtrList<Relation> m_parentProxyRelations;
    TQPtrList<Relation> m_childProxyRelations;
      
    struct Progress m_progress;
    
#ifndef NDEBUG
public:
    void printDebug(bool children, TQCString indent);
#endif
 
};
 
}  //KPlato namespace
 
#endif