xio_base_datatypes 0.8.0

XIO base data structures
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

#[cfg(feature = "serde")]
#[macro_use]
extern crate serde;

#[macro_use]
extern crate snafu;

#[cfg(feature = "bidir-map")]
extern crate bidir_map;

extern crate indexmap;
extern crate try_from;

mod channel_permission;
mod convert;
mod data_type;
mod data_value;
mod error_code;
mod job_stopped_reason;
mod module_channel_reference;
mod module_state;
mod override_option;
mod parameter_value;
mod storage_type;
mod storage_type_with_mixed;

pub use channel_permission::ChannelPermission;
pub use convert::TryConvertTo;
pub use data_type::{DataType, HasDataType};
pub use data_value::{
    ConstructParameterMask, DataValue, DataValueDescriptive, DataValueRaw,
    DeconstructParameterMask, IsParameterMask,
};
pub use error_code::{ErrorCode, HasErrorCode};
pub use job_stopped_reason::JobStoppedReason;
pub use module_channel_reference::{
    IsModuleChannelReference, ModuleChannelReference,
};
pub use module_state::ModuleState;
pub use override_option::OverrideOption;
pub use parameter_value::{ParameterValue, ParameterValueRaw};
pub use storage_type::{HasStorageType, IsInStorageType, StorageType};
pub use storage_type_with_mixed::StorageTypeWithMixed;

use indexmap::IndexSet;
use snafu::{Backtrace, Snafu};

pub type Result<T, E = Error> = std::result::Result<T, E>;

#[derive(Debug, Snafu)]
pub enum Error {
    #[snafu(display(
        "Value {:?} is not in range for type {:?}",
        value,
        datatype
    ))]
    ValueOutOfRangeForType {
        value: DataValueRaw,
        datatype: DataType,
        backtrace: Backtrace,
    },
    #[snafu(display(
        "Expected datatype compatible with {:?} found {:?}",
        expected,
        found
    ))]
    IncompatibleDataType {
        expected: DataType,
        found: DataType,
        backtrace: Backtrace,
    },
    #[snafu(display(
        "Parameter {:?} with index {} of mask range 64",
        parameter,
        index
    ))]
    ParameterOutOfMaskRange {
        parameter: String,
        index: usize,
        backtrace: Backtrace,
    },
    #[snafu(display(
        "Mask {:#b} has bit {} for non-existing parameters set",
        mask,
        index
    ))]
    ParameterMaskOutOfRange {
        mask: u64,
        index: usize,
        backtrace: Backtrace,
    },
    #[snafu(display(
        "Parameters {:?} are not in parameter set",
        parameters
    ))]
    ParametersNotInParameterSet {
        parameters: IndexSet<String>,
        backtrace: Backtrace,
    },
}