Package org.hl7.fhir.r4.model

Class Timing.TimingRepeatComponent

java.lang.Object
org.hl7.fhir.r4.model.Base
org.hl7.fhir.r4.model.Element
org.hl7.fhir.r4.model.Timing.TimingRepeatComponent
All Implemented Interfaces:
ca.uhn.fhir.model.api.IElement, Serializable, org.hl7.fhir.instance.model.api.IBase, org.hl7.fhir.instance.model.api.IBaseDatatypeElement, org.hl7.fhir.instance.model.api.IBaseElement, org.hl7.fhir.instance.model.api.IBaseHasExtensions
Enclosing class:
Timing
public static class Timing.TimingRepeatComponent extends Element implements org.hl7.fhir.instance.model.api.IBaseDatatypeElement
See Also:

  • Field Details

    • bounds

      protected Type bounds
      Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.

    • count

      protected PositiveIntType count
      A total count of the desired number of repetitions across the duration of the entire timing specification. If countMax is present, this element indicates the lower bound of the allowed range of count values.

    • countMax

      protected PositiveIntType countMax
      If present, indicates that the count is a range - so to perform the action between [count] and [countMax] times.

    • duration

      protected DecimalType duration
      How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.

    • durationMax

      protected DecimalType durationMax
      If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.

    • durationUnit

      protected Enumeration<Timing.UnitsOfTime> durationUnit
      The units of time for the duration, in UCUM units.

    • frequency

      protected PositiveIntType frequency
      The number of times to repeat the action within the specified period. If frequencyMax is present, this element indicates the lower bound of the allowed range of the frequency.

    • frequencyMax

      protected PositiveIntType frequencyMax
      If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.

    • period

      protected DecimalType period
      Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.

    • periodMax

      protected DecimalType periodMax
      If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.

    • periodUnit

      protected Enumeration<Timing.UnitsOfTime> periodUnit
      The units of time for the period in UCUM units.

    • dayOfWeek

      protected List<Enumeration<Timing.DayOfWeek>> dayOfWeek
      If one or more days of week is provided, then the action happens only on the specified day(s).

    • timeOfDay

      protected List<TimeType> timeOfDay
      Specified time of day for action to take place.

    • when

      protected List<Enumeration<Timing.EventTiming>> when
      An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.

    • offset

      protected UnsignedIntType offset
      The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.

  • Constructor Details

  • Method Details

    • getBounds

      public Type getBounds()
      Returns:
      bounds (Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.)

    • getBoundsDuration

      public Duration getBoundsDuration() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      bounds (Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • hasBoundsDuration

      public boolean hasBoundsDuration()

    • getBoundsRange

      public Range getBoundsRange() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      bounds (Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • hasBoundsRange

      public boolean hasBoundsRange()

    • getBoundsPeriod

      public Period getBoundsPeriod() throws org.hl7.fhir.exceptions.FHIRException
      Returns:
      bounds (Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.)
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • hasBoundsPeriod

      public boolean hasBoundsPeriod()

    • hasBounds

      public boolean hasBounds()

    • setBounds

      public Timing.TimingRepeatComponent setBounds(Type value)
      Parameters:
      value - bounds (Either a duration for the length of the timing schedule, a range of possible length, or outer bounds for start and/or end limits of the timing schedule.)

    • getCountElement

      public PositiveIntType getCountElement()
      Returns:
      count (A total count of the desired number of repetitions across the duration of the entire timing specification. If countMax is present, this element indicates the lower bound of the allowed range of count values.). This is the underlying object with id, value and extensions. The accessor "getCount" gives direct access to the value

    • hasCountElement

      public boolean hasCountElement()

    • hasCount

      public boolean hasCount()

    • setCountElement

      public Timing.TimingRepeatComponent setCountElement(PositiveIntType value)
      Parameters:
      value - count (A total count of the desired number of repetitions across the duration of the entire timing specification. If countMax is present, this element indicates the lower bound of the allowed range of count values.). This is the underlying object with id, value and extensions. The accessor "getCount" gives direct access to the value

    • getCount

      public int getCount()
      Returns:
      A total count of the desired number of repetitions across the duration of the entire timing specification. If countMax is present, this element indicates the lower bound of the allowed range of count values.

    • setCount

      public Timing.TimingRepeatComponent setCount(int value)
      Parameters:
      value - A total count of the desired number of repetitions across the duration of the entire timing specification. If countMax is present, this element indicates the lower bound of the allowed range of count values.

    • getCountMaxElement

      public PositiveIntType getCountMaxElement()
      Returns:
      countMax (If present, indicates that the count is a range - so to perform the action between [count] and [countMax] times.). This is the underlying object with id, value and extensions. The accessor "getCountMax" gives direct access to the value

    • hasCountMaxElement

      public boolean hasCountMaxElement()

    • hasCountMax

      public boolean hasCountMax()

    • setCountMaxElement

      public Timing.TimingRepeatComponent setCountMaxElement(PositiveIntType value)
      Parameters:
      value - countMax (If present, indicates that the count is a range - so to perform the action between [count] and [countMax] times.). This is the underlying object with id, value and extensions. The accessor "getCountMax" gives direct access to the value

    • getCountMax

      public int getCountMax()
      Returns:
      If present, indicates that the count is a range - so to perform the action between [count] and [countMax] times.

    • setCountMax

      public Timing.TimingRepeatComponent setCountMax(int value)
      Parameters:
      value - If present, indicates that the count is a range - so to perform the action between [count] and [countMax] times.

    • getDurationElement

      public DecimalType getDurationElement()
      Returns:
      duration (How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.). This is the underlying object with id, value and extensions. The accessor "getDuration" gives direct access to the value

    • hasDurationElement

      public boolean hasDurationElement()

    • hasDuration

      public boolean hasDuration()

    • setDurationElement

      public Timing.TimingRepeatComponent setDurationElement(DecimalType value)
      Parameters:
      value - duration (How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.). This is the underlying object with id, value and extensions. The accessor "getDuration" gives direct access to the value

    • getDuration

      public BigDecimal getDuration()
      Returns:
      How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.

    • setDuration

      public Timing.TimingRepeatComponent setDuration(BigDecimal value)
      Parameters:
      value - How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.

    • setDuration

      public Timing.TimingRepeatComponent setDuration(long value)
      Parameters:
      value - How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.

    • setDuration

      public Timing.TimingRepeatComponent setDuration(double value)
      Parameters:
      value - How long this thing happens for when it happens. If durationMax is present, this element indicates the lower bound of the allowed range of the duration.

    • getDurationMaxElement

      public DecimalType getDurationMaxElement()
      Returns:
      durationMax (If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.). This is the underlying object with id, value and extensions. The accessor "getDurationMax" gives direct access to the value

    • hasDurationMaxElement

      public boolean hasDurationMaxElement()

    • hasDurationMax

      public boolean hasDurationMax()

    • setDurationMaxElement

      public Timing.TimingRepeatComponent setDurationMaxElement(DecimalType value)
      Parameters:
      value - durationMax (If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.). This is the underlying object with id, value and extensions. The accessor "getDurationMax" gives direct access to the value

    • getDurationMax

      public BigDecimal getDurationMax()
      Returns:
      If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.

    • setDurationMax

      public Timing.TimingRepeatComponent setDurationMax(BigDecimal value)
      Parameters:
      value - If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.

    • setDurationMax

      public Timing.TimingRepeatComponent setDurationMax(long value)
      Parameters:
      value - If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.

    • setDurationMax

      public Timing.TimingRepeatComponent setDurationMax(double value)
      Parameters:
      value - If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.

    • getDurationUnitElement

      public Enumeration<Timing.UnitsOfTime> getDurationUnitElement()
      Returns:
      durationUnit (The units of time for the duration, in UCUM units.). This is the underlying object with id, value and extensions. The accessor "getDurationUnit" gives direct access to the value

    • hasDurationUnitElement

      public boolean hasDurationUnitElement()

    • hasDurationUnit

      public boolean hasDurationUnit()

    • setDurationUnitElement

      public Timing.TimingRepeatComponent setDurationUnitElement(Enumeration<Timing.UnitsOfTime> value)
      Parameters:
      value - durationUnit (The units of time for the duration, in UCUM units.). This is the underlying object with id, value and extensions. The accessor "getDurationUnit" gives direct access to the value

    • getDurationUnit

      public Timing.UnitsOfTime getDurationUnit()
      Returns:
      The units of time for the duration, in UCUM units.

    • setDurationUnit

      public Timing.TimingRepeatComponent setDurationUnit(Timing.UnitsOfTime value)
      Parameters:
      value - The units of time for the duration, in UCUM units.

    • getFrequencyElement

      public PositiveIntType getFrequencyElement()
      Returns:
      frequency (The number of times to repeat the action within the specified period. If frequencyMax is present, this element indicates the lower bound of the allowed range of the frequency.). This is the underlying object with id, value and extensions. The accessor "getFrequency" gives direct access to the value

    • hasFrequencyElement

      public boolean hasFrequencyElement()

    • hasFrequency

      public boolean hasFrequency()

    • setFrequencyElement

      public Timing.TimingRepeatComponent setFrequencyElement(PositiveIntType value)
      Parameters:
      value - frequency (The number of times to repeat the action within the specified period. If frequencyMax is present, this element indicates the lower bound of the allowed range of the frequency.). This is the underlying object with id, value and extensions. The accessor "getFrequency" gives direct access to the value

    • getFrequency

      public int getFrequency()
      Returns:
      The number of times to repeat the action within the specified period. If frequencyMax is present, this element indicates the lower bound of the allowed range of the frequency.

    • setFrequency

      public Timing.TimingRepeatComponent setFrequency(int value)
      Parameters:
      value - The number of times to repeat the action within the specified period. If frequencyMax is present, this element indicates the lower bound of the allowed range of the frequency.

    • getFrequencyMaxElement

      public PositiveIntType getFrequencyMaxElement()
      Returns:
      frequencyMax (If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.). This is the underlying object with id, value and extensions. The accessor "getFrequencyMax" gives direct access to the value

    • hasFrequencyMaxElement

      public boolean hasFrequencyMaxElement()

    • hasFrequencyMax

      public boolean hasFrequencyMax()

    • setFrequencyMaxElement

      public Timing.TimingRepeatComponent setFrequencyMaxElement(PositiveIntType value)
      Parameters:
      value - frequencyMax (If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.). This is the underlying object with id, value and extensions. The accessor "getFrequencyMax" gives direct access to the value

    • getFrequencyMax

      public int getFrequencyMax()
      Returns:
      If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.

    • setFrequencyMax

      public Timing.TimingRepeatComponent setFrequencyMax(int value)
      Parameters:
      value - If present, indicates that the frequency is a range - so to repeat between [frequency] and [frequencyMax] times within the period or period range.

    • getPeriodElement

      public DecimalType getPeriodElement()
      Returns:
      period (Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.). This is the underlying object with id, value and extensions. The accessor "getPeriod" gives direct access to the value

    • hasPeriodElement

      public boolean hasPeriodElement()

    • hasPeriod

      public boolean hasPeriod()

    • setPeriodElement

      public Timing.TimingRepeatComponent setPeriodElement(DecimalType value)
      Parameters:
      value - period (Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.). This is the underlying object with id, value and extensions. The accessor "getPeriod" gives direct access to the value

    • getPeriod

      public BigDecimal getPeriod()
      Returns:
      Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.

    • setPeriod

      public Timing.TimingRepeatComponent setPeriod(BigDecimal value)
      Parameters:
      value - Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.

    • setPeriod

      public Timing.TimingRepeatComponent setPeriod(long value)
      Parameters:
      value - Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.

    • setPeriod

      public Timing.TimingRepeatComponent setPeriod(double value)
      Parameters:
      value - Indicates the duration of time over which repetitions are to occur; e.g. to express "3 times per day", 3 would be the frequency and "1 day" would be the period. If periodMax is present, this element indicates the lower bound of the allowed range of the period length.

    • getPeriodMaxElement

      public DecimalType getPeriodMaxElement()
      Returns:
      periodMax (If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.). This is the underlying object with id, value and extensions. The accessor "getPeriodMax" gives direct access to the value

    • hasPeriodMaxElement

      public boolean hasPeriodMaxElement()

    • hasPeriodMax

      public boolean hasPeriodMax()

    • setPeriodMaxElement

      public Timing.TimingRepeatComponent setPeriodMaxElement(DecimalType value)
      Parameters:
      value - periodMax (If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.). This is the underlying object with id, value and extensions. The accessor "getPeriodMax" gives direct access to the value

    • getPeriodMax

      public BigDecimal getPeriodMax()
      Returns:
      If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.

    • setPeriodMax

      public Timing.TimingRepeatComponent setPeriodMax(BigDecimal value)
      Parameters:
      value - If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.

    • setPeriodMax

      public Timing.TimingRepeatComponent setPeriodMax(long value)
      Parameters:
      value - If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.

    • setPeriodMax

      public Timing.TimingRepeatComponent setPeriodMax(double value)
      Parameters:
      value - If present, indicates that the period is a range from [period] to [periodMax], allowing expressing concepts such as "do this once every 3-5 days.

    • getPeriodUnitElement

      public Enumeration<Timing.UnitsOfTime> getPeriodUnitElement()
      Returns:
      periodUnit (The units of time for the period in UCUM units.). This is the underlying object with id, value and extensions. The accessor "getPeriodUnit" gives direct access to the value

    • hasPeriodUnitElement

      public boolean hasPeriodUnitElement()

    • hasPeriodUnit

      public boolean hasPeriodUnit()

    • setPeriodUnitElement

      public Timing.TimingRepeatComponent setPeriodUnitElement(Enumeration<Timing.UnitsOfTime> value)
      Parameters:
      value - periodUnit (The units of time for the period in UCUM units.). This is the underlying object with id, value and extensions. The accessor "getPeriodUnit" gives direct access to the value

    • getPeriodUnit

      public Timing.UnitsOfTime getPeriodUnit()
      Returns:
      The units of time for the period in UCUM units.

    • setPeriodUnit

      public Timing.TimingRepeatComponent setPeriodUnit(Timing.UnitsOfTime value)
      Parameters:
      value - The units of time for the period in UCUM units.

    • getDayOfWeek

      public List<Enumeration<Timing.DayOfWeek>> getDayOfWeek()
      Returns:
      dayOfWeek (If one or more days of week is provided, then the action happens only on the specified day(s).)

    • setDayOfWeek

      public Timing.TimingRepeatComponent setDayOfWeek(List<Enumeration<Timing.DayOfWeek>> theDayOfWeek)
      Returns:
      Returns a reference to this for easy method chaining

    • hasDayOfWeek

      public boolean hasDayOfWeek()

    • addDayOfWeekElement

      public Enumeration<Timing.DayOfWeek> addDayOfWeekElement()
      Returns:
      dayOfWeek (If one or more days of week is provided, then the action happens only on the specified day(s).)

    • addDayOfWeek

      public Timing.TimingRepeatComponent addDayOfWeek(Timing.DayOfWeek value)
      Parameters:
      value - dayOfWeek (If one or more days of week is provided, then the action happens only on the specified day(s).)

    • hasDayOfWeek

      public boolean hasDayOfWeek(Timing.DayOfWeek value)
      Parameters:
      value - dayOfWeek (If one or more days of week is provided, then the action happens only on the specified day(s).)

    • getTimeOfDay

      public List<TimeType> getTimeOfDay()
      Returns:
      timeOfDay (Specified time of day for action to take place.)

    • setTimeOfDay

      public Timing.TimingRepeatComponent setTimeOfDay(List<TimeType> theTimeOfDay)
      Returns:
      Returns a reference to this for easy method chaining

    • hasTimeOfDay

      public boolean hasTimeOfDay()

    • addTimeOfDayElement

      public TimeType addTimeOfDayElement()
      Returns:
      timeOfDay (Specified time of day for action to take place.)

    • addTimeOfDay

      public Timing.TimingRepeatComponent addTimeOfDay(String value)
      Parameters:
      value - timeOfDay (Specified time of day for action to take place.)

    • hasTimeOfDay

      public boolean hasTimeOfDay(String value)
      Parameters:
      value - timeOfDay (Specified time of day for action to take place.)

    • getWhen

      public List<Enumeration<Timing.EventTiming>> getWhen()
      Returns:
      when (An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.)

    • setWhen

      public Timing.TimingRepeatComponent setWhen(List<Enumeration<Timing.EventTiming>> theWhen)
      Returns:
      Returns a reference to this for easy method chaining

    • hasWhen

      public boolean hasWhen()

    • addWhenElement

      public Enumeration<Timing.EventTiming> addWhenElement()
      Returns:
      when (An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.)

    • addWhen

      public Timing.TimingRepeatComponent addWhen(Timing.EventTiming value)
      Parameters:
      value - when (An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.)

    • hasWhen

      public boolean hasWhen(Timing.EventTiming value)
      Parameters:
      value - when (An approximate time period during the day, potentially linked to an event of daily living that indicates when the action should occur.)

    • getOffsetElement

      public UnsignedIntType getOffsetElement()
      Returns:
      offset (The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.). This is the underlying object with id, value and extensions. The accessor "getOffset" gives direct access to the value

    • hasOffsetElement

      public boolean hasOffsetElement()

    • hasOffset

      public boolean hasOffset()

    • setOffsetElement

      public Timing.TimingRepeatComponent setOffsetElement(UnsignedIntType value)
      Parameters:
      value - offset (The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.). This is the underlying object with id, value and extensions. The accessor "getOffset" gives direct access to the value

    • getOffset

      public int getOffset()
      Returns:
      The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.

    • setOffset

      public Timing.TimingRepeatComponent setOffset(int value)
      Parameters:
      value - The number of minutes from the event. If the event code does not indicate whether the minutes is before or after the event, then the offset is assumed to be after the event.

    • listChildren

      protected void listChildren(List<Property> children)
      Overrides:
      listChildren in class Element

    • getNamedProperty

      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      getNamedProperty in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • getProperty

      public Base[] getProperty(int hash, String name, boolean checkValid) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      getProperty in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • setProperty

      public Base setProperty(int hash, String name, Base value) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      setProperty in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • setProperty

      public Base setProperty(String name, Base value) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      setProperty in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • removeChild

      public void removeChild(String name, Base value) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      removeChild in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • makeProperty

      public Base makeProperty(int hash, String name) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      makeProperty in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • getTypesForProperty

      public String[] getTypesForProperty(int hash, String name) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      getTypesForProperty in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • addChild

      public Base addChild(String name) throws org.hl7.fhir.exceptions.FHIRException
      Overrides:
      addChild in class Element
      Throws:
      org.hl7.fhir.exceptions.FHIRException

    • copy

      public Timing.TimingRepeatComponent copy()
      Specified by:
      copy in class Element

    • copyValues

      public void copyValues(Timing.TimingRepeatComponent dst)

    • equalsDeep

      public boolean equalsDeep(Base other_)
      Overrides:
      equalsDeep in class Element

    • equalsShallow

      public boolean equalsShallow(Base other_)
      Overrides:
      equalsShallow in class Element

    • isEmpty

      public boolean isEmpty()
      Specified by:
      isEmpty in interface org.hl7.fhir.instance.model.api.IBase
      Overrides:
      isEmpty in class Element

    • fhirType

      public String fhirType()
      Specified by:
      fhirType in interface org.hl7.fhir.instance.model.api.IBase
      Overrides:
      fhirType in class Element