operatorValues function

ParserList operatorValues(List fullList)

This ensures that any response is a ParserList (this allows easy recursion when evaluating the expression)

Implementation

ParserList operatorValues(List fullList) {
  /// if not arguments passed, then it is an empty ParserList
  if (fullList.isEmpty) {
    return ParserList([]);
  }

  /// We remove the whiteSpace because for evaluation purposes it's unimportant
  fullList.removeWhere((element) => element is WhiteSpaceParser);

  if (fullList.indexWhere((element) => element is OperatorParser) == -1) {
    /// If there are no Operators, we just return the current elements
    return ParserList(fullList.map((e) => e as FhirPathParser).toList());
  } else {
    // Replace +/- with unary representation based on simple rules
    fullList.forEachIndexed(
      (i, entry) => {
        if (entry is MinusParser || entry is PlusParser)
          {
            if (i == 0 || fullList[i - 1] is OperatorParser)
              {
                fullList[i] = entry is MinusParser
                    ? UnaryNegateParser()
                    : UnaryPlusParser()
              }
          }
      },
    );

    int highest = -1;
    for (final entry in fullList) {
      if ((operatorOrderMap[entry.runtimeType] ?? -1) > highest &&
          entry is OperatorParser) {
        highest = operatorOrderMap[entry.runtimeType] ?? -1;
      }
    }

    final splitIndex = fullList
        .lastIndexWhere((e) => operatorOrderMap[e.runtimeType] == highest);

    fullList[splitIndex].before =
        operatorValues(fullList.sublist(0, splitIndex));
    fullList[splitIndex].after =
        operatorValues(fullList.sublist(splitIndex + 1, fullList.length));
    return ParserList(<FhirPathParser>[fullList[splitIndex] as FhirPathParser]);
  }
}