Enum FixDatatype

#[non_exhaustive]
#[repr(u8)]
pub enum FixDatatype {
    Char = 0,
    Boolean = 1,
    Float = 2,
    Amt = 3,
    Price = 4,
    PriceOffset = 5,
    Qty = 6,
    Percentage = 7,
    Int = 8,
    DayOfMonth = 9,
    Length = 10,
    NumInGroup = 11,
    SeqNum = 12,
    TagNum = 13,
    String = 14,
    Data = 15,
    MonthYear = 16,
    MultipleCharValue = 17,
    Currency = 18,
    Exchange = 19,
    Language = 20,
    LocalMktDate = 21,
    MultipleStringValue = 22,
    UtcDateOnly = 23,
    UtcTimeOnly = 24,
    UtcTimestamp = 25,
    XmlData = 26,
    Country = 27,
}

Sum type for all possible FIX data types ever defined across all FIX application versions.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Char = 0

Single character value, can include any alphanumeric character or punctuation except the delimiter. All char fields are case sensitive (i.e. m != M). The following fields are based on char.

Boolean = 1

char field containing one of two values: ‘Y’ = True/Yes ‘N’ = False/No.

Float = 2

Sequence of digits with optional decimal point and sign character (ASCII characters “-”, “0” - “9” and “.”); the absence of the decimal point within the string will be interpreted as the float representation of an integer value. All float fields must accommodate up to fifteen significant digits. The number of decimal places used should be a factor of business/market needs and mutual agreement between counterparties. Note that float values may contain leading zeros (e.g. “00023.23” = “23.23”) and may contain or omit trailing zeros after the decimal point (e.g. “23.0” = “23.0000” = “23” = “23.”). Note that fields which are derived from float may contain negative values unless explicitly specified otherwise. The following data types are based on float.

Amt = 3

float field typically representing a Price times a Qty.

Price = 4

float field representing a price. Note the number of decimal places may vary. For certain asset classes prices may be negative values. For example, prices for options strategies can be negative under certain market conditions. Refer to Volume 7: FIX Usage by Product for asset classes that support negative price values.

PriceOffset = 5

float field representing a price offset, which can be mathematically added to a “Price”. Note the number of decimal places may vary and some fields such as LastForwardPoints may be negative.

Qty = 6

float field capable of storing either a whole number (no decimal places) of “shares” (securities denominated in whole units) or a decimal value containing decimal places for non-share quantity asset classes (securities denominated in fractional units).

Percentage = 7

float field representing a percentage (e.g. 0.05 represents 5% and 0.9525 represents 95.25%). Note the number of decimal places may vary.

Int = 8

Sequence of digits without commas or decimals and optional sign character (ASCII characters “-” and “0” - “9” ). The sign character utilizes one byte (i.e. positive int is “99999” while negative int is “-99999”). Note that int values may contain leading zeros (e.g. “00023” = “23”). Examples: 723 in field 21 would be mapped int as |21=723|. -723 in field 12 would be mapped int as |12=-723| The following data types are based on int.

DayOfMonth = 9

int field representing a day during a particular monthy (values 1 to 31).

Length = 10

int field representing the length in bytes. Value must be positive.

NumInGroup = 11

int field representing the number of entries in a repeating group. Value must be positive.

SeqNum = 12

int field representing a message sequence number. Value must be positive.

TagNum = 13

int field representing a field’s tag number when using FIX “Tag=Value” syntax. Value must be positive and may not contain leading zeros.

String = 14

Alpha-numeric free format strings, can include any character or punctuation except the delimiter. All String fields are case sensitive (i.e. morstatt != Morstatt).

Data = 15

string field containing raw data with no format or content restrictions. Data fields are always immediately preceded by a length field. The length field should specify the number of bytes of the value of the data field (up to but not including the terminating SOH). Caution: the value of one of these fields may contain the delimiter (SOH) character. Note that the value specified for this field should be followed by the delimiter (SOH) character as all fields are terminated with an “SOH”.

MonthYear = 16

string field representing month of a year. An optional day of the month can be appended or an optional week code. Valid formats: YYYYMM YYYYMMDD YYYYMMWW Valid values: YYYY = 0000-9999; MM = 01-12; DD = 01-31; WW = w1, w2, w3, w4, w5.

MultipleCharValue = 17

string field containing one or more space delimited single character values (e.g. |18=2 A F| ).

Currency = 18

string field representing a currency type using ISO 4217 Currency code (3 character) values (see Appendix 6-A).

Exchange = 19

string field representing a market or exchange using ISO 10383 Market Identifier Code (MIC) values (see“Appendix 6-C).

Language = 20

Identifier for a national language - uses ISO 639-1 standard.

LocalMktDate = 21

string field represening a Date of Local Market (as oppose to UTC) in YYYYMMDD format. This is the “normal” date field used by the FIX Protocol. Valid values: YYYY = 0000-9999, MM = 01-12, DD = 01-31.

MultipleStringValue = 22

string field containing one or more space delimited multiple character values (e.g. |277=AV AN A| ).

UtcDateOnly = 23

string field representing Date represented in UTC (Universal Time Coordinated, also known as “GMT”) in YYYYMMDD format. This special-purpose field is paired with UTCTimeOnly to form a proper UTCTimestamp for bandwidth-sensitive messages. Valid values: YYYY = 0000-9999, MM = 01-12, DD = 01-31.

UtcTimeOnly = 24

string field representing Time-only represented in UTC (Universal Time Coordinated, also known as “GMT”) in either HH:MM:SS (whole seconds) or HH:MM:SS.sss (milliseconds) format, colons, and period required. This special-purpose field is paired with UTCDateOnly to form a proper UTCTimestamp for bandwidth-sensitive messages. Valid values: HH = 00-23, MM = 00-60 (60 only if UTC leap second), SS = 00-59. (without milliseconds) HH = 00-23, MM = 00-59, SS = 00-60 (60 only if UTC leap second), sss=000-999 (indicating milliseconds).

UtcTimestamp = 25

string field representing Time/date combination represented in UTC (Universal Time Coordinated, also known as “GMT”) in either YYYYMMDD-HH:MM:SS (whole seconds) or YYYYMMDD-HH:MM:SS.sss (milliseconds) format, colons, dash, and period required. Valid values: * YYYY = 0000-9999, MM = 01-12, DD = 01-31, HH = 00-23, MM = 00-59, SS = 00-60 (60 only if UTC leap second) (without milliseconds). * YYYY = 0000-9999, MM = 01-12, DD = 01-31, HH = 00-23, MM = 00-59, SS = 00-60 (60 only if UTC leap second), sss=000-999 (indicating milliseconds). Leap Seconds: Note that UTC includes corrections for leap seconds, which are inserted to account for slowing of the rotation of the earth. Leap second insertion is declared by the International Earth Rotation Service (IERS) and has, since 1972, only occurred on the night of Dec. 31 or Jun 30. The IERS considers March 31 and September 30 as secondary dates for leap second insertion, but has never utilized these dates. During a leap second insertion, a UTCTimestamp field may read “19981231-23:59:59”, “19981231-23:59:60”, “19990101-00:00:00”. (see http://tycho.usno.navy.mil/leapsec.html)

XmlData = 26

Contains an XML document raw data with no format or content restrictions. XMLData fields are always immediately preceded by a length field. The length field should specify the number of bytes of the value of the data field (up to but not including the terminating SOH).

Country = 27

string field representing a country using ISO 3166 Country code (2 character) values (see Appendix 6-B).

Implementations

impl FixDatatype

pub fn from_quickfix_name(name: &str) -> Option<Self>

Compares name to the set of strings commonly used by QuickFIX’s custom specification format and returns its associated Datatype if a match was found. The query is case-insensitive.

Examples

use hotfix_dictionary::FixDatatype;

assert_eq!(FixDatatype::from_quickfix_name("AMT"), Some(FixDatatype::Amt));
assert_eq!(FixDatatype::from_quickfix_name("Amt"), Some(FixDatatype::Amt));
assert_eq!(FixDatatype::from_quickfix_name("MONTHYEAR"), Some(FixDatatype::MonthYear));
assert_eq!(FixDatatype::from_quickfix_name(""), None);

pub fn to_quickfix_name(&self) -> &str

Returns the name adopted by QuickFIX for self.

pub fn name(&self) -> &'static str

Returns the name of self, character by character identical to the name that appears in the official guidelines. Generally primitive datatypes will use snake_case and non-primitive ones will have PascalCase, but that’s not true for every Datatype.

Examples

use hotfix_dictionary::FixDatatype;

assert_eq!(FixDatatype::Qty.name(), "Qty");
assert_eq!(FixDatatype::Float.name(), "float");
assert_eq!(FixDatatype::String.name(), "String");

pub fn is_base_type(&self) -> bool

Returns true if and only if self is a “base type”, i.e. a primitive; returns false otherwise.

Examples

use hotfix_dictionary::FixDatatype;

assert_eq!(FixDatatype::Float.is_base_type(), true);
assert_eq!(FixDatatype::Price.is_base_type(), false);

pub fn base_type(&self) -> Self

Returns the primitive Datatype from which self is derived. If self is primitive already, returns self unchanged.

Examples

use hotfix_dictionary::FixDatatype;

assert_eq!(FixDatatype::Float.base_type(), FixDatatype::Float);
assert_eq!(FixDatatype::Price.base_type(), FixDatatype::Float);

pub fn iter_all() -> impl Iterator<Item = Self>

Returns an Iterator over all variants of Datatype.

Trait Implementations

impl Clone for FixDatatype

fn clone(&self) -> FixDatatype

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FixDatatype

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'_derivative_strum> From<&'_derivative_strum FixDatatype> for &'static str

fn from(x: &'_derivative_strum FixDatatype) -> &'static str

Converts to this type from the input type.

impl From<FixDatatype> for &'static str

fn from(x: FixDatatype) -> &'static str

Converts to this type from the input type.

impl Hash for FixDatatype

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoEnumIterator for FixDatatype

type Iterator = FixDatatypeIter

fn iter() -> FixDatatypeIter

impl PartialEq for FixDatatype

fn eq(&self, other: &FixDatatype) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for FixDatatype

impl Eq for FixDatatype

impl StructuralPartialEq for FixDatatype