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

Left operand.
right FHIRPath

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

    Attributes:
        left (FHIRPath): Left operand.
        right (FHIRPath): Right operand.
    """
    def __init__(self, left: FHIRPath, right:FHIRPath):
        self.left = left
        self.right = right

    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
        """
        Returns `True` if both operands evaluate to `True`, `False` if either operand evaluates to `False`, and the empty collection (`[]`) otherwise.

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

        Returns:
            bool
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
        if left_boolean is None:
            if right_boolean is True:
                return []
            elif right_boolean is False:
                return False
            elif right_boolean is None:
                return []
        elif right_boolean is None:
            if left_boolean is True:
                return []
            elif left_boolean is False:
                return False
            elif left_boolean is None:
                return []
        return 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, *args, **kwargs)

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 List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
bool

bool
Source code in fhircraft/fhir/path/engine/boolean.py 
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
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
    """
    Returns `True` if both operands evaluate to `True`, `False` if either operand evaluates to `False`, and the empty collection (`[]`) otherwise.

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

    Returns:
        bool
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
    if left_boolean is None:
        if right_boolean is True:
            return []
        elif right_boolean is False:
            return False
        elif right_boolean is None:
            return []
    elif right_boolean is None:
        if left_boolean is True:
            return []
        elif left_boolean is False:
            return False
        elif left_boolean is None:
            return []
    return left_boolean and right_boolean

Implies

Bases: FHIRPath

A representation of the FHIRPath implies boolean logic operator.

Attributes:

Name Type Description
left FHIRPath

Left operand.
right FHIRPath

Right operand.
Source code in fhircraft/fhir/path/engine/boolean.py 
186
187
188
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
240
241
242
243
244
245
246
247
248
class Implies(FHIRPath):
    """
    A representation of the FHIRPath [`implies`](https://hl7.org/fhirpath/N1/#implies) boolean logic operator.

    Attributes:
        left (FHIRPath): Left operand.
        right (FHIRPath): Right operand.
    """
    def __init__(self, left: FHIRPath, right:FHIRPath):
        self.left = left
        self.right = right

    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
        """
        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 (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
        if left_boolean is None:
            if right_boolean is True:
                return 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 True
            elif left_boolean is None:
                return []
        elif left_boolean is True:
            if right_boolean is True:
                return True
            elif right_boolean is False:
                return False
        elif right_boolean is True:
            if left_boolean is True:
                return True
            elif left_boolean is False:
                return True
        elif right_boolean is False and left_boolean is False:
            return True

    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, *args, **kwargs)

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 List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
bool

bool
Source code in fhircraft/fhir/path/engine/boolean.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
225
226
227
228
229
230
231
232
233
234
235
236
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
    """
    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 (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
    if left_boolean is None:
        if right_boolean is True:
            return 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 True
        elif left_boolean is None:
            return []
    elif left_boolean is True:
        if right_boolean is True:
            return True
        elif right_boolean is False:
            return False
    elif right_boolean is True:
        if left_boolean is True:
            return True
        elif left_boolean is False:
            return True
    elif right_boolean is False and left_boolean is False:
        return True

Not

Bases: FHIRPathFunction

A representation of the FHIRPath not boolean logic function.

Source code in fhircraft/fhir/path/engine/boolean.py 
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
class Not(FHIRPathFunction):
    """
    A representation of the FHIRPath [`not`](https://hl7.org/fhirpath/N1/#not) boolean logic function.
    """
    def evaluate(self, collection: Union[List[FHIRPathCollectionItem], bool], *args, **kwargs) -> bool:
        """
        Returns `True` if the input collection evaluates to `False`, and `False` if it evaluates to `True`. Otherwise, the result is empty (`[]`):


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

        Returns:
            bool
        """
        if isinstance(collection, bool):
            boolean = collection
        else:
            collection = ensure_list(collection)
            if len(collection) > 0:
                boolean = bool(collection)
            else:
                return []
        return not boolean

evaluate(collection, *args, **kwargs)

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 List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
bool

bool
Source code in fhircraft/fhir/path/engine/boolean.py 
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
def evaluate(self, collection: Union[List[FHIRPathCollectionItem], bool], *args, **kwargs) -> bool:
    """
    Returns `True` if the input collection evaluates to `False`, and `False` if it evaluates to `True`. Otherwise, the result is empty (`[]`):


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

    Returns:
        bool
    """
    if isinstance(collection, bool):
        boolean = collection
    else:
        collection = ensure_list(collection)
        if len(collection) > 0:
            boolean = bool(collection)
        else:
            return []
    return not boolean

Or

Bases: FHIRPath

A representation of the FHIRPath or boolean logic operator.

Attributes:

Name Type Description
left FHIRPath

Left operand.
right FHIRPath

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

    Attributes:
        left (FHIRPath): Left operand.
        right (FHIRPath): Right operand.
    """
    def __init__(self, left: FHIRPath, right:FHIRPath):
        self.left = left
        self.right = right

    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
        """
        Returns `False` if both operands evaluate to `False`, `True` if either operand evaluates to `True`, and empty (`[]`) otherwise.

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

        Returns:
            bool
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
        if left_boolean is None:
            if right_boolean is True:
                return True
            elif right_boolean is False:
                return []
            elif right_boolean is None:
                return []
        elif right_boolean is None:
            if left_boolean is True:
                return True
            elif left_boolean is False:
                return []
            elif left_boolean is None:
                return []
        return 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, *args, **kwargs)

Returns False if both operands evaluate to False, True if either operand evaluates to True, and empty ([]) otherwise.

Parameters:

Name Type Description Default
collection List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
bool

bool
Source code in fhircraft/fhir/path/engine/boolean.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
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
    """
    Returns `False` if both operands evaluate to `False`, `True` if either operand evaluates to `True`, and empty (`[]`) otherwise.

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

    Returns:
        bool
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
    if left_boolean is None:
        if right_boolean is True:
            return True
        elif right_boolean is False:
            return []
        elif right_boolean is None:
            return []
    elif right_boolean is None:
        if left_boolean is True:
            return True
        elif left_boolean is False:
            return []
        elif left_boolean is None:
            return []
    return left_boolean or right_boolean

Xor

Bases: FHIRPath

A representation of the FHIRPath xor boolean logic operator.

Attributes:

Name Type Description
left FHIRPath

Left operand.
right FHIRPath

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

    Attributes:
        left (FHIRPath): Left operand.
        right (FHIRPath): Right operand.
    """
    def __init__(self, left: FHIRPath, right:FHIRPath):
        self.left = left
        self.right = right

    def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
        """
        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 (List[FHIRPathCollectionItem])): The input collection.

        Returns:
            bool
        """
        left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
        if left_boolean is None:
            if right_boolean is True:
                return []
            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 []
            elif left_boolean is None:
                return []
        return 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, *args, **kwargs)

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 List[FHIRPathCollectionItem]

The input collection.

 required

Returns:

Type Description
bool

bool
Source code in fhircraft/fhir/path/engine/boolean.py 
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
def evaluate(self, collection: List[FHIRPathCollectionItem], *args, **kwargs) -> bool:
    """
    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 (List[FHIRPathCollectionItem])): The input collection.

    Returns:
        bool
    """
    left_boolean, right_boolean = _evaluate_boolean_expressions(self.left, self.right, collection, create=kwargs.get('create', False))
    if left_boolean is None:
        if right_boolean is True:
            return []
        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 []
        elif left_boolean is None:
            return []
    return left_boolean ^ right_boolean