fhir-types 0.1.98

// @generated by fhir-codegen from hl7.fhir.r4.core 4.0.1. DO NOT EDIT.
// Change the emitter (tools/fhir-codegen) and regenerate.
//! Content in a format defined elsewhere

/// Content in a format defined elsewhere
///
/// For referring to data content defined in other formats.
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Attachment {
    /// Unique id for inter-element referencing
    ///
    /// Unique id for the element within a resource (for internal references). This
    /// may be any string value that does not contain spaces.
    pub id: Option<std::string::String>,
    /// Additional content defined by implementations
    ///
    /// May be used to represent additional information that is not part of the
    /// basic definition of the element. To make the use of extensions safe and
    /// manageable, there is a strict set of governance applied to the definition
    /// and use of extensions. Though any implementer can define an extension, there
    /// is a set of requirements that SHALL be met as part of the definition of the
    /// extension.
    pub extension: Vec<super::extension::Extension>,
    /// Mime type of the content, with charset etc.
    ///
    /// Identifies the type of the data in the attachment and allows a method to be
    /// chosen to interpret or render the data. Includes mime type parameters such
    /// as charset where appropriate.
    pub content_type: Option<super::primitives::Code>,
    /// Human language of the content (BCP-47)
    ///
    /// The human language of the content. The value can be any valid value
    /// according to BCP 47.
    pub language: Option<super::primitives::Code>,
    /// Data inline, base64ed
    ///
    /// The actual data of the attachment - a sequence of bytes, base64 encoded.
    pub data: Option<super::primitives::Base64Binary>,
    /// Uri where the data can be found
    ///
    /// A location where the data can be accessed.
    pub url: Option<super::primitives::Url>,
    /// Number of bytes of content (if url provided)
    ///
    /// The number of bytes of data that make up this attachment (before base64
    /// encoding, if that is done).
    pub size: Option<super::primitives::UnsignedInt>,
    /// Hash of the data (sha-1, base64ed)
    ///
    /// The calculated hash of the data using SHA-1. Represented using base64.
    pub hash: Option<super::primitives::Base64Binary>,
    /// Label to display in place of the data
    ///
    /// A label or set of text to display in place of the data.
    pub title: Option<super::primitives::String>,
    /// Date attachment was first created
    ///
    /// The date that the attachment was first created.
    pub creation: Option<super::primitives::DateTime>,
}

impl super::super::codec::Json for Attachment {
    fn to_json(&self) -> Result<super::super::codec::Object, super::super::codec::EncodeError> {
        let mut object = super::super::codec::Object::new();
        if let Some(v) = &self.id {
            object.insert(
                std::string::String::from("id"),
                super::super::codec::Value::String(v.clone()),
            );
        }
        if !self.extension.is_empty() {
            let mut items = Vec::with_capacity(self.extension.len());
            for item in &self.extension {
                items.push(super::super::codec::Value::Object(
                    super::super::codec::Json::to_json(item)?,
                ));
            }
            object.insert(
                std::string::String::from("extension"),
                super::super::codec::Value::Array(items),
            );
        }
        if let Some(item) = &self.content_type {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("contentType"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_contentType"), e);
            }
        }
        if let Some(item) = &self.language {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("language"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_language"), e);
            }
        }
        if let Some(item) = &self.data {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("data"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_data"), e);
            }
        }
        if let Some(item) = &self.url {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("url"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_url"), e);
            }
        }
        if let Some(item) = &self.size {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("size"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_size"), e);
            }
        }
        if let Some(item) = &self.hash {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("hash"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_hash"), e);
            }
        }
        if let Some(item) = &self.title {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("title"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_title"), e);
            }
        }
        if let Some(item) = &self.creation {
            if let Some(v) = super::super::codec::Primitive::value_json(item)? {
                object.insert(std::string::String::from("creation"), v);
            }
            if let Some(e) = super::super::codec::Primitive::element_json(item)? {
                object.insert(std::string::String::from("_creation"), e);
            }
        }
        Ok(object)
    }

    fn from_json(
        object: &super::super::codec::Object,
        path: &mut super::super::codec::Path,
    ) -> Result<Self, super::super::codec::DecodeError> {
        let mut raw_id: Option<&super::super::codec::Value> = None;
        let mut raw_extension: Option<&super::super::codec::Value> = None;
        let mut raw_content_type: Option<&super::super::codec::Value> = None;
        let mut raw_content_type_element: Option<&super::super::codec::Value> = None;
        let mut raw_language: Option<&super::super::codec::Value> = None;
        let mut raw_language_element: Option<&super::super::codec::Value> = None;
        let mut raw_data: Option<&super::super::codec::Value> = None;
        let mut raw_data_element: Option<&super::super::codec::Value> = None;
        let mut raw_url: Option<&super::super::codec::Value> = None;
        let mut raw_url_element: Option<&super::super::codec::Value> = None;
        let mut raw_size: Option<&super::super::codec::Value> = None;
        let mut raw_size_element: Option<&super::super::codec::Value> = None;
        let mut raw_hash: Option<&super::super::codec::Value> = None;
        let mut raw_hash_element: Option<&super::super::codec::Value> = None;
        let mut raw_title: Option<&super::super::codec::Value> = None;
        let mut raw_title_element: Option<&super::super::codec::Value> = None;
        let mut raw_creation: Option<&super::super::codec::Value> = None;
        let mut raw_creation_element: Option<&super::super::codec::Value> = None;
        for (key, value) in object {
            match key.as_str() {
                "id" => raw_id = Some(value),
                "extension" => raw_extension = Some(value),
                "contentType" => raw_content_type = Some(value),
                "_contentType" => raw_content_type_element = Some(value),
                "language" => raw_language = Some(value),
                "_language" => raw_language_element = Some(value),
                "data" => raw_data = Some(value),
                "_data" => raw_data_element = Some(value),
                "url" => raw_url = Some(value),
                "_url" => raw_url_element = Some(value),
                "size" => raw_size = Some(value),
                "_size" => raw_size_element = Some(value),
                "hash" => raw_hash = Some(value),
                "_hash" => raw_hash_element = Some(value),
                "title" => raw_title = Some(value),
                "_title" => raw_title_element = Some(value),
                "creation" => raw_creation = Some(value),
                "_creation" => raw_creation_element = Some(value),
                other => {
                    return path.with(other, |path| {
                        Err(path.error(super::super::codec::DecodeErrorKind::UnknownProperty))
                    });
                }
            }
        }
        let field_id = raw_id
            .map(|value| {
                path.with("id", |path| {
                    let value = super::super::codec::expect_single(value, path)?;
                    super::super::codec::expect_string(value, path)
                })
            })
            .transpose()?;
        let mut field_extension = Vec::new();
        if let Some(raw) = raw_extension {
            for (index, value) in super::super::codec::expect_array(raw, path)?
                .iter()
                .enumerate()
            {
                field_extension.push(path.with_index("extension", index, |path| {
                    super::super::codec::Json::from_json(
                        super::super::codec::expect_object(value, path)?,
                        path,
                    )
                })?);
            }
        }
        let field_content_type = match (raw_content_type, raw_content_type_element) {
            (None, None) => None,
            (value, element) => Some(path.with("contentType", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_language = match (raw_language, raw_language_element) {
            (None, None) => None,
            (value, element) => Some(path.with("language", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_data = match (raw_data, raw_data_element) {
            (None, None) => None,
            (value, element) => Some(path.with("data", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_url = match (raw_url, raw_url_element) {
            (None, None) => None,
            (value, element) => Some(path.with("url", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_size = match (raw_size, raw_size_element) {
            (None, None) => None,
            (value, element) => Some(path.with("size", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_hash = match (raw_hash, raw_hash_element) {
            (None, None) => None,
            (value, element) => Some(path.with("hash", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_title = match (raw_title, raw_title_element) {
            (None, None) => None,
            (value, element) => Some(path.with("title", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        let field_creation = match (raw_creation, raw_creation_element) {
            (None, None) => None,
            (value, element) => Some(path.with("creation", |path| {
                super::super::codec::Primitive::from_json_parts(value, element, path)
            })?),
        };
        Ok(Self {
            id: field_id,
            extension: field_extension,
            content_type: field_content_type,
            language: field_language,
            data: field_data,
            url: field_url,
            size: field_size,
            hash: field_hash,
            title: field_title,
            creation: field_creation,
        })
    }
}

impl serde::Serialize for Attachment {
    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
        let mut map = serde::Serializer::serialize_map(serializer, None)?;
        if let Some(item) = &self.content_type {
            super::super::codec::element_entry(&mut map, "_contentType", item)?;
        }
        if let Some(item) = &self.creation {
            super::super::codec::element_entry(&mut map, "_creation", item)?;
        }
        if let Some(item) = &self.data {
            super::super::codec::element_entry(&mut map, "_data", item)?;
        }
        if let Some(item) = &self.hash {
            super::super::codec::element_entry(&mut map, "_hash", item)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::element_entry(&mut map, "_language", item)?;
        }
        if let Some(item) = &self.size {
            super::super::codec::element_entry(&mut map, "_size", item)?;
        }
        if let Some(item) = &self.title {
            super::super::codec::element_entry(&mut map, "_title", item)?;
        }
        if let Some(item) = &self.url {
            super::super::codec::element_entry(&mut map, "_url", item)?;
        }
        if let Some(item) = &self.content_type {
            super::super::codec::value_entry(&mut map, "contentType", item)?;
        }
        if let Some(item) = &self.creation {
            super::super::codec::value_entry(&mut map, "creation", item)?;
        }
        if let Some(item) = &self.data {
            super::super::codec::value_entry(&mut map, "data", item)?;
        }
        if !self.extension.is_empty() {
            serde::ser::SerializeMap::serialize_entry(&mut map, "extension", &self.extension)?;
        }
        if let Some(item) = &self.hash {
            super::super::codec::value_entry(&mut map, "hash", item)?;
        }
        if let Some(v) = &self.id {
            serde::ser::SerializeMap::serialize_entry(&mut map, "id", v)?;
        }
        if let Some(item) = &self.language {
            super::super::codec::value_entry(&mut map, "language", item)?;
        }
        if let Some(item) = &self.size {
            super::super::codec::value_entry(&mut map, "size", item)?;
        }
        if let Some(item) = &self.title {
            super::super::codec::value_entry(&mut map, "title", item)?;
        }
        if let Some(item) = &self.url {
            super::super::codec::value_entry(&mut map, "url", item)?;
        }
        serde::ser::SerializeMap::end(map)
    }
}

impl<'de> serde::Deserialize<'de> for Attachment {
    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        let value = <super::super::codec::Value as serde::Deserialize>::deserialize(deserializer)?;
        let mut path = super::super::codec::Path::root("Attachment");
        let object =
            super::super::codec::expect_object(&value, &path).map_err(serde::de::Error::custom)?;
        super::super::codec::Json::from_json(object, &mut path).map_err(serde::de::Error::custom)
    }
}