Struct ElementDefinitionSlicing

pub struct ElementDefinitionSlicing {
    pub id: Option<String>,
    pub extension: Vec<Extension>,
    pub discriminator: Vec<Option<ElementDefinitionSlicingDiscriminator>>,
    pub discriminator_ext: Vec<Option<FieldExtension>>,
    pub description: Option<String>,
    pub description_ext: Option<FieldExtension>,
    pub ordered: Option<bool>,
    pub ordered_ext: Option<FieldExtension>,
    pub rules: SlicingRules,
    pub rules_ext: Option<FieldExtension>,
}

Sub-fields of the slicing field in ElementDefinition

Fields

id: Option<String>

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.

extension: Vec<Extension>

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 managable, 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.

There can be no stigma associated with the use of extensions by any application, project, or standard - regardless of the institution or jurisdiction that uses or defines the extensions. The use of extensions is what allows the FHIR specification to retain a core level of simplicity for everyone.

discriminator: Vec<Option<ElementDefinitionSlicingDiscriminator>>

Element values that are used to distinguish the slices

Designates which child elements are used to discriminate between the slices when processing an instance. If one or more discriminators are provided, the value of the child elements in the instance data SHALL completely distinguish which slice the element in the resource matches based on the allowed values for those elements in each of the slices.

If there is no discriminator, the content is hard to process, so this should be avoided.

discriminator_ext: Vec<Option<FieldExtension>>

Extension field.

description: Option<String>

Text description of how slicing works (or not)

A human-readable text description of how the slicing works. If there is no discriminator, this is required to be present to provide whatever information is possible about how the slices can be differentiated.

If it’s really not possible to differentiate them, the design should be re-evaluated to make the content usable.

description_ext: Option<FieldExtension>

Extension field.

ordered: Option<bool>

If elements must be in same order as slices

If the matching elements have to occur in the same order as defined in the profile.

Order should only be required when it is a pressing concern for presentation. Profile authors should consider making the order a feature of the rules about the narrative, not the rules about the data - requiring ordered data makes the profile much less re-usable.

ordered_ext: Option<FieldExtension>

Extension field.

rules: SlicingRules

SlicingRules; closed | open | openAtEnd

Whether additional slices are allowed or not. When the slices are ordered, profile authors can also say that additional slices are only allowed at the end.

Allowing additional elements makes for a much for flexible template - it’s open for use in wider contexts, but also means that the content of the resource is not closed, and applications have to decide how to handle content not described by the profile.

rules_ext: Option<FieldExtension>

Extension field.

Implementations

impl ElementDefinitionSlicing

pub fn builder() -> ElementDefinitionSlicingBuilder

Start building a new instance

Trait Implementations

impl Clone for ElementDefinitionSlicing

fn clone(&self) -> ElementDefinitionSlicing

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ElementDefinitionSlicing

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ElementDefinitionSlicing

fn deserialize<__D>( __deserializer: __D, ) -> Result<ElementDefinitionSlicing, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ElementDefinitionSlicing

fn eq(&self, other: &ElementDefinitionSlicing) -> 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 Serialize for ElementDefinitionSlicing

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ElementDefinitionSlicing