---

mrprjContent.h

Go to the documentation of this file.

/*
 * Copyright (C) 2001 Karsten Reincke <karsten.reincke@karubik.de>
 *  
 *  
 * This file is part of of the software-project MRPROJEXT.
 * 
 * MRPROJEXT 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.
 * 
 * MRPROJEXT 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.
 *  
 * file <mrprjContent.h> version <#1.3.1#> of project <MrProjext>
 */   

#ifndef  MRPRJCONTENT_H
#define  MRPRJCONTENT_H

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <string>
#include <map>
#include <list>
#include <muo.h>
#include <libxml/parser.h>
#include <libxml/tree.h>

/* &&& exported preprocessor-defines &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */

/* &&& class-declarations &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */

namespace mrprj
{

class DateStringConverter
{
  private:
  public:
    
    DateStringConverter();  
    ~DateStringConverter(); 

    string formYankDateString(const string& pMrprojectDateString)const;
    
   string formGermanDateString(const string& pMrprojectDateString)const;

};

class XmlNodeReader
{
  private:
    krmuo::XmlConverter xmlConverter;  

  public:
    XmlNodeReader();    
    
    ~XmlNodeReader();  


    bool getStringProperty
    ( 
      const xmlDocPtr xmlDoc,
      const xmlNodePtr pPropertyNode, 
      const string& pPropertySigner,
      string& pPropertyValue
    );

    
    inline bool getIntProperty
    ( 
      const xmlDocPtr xmlDoc,
      const xmlNodePtr pPropertyNode, 
      const string& pPropertySigner,
      int& pPropertyValue
    )
    {
      string localStringValue;
      if (!(getStringProperty(xmlDoc,pPropertyNode,pPropertySigner,localStringValue)))
        return false;
      pPropertyValue=atoi(localStringValue.c_str());
      return true;
    }
    
    inline bool getLongProperty
    ( 
      const xmlDocPtr xmlDoc,
      const xmlNodePtr pPropertyNode, 
      const string& pPropertySigner,
      long& pPropertyValue
    )
    {
      string localStringValue;
      if (!(getStringProperty(xmlDoc,pPropertyNode,pPropertySigner,localStringValue)))
        return false;
      pPropertyValue=atol(localStringValue.c_str());
      return true;
    }


    inline bool getFloatProperty
    ( 
      const xmlDocPtr xmlDoc,
      const xmlNodePtr pPropertyNode, 
      const string& pPropertySigner,
      float& pPropertyValue
    )
    {
      string localStringValue;
      if (!(getStringProperty(xmlDoc,pPropertyNode,pPropertySigner,localStringValue)))
        return false;
      pPropertyValue=atof(localStringValue.c_str());
      return true;
    }

};

class Property
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    krmuo::LoggingUnit& mLoggingUnit;
    string mName; 
    string mType; 
    string mOwner; 
    string mLabel; 
    string mDescription; 
    
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Property
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pName,
      const string& pType,
      const string& pOwner,
      const string& pLabel,
      const string& pDescription
    );                       
        
    ~Property();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getName() const { return mName; }

    inline const string& getType() const { return mType; }

    inline const string& getOwner() const { return mOwner; }

    inline const string& getLabel() const { return mLabel; }

    inline const string& getDescription() const { return mDescription; }


    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     Property(const Property& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class Phase
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    krmuo::LoggingUnit& mLoggingUnit;
    string mName; 
    
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Phase
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pName
    );                       
        
    ~Phase();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getName() const { return mName; }


    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     Phase(const Phase& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class DayType
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    krmuo::LoggingUnit& mLoggingUnit;
    string mId; 
    string mName; 
    string mDescription; 
    
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    DayType
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pId,
      const string& pName,
      const string& pDescription
    );                       
        
    ~DayType();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getId() const { return mId; }

    inline const string& getName() const { return mName; }


    inline const string& getDescription() const { return mDescription; }


    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     DayType(const DayType& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class Interval
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    krmuo::LoggingUnit& mLoggingUnit;
    string mStart; 
    string mEnd; 
    
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Interval
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pStart,
      const string& pEnd
    );                       
        
    ~Interval();                      
        
     Interval(const Interval& co);     
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getStart() const { return mStart; }

    inline const string& getEnd() const { return mEnd; }


    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};


class OverriddenDayType
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
    list<Interval> mIntervalList;    
  
  private:
    krmuo::LoggingUnit& mLoggingUnit;
    string mId; 
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    OverriddenDayType
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pId
    );                       
        
    ~OverriddenDayType();                      
        

    OverriddenDayType(const OverriddenDayType& co);     
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getId() const { return mId; }


    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class Day
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    krmuo::LoggingUnit& mLoggingUnit;
    string mDate; 
    string mType; 
    string mId; 
    
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Day
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pDate,
      const string& pType,
      const string& pId
    );                       
        
    ~Day();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getDate() const { return mDate; }

    inline const string& getType() const { return mType; }

    inline const string& getId() const { return mId; }


    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
     Day(const Day& co);     
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class Calendar
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
    string mMon; 
    string mTue; 
    string mWed; 
    string mThu; 
    string mFri; 
    string mSat; 
    string mSun; 
    
    list<OverriddenDayType> mOverriddenDayTypeList;
    list<Day> mDayList;  
  private:
    krmuo::LoggingUnit& mLoggingUnit;
    string mId; 
    string mName; 
            
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Calendar
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pId,
      const string& pName
    );                       
        
    ~Calendar();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getId() const { return mId; }

    inline const string& getName() const { return mName; }


    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     Calendar(const Calendar& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class ResourceGroup
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    string mGroupId; 
    string mGroupTitle; 
    string mGroupDescription; 
    string mGroupAdminName; 
    string mGroupAdminPhone; 
    string mGroupAdminEmail; 
    krmuo::LoggingUnit& mLoggingUnit; 
    
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    ResourceGroup
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pGroupId,
      const string& pGroupTitle="???",
      const string& pGroupDescription="???",
      const string& pGroupAdminName="???",
      const string& pGroupAdminPhone="???",
      const string& pGroupAdminEmail="???"
    );                       
        
    ~ResourceGroup();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    inline const string& getGroupId() const { return mGroupId; }
    
    inline const string& getGroupTitle() const { return mGroupTitle; }
    
    inline const string& getGroupAdminName() const { return mGroupAdminName; }

    inline const string& getGroupAdminPhone() const { return mGroupAdminPhone; }

    inline const string& getGroupAdminEmail() const { return mGroupAdminEmail; }
    
    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     ResourceGroup(const ResourceGroup& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class Resource
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    string mResourceId;
    string mResourceGroupId;
    string mResourceTitle;
    string mResourceDescription;
    int mResourceType; 
    long mResourceUnits; 
    string mRecourceEmail; 
    float mRecourceStdRate; 
    float mRecourceOvtRate; 
    krmuo::LoggingUnit& mLoggingUnit; 
    
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Resource
    ( 
      krmuo::LoggingUnit& mLoggingUnit,    
      const string& pResourceId,
      const string& pResourceGroupId,      
      const string& pResourceTitle="???",
      const string& pResourceDescription="???",
      const int pResourceType=1,
      const long pResourceUnits=100,
      const string& pRecourceEmail="???",
      float pRecourceStdRate=0.0,
      float pRecourceOvtRate=200.0
    );                       
        
    ~Resource();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    inline const string& getResourceId() const { return mResourceId; }
    
    inline const string& getResourceGroupId() const { return mResourceGroupId; }

    inline const string& getResourceTitle() const { return mResourceTitle; }

    inline const int getResourceType() const { return mResourceType; }

    inline const long getResourceUnits() const { return mResourceUnits; }

    inline const string& getRecourceEmail() const { return mRecourceEmail; }

    inline const float getRecourceStdRate() const { return mRecourceStdRate; }

    inline const float getRecourceOvtRate() const { return mRecourceOvtRate; }
    
    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     Resource(const Resource& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};

class Allocation
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    string mTaskId; 
    string mResourceId; 
    krmuo::LoggingUnit& mLoggingUnit;
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Allocation
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& pTaskId,
      const string& pResourceId      
    );                       
        
    ~Allocation();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    inline const string& getTaskId() const { return mTaskId; }

    inline const string& getResourceId() const { return mResourceId; }
    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
              
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     Allocation(const Allocation& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};




class Predecessor
{
  public:
  
  private:
    const string mEntryId;  
    const string mPredecessorTaskId;  
    const string mType;   
  protected:

  public:
  
    Predecessor
    ( 
      const string& pEntryId,
      const string& pPredecessorTaskId,
      const string& pType  
    );
    
    ~Predecessor();
    
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    
    inline const string& getEntryId() const { return mEntryId; }
    inline const string& getPredecessorTaskId() const { return mPredecessorTaskId; }
    inline const string& getType() const { return mType ; }
};

class Task
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    string mTaskId; 
    string mTaskTitle; 
    string mTaskDescription; 
    string mTaskStartDate; 
    string mTaskEndDate; 
    int mFullFilledPercent; 
    bool mIsEmptyTopTask;
     
    map<string, Task*> mSubTaskMap; 
    list<string> mSubTaskOrderList; 
    map<string,Predecessor*> mPredecessorMap; 
    krmuo::LoggingUnit& mLoggingUnit; 

    bool mIsActive; 
    bool mIsAllocated; 
    bool mAnyDaughterIsActive; 
    int mXrowspan;
    int mXrowTacker;
    int mNodeEmbeddedLevel;
    bool mXdoPrint;
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    Task 
    ( 
      krmuo::LoggingUnit& pLoggingUnit,  
      const string& spTaskId,
      const string& pTaskTitle="???",
      const string& pTaskDescription="???",
      const string& pTaskStartDate="19700101T000000",
      const string& pTaskEndDate="21001231T240000",
      const int pFullFilledPercent=0,
      const bool pIsEmptyTopTask=false
    );                       
        
    ~Task();                      
        
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    inline const string& getTaskId() const { return mTaskId; }

    inline const string& getTaskTitle() const { return mTaskTitle; }

    inline const string& getTaskDescription() const { return mTaskDescription; }


    const string getTaskDescriptionAsOneLine() const;

    const string  getPredecessorString()const;

    const string getTaskDescriptionAsFormattedString
      ( const string& pIndent,
        const int pLineLength) const;

    const string getClearTaskDescriptionAsOneLine
      () const;
        
    inline const string& getStartDate() const { return mTaskStartDate; }

    inline const string& getEndDate() const { return mTaskEndDate; }

    inline const int getFullFilledPercent() const { return mFullFilledPercent; }


    inline const bool isEmptyTopTask()const { return  mIsEmptyTopTask; }
    
    inline const bool isActive() const { return mIsActive; }

    inline const bool isAllocated() const { return mIsAllocated; }

    inline const bool isAnyDaughterIsActive() const { return mAnyDaughterIsActive; }


    inline const long numberOfDaughters() const { return mSubTaskMap.size(); }
    
    
    inline const bool isLeafNode() const 
    {
      if (numberOfDaughters()==0)
        return true;
      else
        return false;
    }
    
     inline const bool isOpenTask() const
     { 
        if (mFullFilledPercent==100)
        return false;
            else
              return true;
     }
     
     inline const string getDoneDescription() const 
     { 
        if (mFullFilledPercent==100)
          return "done";
              else
                return "open";
     }
     
    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    
    inline void setPassive() { mIsActive=false; }
    
    inline void setActive() { mIsActive=true; }
    inline void setAllocated() { mIsAllocated=true; }

    inline void setAnyDaughterIsActive() { mAnyDaughterIsActive=true; }
    
    void setPassiveIfAllDaughtersPassive();
    
    inline void setStartDate(const string& pStartDate) { mTaskStartDate=pStartDate; }


    inline void setEndDate(const string& pEndDate) { mTaskEndDate=pEndDate; }
    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    
    bool fillTaskSubStructureByMrPrjXmlTaskNodes
    ( 
      xmlDocPtr xmlDoc,
      const xmlNodePtr pFirstTaskSubnode,
      map<string,Task*>& mGlobalTaskMap
    );
        
    bool limitToTimeSlot
    (
      const string& pTimeSlotStart,
      const string& pTimeSlotEnd
    );

    bool limitToOpenTasks();

    int insertXYposition
    ( 
      const int pEmbeddedLevel,
      int& pMaxEmbeddedLevel
    );


    bool printTaskAsMrPrjXmlFileMember(int pBlankIndents)const;
    
    bool printTaskAsLeafMemoListMember
    ( const string& pTaskPrefix,
      const string& pLevelOrderString,
      const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList,
      const bool iso8601
    )const;

    bool printTaskAsTreeMemoMember
    ( const string& pLevelOrderString,
      int pTreeDepth,
      const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList,
      const bool iso8601
    )const;

    bool printTaskAsLeafVTodoMember
    ( const map<string,Resource*>& pResourceMap,
     const list<Allocation*>& pAllocationList,
      const string& pConnectedProjectName
    ) const;
     
     bool printTaskAsTreeVTodoMember
    ( const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList,
      const string& pConnectedProjectName
    )const;
 
     
    bool printTaskAsPilotLeafTodoMember
    ( const string& pLevelOrderString,
      const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList
    )const;

    bool printTaskAsPilotTreeTodoMember
    ( const string& pLevelOrderString,
      const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList
    )const;

    bool printTaskAsLeafYankTodoMember
    ( const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList
    )const;

    bool printTaskAsTreeYankTodoMember
    ( const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList,
      const int pBlankIndents
    )const;
   
    bool printTaskAsLeafCslTodoMember
   ( const string& pLevelOrderString,
     const map<string,Resource*>& pResourceMap,
     const list<Allocation*>& pAllocationList
   )const;
   
   
    bool printTaskAsTreeCslTodoMember
    ( const string& pLevelOrderString,
      const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList
    )const;


    bool printTaskAsHtmlSurveyMember
    ( const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList,
      const int maxPathLength,
      const string& pSurveyReferenceDayString     
    );

  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     Task(const Task& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    Task* insertSubTask 
    ( 
      const string& pSubTaskId,
      const string& pSubTaskTitle="???",
      const string& pSubTaskDescription="???",
      const string& pSubTaskStartDate="19700101T000000",
      const string& pSubTaskEndDate="21001231T240000",
      const int pFullFilledPercent=0      
    );
    
    bool fillTaskPredecessorByMrPrjXmlPredecessorNodes
    ( 
      xmlDocPtr xmlDoc,
      const xmlNodePtr pFirstPredecessors
    );

    bool getResourceInfos
    (
      const map<string,Resource*>& pResourceMap,
      const list<Allocation*>& pAllocationList,
      string& pResourceId,
      string& pResourceTitle
    ) const;
      
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};



class TaskField
{
  /* &&& attributes &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  public:
  
  private:
    
  
    Task mMainTask; 
    map<string,Task*> mGlobalTaskMap;  
      
    map<string,ResourceGroup*> mResourceGroupMap; 
    string mDefaultResourceGroup;
    
    map<string,Resource*> mResourceMap; 
    
    list<Allocation*> mAllocationList; 
    list<Property*> mPropertyList; 
    list<Phase*> mPhaseList; 
    list<DayType*> mDayTypeList; 
    list<Calendar*> mCalendarList; 
    
    krmuo::LoggingUnit& mLoggingUnit; 
    
    string mProjectName;
    string mProjectCompany;
    string mProjectManager;
    string mProjectPhase;
    string mProjectStart;
    string mProjectMrpVersion;
    string mProjectCalendar;
    
    string mRealTimeslotStart;
    string mRealTimeslotEnd;
  protected:
  
  /* &&& methods &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
  
  public:
  
    /* :-: public constructors / init / operators :-:-:-:-:-:-:-: */
    
    TaskField(krmuo::LoggingUnit& pLoggingUnit);                       
        
    ~TaskField();                      
        
  
    /* :-: public getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: public setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */    
    /* :-: public others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    bool fillTaskFieldByMrPrjXmlFileContent
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      const string& mrprjBaseFileContent
    );
        
    inline void limitToTimeSlot(const string& pTimeSlotStart,const string& pTimeSlotEnd)
    {
      mMainTask.limitToTimeSlot(pTimeSlotStart,pTimeSlotEnd);
    }

    inline void limitToOpenTasks()
    {
      mMainTask.limitToOpenTasks();
    }
   
   
    bool limitToResource(const string& pResourceTitel);
    
    bool limitToResourceGroup(const string& pResourceGroupTitel);

    inline void limitToThoseWithActiveDaughters()
    {
      mMainTask.setPassiveIfAllDaughtersPassive();
    }
    
    bool printTaskFieldAsMrPrjXmlFile()const;
    
    
    bool printTaskFieldAsLeafListMemo(bool pIso8601);

    bool  printTaskFieldAsTreeMemo(bool pIso8601);
    
    inline void printTaskFieldAsPilotTreeTodo()
    {
      mMainTask.printTaskAsPilotTreeTodoMember("",mResourceMap,mAllocationList);

    }
    
    inline void printTaskFieldAsPilotLeafTodo()
    {
      mMainTask.printTaskAsPilotLeafTodoMember("",mResourceMap,mAllocationList);

    }

    inline void printTaskFieldAsLeafVTodo()
    {
      mMainTask.printTaskAsLeafVTodoMember
        (mResourceMap,mAllocationList,getConnectProjectName());

    }
    inline void printTaskFieldAsTreeVTodo()
    {
      mMainTask.printTaskAsTreeVTodoMember
        (mResourceMap,mAllocationList,getConnectProjectName());

    }
    void printTaskFieldAsLeafYankTodo();
    
    void printTaskFieldAsTreeYankTodo();
    
    
    void printTaskFieldAsLeafCslTodo();

     void printTaskFieldAsTreeCslTodo();

     void printTaskHtmlSurvey(const string& pSurveyReferenceDayString);
 
  private:
    /* :-: private constructors / init / operators :-:-:-:-:-:-: */
     TaskField(const TaskField& co);     
    /* :-: private getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    string getConnectProjectName()const;
    /* :-: private setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: private others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

    bool fillResourceGroupMapByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc,
      const xmlNodePtr pFirstResourceGroup
    );

    bool fillResourceMapByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstResource
    );

    bool fillAllocationListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstAllocation
    );
    
    bool fillPropertyListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstProperty
    );
    
    bool fillPhaseListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstProperty
    );
    
    
    bool fillDayTypeListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstProperty
    );

    bool fillIntervalListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstInterval,
      list<Interval>& pIntervalList
    );


    bool fillOverriddenDayTypeListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstOverriddenDayType,
     list<OverriddenDayType>& pOverriddenDayTypeList
    );


    bool fillDayListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstDay,
      list<Day>& pDayList
    );



    bool fillCalSubPartByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstCalSubPart,
      Calendar* pCalendar
    );


    bool fillCalendarListByMrPrjXmlEntries
    ( 
      krmuo::LoggingUnit& pLoggingUnit,
      xmlDocPtr xmlDoc, 
      const xmlNodePtr pFirstProperty
    );


    void storeRealTimeSlot();
    
  protected:
    /* :-: protected getter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected setter :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
    /* :-: protected others :-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
};
}
#endif

---