Skip to content

Boolean

For all boolean operators, the collections passed as operands are first evaluated as Booleans. The operators then use three-valued logic to propagate empty operands.

And

Bases: FHIRPath

A representation of the FHIRPath and boolean logic operator.

Attributes:

Name Type Description
left FHIRPath | FHIRPathCollection

Left operand.
right FHIRPath | FHIRPathCollection

Right operand.
Source code in fhircraft/fhir/path/engine/boolean.py 
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 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
class And(FHIRPath):
    """
    A representation of the FHIRPath [`and`](https://hl7.org/fhirpath/N1/#and) boolean logic operator.

    Attributes:
        left (FHIRPath | FHIRPathCollection): Left operand.
        right (FHIRPath | FHIRPathCollection): Right operand.
    """

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

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if both operands evaluate to `True`, `False` if either operand evaluates to `False`, and the empty collection (`[]`) otherwise.

        Args:
            collection (FHIRPathCollection): The input collection.

        Returns:
            FHIRPathCollection: The output collection
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(
            self.left, self.right, collection, create=create
        )
        if left_boolean is None:
            if right_boolean is True:
                return []
            elif right_boolean is False:
                return [FHIRPathCollectionItem.wrap(False)]
            elif right_boolean is None:
                return []
        elif right_boolean is None:
            if left_boolean is True:
                return []
            elif left_boolean is False:
                return [FHIRPathCollectionItem.wrap(False)]
            elif left_boolean is None:
                return []
        return [FHIRPathCollectionItem.wrap(left_boolean and right_boolean)]

    def __str__(self):
        return f"{self.__class__.__name__.lower()}({self.left.__str__(), self.right.__str__()})"

    def __repr__(self):
        return (
            f"{self.__class__.__name__}({self.left.__repr__(), self.right.__repr__()})"
        )

    def __eq__(self, other):
        return (
            isinstance(other, And)
            and other.left == self.left
            and other.right == self.right
        )

    def __hash__(self):
        return hash((self.left, self.right))

evaluate(collection, create=False)

Returns True if both operands evaluate to True, False if either operand evaluates to False, and the empty collection ([]) 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/boolean.py 
 74
 75
 76
 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
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if both operands evaluate to `True`, `False` if either operand evaluates to `False`, and the empty collection (`[]`) otherwise.

    Args:
        collection (FHIRPathCollection): The input collection.

    Returns:
        FHIRPathCollection: The output collection
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(
        self.left, self.right, collection, create=create
    )
    if left_boolean is None:
        if right_boolean is True:
            return []
        elif right_boolean is False:
            return [FHIRPathCollectionItem.wrap(False)]
        elif right_boolean is None:
            return []
    elif right_boolean is None:
        if left_boolean is True:
            return []
        elif left_boolean is False:
            return [FHIRPathCollectionItem.wrap(False)]
        elif left_boolean is None:
            return []
    return [FHIRPathCollectionItem.wrap(left_boolean and right_boolean)]

Implies

Bases: FHIRPath

A representation of the FHIRPath implies boolean logic operator.

Attributes:

Name Type Description
left FHIRPath | FHIRPathCollection

Left operand.
right FHIRPath | FHIRPathCollection

Right operand.
Source code in fhircraft/fhir/path/engine/boolean.py 
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
282
283
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
class Implies(FHIRPath):
    """
    A representation of the FHIRPath [`implies`](https://hl7.org/fhirpath/N1/#implies) boolean logic operator.

    Attributes:
        left (FHIRPath | FHIRPathCollection): Left operand.
        right (FHIRPath | FHIRPathCollection): Right operand.
    """

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

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        If the left operand evaluates to `True`, this operator returns the boolean evaluation of the right operand. If the
        left operand evaluates to `False`, this operator returns `True`. Otherwise, this operator returns `True` if the right
        operand evaluates to `True`, and the empty collection (`[]`) otherwise.

        Args:
            collection (FHIRPathCollection): The input collection.

        Returns:
            FHIRPathCollection: The output collection
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(
            self.left, self.right, collection, create=create
        )
        if left_boolean is None:
            if right_boolean is True:
                return [FHIRPathCollectionItem.wrap(True)]
            elif right_boolean is False:
                return []
            elif right_boolean is None:
                return []
        elif right_boolean is None:
            if left_boolean is True:
                return []
            elif left_boolean is False:
                return [FHIRPathCollectionItem.wrap(True)]
            elif left_boolean is None:
                return []
        elif left_boolean is True:
            if right_boolean is True:
                return [FHIRPathCollectionItem.wrap(True)]
            elif right_boolean is False:
                return [FHIRPathCollectionItem.wrap(False)]
        elif right_boolean is True:
            if left_boolean is True:
                return [FHIRPathCollectionItem.wrap(True)]
            elif left_boolean is False:
                return [FHIRPathCollectionItem.wrap(True)]
        elif right_boolean is False and left_boolean is False:
            return [FHIRPathCollectionItem.wrap(True)]
        return []

    def __str__(self):
        return f"{self.__class__.__name__.lower()}({self.left.__str__(), self.right.__str__()})"

    def __repr__(self):
        return (
            f"{self.__class__.__name__}({self.left.__repr__(), self.right.__repr__()})"
        )

    def __eq__(self, other):
        return (
            isinstance(other, Implies)
            and other.left == self.left
            and other.right == self.right
        )

    def __hash__(self):
        return hash((self.left, self.right))

evaluate(collection, create=False)

If the left operand evaluates to True, this operator returns the boolean evaluation of the right operand. If the left operand evaluates to False, this operator returns True. Otherwise, this operator returns True if the right operand evaluates to True, and the empty collection ([]) 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/boolean.py 
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
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    If the left operand evaluates to `True`, this operator returns the boolean evaluation of the right operand. If the
    left operand evaluates to `False`, this operator returns `True`. Otherwise, this operator returns `True` if the right
    operand evaluates to `True`, and the empty collection (`[]`) otherwise.

    Args:
        collection (FHIRPathCollection): The input collection.

    Returns:
        FHIRPathCollection: The output collection
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(
        self.left, self.right, collection, create=create
    )
    if left_boolean is None:
        if right_boolean is True:
            return [FHIRPathCollectionItem.wrap(True)]
        elif right_boolean is False:
            return []
        elif right_boolean is None:
            return []
    elif right_boolean is None:
        if left_boolean is True:
            return []
        elif left_boolean is False:
            return [FHIRPathCollectionItem.wrap(True)]
        elif left_boolean is None:
            return []
    elif left_boolean is True:
        if right_boolean is True:
            return [FHIRPathCollectionItem.wrap(True)]
        elif right_boolean is False:
            return [FHIRPathCollectionItem.wrap(False)]
    elif right_boolean is True:
        if left_boolean is True:
            return [FHIRPathCollectionItem.wrap(True)]
        elif left_boolean is False:
            return [FHIRPathCollectionItem.wrap(True)]
    elif right_boolean is False and left_boolean is False:
        return [FHIRPathCollectionItem.wrap(True)]
    return []

Not

Bases: FHIRPathFunction

A representation of the FHIRPath not boolean logic function.

Source code in fhircraft/fhir/path/engine/boolean.py 
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
class Not(FHIRPathFunction):
    """
    A representation of the FHIRPath [`not`](https://hl7.org/fhirpath/N1/#not) boolean logic function.
    """

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if the input collection evaluates to `False`, and `False` if it evaluates to `True`. Otherwise, the result is empty (`[]`):


        Args:
            collection (FHIRPathCollection): The input collection.

        Returns:
            FHIRPathCollection: The output collection
        """
        if len(collection) > 1:
            raise FHIRPathRuntimeError(
                "Cannot assert Not() for a collection that has more than one item."
            )
        elif len(collection) == 0:
            return []
        else:
            boolean = bool(collection[0].value)
            return [FHIRPathCollectionItem.wrap(not boolean)]

evaluate(collection, create=False)

Returns True if the input collection evaluates to False, and False if it evaluates to True. Otherwise, the result 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/boolean.py 
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if the input collection evaluates to `False`, and `False` if it evaluates to `True`. Otherwise, the result is empty (`[]`):


    Args:
        collection (FHIRPathCollection): The input collection.

    Returns:
        FHIRPathCollection: The output collection
    """
    if len(collection) > 1:
        raise FHIRPathRuntimeError(
            "Cannot assert Not() for a collection that has more than one item."
        )
    elif len(collection) == 0:
        return []
    else:
        boolean = bool(collection[0].value)
        return [FHIRPathCollectionItem.wrap(not boolean)]

Or

Bases: FHIRPath

A representation of the FHIRPath or boolean logic operator.

Attributes:

Name Type Description
left FHIRPath | FHIRPathCollection

Left operand.
right FHIRPath | FHIRPathCollection

Right operand.
Source code in fhircraft/fhir/path/engine/boolean.py 
124
125
126
127
128
129
130
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
160
161
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
class Or(FHIRPath):
    """
    A representation of the FHIRPath [`or`](https://hl7.org/fhirpath/N1/#or) boolean logic operator.

    Attributes:
        left (FHIRPath | FHIRPathCollection): Left operand.
        right (FHIRPath | FHIRPathCollection): Right operand.
    """

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

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `False` if both operands evaluate to `False`, `True` if either operand evaluates to `True`, and empty (`[]`) otherwise.

        Args:
            collection (FHIRPathCollection): The input collection.

        Returns:
            FHIRPathCollection: The output collection
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(
            self.left, self.right, collection, create=create
        )
        if left_boolean is None:
            if right_boolean is True:
                return [FHIRPathCollectionItem.wrap(True)]
            elif right_boolean is False:
                return []
            elif right_boolean is None:
                return []
        elif right_boolean is None:
            if left_boolean is True:
                return [FHIRPathCollectionItem.wrap(True)]
            elif left_boolean is False:
                return []
            elif left_boolean is None:
                return []
        return [FHIRPathCollectionItem.wrap(left_boolean or right_boolean)]

    def __str__(self):
        return f"{self.__class__.__name__.lower()}({self.left.__str__(), self.right.__str__()})"

    def __repr__(self):
        return (
            f"{self.__class__.__name__}({self.left.__repr__(), self.right.__repr__()})"
        )

    def __eq__(self, other):
        return (
            isinstance(other, Or)
            and other.left == self.left
            and other.right == self.right
        )

    def __hash__(self):
        return hash((self.left, self.right))

evaluate(collection, create=False)

Returns False if both operands evaluate to False, True if either operand evaluates to True, and empty ([]) 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/boolean.py 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `False` if both operands evaluate to `False`, `True` if either operand evaluates to `True`, and empty (`[]`) otherwise.

    Args:
        collection (FHIRPathCollection): The input collection.

    Returns:
        FHIRPathCollection: The output collection
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(
        self.left, self.right, collection, create=create
    )
    if left_boolean is None:
        if right_boolean is True:
            return [FHIRPathCollectionItem.wrap(True)]
        elif right_boolean is False:
            return []
        elif right_boolean is None:
            return []
    elif right_boolean is None:
        if left_boolean is True:
            return [FHIRPathCollectionItem.wrap(True)]
        elif left_boolean is False:
            return []
        elif left_boolean is None:
            return []
    return [FHIRPathCollectionItem.wrap(left_boolean or right_boolean)]

Xor

Bases: FHIRPath

A representation of the FHIRPath xor boolean logic operator.

Attributes:

Name Type Description
left FHIRPath | FHIRPathCollection

Left operand.
right FHIRPath | FHIRPathCollection

Right operand.
Source code in fhircraft/fhir/path/engine/boolean.py 
189
190
191
192
193
194
195
196
197
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
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
class Xor(FHIRPath):
    """
    A representation of the FHIRPath [`xor`](https://hl7.org/fhirpath/N1/#xor) boolean logic operator.

    Attributes:
        left (FHIRPath | FHIRPathCollection): Left operand.
        right (FHIRPath | FHIRPathCollection): Right operand.
    """

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

    def evaluate(
        self, collection: FHIRPathCollection, create=False
    ) -> FHIRPathCollection:
        """
        Returns `True` if exactly one of the operands evaluates to `True`, `False` if either both operands evaluate to `True` or both operands evaluate to `False`, and the empty collection (`[]`) otherwise.

        Args:
            collection (FHIRPathCollection): The input collection.

        Returns:
            FHIRPathCollection: The output collection
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(
            self.left, self.right, collection, create=create
        )
        if left_boolean is None or right_boolean is None:
            return []
        return [FHIRPathCollectionItem.wrap(left_boolean ^ right_boolean)]

    def __str__(self):
        return f"{self.__class__.__name__.lower()}({self.left.__str__(), self.right.__str__()})"

    def __repr__(self):
        return (
            f"{self.__class__.__name__}({self.left.__repr__(), self.right.__repr__()})"
        )

    def __eq__(self, other):
        return (
            isinstance(other, Xor)
            and other.left == self.left
            and other.right == self.right
        )

    def __hash__(self):
        return hash((self.left, self.right))

evaluate(collection, create=False)

Returns True if exactly one of the operands evaluates to True, False if either both operands evaluate to True or both operands evaluate to False, and the empty collection ([]) 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/boolean.py 
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
def evaluate(
    self, collection: FHIRPathCollection, create=False
) -> FHIRPathCollection:
    """
    Returns `True` if exactly one of the operands evaluates to `True`, `False` if either both operands evaluate to `True` or both operands evaluate to `False`, and the empty collection (`[]`) otherwise.

    Args:
        collection (FHIRPathCollection): The input collection.

    Returns:
        FHIRPathCollection: The output collection
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(
        self.left, self.right, collection, create=create
    )
    if left_boolean is None or right_boolean is None:
        return []
    return [FHIRPathCollectionItem.wrap(left_boolean ^ right_boolean)]