mesc 0.3.0

libraries for creating, loading, and modifying MESC configuation data
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
156
157
158
159
160
161
162
163
164
165
166
167
168
169

use crate::{ChainId, MescError, TryIntoChainId};

/// Multi Endpoint Query
#[derive(Debug, Default, Clone)]
pub struct MultiEndpointQuery {
    /// chain_id
    pub chain_id: Option<ChainId>,
    /// name_contains
    pub name_contains: Option<String>,
    /// url_contains
    pub url_contains: Option<String>,
}

/// builder for MultiEndpointQuery
impl MultiEndpointQuery {
    /// new MultiEndpointQuery
    pub fn new() -> Self {
        Self::default()
    }

    /// set chain_id
    pub fn chain_id<T: TryIntoChainId>(mut self, chain_id: T) -> Result<Self, MescError> {
        self.chain_id = Some(chain_id.try_into_chain_id()?);
        Ok(self)
    }

    /// set name
    pub fn name<T: AsRef<str>>(mut self, query: T) -> Result<Self, MescError> {
        self.name_contains = Some(query.as_ref().to_string());
        Ok(self)
    }

    /// set url
    pub fn url<T: AsRef<str>>(mut self, query: T) -> Result<Self, MescError> {
        self.url_contains = Some(query.as_ref().to_string());
        Ok(self)
    }
}

//
// // individual queries
//

/// EndpointQuery
#[derive(Debug, Clone)]
pub struct EndpointQuery {
    /// query_type
    pub query_type: EndpointQueryType,
    /// fields
    pub fields: EndpointQueryFields,
}

/// EndpointQueryType
#[derive(Debug, Clone)]
pub enum EndpointQueryType {
    /// DefeaultEndpoint
    DefaultEndpoint,
    /// EndpointByName
    EndpointByName,
    /// EndpointByNetwork
    EndpointByNetwork,
    /// UserInput
    UserInput,
}

/// EndpointQueryFields
#[derive(Debug, Clone)]
pub enum EndpointQueryFields {
    /// DefaultEndpoint
    DefaultEndpoint(DefaultEndpointQuery),
    /// EndpointName
    EndpointName(EndpointNameQuery),
    /// EndpointNetwork
    EndpointNetwork(EndpointNetworkQuery),
    /// UserInput
    UserInput(UserInputQuery),
}

/// DefaultEndpointQuery
#[derive(Debug, Clone)]
pub struct DefaultEndpointQuery {
    /// profile
    pub profile: Option<String>,
}

/// EndpointNameQuery
#[derive(Debug, Clone)]
pub struct EndpointNameQuery {
    /// name
    pub name: String,
}

/// EndpointNetworkQuery
#[derive(Debug, Clone)]
pub struct EndpointNetworkQuery {
    /// profile
    pub profile: Option<String>,
    /// chain_id
    pub chain_id: String,
}

/// UserInputQuery
#[derive(Debug, Clone)]
pub struct UserInputQuery {
    /// profile
    pub profile: Option<String>,
    /// user_input
    pub user_input: String,
}

//
// // global metadata
//

/// GlobalMetadataQuery
#[derive(Debug, Clone)]
pub struct GlobalMetadataQuery {
    /// profile
    pub profile: Option<String>,
    /// path
    pub path: Option<Vec<String>>,
}

//
// // general MESC queries
//

/// MescQuery
#[derive(Debug, Clone)]
pub struct MescQuery {
    /// query_type
    pub query_type: MescQueryType,
    /// field
    pub fields: MescQueryFields,
}

/// MescQueryType
#[derive(Debug, Clone)]
pub enum MescQueryType {
    /// DefaultEndpoint
    DefaultEndpoint,
    /// EndpointByName
    EndpointByName,
    /// EndpointByNetwork
    EndpointByNetwork,
    /// UserInput
    UserInput,
    /// MultiEndpoint
    MultiEndpoint,
    /// GlobalMetadata
    GlobalMetadata,
}

/// MescQueryFields
#[derive(Debug, Clone)]
pub enum MescQueryFields {
    /// DefaultEndpoint
    DefaultEndpoint(DefaultEndpointQuery),
    /// EndpointName
    EndpointName(EndpointNameQuery),
    /// EndpointNetwork
    EndpointNetwork(EndpointNetworkQuery),
    /// UserInput
    UserInput(UserInputQuery),
    /// MultiEndpoint
    MultiEndpoint(MultiEndpointQuery),
    /// GlobalMetadata
    GlobalMetadata(GlobalMetadataQuery),
}