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
170
171
172
173
174
175
176
177
178
179
180

mod decimal;
mod double;
mod float;

pub use decimal::*;
pub use double::*;
pub use float::*;

use crate::Datatype;

pub trait XsdDatatype {
	/// Returns the XSD datatype that best describes the value.
	fn type_(&self) -> Datatype;
}

pub type String = std::string::String;

impl XsdDatatype for String {
	fn type_(&self) -> Datatype {
		Datatype::String(None)
	}
}

pub type Boolean = bool;

impl XsdDatatype for Boolean {
	fn type_(&self) -> Datatype {
		Datatype::Boolean
	}
}

#[derive(Debug, Clone)]
pub struct Duration;

impl XsdDatatype for Duration {
	fn type_(&self) -> Datatype {
		Datatype::Duration(None)
	}
}

#[derive(Debug, Clone)]
pub struct DateTime;

impl XsdDatatype for DateTime {
	fn type_(&self) -> Datatype {
		Datatype::DateTime(None)
	}
}

#[derive(Debug, Clone)]
pub struct Time;

impl XsdDatatype for Time {
	fn type_(&self) -> Datatype {
		Datatype::Time
	}
}

#[derive(Debug, Clone)]
pub struct Date;

impl XsdDatatype for Date {
	fn type_(&self) -> Datatype {
		Datatype::Date
	}
}

#[derive(Debug, Clone)]
pub struct GYearMonth;

impl XsdDatatype for GYearMonth {
	fn type_(&self) -> Datatype {
		Datatype::GYearMonth
	}
}

#[derive(Debug, Clone)]
pub struct GYear;

impl XsdDatatype for GYear {
	fn type_(&self) -> Datatype {
		Datatype::GYear
	}
}

#[derive(Debug, Clone)]
pub struct GMonthDay;

impl XsdDatatype for GMonthDay {
	fn type_(&self) -> Datatype {
		Datatype::GMonthDay
	}
}

#[derive(Debug, Clone)]
pub struct GDay;

impl XsdDatatype for GDay {
	fn type_(&self) -> Datatype {
		Datatype::GDay
	}
}

#[derive(Debug, Clone)]
pub struct GMonth;

impl XsdDatatype for GMonth {
	fn type_(&self) -> Datatype {
		Datatype::GMonth
	}
}

#[derive(Debug, Clone)]
pub struct HexBinary;

impl XsdDatatype for HexBinary {
	fn type_(&self) -> Datatype {
		Datatype::HexBinary
	}
}

#[derive(Debug, Clone)]
pub struct Base64Binary;

impl XsdDatatype for Base64Binary {
	fn type_(&self) -> Datatype {
		Datatype::Base64Binary
	}
}

#[derive(Debug, Clone)]
pub struct AnyUri;

impl XsdDatatype for AnyUri {
	fn type_(&self) -> Datatype {
		Datatype::AnyUri
	}
}

#[derive(Debug, Clone)]
pub struct QName;

impl XsdDatatype for QName {
	fn type_(&self) -> Datatype {
		Datatype::QName
	}
}

#[derive(Debug, Clone)]
pub struct Notation;

impl XsdDatatype for Notation {
	fn type_(&self) -> Datatype {
		Datatype::Notation
	}
}

/// XSD datatype value.
#[derive(Debug, Clone)]
pub enum Value {
	String(String),
	Boolean(Boolean),
	Decimal(Decimal),
	Float(Float),
	Double(Double),
	Duration(Duration),
	DateTime(DateTime),
	Time(Time),
	Date(Date),
	GYearMonth(GYearMonth),
	GYear(GYear),
	GMonthDay(GMonthDay),
	GDay(GDay),
	GMonth(GMonth),
	HexBinary(HexBinary),
	Base64Binary(Base64Binary),
	AnyUri(AnyUri),
	QName(QName),
	Notation(Notation),
}