How to use

ResultComparator

in

rocks.inspectit.shared.cs.communication.comparator

/**
 * {@inheritDoc}
 */
@Override
public Collection<? extends Span> getRootSpans(int limit, Date fromDate, Date toDate, ResultComparator<AbstractSpan> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  return spanDao.getRootSpans(limit, fromDate, toDate, resultComparator);
}

/**
 * {@inheritDoc}
 */
@SuppressWarnings("unchecked")
@Override
public int compare(Viewer viewer, Object o1, Object o2) {
  if (null == comparator) {
    return 0;
  }
  // just return 0 if we don't want to sort
  if (SortState.NONE.equals(sortState)) {
    return 0;
  }
  T e1 = (T) o1;
  T e2 = (T) o2;
  return comparator.compare(e1, e2);
}

/**
 * Toggles the sorting of the column.
 *
 * @param id
 *            The comparator provider.
 */
protected void toggleSortColumn(ResultComparator<T> id) {
  if (comparator == id) { // NOPMD
    switch (sortState) {
    case NONE:
      sortState = SortState.UP;
      comparator.setAscending(true);
      break;
    case UP:
      sortState = SortState.DOWN;
      comparator.setAscending(false);
      break;
    case DOWN:
      sortState = SortState.NONE;
      break;
    default:
      break;
    }
  } else {
    comparator = id;
    sortState = SortState.UP;
    comparator.setAscending(true);
  }
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  TableViewerComparator<TimerData> timerDataViewerComparator = new TableViewerComparator<>();
  for (Column column : Column.values()) {
    ResultComparator<TimerData> resultComparator = new ResultComparator<>(column.dataComparator, cachedDataService);
    timerDataViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
  }
  return timerDataViewerComparator;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  TableViewerComparator<JmxSensorValueData> timerDataViewerComparator = new TableViewerComparator<>();
  for (Column column : Column.values()) {
    ResultComparator<JmxSensorValueData> resultComparator = new ResultComparator<>(column.dataComparator, cachedDataService);
    timerDataViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
  }
  return timerDataViewerComparator;
}

/**
 * {@inheritDoc}
 */
@Override
@MethodLog
public List<ExceptionSensorData> getUngroupedExceptionOverview(ExceptionSensorData template, Date fromDate, Date toDate, ResultComparator<ExceptionSensorData> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  List<ExceptionSensorData> result = exceptionSensorDataDao.getUngroupedExceptionOverview(template, fromDate, toDate, resultComparator);
  return result;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  TreeViewerComparator<SqlStatementData> sqlViewerComparator = new DatabaseSqlTreeComparator();
  for (Column column : Column.values()) {
    if (null != column.dataComparator) {
      ResultComparator<SqlStatementData> resultComparator = new ResultComparator<>(column.dataComparator, cachedDataService);
      sqlViewerComparator.addColumn(getMappedTreeViewerColumn(column).getColumn(), resultComparator);
    }
  }
  return sqlViewerComparator;
}

/**
 * {@inheritDoc}
 * <p>
 * Will only compare if the conditions are met.
 */
@Override
public int compare(T o1, T o2) {
  if ((compareInRawMode && isRawMode()) || (compareInAggregatedMode && !isRawMode())) {
    return super.compare(o1, o2);
  } else {
    return 0;
  }
};

/**
 * {@inheritDoc}
 */
@Override
@MethodLog
public List<InvocationSequenceData> getInvocationSequenceOverview(long platformId, Collection<Long> invocationIdCollection, int limit, ResultComparator<InvocationSequenceData> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  List<InvocationSequenceData> result = invocationDataDao.getInvocationSequenceOverview(platformId, invocationIdCollection, limit, resultComparator);
  return result;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  RemoteTableViewerComparator<InvocationSequenceData> invocOverviewViewerComparator = new RemoteTableViewerComparator<InvocationSequenceData>() {
    @Override
    protected void sortRemotely(ResultComparator<InvocationSequenceData> resultComparator) {
      if (null != resultComparator) {
        InvocOverviewInputController.this.resultComparator = resultComparator;
      } else {
        InvocOverviewInputController.this.resultComparator = defaultComparator;
      }
      loadDataFromService();
    }
  };
  for (Column column : Column.values()) {
    // since it is remote sorting we do not provide local cached data service
    ResultComparator<InvocationSequenceData> resultComparator = new ResultComparator<>(column.dataComparator);
    invocOverviewViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
  }
  return invocOverviewViewerComparator;
}

/**
 * {@inheritDoc}
 */
@Override
@MethodLog
public List<ExceptionSensorData> getUngroupedExceptionOverview(ExceptionSensorData template, int limit, Date fromDate, Date toDate, ResultComparator<ExceptionSensorData> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  List<ExceptionSensorData> result = exceptionSensorDataDao.getUngroupedExceptionOverview(template, limit, fromDate, toDate, resultComparator);
  return result;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  RemoteTableViewerComparator<ExceptionSensorData> exceptionViewerComparator = new RemoteTableViewerComparator<ExceptionSensorData>() {
    @Override
    protected void sortRemotely(ResultComparator<ExceptionSensorData> resultComparator) {
      if (null != resultComparator) {
        UngroupedExceptionOverviewInputController.this.resultComparator = resultComparator;
      } else {
        UngroupedExceptionOverviewInputController.this.resultComparator = defaultComparator;
      }
      loadDataFromService();
    }
  };
  for (Column column : Column.values()) {
    // since it is remote sorting we do not provide local cached data service
    ResultComparator<ExceptionSensorData> resultComparator = new ResultComparator<>(column.dataComparator);
    exceptionViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
  }
  return exceptionViewerComparator;
}

/**
 * {@inheritDoc}
 */
@Override
@MethodLog
public List<InvocationSequenceData> getInvocationSequenceOverview(long platformId, long methodId, int limit, ResultComparator<InvocationSequenceData> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  List<InvocationSequenceData> result = invocationDataDao.getInvocationSequenceOverview(platformId, methodId, limit, resultComparator);
  return result;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  RemoteTableViewerComparator<AbstractSpan> spanViewerComparator = new RemoteTableViewerComparator<AbstractSpan>() {
    @Override
    protected void sortRemotely(ResultComparator<AbstractSpan> resultComparator) {
      if (null != resultComparator) {
        TraceOverviewInputController.this.resultComparator = resultComparator;
      } else {
        TraceOverviewInputController.this.resultComparator = defaultComparator;
      }
      loadDataFromService();
    }
  };
  for (Column column : Column.values()) {
    if (null != column.dataComparator) {
      ResultComparator<AbstractSpan> resultComparator = new ResultComparator<>(column.dataComparator);
      spanViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
    }
  }
  return spanViewerComparator;
}

/**
 * {@inheritDoc}
 */
@Override
@MethodLog
public List<ExceptionSensorData> getUngroupedExceptionOverview(ExceptionSensorData template, int limit, ResultComparator<ExceptionSensorData> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  List<ExceptionSensorData> result = exceptionSensorDataDao.getUngroupedExceptionOverview(template, limit, resultComparator);
  return result;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  TableViewerComparator<InvocationSequenceData> invocationDataViewerComparator = new TableViewerComparator<>();
  for (Column column : Column.values()) {
    ResultComparator<InvocationSequenceData> resultComparator = new ResultComparator<>(column.dataComparator, getCachedDataService());
    invocationDataViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
  }
  return invocationDataViewerComparator;
}

/**
 * {@inheritDoc}
 */
@Override
@MethodLog
public List<ExceptionSensorData> getUngroupedExceptionOverview(ExceptionSensorData template, ResultComparator<ExceptionSensorData> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  List<ExceptionSensorData> result = exceptionSensorDataDao.getUngroupedExceptionOverview(template, resultComparator);
  return result;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  TableViewerComparator<InvocationSequenceData> invocationDataViewerComparator = new TableViewerComparator<>();
  for (Column column : Column.values()) {
    ResultComparator<InvocationSequenceData> resultComparator = new ResultComparator<>(column.dataComparator, getCachedDataService());
    invocationDataViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
  }
  return invocationDataViewerComparator;
}

/**
 * {@inheritDoc}
 */
@Override
@MethodLog
public List<InvocationSequenceData> getInvocationSequenceOverview(long platformId, int limit, ResultComparator<InvocationSequenceData> resultComparator) {
  if (null != resultComparator) {
    resultComparator.setCachedDataService(cachedDataService);
  }
  List<InvocationSequenceData> result = invocationDataDao.getInvocationSequenceOverview(platformId, limit, resultComparator);
  return result;
}

/**
 * {@inheritDoc}
 */
@Override
public ViewerComparator getComparator() {
  TableViewerComparator<InvocationSequenceData> invocationDataViewerComparator = new TableViewerComparator<>();
  for (Column column : Column.values()) {
    ResultComparator<InvocationSequenceData> resultComparator = new ResultComparator<>(column.dataComparator, getCachedDataService());
    invocationDataViewerComparator.addColumn(getMappedTableViewerColumn(column).getColumn(), resultComparator);
  }
  return invocationDataViewerComparator;
}