cog-task 1.2.0

A general-purpose low-latency application to run cognitive tasks
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use crate::assets::VERSION;
use crate::server::{Block, Server, Task};
use crate::util::Hash;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;

#[derive(Debug, Default, Deserialize, Serialize)]
pub struct Info {
    subject: String,
    output: PathBuf,
    server: ServerInfo,
    task: TaskInfo,
    block: BlockInfo,
}

#[derive(Debug, Default, Deserialize, Serialize)]
pub struct TaskInfo {
    name: String,
    version: String,
    hash: String,
}

#[derive(Debug, Default, Deserialize, Serialize)]
pub struct BlockInfo {
    name: String,
    hash: String,
}

#[derive(Debug, Default, Deserialize, Serialize)]
pub struct ServerInfo {
    version: String,
    hash: String,
}

impl Info {
    pub fn new(server: &Server, task: &Task, block: &Block) -> Self {
        Self {
            subject: server.subject().to_owned(),
            output: server.env().output().join(server.subject()),
            server: ServerInfo {
                version: VERSION.to_owned(),
                hash: server.hash(),
            },
            task: TaskInfo {
                name: task.name().to_owned(),
                version: task.version().to_owned(),
                hash: task.hash(),
            },
            block: BlockInfo {
                name: block.label().to_owned(),
                hash: block.hash(),
            },
        }
    }

    #[inline(always)]
    pub fn subject(&self) -> &String {
        &self.subject
    }

    #[inline(always)]
    pub fn block(&self) -> &String {
        &self.block.name
    }

    #[inline(always)]
    pub fn output(&self) -> &PathBuf {
        &self.output
    }
}