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}