MrpTask

MrpTask — represents a task in the project.

Synopsis


#include <libplanner/planner.h>


            MrpTaskPriv;
            MrpTask;
            MrpConstraint;
enum        MrpConstraintType;
MrpTask*    mrp_task_new                    (void);
void        mrp_task_set_name               (MrpTask *task,
                                             const gchar *name);
const gchar* mrp_task_get_name              (MrpTask *task);
MrpRelation* mrp_task_add_predecessor       (MrpTask *task,
                                             MrpTask *predecessor,
                                             MrpRelationType type,
                                             glong lag,
                                             GError **error);
void        mrp_task_remove_predecessor     (MrpTask *task,
                                             MrpTask *predecessor);
MrpRelation* mrp_task_get_relation          (MrpTask *task_a,
                                             MrpTask *task_b);
MrpRelation* mrp_task_get_predecessor_relation
                                            (MrpTask *task,
                                             MrpTask *predecessor);
MrpRelation* mrp_task_get_successor_relation
                                            (MrpTask *task,
                                             MrpTask *successor);
GList*      mrp_task_get_predecessor_relations
                                            (MrpTask *task);
GList*      mrp_task_get_successor_relations
                                            (MrpTask *task);
gboolean    mrp_task_has_relation_to        (MrpTask *task_a,
                                             MrpTask *task_b);
gboolean    mrp_task_has_relation           (MrpTask *task);
MrpTask*    mrp_task_get_parent             (MrpTask *task);
MrpTask*    mrp_task_get_first_child        (MrpTask *task);
MrpTask*    mrp_task_get_next_sibling       (MrpTask *task);
guint       mrp_task_get_n_children         (MrpTask *task);
MrpTask*    mrp_task_get_nth_child          (MrpTask *task,
                                             guint n);
gint        mrp_task_get_position           (MrpTask *task);
mrptime     mrp_task_get_start              (MrpTask *task);
mrptime     mrp_task_get_work_start         (MrpTask *task);
mrptime     mrp_task_get_finish             (MrpTask *task);
mrptime     mrp_task_get_latest_start       (MrpTask *task);
mrptime     mrp_task_get_latest_finish      (MrpTask *task);
gint        mrp_task_get_duration           (MrpTask *task);
gint        mrp_task_get_work               (MrpTask *task);
GList*      mrp_task_get_assignments        (MrpTask *task);
MrpAssignment* mrp_task_get_assignment      (MrpTask *task,
                                             MrpResource *resource);
void        mrp_task_reset_constraint       (MrpTask *task);
gfloat      mrp_task_get_cost               (MrpTask *task);
GList*      mrp_task_get_assigned_resources (MrpTask *task);
gint        mrp_task_compare                (gconstpointer a,
                                             gconstpointer b);

Object Hierarchy


  GObject
   +----MrpObject
         +----MrpTask

Properties


  "constraint"           MrpConstraint         : Read / Write
  "critical"             gboolean              : Read / Write
  "duration"             gint                  : Read / Write
  "finish"               glong                 : Read
  "latest-finish"        glong                 : Read
  "latest-start"         glong                 : Read
  "name"                 gchararray            : Read / Write
  "note"                 gchararray            : Read / Write
  "percent-complete"     gint                  : Read / Write
  "priority"             gint                  : Read / Write
  "sched"                MrpTaskSched          : Read / Write
  "start"                glong                 : Read
  "type"                 MrpTaskType           : Read / Write
  "work"                 gint                  : Read / Write

Signals


"assignment-added"
            void        user_function      (MrpTask       *mrptask,
                                            MrpAssignment *arg1,
                                            gpointer       user_data)      : Run last
"assignment-removed"
            void        user_function      (MrpTask       *mrptask,
                                            MrpAssignment *arg1,
                                            gpointer       user_data)      : Run last
"child-added"
            void        user_function      (MrpTask *mrptask,
                                            gpointer user_data)      : Run last
"child-removed"
            void        user_function      (MrpTask *mrptask,
                                            gpointer user_data)      : Run last
"relation-added"
            void        user_function      (MrpTask *mrptask,
                                            gpointer arg1,
                                            gpointer user_data)      : Run last
"relation-removed"
            void        user_function      (MrpTask *mrptask,
                                            gpointer arg1,
                                            gpointer user_data)      : Run last
"task-moved"
            void        user_function      (MrpTask *mrptask,
                                            MrpTask *arg1,
                                            gint     arg2,
                                            gpointer user_data)      : Run last

Description

Details

MrpTaskPriv

typedef struct _MrpTaskPriv MrpTaskPriv;

A private struct for internal use only. The definition of this structure is not publically available.

MrpTask

typedef struct _MrpTask MrpTask;

Object representing a task in the project.

MrpConstraint

typedef struct {
	MrpConstraintType type;
	mrptime           time;
} MrpConstraint;

A struct representing a scheduling constraint on a task.

enum MrpConstraintType

typedef enum {
	MRP_CONSTRAINT_ASAP = 0, /* as-soon-as-possible */
	MRP_CONSTRAINT_ALAP,     /* as-late-as-possible */
	MRP_CONSTRAINT_SNET,     /* start-no-earlier-than */
	MRP_CONSTRAINT_FNLT,     /* finish-no-later-than */
	MRP_CONSTRAINT_MSO,      /* must-start-on */
} MrpConstraintType;

The type of constraint for the task. The default is MRP_CONSTRAINT_ASAP.

MRP_CONSTRAINT_ASAP as soon as possible
MRP_CONSTRAINT_ALAP as late as possible (unimplemented)
MRP_CONSTRAINT_SNET start no eariler than
MRP_CONSTRAINT_FNLT finish no later than (unimplemented)
MRP_CONSTRAINT_MSO must start on

mrp_task_new ()

MrpTask*    mrp_task_new                    (void);

Create a new task.

Returns : the newly created MrpTask.

mrp_task_set_name ()

void        mrp_task_set_name               (MrpTask *task,
                                             const gchar *name);

Sets the name of task.

task : an MrpResource
name : new name of task

mrp_task_get_name ()

const gchar* mrp_task_get_name              (MrpTask *task);

Retrives the name of task.

task : an MrpTask
Returns : the name

mrp_task_add_predecessor ()

MrpRelation* mrp_task_add_predecessor       (MrpTask *task,
                                             MrpTask *predecessor,
                                             MrpRelationType type,
                                             glong lag,
                                             GError **error);

Adds a predecessor task to a task. Depending on type, the predecessor must be started or finished before task can be started or finished, with an optional lag/lead time.

task : an MrpTask
predecessor : the predecessor
type : type of relation
lag : lag time, if negative, it means lead time
error : location to store error, or NULL
Returns : the relation that represents the predecessor/successor link.

mrp_task_remove_predecessor ()

void        mrp_task_remove_predecessor     (MrpTask *task,
                                             MrpTask *predecessor);

Removes a predecessor previously added to task.

task : an MrpTask
predecessor : the predecessor to remove

mrp_task_get_relation ()

MrpRelation* mrp_task_get_relation          (MrpTask *task_a,
                                             MrpTask *task_b);

Fetches a relation between two tasks if it exists.

task_a : an MrpTask
task_b : an MrpTask
Returns : a MrpRelation representing the relation between task_a and task_b or NULL if they don't have any relation.

mrp_task_get_predecessor_relation ()

MrpRelation* mrp_task_get_predecessor_relation
                                            (MrpTask *task,
                                             MrpTask *predecessor);

Fetches a predecessor relation between task and it's predecessor.

task : an MrpTask
predecessor : an MrpTask
Returns : the MrpRelation if it exists, otherwise NULL

mrp_task_get_successor_relation ()

MrpRelation* mrp_task_get_successor_relation
                                            (MrpTask *task,
                                             MrpTask *successor);

Fetches a successor relation between task and it's successor.

task : an MrpTask
successor : an MrpTask
Returns : the MrpRelation if it exists, otherwise NULL

mrp_task_get_predecessor_relations ()

GList*      mrp_task_get_predecessor_relations
                                            (MrpTask *task);

Fetches a list of predecessor relations to task.

task : an MrpTask
Returns : the list of predecessor relations to task

mrp_task_get_successor_relations ()

GList*      mrp_task_get_successor_relations
                                            (MrpTask *task);

Fetches a list of successor relations to task.

task : an MrpTask
Returns : a list of successor relations to task

mrp_task_has_relation_to ()

gboolean    mrp_task_has_relation_to        (MrpTask *task_a,
                                             MrpTask *task_b);

Checks if a and b has a relation, i.e. if a is a predecessor or successor of b.

task_a : an MrpTask
task_b : an MrpTask
Returns : TRUE if a and b has a relation

mrp_task_has_relation ()

gboolean    mrp_task_has_relation           (MrpTask *task);

Checks if a task has any relations, i.e. predecessors or successors.

task : an MrpTask
Returns : TRUE if there are any relations.

mrp_task_get_parent ()

MrpTask*    mrp_task_get_parent             (MrpTask *task);

Fetches the parent of task.

task : an MrpTask
Returns : the parent of task, or NULL if there is no parent..

mrp_task_get_first_child ()

MrpTask*    mrp_task_get_first_child        (MrpTask *task);

Fetches the first child of task.

task : an MrpTask
Returns : the first child of task, or NULL if there are no children.

mrp_task_get_next_sibling ()

MrpTask*    mrp_task_get_next_sibling       (MrpTask *task);

Fetches the next sibling of task.

task : an MrpTask
Returns : the next sibling of task, or NULL if there is no next sibling.

mrp_task_get_n_children ()

guint       mrp_task_get_n_children         (MrpTask *task);

Fetches the number of children task has.

task : an MrpTask
Returns : the number of children task has

mrp_task_get_nth_child ()

MrpTask*    mrp_task_get_nth_child          (MrpTask *task,
                                             guint n);

Fetches the nth child of task.

task : an MrpTask
n : the index of the child to get
Returns : the nth child of task, or NULL if there is no such child.

mrp_task_get_position ()

gint        mrp_task_get_position           (MrpTask *task);

Fetches the index or position of task among its siblings.

task : an MrpTask
Returns : the position of task among its siblings.

mrp_task_get_start ()

mrptime     mrp_task_get_start              (MrpTask *task);

Fetches the start time of task.

task : an MrpTask
Returns : the start time of task.

mrp_task_get_work_start ()

mrptime     mrp_task_get_work_start         (MrpTask *task);

Retrieves the first time where work is performed of task. This might be different from the start time, if the start time is during non-working time. In that case, the work start would be right after the non-working interval.

task : an MrpTask
Returns : The work start time of task.

mrp_task_get_finish ()

mrptime     mrp_task_get_finish             (MrpTask *task);

Fetches the finish time of task.

task : an MrpTask
Returns : the finish time of task.

mrp_task_get_latest_start ()

mrptime     mrp_task_get_latest_start       (MrpTask *task);

Retrieves the latest start time of task, i.e. the latest time the task can start without delaying the project.

task : an MrpTask
Returns : The latest start time of task.

mrp_task_get_latest_finish ()

mrptime     mrp_task_get_latest_finish      (MrpTask *task);

Retrieves the latest finish time of task, i.e. the latest time the task can finish without delaying the project.

task : an MrpTask
Returns : The latest finish time of task.

mrp_task_get_duration ()

gint        mrp_task_get_duration           (MrpTask *task);

Fetches the duration of task. This differs from the calendar duration that is retrieved by (finish - start).

task : an MrpTask
Returns : The duration of task.

mrp_task_get_work ()

gint        mrp_task_get_work               (MrpTask *task);

Retrieves the amount of work of task.

task : an MrpTask
Returns : The work of task.

mrp_task_get_assignments ()

GList*      mrp_task_get_assignments        (MrpTask *task);

Fetches a list of MrpAssignment.

task : an MrpTask
Returns : the list of assignments.

mrp_task_get_assignment ()

MrpAssignment* mrp_task_get_assignment      (MrpTask *task,
                                             MrpResource *resource);

retrieves the MrpAssignment associated with task and resource if the resource is assigned to task, or NULL if there is no such assignment.

task : an MrpTask
resource : an MrpResource
Returns : The assignment if it exists, otherwise NULL.

mrp_task_reset_constraint ()

void        mrp_task_reset_constraint       (MrpTask *task);

Sets the contraint type to MRP_CONTRAINT_ASAP and notifies listeners.

task : an MrpTask

mrp_task_get_cost ()

gfloat      mrp_task_get_cost               (MrpTask *task);

Calculates the cost to complete task.

task : an MrpTask
Returns : The cost to complete task.

mrp_task_get_assigned_resources ()

GList*      mrp_task_get_assigned_resources (MrpTask *task);

Fetches a list of resources assigned to task. The list needs to be freed with g_list_free() by caller.

task : an MrpTask
Returns : A newly created list of MrpResource.

mrp_task_compare ()

gint        mrp_task_compare                (gconstpointer a,
                                             gconstpointer b);

Compares the name of the tasks, by calling strcmp() on the names.

a : an MrpTask
b : an MrpTask
Returns : the return value of strcmp (a->name, b->name).

Property Details

The "constraint" property

  "constraint"           MrpConstraint         : Read / Write

Task scheduling constraint.

The "critical" property

  "critical"             gboolean              : Read / Write

In critical path.

Default value: FALSE

The "duration" property

  "duration"             gint                  : Read / Write

Duration of the task.

Allowed values: >= G_MAXULONG

Default value: 0

The "finish" property

  "finish"               glong                 : Read

Task finish time.

Allowed values: [0,G_MAXINT]

Default value: 0

The "latest-finish" property

  "latest-finish"        glong                 : Read

Latest task finish time.

Allowed values: [0,G_MAXINT]

Default value: 0

The "latest-start" property

  "latest-start"         glong                 : Read

Latest task start time.

Allowed values: [0,G_MAXINT]

Default value: 0

The "name" property

  "name"                 gchararray            : Read / Write

Name of the task.

Default value: ""

The "note" property

  "note"                 gchararray            : Read / Write

Note attached to the task.

Default value: ""

The "percent-complete" property

  "percent-complete"     gint                  : Read / Write

Percent completed of task.

Allowed values: [0,100]

Default value: 0

The "priority" property

  "priority"             gint                  : Read / Write

Priority of the task.

Allowed values: [0,9999]

Default value: 0

The "sched" property

  "sched"                MrpTaskSched          : Read / Write

Task scheduling type.

Default value: MRP_TASK_SCHED_FIXED_WORK

The "start" property

  "start"                glong                 : Read

Task Start time.

Allowed values: [0,G_MAXINT]

Default value: 0

The "type" property

  "type"                 MrpTaskType           : Read / Write

Task type.

Default value: MRP_TASK_TYPE_NORMAL

The "work" property

  "work"                 gint                  : Read / Write

Task work.

Allowed values: >= G_MAXULONG

Default value: 0

Signal Details

The "assignment-added" signal

void        user_function                  (MrpTask       *mrptask,
                                            MrpAssignment *arg1,
                                            gpointer       user_data)      : Run last

mrptask : the object which received the signal.
arg1 :
user_data : user data set when the signal handler was connected.

The "assignment-removed" signal

void        user_function                  (MrpTask       *mrptask,
                                            MrpAssignment *arg1,
                                            gpointer       user_data)      : Run last

mrptask : the object which received the signal.
arg1 :
user_data : user data set when the signal handler was connected.

The "child-added" signal

void        user_function                  (MrpTask *mrptask,
                                            gpointer user_data)      : Run last

mrptask : the object which received the signal.
user_data : user data set when the signal handler was connected.

The "child-removed" signal

void        user_function                  (MrpTask *mrptask,
                                            gpointer user_data)      : Run last

mrptask : the object which received the signal.
user_data : user data set when the signal handler was connected.

The "relation-added" signal

void        user_function                  (MrpTask *mrptask,
                                            gpointer arg1,
                                            gpointer user_data)      : Run last

mrptask : the object which received the signal.
arg1 :
user_data : user data set when the signal handler was connected.

The "relation-removed" signal

void        user_function                  (MrpTask *mrptask,
                                            gpointer arg1,
                                            gpointer user_data)      : Run last

mrptask : the object which received the signal.
arg1 :
user_data : user data set when the signal handler was connected.

The "task-moved" signal

void        user_function                  (MrpTask *mrptask,
                                            MrpTask *arg1,
                                            gint     arg2,
                                            gpointer user_data)      : Run last

mrptask : the object which received the signal.
arg1 :
arg2 :
user_data : user data set when the signal handler was connected.