public String getValueString(double position, WindowFunction windowFunction) {
    //  //LOG.info("getValueString");
    MutableString buffer = new MutableString();

    buffer.append(entry.toString());
    buffer.replace("\n", "<br>");

    if (this.isPaired()) {
      buffer.append("----------------------" + "<br>");
      buffer.append("Pair start = " + getMate().positionString() + "<br>");
      buffer.append("Pair is mapped = " + (getMate().isMapped() ? "yes" : "no") + "<br>");
      // buf.append("Pair is proper = " + (getProperPairFlag() ? "yes" : "no") + "<br>");
      if (getChr().equals(getMate().getChr())) {
        buffer.append("Insert size = " + getInferredInsertSize() + "<br>");
      }
      if (getPairOrientation().length() > 0) {
        buffer.append("Pair orientation = " + getPairOrientation() + "<br>");
      }
      if (isFirstOfPair()) {
        buffer.append("First of pair <br>");
      }
      if (isSecondOfPair()) {
        buffer.append("Second of pair <br>");
      }
    }
    return buffer.toString();
  }
  protected void ensureParsed_(Iterator<Relation> relations) throws IOException {
    objects.clear();
    predicates.clear();
    contexts.clear();
    subjectTokens.clear();

    // Index subject tokens
    // We index the BNode id. Do we need it?
    String subject = getSubject();
    FastBufferedReader fbr;
    // remove http/https or _:
    int startAt = subject.indexOf(':');

    if (startAt < 0) {
      fbr = new FastBufferedReader(subject.toCharArray());
    } else {
      startAt++;
      fbr = new FastBufferedReader(subject.toCharArray(), startAt, subject.length() - startAt);
    }
    MutableString word = new MutableString();
    MutableString nonWord = new MutableString();
    while (fbr.next(word, nonWord)) {
      if (word != null && !word.equals("")) {
        if (CombinedTermProcessor.getInstance().processTerm(word)) {
          subjectTokens.add(word.toString().toLowerCase());
        }
      }
    }
    fbr.close();

    while (relations.hasNext()) {
      Relation relation = relations.next();
      String predicate = relation.getPredicate().toString();

      // Check if prefix is on blacklist
      if (RDFDocumentFactory.isOnPredicateBlacklist(predicate.toLowerCase())) {
        factory.incrementCounter(RdfCounters.BLACKLISTED_TRIPLES, 1);
        continue;
      }

      String predicateId = factory.lookupResource(predicate, false);
      if (predicateId == null) {
        throw new IllegalStateException(
            "Predicate " + predicate + " not in resources hash function!");
      }

      String contextId = NO_CONTEXT;
      if (factory.isWithContexts() && relation.getContext() != null) {
        if (relation.getContext() instanceof Resource) {
          contextId = factory.lookupResource(relation.getContext().toString(), false);
          if (contextId == null) {
            throw new IllegalStateException(
                "Context " + relation.getContext() + " not in resources hash function!");
          }
        } else {
          throw new IllegalStateException(
              "Context " + relation.getContext() + " is not a Resource.");
        }
      }

      if (relation.getObject() instanceof Resource) {
        if (predicate.equals(RDF.TYPE.toString())) {
          factory.incrementCounter(RdfCounters.RDF_TYPE_TRIPLES, 1);
          objects.add(relation.getObject().toString());
        } else {
          String objectId = factory.lookupResource(relation.getObject().toString(), true);
          if (objectId == null) {
            throw new IllegalStateException(
                "Object " + relation.getObject() + " not in resources hash function!");
          }
          objects.add(objectId);
        }
        predicates.add(predicateId);
        contexts.add(contextId);
      } else if (relation.getObject() instanceof BNode) {
        String objectId = factory.lookupResource(relation.getObject().toString(), false);
        if (objectId == null) {
          throw new IllegalStateException(
              "Object " + relation.getObject() + " not in resources hash function!");
        }
        objects.add(objectId);
        predicates.add(predicateId);
        contexts.add(contextId);
      } else {
        String object = relation.getObject().toString();
        // Iterate over the words of the value
        fbr = new FastBufferedReader(object.toCharArray());
        while (fbr.next(word, nonWord)) {
          if (word != null && !word.equals("")) {
            if (CombinedTermProcessor.getInstance().processTerm(word)) {
              // Lowercase terms
              objects.add(word.toString());

              // Preserve casing for properties and
              // contexts
              predicates.add(predicateId);
              contexts.add(contextId);
            }
          }
        }
        fbr.close();
      }

      factory.incrementCounter(RdfCounters.INDEXED_TRIPLES, 1);
    }
  }