#![allow(
clippy::all,
clippy::pedantic,
clippy::nursery,
unused_variables,
unused_mut,
unused_qualifications,
reason = "mechanically generated codec text: every item is named by its full path and every branch shape is emitted uniformly, so style and unused-binding lints do not apply — the hand-written runtime carries the lint bar"
)]
impl ::serde::Serialize for crate::v3_1::terminology::code::Code {
fn serialize<__S: ::serde::Serializer>(
&self,
__serializer: __S,
) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 2usize;
if self.description.is_some() {
__n += 1;
}
if self.status.is_some() {
__n += 1;
}
let mut __st = ::serde::Serializer::serialize_struct(__serializer, "CODE", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "CODE")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "value", &self.value)?;
if let Some(__v) = &self.description {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "description", __v)?;
}
if let Some(__v) = &self.status {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "status", __v)?;
}
::serde::ser::SerializeStruct::end(__st)
}
}
impl<'de> ::serde::Deserialize<'de> for crate::v3_1::terminology::code::Code {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["description", "status", "value"];
enum __Field {
__Type,
__F0,
__F1,
__F2,
}
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(
&self,
__f: &mut ::core::fmt::Formatter<'_>,
) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(
self,
__v: &str,
) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"value" => ::core::result::Result::Ok(__Field::__F0),
"description" => ::core::result::Result::Ok(__Field::__F1),
"status" => ::core::result::Result::Ok(__Field::__F2),
_ => ::core::result::Result::Err(
::openehr_base::serde_support::unknown_field(__v, "CODE", __FIELDS),
),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v3_1::terminology::code::Code;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `CODE` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(
self,
mut __map: __A,
) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
match __key {
__Field::__Type => {
if __seen_type {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("_type"),
);
}
__seen_type = true;
::serde::de::MapAccess::next_value_seed(
&mut __map,
::openehr_base::serde_support::ExpectedType("CODE"),
)?;
}
__Field::__F0 => {
if __s0.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("value"),
);
}
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("description"),
);
}
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("status"),
);
}
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v3_1::terminology::code::Code {
value: __s0
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("value"))?,
description: __s1.flatten(),
status: __s2.flatten(),
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "CODE", __FIELDS, __Visitor)
}
}
impl ::serde::Serialize for crate::v3_1::terminology::code_set::CodeSet {
fn serialize<__S: ::serde::Serializer>(
&self,
__serializer: __S,
) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 4usize;
if self.codes.as_ref().is_some_and(|__v| !__v.is_empty()) {
__n += 1;
}
if self.external_id.is_some() {
__n += 1;
}
if self.status.is_some() {
__n += 1;
}
let mut __st = ::serde::Serializer::serialize_struct(__serializer, "CODE_SET", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "CODE_SET")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "openehr_id", &self.openehr_id)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "issuer", &self.issuer)?;
if let Some(__v) = &self.codes
&& !__v.is_empty()
{
::serde::ser::SerializeStruct::serialize_field(&mut __st, "codes", __v)?;
}
if let Some(__v) = &self.external_id {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "external_id", __v)?;
}
if let Some(__v) = &self.status {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "status", __v)?;
}
::serde::ser::SerializeStruct::end(__st)
}
}
impl<'de> ::serde::Deserialize<'de> for crate::v3_1::terminology::code_set::CodeSet {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &[
"codes",
"external_id",
"issuer",
"name",
"openehr_id",
"status",
];
enum __Field {
__Type,
__F0,
__F1,
__F2,
__F3,
__F4,
__F5,
}
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(
&self,
__f: &mut ::core::fmt::Formatter<'_>,
) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(
self,
__v: &str,
) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"name" => ::core::result::Result::Ok(__Field::__F0),
"openehr_id" => ::core::result::Result::Ok(__Field::__F1),
"issuer" => ::core::result::Result::Ok(__Field::__F2),
"codes" => ::core::result::Result::Ok(__Field::__F3),
"external_id" => ::core::result::Result::Ok(__Field::__F4),
"status" => ::core::result::Result::Ok(__Field::__F5),
_ => ::core::result::Result::Err(
::openehr_base::serde_support::unknown_field(
__v, "CODE_SET", __FIELDS,
),
),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v3_1::terminology::code_set::CodeSet;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `CODE_SET` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(
self,
mut __map: __A,
) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s3: ::core::option::Option<_> = None;
let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
match __key {
__Field::__Type => {
if __seen_type {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("_type"),
);
}
__seen_type = true;
::serde::de::MapAccess::next_value_seed(
&mut __map,
::openehr_base::serde_support::ExpectedType("CODE_SET"),
)?;
}
__Field::__F0 => {
if __s0.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("name"),
);
}
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("openehr_id"),
);
}
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("issuer"),
);
}
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F3 => {
if __s3.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("codes"),
);
}
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F4 => {
if __s4.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("external_id"),
);
}
__s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F5 => {
if __s5.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("status"),
);
}
__s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v3_1::terminology::code_set::CodeSet {
name: __s0
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
openehr_id: __s1
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("openehr_id"))?,
issuer: __s2
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("issuer"))?,
codes: __s3,
external_id: __s4.flatten(),
status: __s5.flatten(),
})
}
}
::serde::Deserializer::deserialize_struct(__deserializer, "CODE_SET", __FIELDS, __Visitor)
}
}
impl ::serde::Serialize for crate::v3_1::terminology::terminology::Terminology {
fn serialize<__S: ::serde::Serializer>(
&self,
__serializer: __S,
) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 3usize;
if self.code_sets.as_ref().is_some_and(|__v| !__v.is_empty()) {
__n += 1;
}
if self
.vocabularies
.as_ref()
.is_some_and(|__v| !__v.is_empty())
{
__n += 1;
}
if self.version.is_some() {
__n += 1;
}
if self.date.is_some() {
__n += 1;
}
let mut __st = ::serde::Serializer::serialize_struct(__serializer, "TERMINOLOGY", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TERMINOLOGY")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "language", &self.language)?;
if let Some(__v) = &self.code_sets
&& !__v.is_empty()
{
::serde::ser::SerializeStruct::serialize_field(&mut __st, "code_sets", __v)?;
}
if let Some(__v) = &self.vocabularies
&& !__v.is_empty()
{
::serde::ser::SerializeStruct::serialize_field(&mut __st, "vocabularies", __v)?;
}
if let Some(__v) = &self.version {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "version", __v)?;
}
if let Some(__v) = &self.date {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "date", __v)?;
}
::serde::ser::SerializeStruct::end(__st)
}
}
impl<'de> ::serde::Deserialize<'de> for crate::v3_1::terminology::terminology::Terminology {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &[
"code_sets",
"date",
"language",
"name",
"version",
"vocabularies",
];
enum __Field {
__Type,
__F0,
__F1,
__F2,
__F3,
__F4,
__F5,
}
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(
&self,
__f: &mut ::core::fmt::Formatter<'_>,
) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(
self,
__v: &str,
) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"name" => ::core::result::Result::Ok(__Field::__F0),
"language" => ::core::result::Result::Ok(__Field::__F1),
"code_sets" => ::core::result::Result::Ok(__Field::__F2),
"vocabularies" => ::core::result::Result::Ok(__Field::__F3),
"version" => ::core::result::Result::Ok(__Field::__F4),
"date" => ::core::result::Result::Ok(__Field::__F5),
_ => ::core::result::Result::Err(
::openehr_base::serde_support::unknown_field(
__v,
"TERMINOLOGY",
__FIELDS,
),
),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v3_1::terminology::terminology::Terminology;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `TERMINOLOGY` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(
self,
mut __map: __A,
) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<_> = None;
let mut __s3: ::core::option::Option<_> = None;
let mut __s4: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s5: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
match __key {
__Field::__Type => {
if __seen_type {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("_type"),
);
}
__seen_type = true;
::serde::de::MapAccess::next_value_seed(
&mut __map,
::openehr_base::serde_support::ExpectedType("TERMINOLOGY"),
)?;
}
__Field::__F0 => {
if __s0.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("name"),
);
}
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("language"),
);
}
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("code_sets"),
);
}
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F3 => {
if __s3.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("vocabularies"),
);
}
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F4 => {
if __s4.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("version"),
);
}
__s4 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F5 => {
if __s5.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("date"),
);
}
__s5 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(crate::v3_1::terminology::terminology::Terminology {
name: __s0
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
language: __s1
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("language"))?,
code_sets: __s2,
vocabularies: __s3,
version: __s4.flatten(),
date: __s5.flatten(),
})
}
}
::serde::Deserializer::deserialize_struct(
__deserializer,
"TERMINOLOGY",
__FIELDS,
__Visitor,
)
}
}
impl ::serde::Serialize for crate::v3_1::terminology::terminology_concept::TerminologyConcept {
fn serialize<__S: ::serde::Serializer>(
&self,
__serializer: __S,
) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 3usize;
if self.status.is_some() {
__n += 1;
}
let mut __st =
::serde::Serializer::serialize_struct(__serializer, "TERMINOLOGY_CONCEPT", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TERMINOLOGY_CONCEPT")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "id", &self.id)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "rubric", &self.rubric)?;
if let Some(__v) = &self.status {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "status", __v)?;
}
::serde::ser::SerializeStruct::end(__st)
}
}
impl<'de> ::serde::Deserialize<'de>
for crate::v3_1::terminology::terminology_concept::TerminologyConcept
{
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["id", "rubric", "status"];
enum __Field {
__Type,
__F0,
__F1,
__F2,
}
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(
&self,
__f: &mut ::core::fmt::Formatter<'_>,
) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(
self,
__v: &str,
) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"id" => ::core::result::Result::Ok(__Field::__F0),
"rubric" => ::core::result::Result::Ok(__Field::__F1),
"status" => ::core::result::Result::Ok(__Field::__F2),
_ => ::core::result::Result::Err(
::openehr_base::serde_support::unknown_field(
__v,
"TERMINOLOGY_CONCEPT",
__FIELDS,
),
),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v3_1::terminology::terminology_concept::TerminologyConcept;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `TERMINOLOGY_CONCEPT` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(
self,
mut __map: __A,
) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
match __key {
__Field::__Type => {
if __seen_type {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("_type"),
);
}
__seen_type = true;
::serde::de::MapAccess::next_value_seed(
&mut __map,
::openehr_base::serde_support::ExpectedType("TERMINOLOGY_CONCEPT"),
)?;
}
__Field::__F0 => {
if __s0.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("id"),
);
}
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("rubric"),
);
}
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("status"),
);
}
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(
crate::v3_1::terminology::terminology_concept::TerminologyConcept {
id: __s0
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("id"))?,
rubric: __s1
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("rubric"))?,
status: __s2.flatten(),
},
)
}
}
::serde::Deserializer::deserialize_struct(
__deserializer,
"TERMINOLOGY_CONCEPT",
__FIELDS,
__Visitor,
)
}
}
impl ::serde::Serialize for crate::v3_1::terminology::terminology_group::TerminologyGroup {
fn serialize<__S: ::serde::Serializer>(
&self,
__serializer: __S,
) -> ::core::result::Result<__S::Ok, __S::Error> {
let mut __n = 3usize;
if self.concepts.as_ref().is_some_and(|__v| !__v.is_empty()) {
__n += 1;
}
if self.status.is_some() {
__n += 1;
}
let mut __st =
::serde::Serializer::serialize_struct(__serializer, "TERMINOLOGY_GROUP", __n)?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "_type", "TERMINOLOGY_GROUP")?;
::serde::ser::SerializeStruct::serialize_field(&mut __st, "name", &self.name)?;
if let Some(__v) = &self.concepts
&& !__v.is_empty()
{
::serde::ser::SerializeStruct::serialize_field(&mut __st, "concepts", __v)?;
}
::serde::ser::SerializeStruct::serialize_field(&mut __st, "openehr_id", &self.openehr_id)?;
if let Some(__v) = &self.status {
::serde::ser::SerializeStruct::serialize_field(&mut __st, "status", __v)?;
}
::serde::ser::SerializeStruct::end(__st)
}
}
impl<'de> ::serde::Deserialize<'de>
for crate::v3_1::terminology::terminology_group::TerminologyGroup
{
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
const __FIELDS: &[&str] = &["concepts", "name", "openehr_id", "status"];
enum __Field {
__Type,
__F0,
__F1,
__F2,
__F3,
}
impl<'de> ::serde::Deserialize<'de> for __Field {
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
struct __KeyVisitor;
impl<'de> ::serde::de::Visitor<'de> for __KeyVisitor {
type Value = __Field;
fn expecting(
&self,
__f: &mut ::core::fmt::Formatter<'_>,
) -> ::core::fmt::Result {
__f.write_str("an object member name")
}
fn visit_str<__E: ::serde::de::Error>(
self,
__v: &str,
) -> ::core::result::Result<__Field, __E> {
match __v {
"_type" => ::core::result::Result::Ok(__Field::__Type),
"name" => ::core::result::Result::Ok(__Field::__F0),
"concepts" => ::core::result::Result::Ok(__Field::__F1),
"openehr_id" => ::core::result::Result::Ok(__Field::__F2),
"status" => ::core::result::Result::Ok(__Field::__F3),
_ => ::core::result::Result::Err(
::openehr_base::serde_support::unknown_field(
__v,
"TERMINOLOGY_GROUP",
__FIELDS,
),
),
}
}
}
::serde::Deserializer::deserialize_identifier(__deserializer, __KeyVisitor)
}
}
struct __Visitor;
impl<'de> ::serde::de::Visitor<'de> for __Visitor {
type Value = crate::v3_1::terminology::terminology_group::TerminologyGroup;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("an openEHR `TERMINOLOGY_GROUP` object")
}
fn visit_map<__A: ::serde::de::MapAccess<'de>>(
self,
mut __map: __A,
) -> ::core::result::Result<Self::Value, __A::Error> {
let mut __seen_type = false;
let mut __s0: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s1: ::core::option::Option<_> = None;
let mut __s2: ::core::option::Option<::core::option::Option<_>> = None;
let mut __s3: ::core::option::Option<::core::option::Option<_>> = None;
while let Some(__key) = ::serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
match __key {
__Field::__Type => {
if __seen_type {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("_type"),
);
}
__seen_type = true;
::serde::de::MapAccess::next_value_seed(
&mut __map,
::openehr_base::serde_support::ExpectedType("TERMINOLOGY_GROUP"),
)?;
}
__Field::__F0 => {
if __s0.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("name"),
);
}
__s0 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F1 => {
if __s1.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("concepts"),
);
}
__s1 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F2 => {
if __s2.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("openehr_id"),
);
}
__s2 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
__Field::__F3 => {
if __s3.is_some() {
return ::core::result::Result::Err(
::serde::de::Error::duplicate_field("status"),
);
}
__s3 = Some(::serde::de::MapAccess::next_value(&mut __map)?);
}
}
}
::core::result::Result::Ok(
crate::v3_1::terminology::terminology_group::TerminologyGroup {
name: __s0
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("name"))?,
concepts: __s1,
openehr_id: __s2
.flatten()
.ok_or_else(|| ::serde::de::Error::missing_field("openehr_id"))?,
status: __s3.flatten(),
},
)
}
}
::serde::Deserializer::deserialize_struct(
__deserializer,
"TERMINOLOGY_GROUP",
__FIELDS,
__Visitor,
)
}
}
impl ::serde::Serialize for crate::v3_1::terminology::terminology_status::TerminologyStatus {
fn serialize<__S: ::serde::Serializer>(
&self,
__serializer: __S,
) -> ::core::result::Result<__S::Ok, __S::Error> {
::serde::Serializer::serialize_str(__serializer, self.as_str())
}
}
impl<'de> ::serde::Deserialize<'de>
for crate::v3_1::terminology::terminology_status::TerminologyStatus
{
fn deserialize<__D: ::serde::Deserializer<'de>>(
__deserializer: __D,
) -> ::core::result::Result<Self, __D::Error> {
struct __V;
impl<'de> ::serde::de::Visitor<'de> for __V {
type Value = crate::v3_1::terminology::terminology_status::TerminologyStatus;
fn expecting(&self, __f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
__f.write_str("a `TerminologyStatus` token")
}
fn visit_str<__E: ::serde::de::Error>(
self,
__v: &str,
) -> ::core::result::Result<Self::Value, __E> {
::core::result::Result::Ok(
crate::v3_1::terminology::terminology_status::TerminologyStatus::from_wire(__v),
)
}
}
::serde::Deserializer::deserialize_str(__deserializer, __V)
}
}