## 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"                     gchar*                : Read / Write
      "note"                     gchar*                : 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"                               : Run Last
      "assignment-removed"                             : Run Last
      "child-added"                                    : Run Last
      "child-removed"                                  : Run Last
      "relation-added"                                 : Run Last
      "relation-removed"                               : Run Last
      "task-moved"                                     : 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: >= -1

Default value: 0

### The `"finish"` property

      "finish"                   glong                 : Read

Task finish time.

Allowed values: >= 0

Default value: 0

### The `"latest-finish"` property

      "latest-finish"            glong                 : Read

Latest task finish time.

Allowed values: >= 0

Default value: 0

### The `"latest-start"` property

      "latest-start"             glong                 : Read

Latest task start time.

Allowed values: >= 0

Default value: 0

### The `"name"` property

      "name"                     gchar*                : Read / Write

Name of the task.

Default value: ""

### The `"note"` property

      "note"                     gchar*                : 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

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: >= -1

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.
`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.
`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.
`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.
`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.
`user_data` : | user data set when the signal handler was connected.