it.unimi.dsi.fastutil.ints.IntComparator Java Examples

public int compare(int o1, int o2) throws UnsupportedOperationException {
  if (!this.isLocked) {
    this.checkChainIntegrity();
    this.isLocked = true;
  }

  Iterator<IntComparator> comparators = this.comparatorChain.iterator();

  for (int comparatorIndex = 0; comparators.hasNext(); ++comparatorIndex) {
    IntComparator comparator = comparators.next();
    int retval = comparator.compare(o1, o2);
    if (retval != 0) {
      if (this.orderingBits.get(comparatorIndex)) {
        if (retval > 0) {
          retval = -1;
        } else {
          retval = 1;
        }
      }
      return retval;
    }
  }
  return 0;
}
 

private static IntComparator intBlockCompare(Type type, Block block)
{
    return new AbstractIntComparator()
    {
        @Override
        public int compare(int left, int right)
        {
            if (block.isNull(left) && block.isNull(right)) {
                return 0;
            }
            if (block.isNull(left)) {
                return 1;
            }
            if (block.isNull(right)) {
                return -1;
            }
            return type.compareTo(block, left, block, right);
        }
    };
}
 

public int compare(int o1, int o2) throws UnsupportedOperationException {
  if (!this.isLocked) {
    this.checkChainIntegrity();
    this.isLocked = true;
  }

  Iterator<IntComparator> comparators = this.comparatorChain.iterator();

  for (int comparatorIndex = 0; comparators.hasNext(); ++comparatorIndex) {
    IntComparator comparator = comparators.next();
    int retval = comparator.compare(o1, o2);
    if (retval != 0) {
      if (this.orderingBits.get(comparatorIndex)) {
        if (retval > 0) {
          retval = -1;
        } else {
          retval = 1;
        }
      }
      return retval;
    }
  }
  return 0;
}
 

/** Returns an array of integers representing the source table indexes in sorted order. */
private int[] sortOn(IntComparator rowComparator) {
  int[] newRows;
  if (hasSelection()) {
    newRows = this.selection.toArray();
  } else {
    newRows = IntStream.range(0, table.rowCount()).toArray();
  }
  IntArrays.parallelQuickSort(newRows, rowComparator);
  return newRows;
}
 

private IntComparatorChain(IntComparator comparator, boolean reverse) {
  this.orderingBits = null;
  this.isLocked = false;
  this.comparatorChain = new ArrayList<>(1);
  this.comparatorChain.add(comparator);
  this.orderingBits = new BitSet(1);
  if (reverse) {
    this.orderingBits.set(0);
  }
}
 

/** Returns an array of integers representing the source table indexes in sorted order. */
private int[] sortOn(IntComparator rowComparator) {
  int[] newRows;
  if (hasSelection()) {
    newRows = this.selection.toArray();
  } else {
    newRows = IntStream.range(0, table.rowCount()).toArray();
  }
  IntArrays.parallelQuickSort(newRows, rowComparator);
  return newRows;
}
 

/**
 * Sort this view in place without modifying or copying the underlying source table. Unlike {@link
 * Table#sortOn(Sort)} which returns a copy of the table, this method sorts the view in place.
 *
 * @param key to sort on.
 */
public void sortOn(Sort key) {
  Preconditions.checkArgument(!key.isEmpty());
  if (key.size() == 1) {
    IntComparator comparator = SortUtils.getComparator(table, key);
    this.sortOrder = sortOn(comparator);
  } else {
    IntComparatorChain chain = SortUtils.getChain(table, key);
    this.sortOrder = sortOn(chain);
  }
}
 

/** Returns a comparator chain for sorting according to the given key */
public static IntComparatorChain getChain(Table table, Sort key) {
  Iterator<Map.Entry<String, Sort.Order>> entries = key.iterator();
  Map.Entry<String, Sort.Order> sort = entries.next();
  Column<?> column = table.column(sort.getKey());
  IntComparator comparator = rowComparator(column, sort.getValue());

  IntComparatorChain chain = new IntComparatorChain(comparator);
  while (entries.hasNext()) {
    sort = entries.next();
    chain.addComparator(rowComparator(table.column(sort.getKey()), sort.getValue()));
  }
  return chain;
}
 

/**
 * Returns a comparator that can be used to sort the records in this table according to the given
 * sort key
 */
public static IntComparator getComparator(Table table, Sort key) {
  Iterator<Map.Entry<String, Sort.Order>> entries = key.iterator();
  Map.Entry<String, Sort.Order> sort = entries.next();
  Column<?> column = table.column(sort.getKey());
  return SortUtils.rowComparator(column, sort.getValue());
}
 

/** Returns a copy of this table sorted using the given comparator */
public Table sortOn(Comparator<Row> rowComparator) {
  Row row1 = new Row(this);
  Row row2 = new Row(this);
  return sortOn(
      (IntComparator)
          (k1, k2) -> {
            row1.at(k1);
            row2.at(k2);
            return rowComparator.compare(row1, row2);
          });
}
 

/** Returns a copy of this table sorted using the given comparator */
private Table sortOn(IntComparator rowComparator) {
  Table newTable = emptyCopy(rowCount());

  int[] newRows = rows();
  IntArrays.parallelQuickSort(newRows, rowComparator);

  Rows.copyRowsToTable(newRows, this, newTable);
  return newTable;
}
 

/**
 * Returns a copy of this table sorted using the given sort key.
 *
 * @param key to sort on.
 * @return a sorted copy of this table.
 */
public Table sortOn(Sort key) {
  Preconditions.checkArgument(!key.isEmpty());
  if (key.size() == 1) {
    IntComparator comparator = SortUtils.getComparator(this, key);
    return sortOn(comparator);
  }
  IntComparatorChain chain = SortUtils.getChain(this, key);
  return sortOn(chain);
}
 

/**
 * Returns a copy of this table sorted using the given sort key.
 *
 * @param key to sort on.
 * @return a sorted copy of this table.
 */
public Table sortOn(Sort key) {
  Preconditions.checkArgument(!key.isEmpty());
  if (key.size() == 1) {
    IntComparator comparator = SortUtils.getComparator(this, key);
    return sortOn(comparator);
  }
  IntComparatorChain chain = SortUtils.getChain(this, key);
  return sortOn(chain);
}
 

/**
 * Sort this view in place without modifying or copying the underlying source table. Unlike {@link
 * Table#sortOn(Sort)} which returns a copy of the table, this method sorts the view in place.
 *
 * @param key to sort on.
 */
public void sortOn(Sort key) {
  Preconditions.checkArgument(!key.isEmpty());
  if (key.size() == 1) {
    IntComparator comparator = SortUtils.getComparator(table, key);
    this.sortOrder = sortOn(comparator);
  } else {
    IntComparatorChain chain = SortUtils.getChain(table, key);
    this.sortOrder = sortOn(chain);
  }
}
 

/** Returns a copy of this table sorted using the given comparator */
private Table sortOn(IntComparator rowComparator) {
  Table newTable = emptyCopy(rowCount());

  int[] newRows = rows();
  IntArrays.parallelQuickSort(newRows, rowComparator);

  Rows.copyRowsToTable(newRows, this, newTable);
  return newTable;
}
 

/**
 * Returns a comparator that can be used to sort the records in this table according to the given
 * sort key
 */
public static IntComparator getComparator(Table table, Sort key) {
  Iterator<Map.Entry<String, Sort.Order>> entries = key.iterator();
  Map.Entry<String, Sort.Order> sort = entries.next();
  Column<?> column = table.column(sort.getKey());
  return SortUtils.rowComparator(column, sort.getValue());
}
 

/** Returns a comparator chain for sorting according to the given key */
public static IntComparatorChain getChain(Table table, Sort key) {
  Iterator<Map.Entry<String, Sort.Order>> entries = key.iterator();
  Map.Entry<String, Sort.Order> sort = entries.next();
  Column<?> column = table.column(sort.getKey());
  IntComparator comparator = rowComparator(column, sort.getValue());

  IntComparatorChain chain = new IntComparatorChain(comparator);
  while (entries.hasNext()) {
    sort = entries.next();
    chain.addComparator(rowComparator(table.column(sort.getKey()), sort.getValue()));
  }
  return chain;
}
 

private IntComparatorChain(IntComparator comparator, boolean reverse) {
  this.orderingBits = null;
  this.isLocked = false;
  this.comparatorChain = new ArrayList<>(1);
  this.comparatorChain.add(comparator);
  this.orderingBits = new BitSet(1);
  if (reverse) {
    this.orderingBits.set(0);
  }
}
 

/** Returns a copy of this table sorted using the given comparator */
public Table sortOn(Comparator<Row> rowComparator) {
  Row row1 = new Row(this);
  Row row2 = new Row(this);
  return sortOn(
      (IntComparator)
          (k1, k2) -> {
            row1.at(k1);
            row2.at(k2);
            return rowComparator.compare(row1, row2);
          });
}
 

public IntComparator comparator() {
	return null;
}
 

private ReversingIntComparator(IntComparator intComparator) {
  this.intComparator = intComparator;
}
 

public static IntComparator reverse(IntComparator intComparator) {
  return new ReversingIntComparator(intComparator);
}
 

@Override
public IntComparator rowComparator() {
  return comparator;
}
 

@Override
public IntComparator rowComparator() {
  return rowComparator;
}
 

@Override
public IntComparator rowComparator() {
  return comparator;
}
 

@Override
public IntComparator rowComparator() {
  return rowComparator;
}
 

@Override
public IntComparator rowComparator() {
  return comparator;
}
 

@Override
public IntComparator rowComparator() {
  return comparator;
}
 

/**
 * Compares the given ints, which refer to the indexes of the doubles in this column, according to
 * the values of the doubles themselves
 */
@Override
public IntComparator rowComparator() {
  return comparator;
}
 

@Override
public IntComparator rowComparator() {
  return comparator;
}