Struct task_hookrs::task::Task

pub struct Task { /* private fields */ }

Task type

A task must have four things:

• A Status
• An UUID
• An Entry-Date
• A Description

all other Data is optional by taskwarrior. This type is a simple rust representation of the JSON exported by taskwarrior.

For further explanations of the fields please consult the documentation on https://taskwarrior.org/

It is deserializeable and serializeable via serde_json, so importing and exporting taskwarrior tasks is simply serializing and deserializing objects of this type.

Implementations

impl Task

pub fn new(
    id: Option<u64>,
    status: TaskStatus,
    uuid: Uuid,
    entry: Date,
    description: String,
    annotations: Option<Vec<Annotation>>,
    depends: Option<Vec<Uuid>>,
    due: Option<Date>,
    end: Option<Date>,
    imask: Option<f64>,
    mask: Option<String>,
    modified: Option<Date>,
    parent: Option<Uuid>,
    priority: Option<TaskPriority>,
    project: Option<Project>,
    recur: Option<String>,
    scheduled: Option<Date>,
    start: Option<Date>,
    tags: Option<Vec<Tag>>,
    until: Option<Date>,
    wait: Option<Date>,
    urgency: Option<Urgency>,
    uda: UDA
) -> Task

Create a new Task instance

Examples found in repository

src/task.rs (lines 789-813)

    fn visit_map<V>(self, mut visitor: V) -> RResult<Task, V::Error>
    where
        V: MapAccess<'de>,
    {
        let mut id = None;

        let mut status = None;
        let mut uuid = None;
        let mut entry = None;
        let mut description = None;

        let mut annotations = None;
        let mut depends = None;
        let mut due = None;
        let mut end = None;
        let mut imask = None;
        let mut mask = None;
        let mut modified = None;
        let mut parent = None;
        let mut priority = None;
        let mut project = None;
        let mut recur = None;
        let mut scheduled = None;
        let mut start = None;
        let mut tags = None;
        let mut until = None;
        let mut wait = None;
        let mut urgency = None;
        let mut uda = UDA::default();

        loop {
            let key: Option<String> = visitor.next_key()?;
            if key.is_none() {
                break;
            }
            let key = key.unwrap();

            match &key[..] {
                "id" => {
                    id = Some(visitor.next_value()?);
                }

                "status" => {
                    status = Some(visitor.next_value()?);
                }
                "uuid" => {
                    uuid = Some(visitor.next_value()?);
                }
                "entry" => {
                    entry = Some(visitor.next_value()?);
                }
                "description" => {
                    description = Some(visitor.next_value()?);
                }

                "annotations" => {
                    annotations = Some(visitor.next_value()?);
                }
                "depends" => {
                    let raw: String = visitor.next_value()?;
                    let mut uuids = vec![];
                    for uuid in raw.split(',') {
                        uuids.push(Uuid::parse_str(uuid).map_err(V::Error::custom)?);
                    }
                    depends = Some(uuids);
                }
                "due" => {
                    due = Some(visitor.next_value()?);
                }
                "end" => {
                    end = Some(visitor.next_value()?);
                }
                "imask" => {
                    imask = Some(visitor.next_value()?);
                }
                "mask" => {
                    mask = Some(visitor.next_value()?);
                }
                "modified" => {
                    modified = Some(visitor.next_value()?);
                }
                "parent" => {
                    parent = Some(visitor.next_value()?);
                }
                "priority" => {
                    priority = Some(visitor.next_value()?);
                }
                "project" => {
                    project = Some(visitor.next_value()?);
                }
                "recur" => {
                    recur = Some(visitor.next_value()?);
                }
                "scheduled" => {
                    scheduled = Some(visitor.next_value()?);
                }
                "start" => {
                    start = Some(visitor.next_value()?);
                }
                "tags" => {
                    tags = Some(visitor.next_value()?);
                }
                "until" => {
                    until = Some(visitor.next_value()?);
                }
                "wait" => {
                    wait = Some(visitor.next_value()?);
                }
                "urgency" => {
                    urgency = Some(visitor.next_value()?);
                }

                field => {
                    log::debug!("Inserting '{}' as UDA", field);
                    let uda_value: UDAValue = visitor.next_value()?;
                    uda.insert(UDAName::from(field), uda_value);
                }
            }
        }

        let status = status.ok_or_else(|| V::Error::missing_field("status"))?;
        let uuid = uuid.ok_or_else(|| V::Error::missing_field("uuid"))?;
        let entry = entry.ok_or_else(|| V::Error::missing_field("entry"))?;
        let description = description.ok_or_else(|| V::Error::missing_field("description"))?;

        let task = Task::new(
            id,
            status,
            uuid,
            entry,
            description,
            annotations,
            depends,
            due,
            end,
            imask,
            mask,
            modified,
            parent,
            priority,
            project,
            recur,
            scheduled,
            start,
            tags,
            until,
            wait,
            urgency,
            uda,
        );

        Ok(task)
    }

pub fn id(&self) -> Option<u64>

Get the id of the task

pub fn status(&self) -> &TaskStatus

Get the status of the task

pub fn status_mut(&mut self) -> &mut TaskStatus

Get the status of the task mutable

pub fn uuid(&self) -> &Uuid

Get the uuid of the task

pub fn uuid_mut(&mut self) -> &mut Uuid

Get the uuid of the task mutable

pub fn entry(&self) -> &Date

Get the entry date of the task

pub fn entry_mut(&mut self) -> &mut Date

Get the entry date of the task mutable

pub fn description(&self) -> &String

Get the description of the task

pub fn description_mut(&mut self) -> &mut String

Get the description of the task mutable

pub fn annotations(&self) -> Option<&Vec<Annotation>>

Get the annotations of the task

pub fn annotations_mut(&mut self) -> Option<&mut Vec<Annotation>>

Get the annotations of the task mutable

pub fn set_annotations<T, A>(&mut self, new: Option<T>)where
    T: IntoIterator,
    T::Item: Into<Annotation>,

Set annotations

pub fn depends(&self) -> Option<&Vec<Uuid>>

Get the dependencies of the task

pub fn depends_mut(&mut self) -> Option<&mut Vec<Uuid>>

Get the dependencies of the task mutable

pub fn set_depends<T, U>(&mut self, new: Option<T>)where
    T: IntoIterator,
    T::Item: Into<Uuid>,

Set depends

pub fn due(&self) -> Option<&Date>

Get the due date of the task

pub fn due_mut(&mut self) -> Option<&mut Date>

Get the due date of the task mutable

pub fn set_due<T>(&mut self, new: Option<T>)where
    T: Into<Date>,

Set due

pub fn end(&self) -> Option<&Date>

Get the end date of the task

pub fn end_mut(&mut self) -> Option<&mut Date>

Get the end date of the task mutable

pub fn set_end<T>(&mut self, new: Option<T>)where
    T: Into<Date>,

Set end

pub fn imask(&self) -> Option<&f64>

Get the imask of the task

pub fn imask_mut(&mut self) -> Option<&mut f64>

Get the imask of the task mutable

pub fn set_imask<T>(&mut self, new: Option<T>)where
    T: Into<f64>,

Set imask

pub fn mask(&self) -> Option<&String>

Get the mask of the task

pub fn mask_mut(&mut self) -> Option<&mut String>

Get the mask of the task mutable

pub fn set_mask<T>(&mut self, new: Option<T>)where
    T: Into<String>,

Set mask

pub fn modified(&self) -> Option<&Date>

Get the modified date of the task

pub fn modified_mut(&mut self) -> Option<&mut Date>

Get the modified date of the task mutable

pub fn set_modified<T>(&mut self, new: Option<T>)where
    T: Into<Date>,

Set modified

pub fn parent(&self) -> Option<&Uuid>

Get the parent of the task

pub fn parent_mut(&mut self) -> Option<&mut Uuid>

Get the parent of the task mutable

pub fn set_parent<T>(&mut self, new: Option<T>)where
    T: Into<Uuid>,

Set parent

pub fn priority(&self) -> Option<&TaskPriority>

Get the priority of the task

pub fn priority_mut(&mut self) -> Option<&mut TaskPriority>

Get the priority of the task mutable

pub fn set_priority<T>(&mut self, new: Option<T>)where
    T: Into<TaskPriority>,

Set priority

pub fn project(&self) -> Option<&Project>

Get the project of the task

pub fn project_mut(&mut self) -> Option<&mut Project>

Get the project of the task mutable

pub fn set_project<T>(&mut self, new: Option<T>)where
    T: Into<Project>,

Set project

pub fn recur(&self) -> Option<&String>

Get the recur of the task

This is exported as String by now. This might change in future versions of this crate.

pub fn recur_mut(&mut self) -> Option<&mut String>

This is exported as String by now. This might change in future versions of this crate. mutable

pub fn set_recur<T>(&mut self, new: Option<T>)where
    T: Into<String>,

Set recur

pub fn scheduled(&self) -> Option<&Date>

Get the scheduled date of the task

pub fn scheduled_mut(&mut self) -> Option<&mut Date>

Get the scheduled date of the task mutable

pub fn set_scheduled<T>(&mut self, new: Option<T>)where
    T: Into<Date>,

Set scheduled

pub fn start(&self) -> Option<&Date>

Get the start date of the task

pub fn start_mut(&mut self) -> Option<&mut Date>

Get the start date of the task mutable

pub fn set_start<T>(&mut self, new: Option<T>)where
    T: Into<Date>,

Set start

pub fn tags(&self) -> Option<&Vec<Tag>>

Get the tags of the task

pub fn tags_mut(&mut self) -> Option<&mut Vec<Tag>>

Get the tags of the task mutable

pub fn set_tags<T>(&mut self, new: Option<T>)where
    T: IntoIterator,
    T::Item: Into<Tag>,

Set tags

pub fn until(&self) -> Option<&Date>

Get the until date of the task

pub fn until_mut(&mut self) -> Option<&mut Date>

Get the until date of the task mutable

pub fn set_until<T>(&mut self, new: Option<T>)where
    T: Into<Date>,

Set until

pub fn urgency(&self) -> Option<&Urgency>

Get the urgency of the task

pub fn urgency_mut(&mut self) -> Option<&mut Urgency>

Get the urgency of the task

pub fn set_urgency<T>(&mut self, new: Option<T>)where
    T: Into<Urgency>,

Set the urgency of the task

pub fn wait(&self) -> Option<&Date>

Get the wait date of the task

pub fn wait_mut(&mut self) -> Option<&mut Date>

Get the wait date of the task mutable

pub fn set_wait<T>(&mut self, new: Option<T>)where
    T: Into<Date>,

Set wait

pub fn uda(&self) -> &UDA

Get the BTreeMap that contains the UDA

Examples found in repository

src/task.rs (line 612)

    fn serialize<S>(&self, serializer: S) -> RResult<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut state = serializer.serialize_map(None)?;
        state.serialize_entry("status", &self.status)?;
        state.serialize_entry("uuid", &self.uuid)?;
        state.serialize_entry("entry", &self.entry)?;
        state.serialize_entry("description", &self.description)?;

        self.annotations
            .as_ref()
            .map(|v| state.serialize_entry("annotations", v));
        self.tags.as_ref().map(|v| state.serialize_entry("tags", v));
        self.id.as_ref().map(|v| state.serialize_entry("id", v));
        self.recur
            .as_ref()
            .map(|ref v| state.serialize_entry("recur", v));
        self.depends.as_ref().map(|v| {
            let v: Vec<String> = v.iter().map(Uuid::to_string).collect();
            state.serialize_entry("depends", &v.join(","))
        });
        self.due
            .as_ref()
            .map(|ref v| state.serialize_entry("due", v));
        self.end
            .as_ref()
            .map(|ref v| state.serialize_entry("end", v));
        self.imask
            .as_ref()
            .map(|ref v| state.serialize_entry("imask", v));
        self.mask
            .as_ref()
            .map(|ref v| state.serialize_entry("mask", v));
        self.modified
            .as_ref()
            .map(|ref v| state.serialize_entry("modified", v));
        self.parent
            .as_ref()
            .map(|ref v| state.serialize_entry("parent", v));
        self.priority
            .as_ref()
            .map(|ref v| state.serialize_entry("priority", v));
        self.project
            .as_ref()
            .map(|ref v| state.serialize_entry("project", v));
        self.scheduled
            .as_ref()
            .map(|ref v| state.serialize_entry("scheduled", v));
        self.start
            .as_ref()
            .map(|ref v| state.serialize_entry("start", v));
        self.until
            .as_ref()
            .map(|ref v| state.serialize_entry("until", v));
        self.wait
            .as_ref()
            .map(|ref v| state.serialize_entry("wait", v));
        self.urgency
            .as_ref()
            .map(|ref v| state.serialize_entry("urgency", v));

        for (key, value) in self.uda().iter() {
            state.serialize_entry(key, value)?;
        }

        state.end()
    }

pub fn uda_mut(&mut self) -> &mut UDA

Get the BTreeMap that contains the UDA mutable

Trait Implementations

impl Clone for Task

fn clone(&self) -> Task

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Task

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Task

fn deserialize<D>(deserializer: D) -> RResult<Task, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq<Task> for Task

fn eq(&self, other: &Task) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Task

fn serialize<S>(&self, serializer: S) -> RResult<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Task