dnp3 1.6.0

Rust implementation of DNP3 (IEEE 1815) with idiomatic bindings for C, C++, .NET, and Java
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

use crate::app::format::write::HeaderWriter;
use crate::app::parse::parser::Response;
use crate::app::FunctionCode;
use crate::master::promise::Promise;
use crate::master::tasks::{AppTask, NonReadTask, Task};
use crate::master::{Headers, TaskError, WriteError};

pub(crate) struct EmptyResponseTask {
    function: FunctionCode,
    headers: Headers,
    promise: Promise<Result<(), WriteError>>,
}

impl From<EmptyResponseTask> for Task {
    fn from(value: EmptyResponseTask) -> Self {
        Task::App(AppTask::NonRead(NonReadTask::EmptyResponseTask(value)))
    }
}

impl EmptyResponseTask {
    pub(crate) fn new(
        function: FunctionCode,
        headers: Headers,
        promise: Promise<Result<(), WriteError>>,
    ) -> Self {
        Self {
            function,
            headers,
            promise,
        }
    }

    pub(crate) const fn function(&self) -> FunctionCode {
        self.function
    }

    pub(crate) fn write(&self, writer: &mut HeaderWriter) -> Result<(), TaskError> {
        self.headers.write(writer)
    }

    pub(crate) fn on_task_error(self, err: TaskError) {
        self.promise.complete(Err(err.into()))
    }

    pub(crate) fn handle(self, response: Response) -> Result<Option<NonReadTask>, TaskError> {
        if !response.raw_objects.is_empty() {
            self.promise
                .complete(Err(WriteError::Task(TaskError::UnexpectedResponseHeaders)));
            return Err(TaskError::UnexpectedResponseHeaders);
        }

        self.promise.complete(Ok(()));

        Ok(None)
    }
}