001package org.hl7.fhir.r5.model; 002 003/*- 004 * #%L 005 * org.hl7.fhir.r5 006 * %% 007 * Copyright (C) 2014 - 2019 Health Level 7 008 * %% 009 * Licensed under the Apache License, Version 2.0 (the "License"); 010 * you may not use this file except in compliance with the License. 011 * You may obtain a copy of the License at 012 * 013 * http://www.apache.org/licenses/LICENSE-2.0 014 * 015 * Unless required by applicable law or agreed to in writing, software 016 * distributed under the License is distributed on an "AS IS" BASIS, 017 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 018 * See the License for the specific language governing permissions and 019 * limitations under the License. 020 * #L% 021 */ 022 023 024import java.util.ArrayList; 025import java.util.List; 026 027import org.hl7.fhir.utilities.Utilities; 028 029public class ExpressionNode { 030 031 public enum Kind { 032 Name, Function, Constant, Group, Unary 033 } 034 public static class SourceLocation { 035 private int line; 036 private int column; 037 public SourceLocation(int line, int column) { 038 super(); 039 this.line = line; 040 this.column = column; 041 } 042 public int getLine() { 043 return line; 044 } 045 public int getColumn() { 046 return column; 047 } 048 public void setLine(int line) { 049 this.line = line; 050 } 051 public void setColumn(int column) { 052 this.column = column; 053 } 054 055 public String toString() { 056 return Integer.toString(line)+", "+Integer.toString(column); 057 } 058 } 059 public enum Function { 060 Custom, 061 062 Empty, Not, Exists, SubsetOf, SupersetOf, IsDistinct, Distinct, Count, Where, Select, All, Repeat, Aggregate, Item /*implicit from name[]*/, As, Is, Single, 063 First, Last, Tail, Skip, Take, Union, Combine, Intersect, Exclude, Iif, Upper, Lower, ToChars, IndexOf, Substring, StartsWith, EndsWith, Matches, ReplaceMatches, Contains, Replace, Length, 064 Children, Descendants, MemberOf, Trace, Check, Today, Now, Resolve, Extension, AllFalse, AnyFalse, AllTrue, AnyTrue, 065 HasValue, AliasAs, Alias, HtmlChecks, OfType, Type, 066 ConvertsToBoolean, ConvertsToInteger, ConvertsToString, ConvertsToDecimal, ConvertsToQuantity, ConvertsToDateTime, ConvertsToTime, ToBoolean, ToInteger, ToString, ToDecimal, ToQuantity, ToDateTime, ToTime, ConformsTo; 067 068 public static Function fromCode(String name) { 069 if (name.equals("empty")) return Function.Empty; 070 if (name.equals("not")) return Function.Not; 071 if (name.equals("exists")) return Function.Exists; 072 if (name.equals("subsetOf")) return Function.SubsetOf; 073 if (name.equals("supersetOf")) return Function.SupersetOf; 074 if (name.equals("isDistinct")) return Function.IsDistinct; 075 if (name.equals("distinct")) return Function.Distinct; 076 if (name.equals("count")) return Function.Count; 077 if (name.equals("where")) return Function.Where; 078 if (name.equals("select")) return Function.Select; 079 if (name.equals("all")) return Function.All; 080 if (name.equals("repeat")) return Function.Repeat; 081 if (name.equals("aggregate")) return Function.Aggregate; 082 if (name.equals("item")) return Function.Item; 083 if (name.equals("as")) return Function.As; 084 if (name.equals("is")) return Function.Is; 085 if (name.equals("single")) return Function.Single; 086 if (name.equals("first")) return Function.First; 087 if (name.equals("last")) return Function.Last; 088 if (name.equals("tail")) return Function.Tail; 089 if (name.equals("skip")) return Function.Skip; 090 if (name.equals("take")) return Function.Take; 091 if (name.equals("union")) return Function.Union; 092 if (name.equals("combine")) return Function.Combine; 093 if (name.equals("intersect")) return Function.Intersect; 094 if (name.equals("exclude")) return Function.Exclude; 095 if (name.equals("iif")) return Function.Iif; 096 if (name.equals("lower")) return Function.Lower; 097 if (name.equals("upper")) return Function.Upper; 098 if (name.equals("toChars")) return Function.ToChars; 099 if (name.equals("indexOf")) return Function.IndexOf; 100 if (name.equals("substring")) return Function.Substring; 101 if (name.equals("startsWith")) return Function.StartsWith; 102 if (name.equals("endsWith")) return Function.EndsWith; 103 if (name.equals("matches")) return Function.Matches; 104 if (name.equals("replaceMatches")) return Function.ReplaceMatches; 105 if (name.equals("contains")) return Function.Contains; 106 if (name.equals("replace")) return Function.Replace; 107 if (name.equals("length")) return Function.Length; 108 if (name.equals("children")) return Function.Children; 109 if (name.equals("descendants")) return Function.Descendants; 110 if (name.equals("memberOf")) return Function.MemberOf; 111 if (name.equals("trace")) return Function.Trace; 112 if (name.equals("check")) return Function.Check; 113 if (name.equals("today")) return Function.Today; 114 if (name.equals("now")) return Function.Now; 115 if (name.equals("resolve")) return Function.Resolve; 116 if (name.equals("extension")) return Function.Extension; 117 if (name.equals("allFalse")) return Function.AllFalse; 118 if (name.equals("anyFalse")) return Function.AnyFalse; 119 if (name.equals("allTrue")) return Function.AllTrue; 120 if (name.equals("anyTrue")) return Function.AnyTrue; 121 if (name.equals("hasValue")) return Function.HasValue; 122 if (name.equals("alias")) return Function.Alias; 123 if (name.equals("aliasAs")) return Function.AliasAs; 124 if (name.equals("htmlChecks")) return Function.HtmlChecks; 125 if (name.equals("htmlchecks")) return Function.HtmlChecks; // support change of care from R3 126 if (name.equals("ofType")) return Function.OfType; 127 if (name.equals("type")) return Function.Type; 128 if (name.equals("toInteger")) return Function.ToInteger; 129 if (name.equals("toDecimal")) return Function.ToDecimal; 130 if (name.equals("toString")) return Function.ToString; 131 if (name.equals("toQuantity")) return Function.ToQuantity; 132 if (name.equals("toBoolean")) return Function.ToBoolean; 133 if (name.equals("toDateTime")) return Function.ToDateTime; 134 if (name.equals("toTime")) return Function.ToTime; 135 if (name.equals("convertsToInteger")) return Function.ConvertsToInteger; 136 if (name.equals("convertsToDecimal")) return Function.ConvertsToDecimal; 137 if (name.equals("convertsToString")) return Function.ConvertsToString; 138 if (name.equals("convertsToQuantity")) return Function.ConvertsToQuantity; 139 if (name.equals("convertsToBoolean")) return Function.ConvertsToBoolean; 140 if (name.equals("convertsToDateTime")) return Function.ConvertsToDateTime; 141 if (name.equals("convertsToTime")) return Function.ConvertsToTime; 142 if (name.equals("conformsTo")) return Function.ConformsTo; 143 return null; 144 } 145 public String toCode() { 146 switch (this) { 147 case Empty : return "empty"; 148 case Not : return "not"; 149 case Exists : return "exists"; 150 case SubsetOf : return "subsetOf"; 151 case SupersetOf : return "supersetOf"; 152 case IsDistinct : return "isDistinct"; 153 case Distinct : return "distinct"; 154 case Count : return "count"; 155 case Where : return "where"; 156 case Select : return "select"; 157 case All : return "all"; 158 case Repeat : return "repeat"; 159 case Aggregate : return "aggregate"; 160 case Item : return "item"; 161 case As : return "as"; 162 case Is : return "is"; 163 case Single : return "single"; 164 case First : return "first"; 165 case Last : return "last"; 166 case Tail : return "tail"; 167 case Skip : return "skip"; 168 case Take : return "take"; 169 case Union : return "union"; 170 case Combine : return "combine"; 171 case Intersect : return "intersect"; 172 case Exclude : return "exclude"; 173 case Iif : return "iif"; 174 case ToChars : return "toChars"; 175 case Lower : return "lower"; 176 case Upper : return "upper"; 177 case IndexOf : return "indexOf"; 178 case Substring : return "substring"; 179 case StartsWith : return "startsWith"; 180 case EndsWith : return "endsWith"; 181 case Matches : return "matches"; 182 case ReplaceMatches : return "replaceMatches"; 183 case Contains : return "contains"; 184 case Replace : return "replace"; 185 case Length : return "length"; 186 case Children : return "children"; 187 case Descendants : return "descendants"; 188 case MemberOf : return "memberOf"; 189 case Trace : return "trace"; 190 case Check : return "check"; 191 case Today : return "today"; 192 case Now : return "now"; 193 case Resolve : return "resolve"; 194 case Extension : return "extension"; 195 case AllFalse : return "allFalse"; 196 case AnyFalse : return "anyFalse"; 197 case AllTrue : return "allTrue"; 198 case AnyTrue : return "anyTrue"; 199 case HasValue : return "hasValue"; 200 case Alias : return "alias"; 201 case AliasAs : return "aliasAs"; 202 case HtmlChecks : return "htmlChecks"; 203 case OfType : return "ofType"; 204 case Type : return "type"; 205 case ToInteger : return "toInteger"; 206 case ToDecimal : return "toDecimal"; 207 case ToString : return "toString"; 208 case ToBoolean : return "toBoolean"; 209 case ToQuantity : return "toQuantity"; 210 case ToDateTime : return "toDateTime"; 211 case ToTime : return "toTime"; 212 case ConvertsToInteger : return "convertsToInteger"; 213 case ConvertsToDecimal : return "convertsToDecimal"; 214 case ConvertsToString : return "convertsToString"; 215 case ConvertsToBoolean : return "convertsToBoolean"; 216 case ConvertsToQuantity : return "convertsToQuantity"; 217 case ConvertsToDateTime : return "convertsToDateTime"; 218 case ConvertsToTime : return "isTime"; 219 case ConformsTo : return "conformsTo"; 220 default: return "??"; 221 } 222 } 223 } 224 225 public enum Operation { 226 Equals, Equivalent, NotEquals, NotEquivalent, LessThan, Greater, LessOrEqual, GreaterOrEqual, Is, As, Union, Or, And, Xor, Implies, 227 Times, DivideBy, Plus, Minus, Concatenate, Div, Mod, In, Contains, MemberOf; 228 229 public static Operation fromCode(String name) { 230 if (Utilities.noString(name)) 231 return null; 232 if (name.equals("=")) 233 return Operation.Equals; 234 if (name.equals("~")) 235 return Operation.Equivalent; 236 if (name.equals("!=")) 237 return Operation.NotEquals; 238 if (name.equals("!~")) 239 return Operation.NotEquivalent; 240 if (name.equals(">")) 241 return Operation.Greater; 242 if (name.equals("<")) 243 return Operation.LessThan; 244 if (name.equals(">=")) 245 return Operation.GreaterOrEqual; 246 if (name.equals("<=")) 247 return Operation.LessOrEqual; 248 if (name.equals("|")) 249 return Operation.Union; 250 if (name.equals("or")) 251 return Operation.Or; 252 if (name.equals("and")) 253 return Operation.And; 254 if (name.equals("xor")) 255 return Operation.Xor; 256 if (name.equals("is")) 257 return Operation.Is; 258 if (name.equals("as")) 259 return Operation.As; 260 if (name.equals("*")) 261 return Operation.Times; 262 if (name.equals("/")) 263 return Operation.DivideBy; 264 if (name.equals("+")) 265 return Operation.Plus; 266 if (name.equals("-")) 267 return Operation.Minus; 268 if (name.equals("&")) 269 return Operation.Concatenate; 270 if (name.equals("implies")) 271 return Operation.Implies; 272 if (name.equals("div")) 273 return Operation.Div; 274 if (name.equals("mod")) 275 return Operation.Mod; 276 if (name.equals("in")) 277 return Operation.In; 278 if (name.equals("contains")) 279 return Operation.Contains; 280 if (name.equals("memberOf")) 281 return Operation.MemberOf; 282 return null; 283 284 } 285 public String toCode() { 286 switch (this) { 287 case Equals : return "="; 288 case Equivalent : return "~"; 289 case NotEquals : return "!="; 290 case NotEquivalent : return "!~"; 291 case Greater : return ">"; 292 case LessThan : return "<"; 293 case GreaterOrEqual : return ">="; 294 case LessOrEqual : return "<="; 295 case Union : return "|"; 296 case Or : return "or"; 297 case And : return "and"; 298 case Xor : return "xor"; 299 case Times : return "*"; 300 case DivideBy : return "/"; 301 case Plus : return "+"; 302 case Minus : return "-"; 303 case Concatenate : return "&"; 304 case Implies : return "implies"; 305 case Is : return "is"; 306 case As : return "as"; 307 case Div : return "div"; 308 case Mod : return "mod"; 309 case In : return "in"; 310 case Contains : return "contains"; 311 case MemberOf : return "memberOf"; 312 default: return "??"; 313 } 314 } 315 } 316 317 public enum CollectionStatus { 318 SINGLETON, ORDERED, UNORDERED; 319 } 320 321 //the expression will have one of either name or constant 322 private String uniqueId; 323 private Kind kind; 324 private String name; 325 private Base constant; 326 private Function function; 327 private List<ExpressionNode> parameters; // will be created if there is a function 328 private ExpressionNode inner; 329 private ExpressionNode group; 330 private Operation operation; 331 private boolean proximal; // a proximal operation is the first in the sequence of operations. This is significant when evaluating the outcomes 332 private ExpressionNode opNext; 333 private SourceLocation start; 334 private SourceLocation end; 335 private SourceLocation opStart; 336 private SourceLocation opEnd; 337 private TypeDetails types; 338 private TypeDetails opTypes; 339 340 341 public ExpressionNode(int uniqueId) { 342 super(); 343 this.uniqueId = Integer.toString(uniqueId); 344 } 345 346 public String toString() { 347 StringBuilder b = new StringBuilder(); 348 switch (kind) { 349 case Name: 350 b.append(name); 351 break; 352 case Function: 353 if (function == Function.Item) 354 b.append("["); 355 else { 356 b.append(name); 357 b.append("("); 358 } 359 boolean first = true; 360 for (ExpressionNode n : parameters) { 361 if (first) 362 first = false; 363 else 364 b.append(", "); 365 b.append(n.toString()); 366 } 367 if (function == Function.Item) 368 b.append("]"); 369 else { 370 b.append(")"); 371 } 372 break; 373 case Constant: 374 if (constant instanceof StringType) 375 b.append("'"+Utilities.escapeJson(constant.primitiveValue())+"'"); 376 else if (constant instanceof Quantity) { 377 Quantity q = (Quantity) constant; 378 b.append(Utilities.escapeJson(q.getValue().toPlainString())); 379 b.append(" '"); 380 b.append(Utilities.escapeJson(q.getUnit())); 381 b.append("'"); 382 } else if (constant.primitiveValue() != null) 383 b.append(Utilities.escapeJson(constant.primitiveValue())); 384 else 385 b.append(Utilities.escapeJson(constant.toString())); 386 break; 387 case Group: 388 b.append("("); 389 b.append(group.toString()); 390 b.append(")"); 391 } 392 if (inner != null) { 393 b.append("."); 394 b.append(inner.toString()); 395 } 396 if (operation != null) { 397 b.append(" "); 398 b.append(operation.toCode()); 399 b.append(" "); 400 b.append(opNext.toString()); 401 } 402 403 return b.toString(); 404 } 405 406 public String getName() { 407 return name; 408 } 409 public void setName(String name) { 410 this.name = name; 411 } 412 public Base getConstant() { 413 return constant; 414 } 415 public void setConstant(Base constant) { 416 this.constant = constant; 417 } 418 419 public Function getFunction() { 420 return function; 421 } 422 public void setFunction(Function function) { 423 this.function = function; 424 if (parameters == null) 425 parameters = new ArrayList<ExpressionNode>(); 426 } 427 428 public boolean isProximal() { 429 return proximal; 430 } 431 public void setProximal(boolean proximal) { 432 this.proximal = proximal; 433 } 434 public Operation getOperation() { 435 return operation; 436 } 437 public void setOperation(Operation operation) { 438 this.operation = operation; 439 } 440 public ExpressionNode getInner() { 441 return inner; 442 } 443 public void setInner(ExpressionNode value) { 444 this.inner = value; 445 } 446 public ExpressionNode getOpNext() { 447 return opNext; 448 } 449 public void setOpNext(ExpressionNode value) { 450 this.opNext = value; 451 } 452 public List<ExpressionNode> getParameters() { 453 return parameters; 454 } 455 public boolean checkName() { 456 if (!name.startsWith("$")) 457 return true; 458 else 459 return Utilities.existsInList(name, "$this", "$total"); 460 } 461 462 public Kind getKind() { 463 return kind; 464 } 465 466 public void setKind(Kind kind) { 467 this.kind = kind; 468 } 469 470 public ExpressionNode getGroup() { 471 return group; 472 } 473 474 public void setGroup(ExpressionNode group) { 475 this.group = group; 476 } 477 478 public SourceLocation getStart() { 479 return start; 480 } 481 482 public void setStart(SourceLocation start) { 483 this.start = start; 484 } 485 486 public SourceLocation getEnd() { 487 return end; 488 } 489 490 public void setEnd(SourceLocation end) { 491 this.end = end; 492 } 493 494 public SourceLocation getOpStart() { 495 return opStart; 496 } 497 498 public void setOpStart(SourceLocation opStart) { 499 this.opStart = opStart; 500 } 501 502 public SourceLocation getOpEnd() { 503 return opEnd; 504 } 505 506 public void setOpEnd(SourceLocation opEnd) { 507 this.opEnd = opEnd; 508 } 509 510 public String getUniqueId() { 511 return uniqueId; 512 } 513 514 515 public int parameterCount() { 516 if (parameters == null) 517 return 0; 518 else 519 return parameters.size(); 520 } 521 522 public String Canonical() { 523 StringBuilder b = new StringBuilder(); 524 write(b); 525 return b.toString(); 526 } 527 528 public String summary() { 529 switch (kind) { 530 case Name: return uniqueId+": "+name; 531 case Function: return uniqueId+": "+function.toString()+"()"; 532 case Constant: return uniqueId+": "+constant; 533 case Group: return uniqueId+": (Group)"; 534 } 535 return "??"; 536 } 537 538 private void write(StringBuilder b) { 539 540 switch (kind) { 541 case Name: 542 b.append(name); 543 break; 544 case Constant: 545 b.append(constant); 546 break; 547 case Function: 548 b.append(function.toCode()); 549 b.append('('); 550 boolean f = true; 551 for (ExpressionNode n : parameters) { 552 if (f) 553 f = false; 554 else 555 b.append(", "); 556 n.write(b); 557 } 558 b.append(')'); 559 560 break; 561 case Group: 562 b.append('('); 563 group.write(b); 564 b.append(')'); 565 } 566 567 if (inner != null) { 568 b.append('.'); 569 inner.write(b); 570 } 571 if (operation != null) { 572 b.append(' '); 573 b.append(operation.toCode()); 574 b.append(' '); 575 opNext.write(b); 576 } 577 } 578 579 public String check() { 580 581 switch (kind) { 582 case Name: 583 if (Utilities.noString(name)) 584 return "No Name provided @ "+location(); 585 break; 586 587 case Function: 588 if (function == null) 589 return "No Function id provided @ "+location(); 590 for (ExpressionNode n : parameters) { 591 String msg = n.check(); 592 if (msg != null) 593 return msg; 594 } 595 596 break; 597 598 case Unary: 599 break; 600 case Constant: 601 if (constant == null) 602 return "No Constant provided @ "+location(); 603 break; 604 605 case Group: 606 if (group == null) 607 return "No Group provided @ "+location(); 608 else { 609 String msg = group.check(); 610 if (msg != null) 611 return msg; 612 } 613 } 614 if (inner != null) { 615 String msg = inner.check(); 616 if (msg != null) 617 return msg; 618 } 619 if (operation == null) { 620 621 if (opNext != null) 622 return "Next provided when it shouldn't be @ "+location(); 623 } 624 else { 625 if (opNext == null) 626 return "No Next provided @ "+location(); 627 else 628 opNext.check(); 629 } 630 return null; 631 632 } 633 634 private String location() { 635 return Integer.toString(start.line)+", "+Integer.toString(start.column); 636 } 637 638 public TypeDetails getTypes() { 639 return types; 640 } 641 642 public void setTypes(TypeDetails types) { 643 this.types = types; 644 } 645 646 public TypeDetails getOpTypes() { 647 return opTypes; 648 } 649 650 public void setOpTypes(TypeDetails opTypes) { 651 this.opTypes = opTypes; 652 } 653 654}