Struct ElementDefinition 

pub struct ElementDefinition {

    pub id: Option<Id>,
    pub extension: Option<Vec<Extension>>,
    pub modifier_extension: Option<Vec<Extension>>,
    pub path: Option<StringDt>,
    pub representation: Option<Vec<CodeDt>>,
    pub slice_name: Option<StringDt>,
    pub slice_is_constraining: Option<BooleanDt>,
    pub label: Option<StringDt>,
    pub code: Option<Vec<Coding>>,
    pub slicing: Option<ElementDefinitionSlicingElement>,
    pub short: Option<StringDt>,
    pub definition: Option<MarkdownDt>,
    pub comment: Option<MarkdownDt>,
    pub requirements: Option<MarkdownDt>,
    pub alias: Option<Vec<StringDt>>,
    pub min: Option<UnsignedIntDt>,
    pub max: Option<StringDt>,
    pub base: Option<ElementDefinitionBaseElement>,
    pub content_reference: Option<UriDt>,
    pub type_: Option<Vec<ElementDefinitionTypeElement>>,
    pub default_value: Option<Meta>,
    pub meaning_when_missing: Option<MarkdownDt>,
    pub order_meaning: Option<StringDt>,
    pub fixed: Option<Meta>,
    pub pattern: Option<AnyType>,
    pub example: Option<Vec<ElementDefinitionExampleElement>>,
    pub min_value: Option<Quantity>,
    pub max_value: Option<Quantity>,
    pub max_length: Option<IntegerDt>,
    pub condition: Option<Vec<IdDt>>,
    pub constraint: Option<Vec<ElementDefinitionConstraintElement>>,
    pub must_have_value: Option<BooleanDt>,
    pub value_alternatives: Option<Vec<CanonicalDt>>,
    pub must_support: Option<BooleanDt>,
    pub is_modifier: Option<BooleanDt>,
    pub is_modifier_reason: Option<StringDt>,
    pub is_summary: Option<BooleanDt>,
    pub binding: Option<ElementDefinitionBindingElement>,
    pub mapping: Option<Vec<ElementDefinitionMappingElement>>,
}

Fields

id: Option<Id>

Unique id for inter-element referencing

extension: Option<Vec<Extension>>

Additional content defined by implementations

modifier_extension: Option<Vec<Extension>>

Extensions that cannot be ignored even if unrecognized

path: Option<StringDt>

Path of the element in the hierarchy of elements

representation: Option<Vec<CodeDt>>

xmlAttr | xmlText | typeAttr | cdaText | xhtml

slice_name: Option<StringDt>

Name for this particular element (in a set of slices)

slice_is_constraining: Option<BooleanDt>

If this slice definition constrains an inherited slice definition (or not)

label: Option<StringDt>

Name for element to display with or prompt for element

code: Option<Vec<Coding>>

Corresponding codes in terminologies

slicing: Option<ElementDefinitionSlicingElement>

This element is sliced - slices follow

short: Option<StringDt>

Concise definition for space-constrained presentation

definition: Option<MarkdownDt>

Full formal definition as narrative text

comment: Option<MarkdownDt>

Comments about the use of this element

requirements: Option<MarkdownDt>

Why this resource has been created

alias: Option<Vec<StringDt>>

Other names

min: Option<UnsignedIntDt>

Minimum Cardinality

max: Option<StringDt>

Maximum Cardinality (a number or *)

base: Option<ElementDefinitionBaseElement>

content_reference: Option<UriDt>

Reference to definition of content for the element

type_: Option<Vec<ElementDefinitionTypeElement>>

default_value: Option<Meta>

Specified value if missing from instance

meaning_when_missing: Option<MarkdownDt>

Implicit meaning when this element is missing

order_meaning: Option<StringDt>

What the order of the elements means

fixed: Option<Meta>

Value must be exactly this

pattern: Option<AnyType>

Value must have at least these property values

example: Option<Vec<ElementDefinitionExampleElement>>

Example value (as defined for type)

min_value: Option<Quantity>

Minimum Allowed Value (for some types)

max_value: Option<Quantity>

Maximum Allowed Value (for some types)

max_length: Option<IntegerDt>

Max length for string type data

condition: Option<Vec<IdDt>>

Reference to invariant about presence

constraint: Option<Vec<ElementDefinitionConstraintElement>>

Condition that must evaluate to true

must_have_value: Option<BooleanDt>

For primitives, that a value must be present - not replaced by an extension

value_alternatives: Option<Vec<CanonicalDt>>

Extensions that are allowed to replace a primitive value

must_support: Option<BooleanDt>

If the element must be supported (discouraged - see obligations)

is_modifier: Option<BooleanDt>

If this modifies the meaning of other elements

is_modifier_reason: Option<StringDt>

Reason that this element is marked as a modifier

is_summary: Option<BooleanDt>

Include when _summary = true?

binding: Option<ElementDefinitionBindingElement>

ValueSet details if this is coded

mapping: Option<Vec<ElementDefinitionMappingElement>>

Map element to another set of definitions

Implementations

impl ElementDefinition

pub fn set_modifier_extension(self, v: Vec<Extension>) -> Self

pub fn add_modifier_extension(self, v: Extension) -> Self

pub fn set_path<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_representation(self, v: Vec<CodeDt>) -> Self

pub fn add_representation<T: Into<CodeDt>>(self, v: T) -> Self

pub fn set_slice_name<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_slice_is_constraining<T: Into<BooleanDt>>(self, v: T) -> Self

pub fn set_label<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_code(self, v: Vec<Coding>) -> Self

pub fn add_code(self, v: Coding) -> Self

pub fn set_slicing(self, v: ElementDefinitionSlicingElement) -> Self

pub fn set_short<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_definition<T: Into<MarkdownDt>>(self, v: T) -> Self

pub fn set_comment<T: Into<MarkdownDt>>(self, v: T) -> Self

pub fn set_requirements<T: Into<MarkdownDt>>(self, v: T) -> Self

pub fn set_alias(self, v: Vec<StringDt>) -> Self

pub fn add_alias<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_min<T: Into<UnsignedIntDt>>(self, v: T) -> Self

pub fn set_max<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_base(self, v: ElementDefinitionBaseElement) -> Self

pub fn set_content_reference<T: Into<UriDt>>(self, v: T) -> Self

pub fn set_type_(self, v: Vec<ElementDefinitionTypeElement>) -> Self

pub fn add_type_(self, v: ElementDefinitionTypeElement) -> Self

pub fn set_default_value(self, v: Meta) -> Self

pub fn set_meaning_when_missing<T: Into<MarkdownDt>>(self, v: T) -> Self

pub fn set_order_meaning<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_fixed(self, v: Meta) -> Self

pub fn set_pattern(self, v: AnyType) -> Self

pub fn set_example(self, v: Vec<ElementDefinitionExampleElement>) -> Self

pub fn add_example(self, v: ElementDefinitionExampleElement) -> Self

pub fn set_min_value(self, v: Quantity) -> Self

pub fn set_max_value(self, v: Quantity) -> Self

pub fn set_max_length<T: Into<IntegerDt>>(self, v: T) -> Self

pub fn set_condition(self, v: Vec<IdDt>) -> Self

pub fn add_condition<T: Into<IdDt>>(self, v: T) -> Self

pub fn set_constraint(self, v: Vec<ElementDefinitionConstraintElement>) -> Self

pub fn add_constraint(self, v: ElementDefinitionConstraintElement) -> Self

pub fn set_must_have_value<T: Into<BooleanDt>>(self, v: T) -> Self

pub fn set_value_alternatives(self, v: Vec<CanonicalDt>) -> Self

pub fn add_value_alternatives<T: Into<CanonicalDt>>(self, v: T) -> Self

pub fn set_must_support<T: Into<BooleanDt>>(self, v: T) -> Self

pub fn set_is_modifier<T: Into<BooleanDt>>(self, v: T) -> Self

pub fn set_is_modifier_reason<T: Into<StringDt>>(self, v: T) -> Self

pub fn set_is_summary<T: Into<BooleanDt>>(self, v: T) -> Self

pub fn set_binding(self, v: ElementDefinitionBindingElement) -> Self

pub fn set_mapping(self, v: Vec<ElementDefinitionMappingElement>) -> Self

pub fn add_mapping(self, v: ElementDefinitionMappingElement) -> Self

Trait Implementations

impl Base for ElementDefinition

fn type_name(&self) -> &str

impl Clone for ElementDefinition

fn clone(&self) -> ElementDefinition

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Compare for ElementDefinition

fn eq(&self, _right: &dyn Executor) -> Result<bool>

fn gt(&self, _right: &dyn Executor) -> Result<bool>

fn ge(&self, _right: &dyn Executor) -> Result<bool>

fn lt(&self, _right: &dyn Executor) -> Result<bool>

fn le(&self, _right: &dyn Executor) -> Result<bool>

impl Convert for ElementDefinition

fn to_integer(&self) -> Result<Integer>

fn to_decimal(&self) -> Result<Decimal>

fn to_strings(&self) -> Result<String>

fn to_datetime(&self) -> Result<DateTime>

fn to_boolean(&self) -> Result<Boolean>

impl Debug for ElementDefinition

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

Formats the value using the given formatter.

impl Default for ElementDefinition

fn default() -> ElementDefinition

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ElementDefinition

fn deserialize<De>(deserializer: De) -> Result<Self>

where De: Deserializer<'de>,

impl Element for ElementDefinition

fn id(&self) -> Option<&String>

fn set_id<T: Into<String>>(self, id: T) -> Self

fn extensions(&self) -> Option<&Vec<Extension>>

fn set_extensions(self, ext: Vec<Extension>) -> Self

fn add_extension(self, ext: Extension) -> Self

impl Executor for ElementDefinition

fn element(&self, symbol: &String, index: &Option<usize>) -> Result<Collection>

fn to_collection(&self, index: &Option<usize>) -> Collection

fn child(&self, _index: usize) -> Result<Collection>

impl Serialize for ElementDefinition

fn serialize<Ser: Serializer>(&self, serializer: Ser) -> Result<()>

impl DataType for ElementDefinition