parseLine static method

NTriple parseLine(String text)

Parses a single line containing N-Triple.

Implementation

static NTriple parseLine(String text) {
  final result = <NTripleTerm>[];
  var term = NTripleTerm();
  _NTriplesParserState? state;

  for (int i = 0; i < text.characters.length; i++) {
    final char = text.characters.elementAt(i);
    final prevChar = i > 0 ? text.characters.elementAt(i - 1) : "";
    final prevPrevChar = i > 1 ? text.characters.elementAt(i - 2) : "";
    final nextChar = i < text.characters.length - 2
        ? text.characters.elementAt(i + 1)
        : "";
    final nextNextChar = i < text.characters.length - 3
        ? text.characters.elementAt(i + 2)
        : "";

    switch (state) {
      case _NTriplesParserState.parsingTerm:
        term.value += char;
        break;
      case _NTriplesParserState.parsingDataType:
        term.dataType += char;
        break;
      case _NTriplesParserState.parsingLanguageTag:
        term.languageTag += char;
        break;
      case null:
        break;
    }

    switch (char) {
      case "<":
        {
          if (state == null) {
            term = NTripleTerm(termType: NTripleTermType.iri);
            state = _NTriplesParserState.parsingTerm;
          }
        }
        break;

      case ">":
        {
          if (term.termType == NTripleTermType.iri) {
            term.value = utils.removeLastCharacters(term.value, 1);
            result.add(term);
            term = NTripleTerm();
            state = null;
          } else if (term.termType == NTripleTermType.literal &&
              state == _NTriplesParserState.parsingDataType) {
            term.dataType = utils.removeFirstCharacters(term.dataType, 3);
            term.dataType = utils.removeLastCharacters(term.dataType, 1);
            term.value = utils.removeLastCharacters(term.value, 1);
            result.add(term);
            term = NTripleTerm();
            state = null;
          }
        }
        break;

      case ".":
        {
          if (state == null) {
            break;
          }
        }
        break;

      case "#":
        {
          if (state == null) {
            break;
          }
        }
        break;

      case '"':
        {
          if (state == null) {
            term = NTripleTerm(termType: NTripleTermType.literal);
            state = _NTriplesParserState.parsingTerm;
          } else if (term.termType == NTripleTermType.literal) {
            if (prevChar != r"\" || (prevChar == prevPrevChar)) {
              if (nextChar == "@") {
                state = _NTriplesParserState.parsingLanguageTag;
              } else if (nextChar == "^" && nextNextChar == "^") {
                state = _NTriplesParserState.parsingDataType;
              } else {
                term.value = utils.removeLastCharacters(term.value, 1);
                result.add(term);
                term = NTripleTerm();
                state = null;
              }
            }
          }
        }
        break;

      case "_":
        {
          if (state == null && nextChar == ":") {
            term = NTripleTerm(termType: NTripleTermType.blankNode);
            state = _NTriplesParserState.parsingTerm;
          }
        }
        break;

      case " ":
      case "\t":
        {
          if (state == _NTriplesParserState.parsingTerm &&
              term.termType == NTripleTermType.blankNode) {
            term.value = utils.removeFirstCharacters(term.value, 1);
            term.value = utils.removeLastCharacters(term.value, 1);
            result.add(term);
            term = NTripleTerm();
            state = null;
          } else if (state == _NTriplesParserState.parsingLanguageTag &&
              term.termType == NTripleTermType.literal) {
            term.value = utils.removeLastCharacters(term.value, 1);
            term.languageTag =
                utils.removeLastCharacters(term.languageTag, 1);
            term.languageTag =
                utils.removeFirstCharacters(term.languageTag, 1);
            result.add(term);
            term = NTripleTerm();
            state = null;
          }
        }
        break;
    }
  }

  if (result.length != 3) throw Exception("Incorrect N-Triples line syntax");

  return Tuple3(result[0], result[1], result[2]);
}