示例#1
0
 private boolean removeAreas(
     final List<Tuple<Integer, Integer>> areas, final int offset, final int end) {
   // returns true is new area is already included!
   final int delta = end - offset;
   boolean result = false;
   for (Tuple<Integer, Integer> area : areas) {
     if (area.getSecond() < offset) {
       continue;
     } else if (area.getFirst() > end) {
       area.setFirst(area.getFirst() - delta);
       area.setSecond(area.getSecond() - delta);
     } else {
       result = true;
       final int originalFirst = area.getFirst();
       area.setFirst(Math.min(originalFirst, offset));
       if (offset >= originalFirst && end <= area.getSecond()) {
         area.setSecond(area.getSecond() - delta);
       } else if (offset <= originalFirst && end >= area.getSecond()) {
         area.setSecond(offset);
       } else if (originalFirst <= offset) {
         area.setSecond(area.getSecond() - offset);
       } else {
         area.setSecond(area.getSecond() - end);
       }
     }
   }
   return result;
 }
示例#2
0
 private boolean moveAreas(List<Tuple<Integer, Integer>> areas, int offset, int end) {
   // returns true is new area is already included!
   final int delta = end - offset;
   boolean result = false;
   for (Tuple<Integer, Integer> area : areas) {
     if (area.getSecond() < offset) {
       continue;
     } else if (area.getFirst() > end) {
       area.setFirst(area.getFirst() + delta);
       area.setSecond(area.getSecond() + delta);
     } else {
       result = true;
       area.setFirst(Math.min(area.getFirst(), offset));
       area.setSecond(Math.max(area.getSecond() + delta, end));
     }
   }
   return result;
 }
 /**
  * Submits a histogram request to a given url
  *
  * @param histogram the histogram request
  * @param url the url to which the request is sent to
  * @return the response of the histogram request
  */
 public static String submitHistogramRequest(final String histogram, final String url) {
   try {
     final Tuple<String, InputStream> response =
         Client.submitQueryAndRetrieveStream(
             url,
             histogram,
             "application/sparql-results+json"); // mime type would be better application/json, but
     // for that we do not have registered formatter,
     // such that errors would occur
     return EndpointManagement.getStringFromInputStream(response.getSecond());
   } catch (final IOException e) {
     System.err.println(e);
     e.printStackTrace();
     return null;
   }
 }
示例#4
0
  private UpdateEvent forceHighlighting(
      final List<Tuple<Integer, Integer>> areas, UpdateEvent nextEvent) {
    synchronized (this) {
      if (nextEvent != null || !this.buffer.isCurrentlyEmpty()) {
        // if currently some modifications have been done (should be few),
        // then handle these events such that all has been correctly updated!
        // new events should not occur because of the lock in the key listener
        nextEvent = eventHandling(areas, nextEvent);
      }
      this.doc.text.setRepaint(false);
      final String content = this.luposDocumentReader.getText();
      for (Tuple<Integer, Integer> area : areas) {
        // determine start for rescanning:
        // rescan whole line, thus determine line start

        forceHighlightingInnerLoop(area.getFirst(), area.getSecond(), content);
      }

      // However, this is wrong for tokens spanning over several lines
      // For this, rescanning is started for each line with an error token before offset
      // This could theoretically lead also to errors, but should not occur in practical cases
      // (Theoretical case: Insert token c between token a and b, and a b c is also (another) token
      // (which is spanning over several lines))

      LinkedList<ILuposToken> errorTokens = new LinkedList<ILuposToken>();
      for (ILuposToken token : this.tokens.values()) {
        if (token.getDescription().isError()) {
          errorTokens.add(token);
        }
      }

      int lastEnd = -1;
      for (ILuposToken token : errorTokens) {
        final int beginChar = token.getBeginChar();
        if (lastEnd < beginChar) { // rescan only if not already done...
          lastEnd =
              forceHighlightingInnerLoop(
                  beginChar, beginChar + token.getContents().length(), content);
        }
      }
      this.doc.text.setRepaint(true);
      this.doc.text.repaint();
    }
    return nextEvent;
  }
 @Override
 public void run() {
   try {
     while (this.toBeAddedToSet.hasNext()) {
       final Tuple<Bindings, Boolean> next = this.toBeAddedToSet.get();
       if (next == null) {
         break;
       }
       final boolean result = this.bindings.add(next.getFirst());
       if (result && next.getSecond()) {
         this.distinctElements.put(next.getFirst());
       }
     }
   } catch (final InterruptedException e) {
     System.err.println(e);
     e.printStackTrace();
   }
   // all has been detailed checked!
   this.distinctElements.endOfData();
 }