codes-iso-10383 0.1.5

This package contains an implementation of the ISO-10383 Market Identification Code (MIC) specification.
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

use codes_common::{invalid_length, unknown_value};
use std::fmt;
use std::str::FromStr;

#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

///
/// The Market Category specifies the type of market. The list of market types
/// is predefined.
///
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
pub enum Category {
    /// Alternative Trading System
    ATSS,
    /// Approved Publication Arrangement
    APPA,
    /// Approved Reporting Mechanism
    ARMS,
    /// Consolidated Tape Provider
    CTPS,
    /// Crypto Asset Services Provider
    CASP,
    /// Designated Contract Market
    DCMS,
    /// Inter-Dealer Quotation System
    IDQS,
    /// Multilateral Trading Facility
    MLTF,
    /// Not Specified
    NSPD,
    /// Organised Trading Facility
    OTFS,
    /// Other
    OTHR,
    /// Recognised Market Operator
    RMOS,
    /// Regulated Market
    RMKT,
    /// Swap Execution Facility
    SEFS,
    /// Systematic Internaliser
    SINT,
    /// Trade Reporting Facility
    TRFS,
}

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

impl fmt::Display for Category {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.as_ref())
    }
}

impl FromStr for Category {
    type Err = super::MarketIdCodeError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        if s.len() != 4 {
            Err(invalid_length("Category", s.len()))
        } else {
            match s {
                "ATSS" => Ok(Self::ATSS),
                "APPA" => Ok(Self::APPA),
                "ARMS" => Ok(Self::ARMS),
                "CTPS" => Ok(Self::CTPS),
                "CASP" => Ok(Self::CASP),
                "DCMS" => Ok(Self::DCMS),
                "IDQS" => Ok(Self::IDQS),
                "MLTF" => Ok(Self::MLTF),
                "NSPD" => Ok(Self::NSPD),
                "OTFS" => Ok(Self::OTFS),
                "OTHR" => Ok(Self::OTHR),
                "RMOS" => Ok(Self::RMOS),
                "RMKT" => Ok(Self::RMKT),
                "SEFS" => Ok(Self::SEFS),
                "SINT" => Ok(Self::SINT),
                "TRFS" => Ok(Self::TRFS),
                _ => Err(unknown_value("Category", s)),
            }
        }
    }
}

impl AsRef<str> for Category {
    fn as_ref(&self) -> &str {
        match self {
            Self::ATSS => "ATSS",
            Self::APPA => "APPA",
            Self::ARMS => "ARMS",
            Self::CTPS => "CTPS",
            Self::CASP => "CASP",
            Self::DCMS => "DCMS",
            Self::IDQS => "IDQS",
            Self::MLTF => "MLTF",
            Self::NSPD => "NSPD",
            Self::OTFS => "OTFS",
            Self::OTHR => "OTHR",
            Self::RMOS => "RMOS",
            Self::RMKT => "RMKT",
            Self::SEFS => "SEFS",
            Self::SINT => "SINT",
            Self::TRFS => "TRFS",
        }
    }
}

impl From<Category> for String {
    fn from(v: Category) -> Self {
        v.as_ref().to_string()
    }
}

impl Category {
    #[cfg(feature = "category_description")]
    pub fn description(&self) -> &'static str {
        match self {
            Self::ATSS => "Alternative Trading System",
            Self::APPA => "Approved Publication Arrangement",
            Self::ARMS => "Approved Reporting Mechanism",
            Self::CTPS => "Consolidated Tape Provider",
            Self::CASP => "Crypto Asset Services Provider",
            Self::DCMS => "Designated Contract Market",
            Self::IDQS => "Inter-Dealer Quotation System",
            Self::MLTF => "Multilateral Trading Facility",
            Self::NSPD => "Not Specified",
            Self::OTFS => "Organised Trading Facility",
            Self::OTHR => "Other",
            Self::RMOS => "Recognised Market Operator",
            Self::RMKT => "Regulated Market",
            Self::SEFS => "Swap Execution Facility",
            Self::SINT => "Systematic Internaliser",
            Self::TRFS => "Trade Reporting Facility",
        }
    }
}