arcgis 0.1.1

Type-safe Rust SDK for the ArcGIS REST API with compile-time guarantees
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

//! Geoprocessing result types and enums.

use derive_getters::Getters;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;

/// Result from a geoprocessing execution.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters)]
#[serde(rename_all = "camelCase")]
pub struct GPExecuteResult {
    /// Output parameters from the GP task.
    results: Vec<GPResultParameter>,

    /// Messages generated during execution.
    messages: Vec<GPMessage>,
}

/// A geoprocessing result parameter.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters)]
#[serde(rename_all = "camelCase")]
pub struct GPResultParameter {
    /// Parameter name.
    #[serde(default)]
    param_name: Option<String>,

    /// Data type of the parameter.
    #[serde(default)]
    data_type: Option<String>,

    /// Parameter value (type varies by dataType).
    #[serde(default)]
    value: Option<serde_json::Value>,
}

/// A message from geoprocessing execution.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, Getters)]
#[serde(rename_all = "camelCase")]
pub struct GPMessage {
    /// Message type (informative, warning, error, etc.).
    #[serde(rename = "type")]
    message_type: GPMessageType,

    /// Message description.
    description: String,
}

/// Type of geoprocessing message.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum GPMessageType {
    /// Informative message.
    #[serde(rename = "esriJobMessageTypeInformative")]
    Informative,

    /// Warning message.
    #[serde(rename = "esriJobMessageTypeWarning")]
    Warning,

    /// Error message.
    #[serde(rename = "esriJobMessageTypeError")]
    Error,

    /// Empty message.
    #[serde(rename = "esriJobMessageTypeEmpty")]
    Empty,

    /// Abort message.
    #[serde(rename = "esriJobMessageTypeAbort")]
    Abort,
}

/// Status of an asynchronous geoprocessing job.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum GPJobStatus {
    /// Job has been submitted but not yet started.
    #[serde(rename = "esriJobSubmitted")]
    Submitted,

    /// Job is waiting in the queue.
    #[serde(rename = "esriJobWaiting")]
    Waiting,

    /// Job is currently executing.
    #[serde(rename = "esriJobExecuting")]
    Executing,

    /// Job completed successfully.
    #[serde(rename = "esriJobSucceeded")]
    Succeeded,

    /// Job failed.
    #[serde(rename = "esriJobFailed")]
    Failed,

    /// Job timed out.
    #[serde(rename = "esriJobTimedOut")]
    TimedOut,

    /// Job was cancelled.
    #[serde(rename = "esriJobCancelling")]
    Cancelling,

    /// Job has been cancelled.
    #[serde(rename = "esriJobCancelled")]
    Cancelled,

    /// Job is being deleted.
    #[serde(rename = "esriJobDeleting")]
    Deleting,

    /// Job has been deleted.
    #[serde(rename = "esriJobDeleted")]
    Deleted,
}

impl GPJobStatus {
    /// Returns true if the job is in a terminal state (succeeded, failed, cancelled, etc.).
    pub fn is_terminal(&self) -> bool {
        matches!(
            self,
            GPJobStatus::Succeeded
                | GPJobStatus::Failed
                | GPJobStatus::TimedOut
                | GPJobStatus::Cancelled
                | GPJobStatus::Deleted
        )
    }

    /// Returns true if the job is still running.
    pub fn is_running(&self) -> bool {
        matches!(
            self,
            GPJobStatus::Submitted | GPJobStatus::Waiting | GPJobStatus::Executing
        )
    }
}

/// Information about an asynchronous geoprocessing job.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Getters)]
#[serde(rename_all = "camelCase")]
pub struct GPJobInfo {
    /// Job identifier.
    job_id: String,

    /// Current job status.
    job_status: GPJobStatus,

    /// Messages generated during job execution.
    #[serde(default)]
    messages: Vec<GPMessage>,

    /// Results (only present when job succeeds).
    #[serde(default)]
    results: HashMap<String, GPResultParameter>,
}