Skip to content

Existence

The filtering module contains the object representations of the existence-category FHIRPath functions.

All

Bases: FHIRPathFunction

Representation of the FHIRPath all() function.

Attributes:

Name Type Description
criteria FHIRPath

Criteria to be applied to the collection prior to the evalution.
Source code in fhircraft/fhir/path/engine/existence.py 
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 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
class All(FHIRPathFunction):
    """
    Representation of the FHIRPath [`all()`](https://hl7.org/fhirpath/N1/#allcriteria-expression-boolean) function.

    Attributes:
        criteria (FHIRPath): Criteria to be applied to the collection prior to the evalution.
    """

    def __init__(self, criteria: FHIRPath | FHIRPathCollection):
        self.criteria = criteria

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if for every element in the input collection, criteria evaluates to `True`.
        Otherwise, the result is `False`. If the input collection is empty (`{}`), the result is `True`.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        if len(collection) == 0:
            return [FHIRPathCollectionItem.wrap(True)]
        return [
            FHIRPathCollectionItem.wrap(
                all(
                    [
                        (
                            self.criteria.evaluate([item], create=False)
                            if isinstance(self.criteria, FHIRPath)
                            else item.value == self.criteria
                        )
                        for item in collection
                    ]
                )
            )
        ]

    def __str__(self):
        return f"{self.__class__.__name__.lower()}({self.criteria.__str__()})"

    def __repr__(self):
        return f"{self.__class__.__name__}({self.criteria.__repr__()})"

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.criteria == other.criteria

evaluate(collection, create=False)

Returns True if for every element in the input collection, criteria evaluates to True. Otherwise, the result is False. If the input collection is empty ({}), the result is True.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
 88
 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
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if for every element in the input collection, criteria evaluates to `True`.
    Otherwise, the result is `False`. If the input collection is empty (`{}`), the result is `True`.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    if len(collection) == 0:
        return [FHIRPathCollectionItem.wrap(True)]
    return [
        FHIRPathCollectionItem.wrap(
            all(
                [
                    (
                        self.criteria.evaluate([item], create=False)
                        if isinstance(self.criteria, FHIRPath)
                        else item.value == self.criteria
                    )
                    for item in collection
                ]
            )
        )
    ]

AllFalse

Bases: FHIRPathFunction

Representation of the FHIRPath allFalse() function.

Source code in fhircraft/fhir/path/engine/existence.py 
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
class AllFalse(FHIRPathFunction):
    """
    Representation of the FHIRPath [`allFalse()`](https://hl7.org/fhirpath/N1/#allfalse-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Takes a collection of Boolean values and returns `True` if all the items are `False`.
        If any items are `True`, the result is `False`. If the input is empty (`{}`), the result is `True`.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return _all_or_any_boolean(collection, all, False)

evaluate(collection, create=False)

Takes a collection of Boolean values and returns True if all the items are False. If any items are True, the result is False. If the input is empty ({}), the result is True.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
193
194
195
196
197
198
199
200
201
202
203
204
205
206
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Takes a collection of Boolean values and returns `True` if all the items are `False`.
    If any items are `True`, the result is `False`. If the input is empty (`{}`), the result is `True`.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return _all_or_any_boolean(collection, all, False)

AllTrue

Bases: FHIRPathFunction

Representation of the FHIRPath allTrue() function.

Source code in fhircraft/fhir/path/engine/existence.py 
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
class AllTrue(FHIRPathFunction):
    """
    Representation of the FHIRPath [`allTrue()`](https://hl7.org/fhirpath/N1/#alltrue-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Takes a collection of Boolean values and returns `True` if all the items are `True`. If any
        items are `False`, the result is `False`. If the input is empty (`{}`), the result is `True`.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return _all_or_any_boolean(collection, all, True)

evaluate(collection, create=False)

Takes a collection of Boolean values and returns True if all the items are True. If any items are False, the result is False. If the input is empty ({}), the result is True.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
151
152
153
154
155
156
157
158
159
160
161
162
163
164
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Takes a collection of Boolean values and returns `True` if all the items are `True`. If any
    items are `False`, the result is `False`. If the input is empty (`{}`), the result is `True`.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return _all_or_any_boolean(collection, all, True)

AnyFalse

Bases: FHIRPathFunction

Representation of the FHIRPath anyFalse() function.

Source code in fhircraft/fhir/path/engine/existence.py 
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
class AnyFalse(FHIRPathFunction):
    """
    Representation of the FHIRPath [`anyFalse()`](https://hl7.org/fhirpath/N1/#anyfalse-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Takes a collection of Boolean values and returns `True` if any of the items are `False`. If all
        the items are `True`, or if the input is empty (`{}`), the result is `False`.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return _all_or_any_boolean(collection, any, False)

evaluate(collection, create=False)

Takes a collection of Boolean values and returns True if any of the items are False. If all the items are True, or if the input is empty ({}), the result is False.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
214
215
216
217
218
219
220
221
222
223
224
225
226
227
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Takes a collection of Boolean values and returns `True` if any of the items are `False`. If all
    the items are `True`, or if the input is empty (`{}`), the result is `False`.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return _all_or_any_boolean(collection, any, False)

AnyTrue

Bases: FHIRPathFunction

Representation of the FHIRPath anyTrue() function.

Source code in fhircraft/fhir/path/engine/existence.py 
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
class AnyTrue(FHIRPathFunction):
    """
    Representation of the FHIRPath [`anyTrue()`](https://hl7.org/fhirpath/N1/#anytrue-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Takes a collection of Boolean values and returns `True` if any of the items are `True`.
        If all the items are `False`, or if the input is empty (`{}`), the result is `False`.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return _all_or_any_boolean(collection, any, True)

evaluate(collection, create=False)

Takes a collection of Boolean values and returns True if any of the items are True. If all the items are False, or if the input is empty ({}), the result is False.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
172
173
174
175
176
177
178
179
180
181
182
183
184
185
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Takes a collection of Boolean values and returns `True` if any of the items are `True`.
    If all the items are `False`, or if the input is empty (`{}`), the result is `False`.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return _all_or_any_boolean(collection, any, True)

Count

Bases: FHIRPathFunction

Representation of the FHIRPath count() function.

Source code in fhircraft/fhir/path/engine/existence.py 
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
class Count(FHIRPathFunction):
    """
    Representation of the FHIRPath [`count()`](https://hl7.org/fhirpath/N1/#count-integer) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns the integer count of the number of items in the input collection. Returns 0 when the input collection is empty.


        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return [FHIRPathCollectionItem.wrap(len(collection))]

evaluate(collection, create=False)

Returns the integer count of the number of items in the input collection. Returns 0 when the input collection is empty.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
343
344
345
346
347
348
349
350
351
352
353
354
355
356
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns the integer count of the number of items in the input collection. Returns 0 when the input collection is empty.


    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return [FHIRPathCollectionItem.wrap(len(collection))]

Distinct

Bases: FHIRPathFunction

Representation of the FHIRPath distinct() function.

Source code in fhircraft/fhir/path/engine/existence.py 
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
class Distinct(FHIRPathFunction):
    """
    Representation of the FHIRPath [`distinct()`](https://hl7.org/fhirpath/N1/#distinct-collection) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns a collection containing only the unique items in the input collection. If the input collection is empty (`[]`), the result is empty.
        Note that the order of elements in the input collection is not guaranteed to be preserved in the result.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return list(set(collection))

evaluate(collection, create=False)

Returns a collection containing only the unique items in the input collection. If the input collection is empty ([]), the result is empty. Note that the order of elements in the input collection is not guaranteed to be preserved in the result.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
364
365
366
367
368
369
370
371
372
373
374
375
376
377
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns a collection containing only the unique items in the input collection. If the input collection is empty (`[]`), the result is empty.
    Note that the order of elements in the input collection is not guaranteed to be preserved in the result.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return list(set(collection))

Empty

Bases: FHIRPathFunction

Representation of the FHIRPath empty() function.

Source code in fhircraft/fhir/path/engine/existence.py 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Empty(FHIRPathFunction):
    """
    Representation of the FHIRPath [`empty()`](http://hl7.org/fhirpath/N1/#empty-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if the input collection is empty (`{}`) and `False` otherwise.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return [FHIRPathCollectionItem.wrap(len(collection) == 0)]

evaluate(collection, create=False)

Returns True if the input collection is empty ({}) and False otherwise.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
20
21
22
23
24
25
26
27
28
29
30
31
32
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if the input collection is empty (`{}`) and `False` otherwise.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return [FHIRPathCollectionItem.wrap(len(collection) == 0)]

Exists

Bases: FHIRPathFunction

Representation of the FHIRPath exists() function.

Attributes:

Name Type Description
criteria FHIRPath

Optional criteria to be applied to the collection prior to the determination of the exists
Source code in fhircraft/fhir/path/engine/existence.py 
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
65
66
67
68
69
70
71
72
73
74
class Exists(FHIRPathFunction):
    """
    Representation of the FHIRPath [`exists()`](http://hl7.org/fhirpath/N1/#existscriteria-expression-boolean) function.

    Attributes:
        criteria (FHIRPath): Optional criteria to be applied to the collection prior to the determination of the exists
    """

    def __init__(self, criteria: FHIRPath | None = None):
        self.criteria = criteria

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if the collection has any elements, and `False` otherwise.
        This is the opposite of empty(), and as such is a shorthand for empty().not().
        If the input collection is empty (`{}`), the result is `False`.
        The function can also take an optional criteria to be applied to the collection
        prior to the determination of the exists. In this case, the function is
        shorthand for where(criteria).exists().

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        if self.criteria:
            collection = Where(self.criteria).evaluate(collection, create=create)
        return [FHIRPathCollectionItem.wrap(len(collection) > 0)]

    def __str__(self):
        return f'{self.__class__.__name__.lower()}({self.criteria.__str__() if self.criteria else ""})'

    def __repr__(self):
        return f'{self.__class__.__name__}({self.criteria.__repr__() if self.criteria else ""})'

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.criteria == other.criteria

evaluate(collection, create=False)

Returns True if the collection has any elements, and False otherwise. This is the opposite of empty(), and as such is a shorthand for empty().not(). If the input collection is empty ({}), the result is False. The function can also take an optional criteria to be applied to the collection prior to the determination of the exists. In this case, the function is shorthand for where(criteria).exists().

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if the collection has any elements, and `False` otherwise.
    This is the opposite of empty(), and as such is a shorthand for empty().not().
    If the input collection is empty (`{}`), the result is `False`.
    The function can also take an optional criteria to be applied to the collection
    prior to the determination of the exists. In this case, the function is
    shorthand for where(criteria).exists().

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    if self.criteria:
        collection = Where(self.criteria).evaluate(collection, create=create)
    return [FHIRPathCollectionItem.wrap(len(collection) > 0)]

IsDistinct

Bases: FHIRPathFunction

Representation of the FHIRPath isDistinct() function.

Source code in fhircraft/fhir/path/engine/existence.py 
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
class IsDistinct(FHIRPathFunction):
    """
    Representation of the FHIRPath [`isDistinct()`](https://hl7.org/fhirpath/N1/#isdistinct-boolean) function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if all the items in the input collection are distinct.
        If the input collection is empty (`[]`), the result is `True`.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection
        """
        return [
            FHIRPathCollectionItem.wrap(len(list(set(collection))) == len(collection))
        ]

evaluate(collection, create=False)

Returns True if all the items in the input collection are distinct. If the input collection is empty ([]), the result is True.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Source code in fhircraft/fhir/path/engine/existence.py 
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if all the items in the input collection are distinct.
    If the input collection is empty (`[]`), the result is `True`.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection
    """
    return [
        FHIRPathCollectionItem.wrap(len(list(set(collection))) == len(collection))
    ]

SubsetOf

Bases: FHIRPathFunction

Representation of the FHIRPath subsetOf() function.

Attributes:

Name Type Description
other Union[FHIRPathCollection, FHIRPath]

other collection to which to determine whether input is a subset of.
Source code in fhircraft/fhir/path/engine/existence.py 
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
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
class SubsetOf(FHIRPathFunction):
    """
    Representation of the FHIRPath [`subsetOf()`](https://hl7.org/fhirpath/N1/#subsetofother-collection-boolean) function.

    Attributes:
        other (Union[FHIRPathCollection, FHIRPath]): other collection to which to determine whether input is a subset of.
    """

    def __init__(self, other: FHIRPathCollection | FHIRPath):
        self.other = other

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if all items in the input collection are members of the collection passed as the
        other argument.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection

        Note:
            Conceptually, this function is evaluated by testing each element in the input collection for
            membership in the other collection, with a default of `True`. This means that if the input collection
            is empty (`[]`), the result is `True`, otherwise if the other collection is empty, the result is `False`.
        """
        if len(collection) == 0:
            return [FHIRPathCollectionItem.wrap(True)]
        other_collection = (
            self.other.evaluate(collection, create=create)
            if isinstance(self.other, FHIRPath)
            else self.other
        )
        if len(other_collection) == 0:
            return [FHIRPathCollectionItem.wrap(False)]
        for item in collection:
            if item not in other_collection:
                return [FHIRPathCollectionItem.wrap(False)]
        else:
            return [FHIRPathCollectionItem.wrap(True)]

    def __str__(self):
        return f"{self.__class__.__name__.lower()}({self.other.__str__()})"

    def __repr__(self):
        return f"{self.__class__.__name__}({self.other.__repr__()})"

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.other == other.other

evaluate(collection, create=False)

Returns True if all items in the input collection are members of the collection passed as the other argument.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Note

Conceptually, this function is evaluated by testing each element in the input collection for membership in the other collection, with a default of True. This means that if the input collection is empty ([]), the result is True, otherwise if the other collection is empty, the result is False.

Source code in fhircraft/fhir/path/engine/existence.py 
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if all items in the input collection are members of the collection passed as the
    other argument.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection

    Note:
        Conceptually, this function is evaluated by testing each element in the input collection for
        membership in the other collection, with a default of `True`. This means that if the input collection
        is empty (`[]`), the result is `True`, otherwise if the other collection is empty, the result is `False`.
    """
    if len(collection) == 0:
        return [FHIRPathCollectionItem.wrap(True)]
    other_collection = (
        self.other.evaluate(collection, create=create)
        if isinstance(self.other, FHIRPath)
        else self.other
    )
    if len(other_collection) == 0:
        return [FHIRPathCollectionItem.wrap(False)]
    for item in collection:
        if item not in other_collection:
            return [FHIRPathCollectionItem.wrap(False)]
    else:
        return [FHIRPathCollectionItem.wrap(True)]

SupersetOf

Bases: FHIRPathFunction

Representation of the FHIRPath supersetOf() function.

Attributes:

Name Type Description
other Union[FHIRPathCollection, FHIRPath]

Other collection to which to determine whether input is a superset of.
Source code in fhircraft/fhir/path/engine/existence.py 
284
285
286
287
288
289
290
291
292
293
294
295
296
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
333
334
335
class SupersetOf(FHIRPathFunction):
    """
    Representation of the FHIRPath [`supersetOf()`](https://hl7.org/fhirpath/N1/#supersetofother-collection-boolean) function.

    Attributes:
        other (Union[FHIRPathCollection, FHIRPath]): Other collection to which to determine whether input is a superset of.
    """

    def __init__(self, other: FHIRPathCollection | FHIRPath):
        self.other = other

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns true if all items in the collection passed as the other argument are
        members of the input collection. Membership is determined using the = (Equals) (=) operation.

        Args:
            collection (FHIRPathCollection): The input collection

        Returns:
            FHIRPathCollection: The output collection

        Note:
            Conceptually, this function is evaluated by testing each element in the other collection for
            membership in the input collection, with a default of `True`. This means that if the other collection
            is empty (`[]`), the result is `True`, otherwise if the other collection is empty, the result is `False`.
        """
        if len(collection) == 0:
            return [FHIRPathCollectionItem.wrap(True)]
        other_collection = (
            self.other.evaluate(collection, create=create)
            if isinstance(self.other, FHIRPath)
            else self.other
        )
        if len(other_collection) == 0:
            return [FHIRPathCollectionItem.wrap(True)]
        for item in other_collection:
            if item not in collection:
                return [FHIRPathCollectionItem.wrap(False)]
        else:
            return [FHIRPathCollectionItem.wrap(True)]

    def __str__(self):
        return f"{self.__class__.__name__.lower()}({self.other.__str__()})"

    def __repr__(self):
        return f"{self.__class__.__name__}({self.other.__repr__()})"

    def __eq__(self, other):
        return isinstance(other, self.__class__) and self.other == other.other

evaluate(collection, create=False)

Returns true if all items in the collection passed as the other argument are members of the input collection. Membership is determined using the = (Equals) (=) operation.

Parameters:

Name Type Description Default
collection FHIRPathCollection

The input collection

 required

Returns:

Name Type Description
FHIRPathCollection FHIRPathCollection

The output collection
Note

Conceptually, this function is evaluated by testing each element in the other collection for membership in the input collection, with a default of True. This means that if the other collection is empty ([]), the result is True, otherwise if the other collection is empty, the result is False.

Source code in fhircraft/fhir/path/engine/existence.py 
295
296
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
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns true if all items in the collection passed as the other argument are
    members of the input collection. Membership is determined using the = (Equals) (=) operation.

    Args:
        collection (FHIRPathCollection): The input collection

    Returns:
        FHIRPathCollection: The output collection

    Note:
        Conceptually, this function is evaluated by testing each element in the other collection for
        membership in the input collection, with a default of `True`. This means that if the other collection
        is empty (`[]`), the result is `True`, otherwise if the other collection is empty, the result is `False`.
    """
    if len(collection) == 0:
        return [FHIRPathCollectionItem.wrap(True)]
    other_collection = (
        self.other.evaluate(collection, create=create)
        if isinstance(self.other, FHIRPath)
        else self.other
    )
    if len(other_collection) == 0:
        return [FHIRPathCollectionItem.wrap(True)]
    for item in other_collection:
        if item not in collection:
            return [FHIRPathCollectionItem.wrap(False)]
    else:
        return [FHIRPathCollectionItem.wrap(True)]