How to use

SuggestionGroup

in

de.tudarmstadt.ukp.inception.recommendation.api.model

private List<AnnotationSuggestion> getMatchingSuggestion(List<SuggestionGroup> aSuggestions,
    String aDocumentName, long aLayerId, String aFeature, int aBegin, int aEnd,
    String aLabel)
{
  return aSuggestions.stream()
      .filter(group -> 
          aDocumentName.equals(group.getDocumentName()) &&
          aLayerId == group.getLayerId() &&
          (aFeature == null || aFeature == group.getFeature()) &&
          (aBegin == -1 || aBegin == group.getOffset().getBegin()) &&
          (aEnd == -1 || aEnd == group.getOffset().getEnd()))
      .flatMap(group -> group.stream())
      .filter(suggestion ->
          aLabel == null || aLabel.equals(suggestion.getLabel()))
      .collect(toList());
}

private static SuggestionGroup removeDuplicateRecommendations(
    SuggestionGroup unmodifiedRecommendationList)
{
  SuggestionGroup cleanRecommendationList = new SuggestionGroup();
  unmodifiedRecommendationList.forEach(recommendationItem -> {
    if (!isAlreadyInCleanList(cleanRecommendationList, recommendationItem)) {
      cleanRecommendationList.add(recommendationItem);
    }
  });
  return cleanRecommendationList;
}

public SuggestionDocumentGroup(List<AnnotationSuggestion> aSuggestions)
{
  this();
  SuggestionGroup.group(aSuggestions).stream().forEachOrdered(this::add);
}

@Override
public BinaryOperator<SuggestionGroup> combiner()
{
  return (group1, group2) -> {
    group2.forEach(suggestion -> group1.add(suggestion));
    return group1;
  };
}

if (isEmpty()) {
  return emptyMap();
else if (size() == 1) {
  AnnotationSuggestion top = get(0);
  return singletonMap(top.getRecommenderId(), asList(new Delta(top)));
  Map<Long, List<AnnotationSuggestion>> suggestionsByRecommenders = stream()
      .collect(groupingBy(AnnotationSuggestion::getRecommenderId));

private void actionClearSkippedRecommendations(AjaxRequestTarget aTarget, Form<Void> aForm)
  throws IOException
{
  learningRecordService.deleteSkippedSuggestions(getModelObject().getUser(),
      alStateModel.getObject().getLayer());
  ActiveLearningUserState alState = alStateModel.getObject();
  // The history records caused suggestions to disappear. Since visibility is only fully
  // recalculated when new predictions come in, we need to update the visibility explicitly
  // here
  alState.getSuggestions().stream()
    .flatMap(group -> group.stream())
    .forEach(suggestion -> suggestion.show(FLAG_SKIPPED));
  
  refreshSuggestions();
  moveToNextRecommendation(aTarget, false);
  
  aTarget.add(mainContainer);
}

  .filter(group -> group.getLayerId() == aLayer.getId())
    Offset offset = group.getOffset();
    return aWindowBegin <= offset.getBegin() && offset.getEnd() <= aWindowEnd;
  })
    comparingInt(Offset::getBegin).thenComparingInt(Offset::getEnd));
suggestionsInWindow.stream()
    .filter(group -> group.getFeature().equals(feature.getName()))
    .forEach(group -> suggestions.put(group.getOffset(), group));

@Override
public boolean add(SuggestionGroup aGroup)
{
  boolean empty = isEmpty();
  
  if (!empty) {
    Validate.isTrue(documentName.equals(aGroup.getDocumentName()),
        "All suggestions in a group must come from the same document: expected [%s] but got [%s]",
        documentName, aGroup.getDocumentName());
  }
  
  // Cache information that must be consistent in the group when the first item is added
  if (empty) {
    documentName = aGroup.getDocumentName();
  }
  
  return groups.add(aGroup);
}

if (isEmpty()) {
  return emptyMap();
else if (size() == 1) {
  AnnotationSuggestion top = get(0);
  if (top.isVisible()) {
    return singletonMap(top.getRecommenderId(), new Delta(top));
  Map<Long, List<AnnotationSuggestion>> predictionsByRecommenders = stream()
      .collect(groupingBy(AnnotationSuggestion::getRecommenderId));

private void actionClearSkippedRecommendations(AjaxRequestTarget aTarget, Form<Void> aForm)
  throws IOException
{
  learningRecordService.deleteSkippedSuggestions(getModelObject().getUser(),
      alStateModel.getObject().getLayer());
  ActiveLearningUserState alState = alStateModel.getObject();
  // The history records caused suggestions to disappear. Since visibility is only fully
  // recalculated when new predictions come in, we need to update the visibility explicitly
  // here
  alState.getSuggestions().stream()
    .flatMap(group -> group.stream())
    .forEach(suggestion -> suggestion.show(FLAG_SKIPPED));
  
  refreshSuggestions();
  moveToNextRecommendation(aTarget, false);
  
  aTarget.add(mainContainer);
}

private List<AnnotationSuggestion> getMatchingSuggestion(List<SuggestionGroup> aSuggestions,
    String aDocumentName, long aLayerId, String aFeature, int aBegin, int aEnd,
    String aLabel)
{
  return aSuggestions.stream()
      .filter(group -> 
          aDocumentName.equals(group.getDocumentName()) &&
          aLayerId == group.getLayerId() &&
          (aFeature == null || aFeature == group.getFeature()) &&
          (aBegin == -1 || aBegin == group.getOffset().getBegin()) &&
          (aEnd == -1 || aEnd == group.getOffset().getEnd()))
      .flatMap(group -> group.stream())
      .filter(suggestion ->
          aLabel == null || aLabel.equals(suggestion.getLabel()))
      .collect(toList());
}

private static SuggestionGroup removeDuplicateRecommendations(
    SuggestionGroup unmodifiedRecommendationList)
{
  SuggestionGroup cleanRecommendationList = new SuggestionGroup();
  unmodifiedRecommendationList.forEach(recommendationItem -> {
    if (!isAlreadyInCleanList(cleanRecommendationList, recommendationItem)) {
      cleanRecommendationList.add(recommendationItem);
    }
  });
  return cleanRecommendationList;
}

@Override
public boolean isSuggestionVisible(LearningRecord aRecord)
{
  User user = userService.get(aRecord.getUser());
  List<SuggestionGroup> suggestions = getSuggestions(user,
      aRecord.getLayer());
  for (SuggestionGroup listOfAO : suggestions) {
    if (listOfAO.stream().anyMatch(suggestion -> 
        suggestion.getDocumentName().equals(aRecord.getSourceDocument().getName()) && 
        suggestion.getFeature().equals(aRecord.getAnnotationFeature().getName()) && 
        suggestion.getLabel().equals(aRecord.getAnnotation()) && 
        suggestion.getBegin() == aRecord.getOffsetCharacterBegin() && 
        suggestion.getEnd() == aRecord.getOffsetCharacterEnd() &&
        suggestion.isVisible())
    ) {
      return true;
    }
  }
  return false;
}

Collection<SuggestionGroup> groups = SuggestionGroup.group(predictions);
calculateVisibility(learningRecordService, annoService, jCas.get(),
    getUser().getUsername(), layer, groups, 0,

@Override
public boolean isSuggestionVisible(LearningRecord aRecord)
{
  User user = userService.get(aRecord.getUser());
  List<SuggestionGroup> suggestions = getSuggestions(user,
      aRecord.getLayer());
  for (SuggestionGroup listOfAO : suggestions) {
    if (listOfAO.stream().anyMatch(suggestion -> 
        suggestion.getDocumentName().equals(aRecord.getSourceDocument().getName()) && 
        suggestion.getFeature().equals(aRecord.getAnnotationFeature().getName()) && 
        suggestion.getLabel().equals(aRecord.getAnnotation()) && 
        suggestion.getBegin() == aRecord.getOffsetCharacterBegin() && 
        suggestion.getEnd() == aRecord.getOffsetCharacterEnd() &&
        suggestion.isVisible())
    ) {
      return true;
    }
  }
  return false;
}

AnnotationSuggestion canonicalRecommendation = suggestion.stream()
    .filter(p -> p.getLabel().equals(label))
    .max(Comparator.comparingInt(AnnotationSuggestion::getId)).orElse(null);