Skip to content

Conversion

FHIRPath defines both implicit and explicit conversion. Implicit conversions occur automatically, as opposed to explicit conversions that require a function in this section to be called explicitly.

ConvertsToBoolean

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToBoolean() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
class ConvertsToBoolean(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToBoolean()`](http://hl7.org/fhirpath/N1/#convertstoboolean-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is a `Boolean`
            - the item is an `Integer` that is equal to one of the possible integer representations of `Boolean` values
            - the item is a `Decimal` that is equal to one of the possible decimal representations of `Boolean` values
            - the item is a `String` that is equal to one of the possible string representations of `Boolean` values

        If the item is not one of the above types, or the item is a `String`, `Integer`, or `Decimal`, but is not equal to one of the possible values convertible to a `Boolean`, the result is false.
        If the input collection is empty, the result is empty ('[]').


        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToBoolean().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item is a Boolean - the item is an Integer that is equal to one of the possible integer representations of Boolean values - the item is a Decimal that is equal to one of the possible decimal representations of Boolean values - the item is a String that is equal to one of the possible string representations of Boolean values

If the item is not one of the above types, or the item is a String, Integer, or Decimal, but is not equal to one of the possible values convertible to a Boolean, the result is false. If the input collection is empty, the result is empty ('[]').

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is a `Boolean`
        - the item is an `Integer` that is equal to one of the possible integer representations of `Boolean` values
        - the item is a `Decimal` that is equal to one of the possible decimal representations of `Boolean` values
        - the item is a `String` that is equal to one of the possible string representations of `Boolean` values

    If the item is not one of the above types, or the item is a `String`, `Integer`, or `Decimal`, but is not equal to one of the possible values convertible to a `Boolean`, the result is false.
    If the input collection is empty, the result is empty ('[]').


    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToBoolean().evaluate(collection) != []

ConvertsToDate

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToDate() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
class ConvertsToDate(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToDate()`](http://hl7.org/fhirpath/N1/#convertstodate-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is a `Date`
            - the item is a `DateTime`
            - the item is a `String` and is convertible to a `Date`
        If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is `False`.
        If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToDate().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item is a Date - the item is a DateTime - the item is a String and is convertible to a Date If the item is not one of the above types, or is not convertible to a Date (using the format YYYY-MM-DD), the result is False. If the item contains a partial date (e.g. '2012-01'), the result is a partial date. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is a `Date`
        - the item is a `DateTime`
        - the item is a `String` and is convertible to a `Date`
    If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is `False`.
    If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToDate().evaluate(collection) != []

ConvertsToDateTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToDateTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
class ConvertsToDateTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToDateTime()`](http://hl7.org/fhirpath/N1/#convertstodatetime-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is a `DateTime`
            - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
            - the item is a `String` and is convertible to a `DateTime`
        If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
        If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is 'True'.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToDateTime().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item is a DateTime - the item is a Date, in which case the result is a DateTime with the year, month, and day of the Date, and the time components empty (not set to zero) - the item is a String and is convertible to a DateTime If the item is a String, but the string is not convertible to a DateTime (using the format YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm), the result is False. If the item contains a partial datetime (e.g. '2012-01-01T10:00'), the result is 'True'. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is a `DateTime`
        - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
        - the item is a `String` and is convertible to a `DateTime`
    If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
    If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is 'True'.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToDateTime().evaluate(collection) != []

ConvertsToDecimal

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToDecimal() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
class ConvertsToDecimal(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToDecimal()`](http://hl7.org/fhirpath/N1/#convertstodecimal-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is an `Integer` or `Decimal`
            - the item is a `String` and is convertible to a `Decimal`
            - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
        If the item is not one of the above types, or is not convertible to a `Decimal`, the result is `False`.
        If the input collection is empty, the result is empty ('[]').

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToDecimal().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item is an Integer or Decimal - the item is a String and is convertible to a Decimal - the item is a Boolean, where True results in a 1.0 and False results in a 0.0. If the item is not one of the above types, or is not convertible to a Decimal, the result is False. If the input collection is empty, the result is empty ('[]').

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is an `Integer` or `Decimal`
        - the item is a `String` and is convertible to a `Decimal`
        - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
    If the item is not one of the above types, or is not convertible to a `Decimal`, the result is `False`.
    If the input collection is empty, the result is empty ('[]').

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToDecimal().evaluate(collection) != []

ConvertsToInteger

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToInteger() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
class ConvertsToInteger(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToInteger()`](http://hl7.org/fhirpath/N1/#convertstointeger-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is an `Integer`
            - the item is a `String` and is convertible to an integer
            - the item is a `Boolean`, where `True` results in a 1 and `False` results in a 0.
        If the item is not one of the above types, or the item is a `String`, but is not convertible to an `Integer`, the result is false.
        If the input collection is empty, the result is empty ('[]').

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.

        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToInteger().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item is an Integer - the item is a String and is convertible to an integer - the item is a Boolean, where True results in a 1 and False results in a 0. If the item is not one of the above types, or the item is a String, but is not convertible to an Integer, the result is false. If the input collection is empty, the result is empty ('[]').

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is an `Integer`
        - the item is a `String` and is convertible to an integer
        - the item is a `Boolean`, where `True` results in a 1 and `False` results in a 0.
    If the item is not one of the above types, or the item is a `String`, but is not convertible to an `Integer`, the result is false.
    If the input collection is empty, the result is empty ('[]').

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.

    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToInteger().evaluate(collection) != []

ConvertsToQuantity

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToQuantity() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
class ConvertsToQuantity(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToQuantity()`](http://hl7.org/fhirpath/N1/#convertstoquantity-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
            - the item is a `Quantity`
            - the item is a `String` and is convertible to a `Quantity`
            - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
        If the item is not one of the above types, the result is `False`.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToQuantity().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item is an Integer, or Decimal, where the resulting quantity will have the default unit ('1') - the item is a Quantity - the item is a String and is convertible to a Quantity - the item is a Boolean, where true results in the quantity 1.0 '1', and false results in the quantity 0.0 '1' If the item is not one of the above types, the result is False. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
        - the item is a `Quantity`
        - the item is a `String` and is convertible to a `Quantity`
        - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
    If the item is not one of the above types, the result is `False`.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToQuantity().evaluate(collection) != []

ConvertsToString

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToString() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
class ConvertsToString(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToString()`](http://hl7.org/fhirpath/N1/#convertstostring-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item in the input collection is a `String`
            - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
            - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
        If the item is not one of the above types, the result is `False`.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToString().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item in the input collection is a String - the item in the input collection is an Integer, Decimal, Date, Time, DateTime, or Quantity the output will contain its String representation - the item is a Boolean, where true results in 'true' and false in 'false'. If the item is not one of the above types, the result is False. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item in the input collection is a `String`
        - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
        - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
    If the item is not one of the above types, the result is `False`.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToString().evaluate(collection) != []

ConvertsToTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath convertsToTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
class ConvertsToTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`convertsToTime()`](http://hl7.org/fhirpath/N1/#convertstotime-boolean) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return `True` if:
            - the item is a `Time`
            - the item is a `String` and is convertible to a `Time`
        If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
        If the item contains a partial datetime (e.g. `'10:00'`), the result is 'True'.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        return ToTime().evaluate(collection) != []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return True if: - the item is a Time - the item is a String and is convertible to a Time If the item is a String, but the string is not convertible to a DateTime (using the format hh:mm:ss.fff(+|-)hh:mm), the result is False. If the item contains a partial datetime (e.g. '10:00'), the result is 'True'. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
int

bool

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return `True` if:
        - the item is a `Time`
        - the item is a `String` and is convertible to a `Time`
    If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is `False`.
    If the item contains a partial datetime (e.g. `'10:00'`), the result is 'True'.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    return ToTime().evaluate(collection) != []

FHIRTypeConversionFunction

Bases: FHIRPathFunction

Abstract class definition for the category of type conversion FHIRPath functions.

Source code in fhircraft/fhir/path/engine/conversion.py 
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
class FHIRTypeConversionFunction(FHIRPathFunction):    
    """
    Abstract class definition for the category of type conversion FHIRPath functions. 
    """
    def validate_collection(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> List[FHIRPathCollectionItem]:
        """
        Validates the input collection of a FHIRPath type conversion function. 

        Args: 
            collection (List[FHIRPathCollectionItem]): Collection to be validated.

        Returns: 
            collection (List[FHIRPathCollectionItem]): Validated collection.

        Raises:
            FHIRPathError: If input collection has more than one item.
        """
        collection = ensure_list(collection)
        if len(collection)>1:
            raise FHIRPathError(f'FHIRPath function {self.__str__()} expected a single-item collection, instead got a {len(collection)}-items collection.')
        return collection

validate_collection(collection, *args, **kwargs)

Validates the input collection of a FHIRPath type conversion function.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

Collection to be validated.

 required

Returns:

Name Type Description
collection List[FHIRPathCollectionItem]

Validated collection.

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
def validate_collection(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> List[FHIRPathCollectionItem]:
    """
    Validates the input collection of a FHIRPath type conversion function. 

    Args: 
        collection (List[FHIRPathCollectionItem]): Collection to be validated.

    Returns: 
        collection (List[FHIRPathCollectionItem]): Validated collection.

    Raises:
        FHIRPathError: If input collection has more than one item.
    """
    collection = ensure_list(collection)
    if len(collection)>1:
        raise FHIRPathError(f'FHIRPath function {self.__str__()} expected a single-item collection, instead got a {len(collection)}-items collection.')
    return collection

Iif

Bases: FHIRPathFunction

A representation of the FHIRPath iif() function.

Parameters:

Name Type Description Default
criterion FHIRPath

The criterion expression, is expected to evaluate to a Boolean.

 required
true_result Union[FHIRPath, Any]

Value to be returned if criterion evaluates to True

 required
otherwise_result Optional[Union[FHIRPath, Any]]

Value to be returned if criterion evaluates to False. Defaults to an empty collection.

 None
Source code in fhircraft/fhir/path/engine/conversion.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
class Iif(FHIRPathFunction):
    """
    A representation of the FHIRPath [`iif()`](http://hl7.org/fhirpath/N1/#iifcriterion-expression-true-result-collection-otherwise-result-collection-collection) function.

    Args:
        criterion (FHIRPath): The criterion expression,  is expected to evaluate to a `Boolean`.
        true_result (Union[FHIRPath, Any]): Value to be returned if `criterion` evaluates to `True`
        otherwise_result (Optional[Union[FHIRPath, Any]]): Value to be returned if `criterion` evaluates to `False`. Defaults to an empty collection.
    """
    def __init__(self, criterion, true_result, otherwise_result=None):
        self.criterion = criterion 
        self.true_result = true_result 
        self.otherwise_result = otherwise_result 

    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        Thif function acts as an immediate if, also known as a conditional operator.

        If `criterion` evaluates to `True`, the function returns the value of the `true_result` argument. 
        If `true_result` is a FHIRPath expression it is evaluated.  

        If `criterion` is `False` or an empty collection, the function returns the `otherwise_result` argument,
        unless the optional `otherwise_result` is not given, in which case the function returns an empty collection.
        If `otherwise_result` is a FHIRPath expression it is evaluated.  

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.

        """ 
        collection = ensure_list(collection)
        criterion = self.criterion.evaluate(collection, **kwargs)
        if criterion:
            if isinstance(self.true_result, FHIRPath):
                return self.true_result.evaluate(collection, **kwargs)
            else:
                return self.true_result
        else:
            if self.otherwise_result:
                if isinstance(self.otherwise_result, FHIRPath):
                    return self.otherwise_result.evaluate(collection, **kwargs)
                else:
                    return self.otherwise_result
            else:
                return []

evaluate(collection, *args, **kwargs)

Thif function acts as an immediate if, also known as a conditional operator.

If criterion evaluates to True, the function returns the value of the true_result argument. If true_result is a FHIRPath expression it is evaluated.

If criterion is False or an empty collection, the function returns the otherwise_result argument, unless the optional otherwise_result is not given, in which case the function returns an empty collection. If otherwise_result is a FHIRPath expression it is evaluated.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
bool int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    Thif function acts as an immediate if, also known as a conditional operator.

    If `criterion` evaluates to `True`, the function returns the value of the `true_result` argument. 
    If `true_result` is a FHIRPath expression it is evaluated.  

    If `criterion` is `False` or an empty collection, the function returns the `otherwise_result` argument,
    unless the optional `otherwise_result` is not given, in which case the function returns an empty collection.
    If `otherwise_result` is a FHIRPath expression it is evaluated.  

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.

    """ 
    collection = ensure_list(collection)
    criterion = self.criterion.evaluate(collection, **kwargs)
    if criterion:
        if isinstance(self.true_result, FHIRPath):
            return self.true_result.evaluate(collection, **kwargs)
        else:
            return self.true_result
    else:
        if self.otherwise_result:
            if isinstance(self.otherwise_result, FHIRPath):
                return self.otherwise_result.evaluate(collection, **kwargs)
            else:
                return self.otherwise_result
        else:
            return []

ToBoolean

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toBoolean() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
class ToBoolean(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toBoolean()`](http://hl7.org/fhirpath/N1/#boolean-conversion-functions) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single `Boolean` if:
            - the item is a `Boolean`
            - the item is an `Integer` that is equal to one of the possible integer representations of `Boolean` values
            - the item is a `Decimal` that is equal to one of the possible decimal representations of `Boolean` values
            - the item is a `String` that is equal to one of the possible string representations of `Boolean` values

        If the item is not one of the above types, or the item is a `String`, `Integer`, or `Decimal`, but is not equal to one of the possible values convertible to a `Boolean`, the result is false.
        If the input collection is empty, the result is empty ('[]').

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.

        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, str):
            if value.lower() in ['true', 't', 'yes', 'y', '1', '1.0']:
                return True 
            elif value.lower() in ['false', 'f', 'no', 'n', '0', '0.0']:
                return False 
            else:
                return []
        elif isinstance(value, (int, float)):
            return bool(value) 
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single Boolean if: - the item is a Boolean - the item is an Integer that is equal to one of the possible integer representations of Boolean values - the item is a Decimal that is equal to one of the possible decimal representations of Boolean values - the item is a String that is equal to one of the possible string representations of Boolean values

If the item is not one of the above types, or the item is a String, Integer, or Decimal, but is not equal to one of the possible values convertible to a Boolean, the result is false. If the input collection is empty, the result is empty ('[]').

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
bool int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single `Boolean` if:
        - the item is a `Boolean`
        - the item is an `Integer` that is equal to one of the possible integer representations of `Boolean` values
        - the item is a `Decimal` that is equal to one of the possible decimal representations of `Boolean` values
        - the item is a `String` that is equal to one of the possible string representations of `Boolean` values

    If the item is not one of the above types, or the item is a `String`, `Integer`, or `Decimal`, but is not equal to one of the possible values convertible to a `Boolean`, the result is false.
    If the input collection is empty, the result is empty ('[]').

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.

    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, str):
        if value.lower() in ['true', 't', 'yes', 'y', '1', '1.0']:
            return True 
        elif value.lower() in ['false', 'f', 'no', 'n', '0', '0.0']:
            return False 
        else:
            return []
    elif isinstance(value, (int, float)):
        return bool(value) 
    else: 
        return []

ToDate

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toDate() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
class ToDate(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toDate()`](http://hl7.org/fhirpath/N1/#todate-date) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single date if:
            - the item is a `Date`
            - the item is a `DateTime`
            - the item is a `String` and is convertible to a `Date`
        If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is empty.
        If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            str: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, str):
            date_match = re.match(fr'^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$', value)
            datetime_match = re.match(fr'^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?', value)
            if date_match:
                return value
            elif datetime_match:
                return datetime_match.group(1)
            else:
                return []
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single date if: - the item is a Date - the item is a DateTime - the item is a String and is convertible to a Date If the item is not one of the above types, or is not convertible to a Date (using the format YYYY-MM-DD), the result is empty. If the item contains a partial date (e.g. '2012-01'), the result is a partial date. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
str int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single date if:
        - the item is a `Date`
        - the item is a `DateTime`
        - the item is a `String` and is convertible to a `Date`
    If the item is not one of the above types, or is not convertible to a `Date` (using the format `YYYY-MM-DD`), the result is empty.
    If the item contains a partial date (e.g. `'2012-01'`), the result is a partial date.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        str: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, str):
        date_match = re.match(fr'^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$', value)
        datetime_match = re.match(fr'^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?', value)
        if date_match:
            return value
        elif datetime_match:
            return datetime_match.group(1)
        else:
            return []
    else: 
        return []

ToDateTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toDateTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
class ToDateTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toDateTime()`](http://hl7.org/fhirpath/N1/#todatetime-datetime) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single datetime if:
            - the item is a `DateTime`
            - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
            - the item is a `String` and is convertible to a `DateTime`
        If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is empty.
        If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is a partial datetime.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            str: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, str):
            date_match = re.match(fr'^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$', value)
            datetime_match = re.match(fr'^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?', value)
            if date_match or datetime_match:
                return value
            else:
                return []
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single datetime if: - the item is a DateTime - the item is a Date, in which case the result is a DateTime with the year, month, and day of the Date, and the time components empty (not set to zero) - the item is a String and is convertible to a DateTime If the item is a String, but the string is not convertible to a DateTime (using the format YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm), the result is empty. If the item contains a partial datetime (e.g. '2012-01-01T10:00'), the result is a partial datetime. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
str int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single datetime if:
        - the item is a `DateTime`
        - the item is a `Date`, in which case the result is a `DateTime` with the year, month, and day of the `Date`, and the time components empty (not set to zero)
        - the item is a `String` and is convertible to a `DateTime`
    If the item is a `String`, but the string is not convertible to a `DateTime` (using the format `YYYY-MM-DDThh:mm:ss.fff(+|-)hh:mm`), the result is empty.
    If the item contains a partial datetime (e.g. `'2012-01-01T10:00'`), the result is a partial datetime.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        str: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, str):
        date_match = re.match(fr'^{primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?$', value)
        datetime_match = re.match(fr'^({primitives.YEAR_REGEX}(-{primitives.MONTH_REGEX}(-{primitives.DAY_REGEX})?)?)(T{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?)?', value)
        if date_match or datetime_match:
            return value
        else:
            return []
    else: 
        return []

ToDecimal

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toDecimal() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
class ToDecimal(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toDecimal()`](http://hl7.org/fhirpath/N1/#todecimal-decimal) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single decimal if:
            - the item is an `Integer` or `Decimal`
            - the item is a `String` and is convertible to a `Decimal`
            - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
        If the item is not one of the above types, the result is empty (`[]`).
        If the item is a `String`, but the string is not convertible to a `Decimal`, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            float: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, (int, float, bool)):
            return float(value) 
        elif isinstance(value, str):
            if re.match(r"(\\+|-)?\d+(\.\d+)?", value):
                return float(value)
            else:
                return []
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single decimal if: - the item is an Integer or Decimal - the item is a String and is convertible to a Decimal - the item is a Boolean, where True results in a 1.0 and False results in a 0.0. If the item is not one of the above types, the result is empty ([]). If the item is a String, but the string is not convertible to a Decimal, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
float int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single decimal if:
        - the item is an `Integer` or `Decimal`
        - the item is a `String` and is convertible to a `Decimal`
        - the item is a `Boolean`, where `True` results in a `1.0` and `False` results in a `0.0`.
    If the item is not one of the above types, the result is empty (`[]`).
    If the item is a `String`, but the string is not convertible to a `Decimal`, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        float: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, (int, float, bool)):
        return float(value) 
    elif isinstance(value, str):
        if re.match(r"(\\+|-)?\d+(\.\d+)?", value):
            return float(value)
        else:
            return []
    else: 
        return []

ToInteger

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toInteger() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
class ToInteger(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toInteger()`](http://hl7.org/fhirpath/N1/#tointeger-integer) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single `Integer` if:
            - the item is an `Integer`
            - the item is a `String` and is convertible to an integer
            - the item is a `Boolean`, where `True` results in a 1 and `False` results in a 0.
        If the item is not one the above types, the result is empty (`[]`).

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            int: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, (int, bool)):
            return int(value) 
        elif isinstance(value, str):
            if re.match(r"[+-]?\d", value):
                return int(value)
            else:
                return []
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single Integer if: - the item is an Integer - the item is a String and is convertible to an integer - the item is a Boolean, where True results in a 1 and False results in a 0. If the item is not one the above types, the result is empty ([]).

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
int int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single `Integer` if:
        - the item is an `Integer`
        - the item is a `String` and is convertible to an integer
        - the item is a `Boolean`, where `True` results in a 1 and `False` results in a 0.
    If the item is not one the above types, the result is empty (`[]`).

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        int: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, (int, bool)):
        return int(value) 
    elif isinstance(value, str):
        if re.match(r"[+-]?\d", value):
            return int(value)
        else:
            return []
    else: 
        return []

ToQuantity

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toQuantity() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
class ToQuantity(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toQuantity()`](http://hl7.org/fhirpath/N1/#toquantity-string) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single quantity if:
            - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
            - the item is a `Quantity`
            - the item is a `String` and is convertible to a `Quantity`
            - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
        If the item is not one of the above types, the result is empty.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            Quantity: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        Quantity = get_complex_FHIR_type('Quantity')
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, (bool, int, float)):
            return Quantity(value=float(value), unit='1')
        elif isinstance(value, str):
            quantity_match = re.match(r"((\+|-)?\d+(\.\d+)?)\s*(('([^']+)'|([a-zA-Z]+))?)", value)
            if quantity_match:
                return Quantity(value=quantity_match.group(1), unit=quantity_match.group(4))
            else:
                return []
        elif isinstance(value, Quantity):
            return value
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single quantity if: - the item is an Integer, or Decimal, where the resulting quantity will have the default unit ('1') - the item is a Quantity - the item is a String and is convertible to a Quantity - the item is a Boolean, where true results in the quantity 1.0 '1', and false results in the quantity 0.0 '1' If the item is not one of the above types, the result is empty. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
Quantity int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single quantity if:
        - the item is an `Integer`, or `Decimal`, where the resulting quantity will have the default unit (`'1'`)
        - the item is a `Quantity`
        - the item is a `String` and is convertible to a `Quantity`
        - the item is a `Boolean`, where true results in the quantity `1.0 '1'`, and false results in the quantity `0.0 '1'`
    If the item is not one of the above types, the result is empty.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        Quantity: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    Quantity = get_complex_FHIR_type('Quantity')
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, (bool, int, float)):
        return Quantity(value=float(value), unit='1')
    elif isinstance(value, str):
        quantity_match = re.match(r"((\+|-)?\d+(\.\d+)?)\s*(('([^']+)'|([a-zA-Z]+))?)", value)
        if quantity_match:
            return Quantity(value=quantity_match.group(1), unit=quantity_match.group(4))
        else:
            return []
    elif isinstance(value, Quantity):
        return value
    else: 
        return []

ToString

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toString() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
class ToString(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toString()`](http://hl7.org/fhirpath/N1/#tostring-string) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single string if:
            - the item in the input collection is a `String`
            - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
            - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
        If the item is not one of the above types, the result is empty.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            str: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, bool):
            return 'true' if value else 'false'
        elif isinstance(value, (str, int, float)):
            return str(value)
        elif isinstance(value, get_complex_FHIR_type('Quantity')):
            return f'{value.value} {value.unit}'
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single string if: - the item in the input collection is a String - the item in the input collection is an Integer, Decimal, Date, Time, DateTime, or Quantity the output will contain its String representation - the item is a Boolean, where true results in 'true' and false in 'false'. If the item is not one of the above types, the result is empty. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
str int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single string if:
        - the item in the input collection is a `String`
        - the item in the input collection is an `Integer`, `Decimal`, `Date`, `Time`, `DateTime`, or `Quantity` the output will contain its `String` representation
        - the item is a `Boolean`, where true results in `'true'` and false in `'false'`.
    If the item is not one of the above types, the result is empty.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        str: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, bool):
        return 'true' if value else 'false'
    elif isinstance(value, (str, int, float)):
        return str(value)
    elif isinstance(value, get_complex_FHIR_type('Quantity')):
        return f'{value.value} {value.unit}'
    else: 
        return []

ToTime

Bases: FHIRTypeConversionFunction

A representation of the FHIRPath toTime() function.

Source code in fhircraft/fhir/path/engine/conversion.py 
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
class ToTime(FHIRTypeConversionFunction):
    """
    A representation of the FHIRPath [`toTime()`](http://hl7.org/fhirpath/N1/#totime-time) function.
    """
    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
        """
        If the input collection contains a single item, this function will return a single time if:
            - the item is a `Time`
            - the item is a `String` and is convertible to a `Time`
        If the item is a `String`, but the string is not convertible to a `Time` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is empty.
        If the item contains a partial datetime (e.g. `'10:00'`), the result is a partial datetime.
        If the input collection is empty, the result is empty.

        Args: 
            collection (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            str: Converted value

        Raises:
            FHIRPathError: If input collection has more than one item.
        """ 
        collection = super().validate_collection(collection)
        if not collection:
            return []
        value = collection[0].value
        if isinstance(value, str):
            time_match = re.match(fr'^{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?', value)
            if time_match:
                return value
            else:
                return []
        else: 
            return []

evaluate(collection, *args, **kwargs)

If the input collection contains a single item, this function will return a single time if: - the item is a Time - the item is a String and is convertible to a Time If the item is a String, but the string is not convertible to a Time (using the format hh:mm:ss.fff(+|-)hh:mm), the result is empty. If the item contains a partial datetime (e.g. '10:00'), the result is a partial datetime. If the input collection is empty, the result is empty.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Name Type Description
str int

Converted value

Raises:

Type Description
FHIRPathError

If input collection has more than one item.
Source code in fhircraft/fhir/path/engine/conversion.py 
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> int:
    """
    If the input collection contains a single item, this function will return a single time if:
        - the item is a `Time`
        - the item is a `String` and is convertible to a `Time`
    If the item is a `String`, but the string is not convertible to a `Time` (using the format `hh:mm:ss.fff(+|-)hh:mm`), the result is empty.
    If the item contains a partial datetime (e.g. `'10:00'`), the result is a partial datetime.
    If the input collection is empty, the result is empty.

    Args: 
        collection (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        str: Converted value

    Raises:
        FHIRPathError: If input collection has more than one item.
    """ 
    collection = super().validate_collection(collection)
    if not collection:
        return []
    value = collection[0].value
    if isinstance(value, str):
        time_match = re.match(fr'^{primitives.HOUR_REGEX}(:{primitives.MINUTES_REGEX}(:{primitives.SECONDS_REGEX}({primitives.TIMEZONE_REGEX})?)?)?', value)
        if time_match:
            return value
        else:
            return []
    else: 
        return []