Timing.TimingRepeatComponent (org.hl7.fhir.r4 5.4.0 API)

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:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`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.
`protected PositiveIntType`	`count` A total count of the desired number of repetitions across the duration of the entire timing specification.
`protected PositiveIntType`	`countMax` If present, indicates that the count is a range - so to perform the action between [count] and [countMax] times.
`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).
`protected DecimalType`	`duration` How long this thing happens for when it happens.
`protected DecimalType`	`durationMax` If present, indicates that the duration is a range - so to perform the action between [duration] and [durationMax] time length.
`protected Enumeration<Timing.UnitsOfTime>`	`durationUnit` The units of time for the duration, in UCUM units.
`protected PositiveIntType`	`frequency` The number of times to repeat the action within the specified period.
`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.
`protected UnsignedIntType`	`offset` The number of minutes from the event.
`protected DecimalType`	`period` Indicates the duration of time over which repetitions are to occur; e.g.
`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.
`protected Enumeration<Timing.UnitsOfTime>`	`periodUnit` The units of time for the period in UCUM units.
`protected List<TimeType>`	`timeOfDay` Specified time of day for action to take place.
`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.

Fields inherited from class org.hl7.fhir.r4.model.Element
extension, id

Constructor Summary

Constructors
Constructor and Description

TimingRepeatComponent()
Constructor

Constructors
Constructor and Description
`TimingRepeatComponent()` Constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Base`	`addChild(String name)`
`Timing.TimingRepeatComponent`	`addDayOfWeek(Timing.DayOfWeek value)`
`Enumeration<Timing.DayOfWeek>`	`addDayOfWeekElement()`
`Timing.TimingRepeatComponent`	`addTimeOfDay(String value)`
`TimeType`	`addTimeOfDayElement()`
`Timing.TimingRepeatComponent`	`addWhen(Timing.EventTiming value)`
`Enumeration<Timing.EventTiming>`	`addWhenElement()`
`Timing.TimingRepeatComponent`	`copy()`
`void`	`copyValues(Timing.TimingRepeatComponent dst)`
`boolean`	`equalsDeep(Base other_)`
`boolean`	`equalsShallow(Base other_)`
`String`	`fhirType()`
`Type`	`getBounds()`
`Duration`	`getBoundsDuration()`
`Period`	`getBoundsPeriod()`
`Range`	`getBoundsRange()`
`int`	`getCount()`
`PositiveIntType`	`getCountElement()`
`int`	`getCountMax()`
`PositiveIntType`	`getCountMaxElement()`
`List<Enumeration<Timing.DayOfWeek>>`	`getDayOfWeek()`
`BigDecimal`	`getDuration()`
`DecimalType`	`getDurationElement()`
`BigDecimal`	`getDurationMax()`
`DecimalType`	`getDurationMaxElement()`
`Timing.UnitsOfTime`	`getDurationUnit()`
`Enumeration<Timing.UnitsOfTime>`	`getDurationUnitElement()`
`int`	`getFrequency()`
`PositiveIntType`	`getFrequencyElement()`
`int`	`getFrequencyMax()`
`PositiveIntType`	`getFrequencyMaxElement()`
`Property`	`getNamedProperty(int _hash, String _name, boolean _checkValid)`
`int`	`getOffset()`
`UnsignedIntType`	`getOffsetElement()`
`BigDecimal`	`getPeriod()`
`DecimalType`	`getPeriodElement()`
`BigDecimal`	`getPeriodMax()`
`DecimalType`	`getPeriodMaxElement()`
`Timing.UnitsOfTime`	`getPeriodUnit()`
`Enumeration<Timing.UnitsOfTime>`	`getPeriodUnitElement()`
`Base[]`	`getProperty(int hash, String name, boolean checkValid)`
`List<TimeType>`	`getTimeOfDay()`
`String[]`	`getTypesForProperty(int hash, String name)`
`List<Enumeration<Timing.EventTiming>>`	`getWhen()`
`boolean`	`hasBounds()`
`boolean`	`hasBoundsDuration()`
`boolean`	`hasBoundsPeriod()`
`boolean`	`hasBoundsRange()`
`boolean`	`hasCount()`
`boolean`	`hasCountElement()`
`boolean`	`hasCountMax()`
`boolean`	`hasCountMaxElement()`
`boolean`	`hasDayOfWeek()`
`boolean`	`hasDayOfWeek(Timing.DayOfWeek value)`
`boolean`	`hasDuration()`
`boolean`	`hasDurationElement()`
`boolean`	`hasDurationMax()`
`boolean`	`hasDurationMaxElement()`
`boolean`	`hasDurationUnit()`
`boolean`	`hasDurationUnitElement()`
`boolean`	`hasFrequency()`
`boolean`	`hasFrequencyElement()`
`boolean`	`hasFrequencyMax()`
`boolean`	`hasFrequencyMaxElement()`
`boolean`	`hasOffset()`
`boolean`	`hasOffsetElement()`
`boolean`	`hasPeriod()`
`boolean`	`hasPeriodElement()`
`boolean`	`hasPeriodMax()`
`boolean`	`hasPeriodMaxElement()`
`boolean`	`hasPeriodUnit()`
`boolean`	`hasPeriodUnitElement()`
`boolean`	`hasTimeOfDay()`
`boolean`	`hasTimeOfDay(String value)`
`boolean`	`hasWhen()`
`boolean`	`hasWhen(Timing.EventTiming value)`
`boolean`	`isEmpty()`
`protected void`	`listChildren(List<Property> children)`
`Base`	`makeProperty(int hash, String name)`
`Timing.TimingRepeatComponent`	`setBounds(Type value)`
`Timing.TimingRepeatComponent`	`setCount(int value)`
`Timing.TimingRepeatComponent`	`setCountElement(PositiveIntType value)`
`Timing.TimingRepeatComponent`	`setCountMax(int value)`
`Timing.TimingRepeatComponent`	`setCountMaxElement(PositiveIntType value)`
`Timing.TimingRepeatComponent`	`setDayOfWeek(List<Enumeration<Timing.DayOfWeek>> theDayOfWeek)`
`Timing.TimingRepeatComponent`	`setDuration(BigDecimal value)`
`Timing.TimingRepeatComponent`	`setDuration(double value)`
`Timing.TimingRepeatComponent`	`setDuration(long value)`
`Timing.TimingRepeatComponent`	`setDurationElement(DecimalType value)`
`Timing.TimingRepeatComponent`	`setDurationMax(BigDecimal value)`
`Timing.TimingRepeatComponent`	`setDurationMax(double value)`
`Timing.TimingRepeatComponent`	`setDurationMax(long value)`
`Timing.TimingRepeatComponent`	`setDurationMaxElement(DecimalType value)`
`Timing.TimingRepeatComponent`	`setDurationUnit(Timing.UnitsOfTime value)`
`Timing.TimingRepeatComponent`	`setDurationUnitElement(Enumeration<Timing.UnitsOfTime> value)`
`Timing.TimingRepeatComponent`	`setFrequency(int value)`
`Timing.TimingRepeatComponent`	`setFrequencyElement(PositiveIntType value)`
`Timing.TimingRepeatComponent`	`setFrequencyMax(int value)`
`Timing.TimingRepeatComponent`	`setFrequencyMaxElement(PositiveIntType value)`
`Timing.TimingRepeatComponent`	`setOffset(int value)`
`Timing.TimingRepeatComponent`	`setOffsetElement(UnsignedIntType value)`
`Timing.TimingRepeatComponent`	`setPeriod(BigDecimal value)`
`Timing.TimingRepeatComponent`	`setPeriod(double value)`
`Timing.TimingRepeatComponent`	`setPeriod(long value)`
`Timing.TimingRepeatComponent`	`setPeriodElement(DecimalType value)`
`Timing.TimingRepeatComponent`	`setPeriodMax(BigDecimal value)`
`Timing.TimingRepeatComponent`	`setPeriodMax(double value)`
`Timing.TimingRepeatComponent`	`setPeriodMax(long value)`
`Timing.TimingRepeatComponent`	`setPeriodMaxElement(DecimalType value)`
`Timing.TimingRepeatComponent`	`setPeriodUnit(Timing.UnitsOfTime value)`
`Timing.TimingRepeatComponent`	`setPeriodUnitElement(Enumeration<Timing.UnitsOfTime> value)`
`Base`	`setProperty(int hash, String name, Base value)`
`Base`	`setProperty(String name, Base value)`
`Timing.TimingRepeatComponent`	`setTimeOfDay(List<TimeType> theTimeOfDay)`
`Timing.TimingRepeatComponent`	`setWhen(List<Enumeration<Timing.EventTiming>> theWhen)`

Methods inherited from class org.hl7.fhir.r4.model.Element
addExtension, addExtension, addExtension, copyValues, getExtension, getExtensionByUrl, getExtensionFirstRep, getExtensionsByUrl, getExtensionString, getId, getIdBase, getIdElement, hasExtension, hasExtension, hasId, hasIdElement, isDisallowExtensions, noExtensions, removeExtension, setDisallowExtensions, setExtension, setId, setIdBase, setIdElement

Methods inherited from class org.hl7.fhir.r4.model.Base
castToAddress, castToAnnotation, castToAttachment, castToBase64Binary, castToBoolean, castToCanonical, castToCode, castToCodeableConcept, castToCoding, castToContactDetail, castToContactPoint, castToContributor, castToDataRequirement, castToDate, castToDateTime, castToDecimal, castToDosage, castToDuration, castToElementDefinition, castToExpression, castToExtension, castToHumanName, castToId, castToIdentifier, castToInstant, castToInteger, castToMarkdown, castToMarketingStatus, castToMeta, castToMoney, castToNarrative, castToOid, castToParameterDefinition, castToPeriod, castToPopulation, castToPositiveInt, castToProdCharacteristic, castToProductShelfLife, castToQuantity, castToRange, castToRatio, castToReference, castToRelatedArtifact, castToResource, castToSampledData, castToSignature, castToSimpleQuantity, castToString, castToSubstanceAmount, castToTime, castToTiming, castToTriggerDefinition, castToType, castToUnsignedInt, castToUri, castToUrl, castToUsageContext, castToXhtml, castToXhtmlString, children, clearUserData, compareDeep, compareDeep, compareDeep, compareDeep, compareValues, compareValues, dateTimeValue, equals, getChildByName, getFormatCommentsPost, getFormatCommentsPre, getNamedProperty, getUserData, getUserInt, getUserString, hasFormatComment, hasPrimitiveValue, hasType, hasUserData, isBooleanPrimitive, isDateTime, isMetadataBased, isPrimitive, isResource, listChildrenByName, listChildrenByName, primitiveValue, setUserData, setUserDataINN

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.hl7.fhir.instance.model.api.IBase
getFormatCommentsPost, getFormatCommentsPre, getUserData, hasFormatComment, setUserData

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseElement
getUserData, setUserData

- Field Detail
  - 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 Detail
  - TimingRepeatComponent
```
public TimingRepeatComponent()
```
    Constructor
- Method Detail
  - 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
  - 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

Class Timing.TimingRepeatComponent

Field Summary

Fields inherited from class org.hl7.fhir.r4.model.Element

Constructor Summary

Method Summary

Methods inherited from class org.hl7.fhir.r4.model.Element

Methods inherited from class org.hl7.fhir.r4.model.Base

Methods inherited from class java.lang.Object

Methods inherited from interface org.hl7.fhir.instance.model.api.IBase

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseElement

Field Detail

bounds

count

countMax

duration

durationMax

durationUnit

frequency

frequencyMax

period

periodMax

periodUnit

dayOfWeek

timeOfDay

when

offset

Constructor Detail

TimingRepeatComponent

Method Detail

getBounds

getBoundsDuration

hasBoundsDuration

getBoundsRange

hasBoundsRange

getBoundsPeriod

hasBoundsPeriod

hasBounds

setBounds

getCountElement

hasCountElement

hasCount

setCountElement

getCount

setCount

getCountMaxElement

hasCountMaxElement

hasCountMax

setCountMaxElement

getCountMax

setCountMax

getDurationElement

hasDurationElement

hasDuration

setDurationElement

getDuration

setDuration

setDuration

setDuration

getDurationMaxElement

hasDurationMaxElement

hasDurationMax

setDurationMaxElement

getDurationMax

setDurationMax

setDurationMax

setDurationMax

getDurationUnitElement

hasDurationUnitElement

hasDurationUnit

setDurationUnitElement

getDurationUnit

setDurationUnit

getFrequencyElement

hasFrequencyElement

hasFrequency

setFrequencyElement

getFrequency

setFrequency

getFrequencyMaxElement

hasFrequencyMaxElement