Java 类it.unimi.dsi.fastutil.ints.IntIterator 实例源码

/**
 * Get min clock of this row, remove clocks of tasks which would never update this row.
 * 
 * @return min clock value
 */
public int getMinClock() {
  if (clocks.size() == 0) {
    return 0;
  }

  IntIterator iter = clocks.values().iterator();
  int min = Integer.MAX_VALUE;
  while (iter.hasNext()) {
    int clock = iter.nextInt();
    if (clock < min) {
      min = clock;
    }
  }
  return min;
}

public String listRowIds() {
  int[] idList = new int[rowIdSet.size()];
  IntIterator iter = rowIdSet.iterator();
  int i = 0;
  while (iter.hasNext()) {
    idList[i++] = iter.nextInt();
  }

  Arrays.sort(idList);

  StringBuilder sb = new StringBuilder();
  for (i = 0; i < idList.length; i++) {
    sb.append(idList[i]);
    sb.append(",");
  }

  return sb.toString();
}

private DebugLocalsChange createLocalsChange(
    Int2ReferenceMap<DebugLocalInfo> ending, Int2ReferenceMap<DebugLocalInfo> starting) {
  if (ending.isEmpty() && starting.isEmpty()) {
    return null;
  }
  if (ending.isEmpty() || starting.isEmpty()) {
    return new DebugLocalsChange(ending, starting);
  }
  IntSet unneeded = new IntArraySet(Math.min(ending.size(), starting.size()));
  for (Entry<DebugLocalInfo> entry : ending.int2ReferenceEntrySet()) {
    if (starting.get(entry.getIntKey()) == entry.getValue()) {
      unneeded.add(entry.getIntKey());
    }
  }
  if (unneeded.size() == ending.size() && unneeded.size() == starting.size()) {
    return null;
  }
  IntIterator iterator = unneeded.iterator();
  while (iterator.hasNext()) {
    int key = iterator.nextInt();
    ending.remove(key);
    starting.remove(key);
  }
  return new DebugLocalsChange(ending, starting);
}

public boolean intersectionPE(CustomHashMap other){
boolean modified = false;

IntIterator itr = this.keySet().iterator();
while(itr.hasNext()){
    int key = itr.nextInt();
    int keyInv = 0 - key;
    if(!other.containsKey(key) && !other.containsKey(keyInv)){
    itr.remove();
    modified = true;
    }
}

for(int otherKey : other.keySet()){
    int otherKeyInv = 0-otherKey;
    boolean intst = this.containsKey(otherKey); //does this contain otherKey?
    boolean intstPrime = this.containsKey(otherKeyInv); //does this contain -(otherkey)?

    if(!intst && intstPrime){
    this.put(otherKey, other.get(otherKey));
    modified = true;
    }
}
return modified;
   }

public Attribute createNewAttribute(HashMap<String, Attribute> attributes,
           String attribute, int noMonths) {
    Attribute a = attributes.get(attribute);
       int ct = 0;
       IntSet keys = a.data.keySet();
       IntIterator it = keys.iterator();
       ArrayList<SpatioTemporalVal> arr = new ArrayList<SpatioTemporalVal>();
       while(ct < noMonths) {
           if(!it.hasNext()) {
               Utilities.er("no. of months is greater than what is present");
           }
           int month = it.nextInt();
           arr.addAll(a.data.get(month));
           ct++;
       }
       Collections.sort(arr);
       Attribute na = new Attribute();
       na.data.put(0, arr);
       na.nodeSet = a.nodeSet;
       return na;
}

/**
 * Returns an iterator over elements of type {@code T}.
 *
 * @return an Iterator.
 */
@Override
public Iterator<LocalTime> iterator() {

    return new Iterator<LocalTime>() {

        IntIterator intIterator = intIterator();

        @Override
        public boolean hasNext() {
            return intIterator.hasNext();
        }

        @Override
        public LocalTime next() {
            return PackedLocalTime.asLocalTime(intIterator.nextInt());
        }
    };
}

/**
 * Returns an iterator over elements of type {@code T}.
 *
 * @return an Iterator.
 */
@Override
public Iterator<LocalDate> iterator() {

    return new Iterator<LocalDate>() {

        IntIterator intIterator = intIterator();

        @Override
        public boolean hasNext() {
            return intIterator.hasNext();
        }

        @Override
        public LocalDate next() {
            return PackedLocalDate.asLocalDate(intIterator.nextInt());
        }
    };
}

@Test
public void testInternalIdToLongIterator() {
  LongToInternalIntBiMap nodesToIndexBiMap =
      new ArrayBasedLongToInternalIntBiMap(10, 0.5, -1, -1L, nullStatsReceiver);
  int n = 7;
  int[] expectedIndices = new int[n];
  long[] expectedEntries = new long[n];
  for (int i = 0; i < n; i++) {
    expectedIndices[i] = nodesToIndexBiMap.put(i);
    expectedEntries[i] = (long) i;
  }
  IntIterator intIterator = new IntArrayList(expectedIndices).iterator();

  InternalIdToLongIterator internalIdToLongIterator =
      new InternalIdToLongIterator(nodesToIndexBiMap, new IdentityEdgeTypeMask());

  internalIdToLongIterator.resetWithIntIterator(new WithEdgeMetadataIntIteratorImpl(intIterator));
  assertEquals(new LongArrayList(expectedEntries), new LongArrayList(internalIdToLongIterator));
}

private Int2IntMap getFasterIntersectionMap(int uidx) {
    Int2IntOpenHashMap intersectionMap = new Int2IntOpenHashMap();
    intersectionMap.defaultReturnValue(0);

    IntIterator iidxs = data.getUidxIidxs(uidx);
    while (iidxs.hasNext()) {
        IntIterator vidxs = data.getIidxUidxs(iidxs.nextInt());
        while (vidxs.hasNext()) {
            intersectionMap.addTo(vidxs.nextInt(), 1);
        }
    }

    intersectionMap.remove(uidx);

    return intersectionMap;
}

private Int2DoubleMap getProductMap(int uidx) {
    Int2DoubleOpenHashMap productMap = new Int2DoubleOpenHashMap();
    productMap.defaultReturnValue(0.0);

    if (data.useIteratorsPreferentially()) {
        IntIterator iidxs = data.getUidxIidxs(uidx);
        DoubleIterator ivs = data.getUidxVs(uidx);
        while (iidxs.hasNext()) {
            int iidx = iidxs.nextInt();
            double iv = ivs.nextDouble();
            IntIterator vidxs = data.getIidxUidxs(iidx);
            DoubleIterator vvs = data.getIidxVs(iidx);
            while (vidxs.hasNext()) {
                productMap.addTo(vidxs.nextInt(), iv * vvs.nextDouble());
            }
        }
    } else {
        data.getUidxPreferences(uidx)
                .forEach(ip -> data.getIidxPreferences(ip.v1)
                        .forEach(up -> productMap.addTo(up.v1, ip.v2 * up.v2)));
    }

    productMap.remove(uidx);

    return productMap;
}

private double[] getProductArray(int uidx) {
    double[] productArray = new double[data.numUsers()];

    if (data.useIteratorsPreferentially()) {
        IntIterator iidxs = data.getUidxIidxs(uidx);
        DoubleIterator ivs = data.getUidxVs(uidx);
        while (iidxs.hasNext()) {
            int iidx = iidxs.nextInt();
            double iv = ivs.nextDouble();
            IntIterator vidxs = data.getIidxUidxs(iidx);
            DoubleIterator vvs = data.getIidxVs(iidx);
            while (vidxs.hasNext()) {
                productArray[vidxs.nextInt()] += iv * vvs.nextDouble();
            }
        }
    } else {
        data.getUidxPreferences(uidx)
                .forEach(ip -> data.getIidxPreferences(ip.v1)
                        .forEach(up -> productArray[up.v1] += ip.v2 * up.v2));
    }

    productArray[uidx] = 0.0;

    return productArray;
}

/**
 * Estimates the number of bits required for the succinct delta representation from strictly incremental
 * <code>list</code>. For details of the representation (see
 * {@link org.pebble.core.encoding.OutputSuccinctStream#writeDelta(it.unimi.dsi.fastutil.ints.IntList, int) writeDelta}).
 * @param list to encode. List must be strictly incremental with positives (including zero) values.
 * @param valueBitSize fixed number of bits used to represent value in list to be encoded. It can be any value
 *                     between 1bit and 31 bits.
 * @return number of representation bits.
 */
public int getWriteDeltaOffset(final IntList list, final int valueBitSize) {
    final IntIterator listIterator = list.iterator();
    int offset = getWriteDeltaOffset(list.size());
    if (listIterator.hasNext()) {
        int value;
        int deltaValue;
        int lastValue = listIterator.nextInt();
        offset += writeIntOffset(lastValue, valueBitSize);
        while (listIterator.hasNext()) {
            value = listIterator.nextInt();
            deltaValue = value - lastValue - 1;
            offset += getWriteDeltaOffset(deltaValue);
            lastValue = value;
        }
    }
    return offset;
}

@Nullable
public static <T> T getWeightedRandomReversed(Random random, Int2ObjectMap<T> choices)
{
    long i = 0;
    IntSet ints = choices.keySet();
    for (IntIterator iterator = ints.iterator(); iterator.hasNext(); )
    {
        int x = iterator.nextInt();
        i += x;
    }
    i = getRandomLong(random, 0, i);
    for (Int2ObjectMap.Entry<T> entry : choices.int2ObjectEntrySet())
    {
        i -= entry.getIntKey();
        if (i < 0)
        {
            return entry.getValue();
        }
    }
    return null;
}

@Nullable
public static <T> T getWeightedRandom(Random random, Object2IntMap<T> choices)
{
    long i = 0;
    IntCollection ints = choices.values();
    for (IntIterator iterator = ints.iterator(); iterator.hasNext(); )
    {
        int x = iterator.nextInt();
        i += x;
    }
    i = getRandomLong(random, 0, i);
    for (Object2IntMap.Entry<T> entry : choices.object2IntEntrySet())
    {
        i -= entry.getIntValue();
        if (i < 0)
        {
            return entry.getKey();
        }
    }
    return null;
}

private int acquire0() {
    final int id;
    final IntIterator it = allocatorReusableIds.iterator();
    if (it.hasNext()) {
        try {
            id = it.nextInt();
        } finally {
            it.remove();
        }
    } else {
        id = allocatorIdCounter++;
    }
    if (this.entityProtocol != null) {
        this.entityProtocol.entityProtocolManager.idToEntityProtocolMap.put(id, this.entityProtocol);
    }
    return id;
}

public IntCollection values() {
 if ( values == null ) values = new AbstractIntCollection () {
   public IntIterator iterator() {
    return new ValueIterator();
   }
   public int size() {
    return size;
   }
   public boolean contains( int v ) {
    return containsValue( v );
   }
   public void clear() {
    Int2IntOpenHashMap.this.clear();
   }
  };
 return values;
}

/**
 * Returns an iterator over elements of type {@code T}.
 *
 * @return an Iterator.
 */
@Override
public Iterator<LocalTime> iterator() {

    return new Iterator<LocalTime>() {

        IntIterator intIterator = intIterator();

        @Override
        public boolean hasNext() {
            return intIterator.hasNext();
        }

        @Override
        public LocalTime next() {
            return PackedLocalTime.asLocalTime(intIterator.nextInt());
        }
    };
}

/**
 * Returns an iterator over elements of type {@code T}.
 *
 * @return an Iterator.
 */
@Override
public Iterator<LocalDate> iterator() {

    return new Iterator<LocalDate>() {

        IntIterator intIterator = intIterator();

        @Override
        public boolean hasNext() {
            return intIterator.hasNext();
        }

        @Override
        public LocalDate next() {
            return PackedLocalDate.asLocalDate(intIterator.nextInt());
        }
    };
}

public void testMerge( int n0, int n1 ) {
    Random r = new Random();
    int x0[] = new int[ n0 ];
    int x1[] = new int[ n1 ];
    int i, p = 0;

    // Generate
    for ( i = 0; i < n0; i++ ) p = x0[ i ] = p + r.nextInt( 10 );
    p = 0;
    for ( i = 0; i < n1; i++ ) p = x1[ i ] = p + (int)( Math.random() * 10 );

    IntAVLTreeSet s0 = new IntAVLTreeSet( x0 );
    IntAVLTreeSet s1 = new IntAVLTreeSet( x1 );
    IntAVLTreeSet res = new IntAVLTreeSet( s0 );
    res.addAll( s1 );

    MergedIntIterator m = new MergedIntIterator( LazyIntIterators.lazy( s0.iterator() ), LazyIntIterators.lazy( s1.iterator() ) );
    IntIterator it = res.iterator();

    int x;
    while ( ( x = m.nextInt() ) != -1 ) assertEquals( it.nextInt(), x );
    assertEquals( Boolean.valueOf( it.hasNext() ), Boolean.valueOf( m.nextInt() != -1 ) );
}

public String createGraphWithFixedWidthLabels( File basename, ImmutableGraph g, int width ) throws IllegalArgumentException, SecurityException, IOException {
    final int n = g.numNodes();
    System.err.println( "Testing " + n + " nodes, width " + width+ ", basename " + basename );

    OutputBitStream labels = createTempBitStream( basename + "-fixedlabel" + BitStreamArcLabelledImmutableGraph.LABELS_EXTENSION );
    OutputBitStream offsets = createTempBitStream( basename + "-fixedlabel" + BitStreamArcLabelledImmutableGraph.LABEL_OFFSETS_EXTENSION );
    offsets.writeGamma( 0 );
    for( int i = 0; i < n; i++ ) {
        int bits = 0;
        for( IntIterator j = LazyIntIterators.eager( g.successors( i ) ); j.hasNext(); ) bits += labels.writeInt( i * j.nextInt() + i, width );
        offsets.writeGamma( bits );
    }
    labels.close();
    offsets.close();

    PrintWriter pw = new PrintWriter( new FileWriter( basename + "-fixedlabel.properties" ) );
    pw.println( ImmutableGraph.GRAPHCLASS_PROPERTY_KEY + " = " + BitStreamArcLabelledImmutableGraph.class.getName() );
    pw.println( BitStreamArcLabelledImmutableGraph.LABELSPEC_PROPERTY_KEY + " = " + FixedWidthIntLabel.class.getName() + "(TEST," + width + ")" );
    pw.println( ArcLabelledImmutableGraph.UNDERLYINGGRAPH_PROPERTY_KEY + " = " + basename.getName() );
    pw.close();

    return basename + "-fixedlabel";
}

public String createGraphWithGammaLabels( File basename, ImmutableGraph g ) throws IllegalArgumentException, SecurityException, IOException {
    // We create a complete graph with labels 
    final int n = g.numNodes();
    System.err.println( "Testing " + n + " nodes, gamma coding, basename " + basename );

    OutputBitStream labels = createTempBitStream( basename + "-gammalabel" + BitStreamArcLabelledImmutableGraph.LABELS_EXTENSION );
    OutputBitStream offsets = createTempBitStream( basename + "-gammalabel" + BitStreamArcLabelledImmutableGraph.LABEL_OFFSETS_EXTENSION );
    offsets.writeGamma( 0 );
    for( int i = 0; i < n; i++ ) {
        int bits = 0;
        for( IntIterator j = LazyIntIterators.eager( g.successors( i ) ); j.hasNext(); ) bits += labels.writeGamma( i * j.nextInt() + i );
        offsets.writeGamma( bits );
    }
    labels.close();
    offsets.close();

    PrintWriter pw = new PrintWriter( new FileWriter( basename + "-gammalabel" + ImmutableGraph.PROPERTIES_EXTENSION ) );
    pw.println( ImmutableGraph.GRAPHCLASS_PROPERTY_KEY + " = " + BitStreamArcLabelledImmutableGraph.class.getName() );
    pw.println( BitStreamArcLabelledImmutableGraph.LABELSPEC_PROPERTY_KEY + " = " + GammaCodedIntLabel.class.getName() + "(TEST)" );
    pw.println( ArcLabelledImmutableGraph.UNDERLYINGGRAPH_PROPERTY_KEY + " = " + basename.getName() );
    pw.close();

    return basename + "-gammalabel";
}

@Test
public void testConstructor() throws IllegalArgumentException, SecurityException {
    for( int n = 1; n < 8; n++ ) {
        for( int type = 0; type < 3; type++ ) {
            System.err.println( "Testing type " + type + ", n=" + n + "..." );
            ArrayListMutableGraph g = type == 0 ? ArrayListMutableGraph.newCompleteGraph( n, false ) :
                type == 1 ? ArrayListMutableGraph.newCompleteBinaryIntree( n ) :
                    ArrayListMutableGraph.newCompleteBinaryOuttree( n ); 
            final ImmutableGraph immutableView = g.immutableView();
            assertGraph( immutableView );
            assertEquals( g, new ArrayListMutableGraph( immutableView ) );
            int[][] arc = new int[ (int)g.numArcs() ][ 2 ];
            for( int i = 0, k = 0; i < g.numNodes(); i++ )
                for( IntIterator successors = g.successors( i ); successors.hasNext(); ) 
                    arc[ k++ ] = new int[] { i, successors.nextInt() };

            assertEquals( g, new ArrayListMutableGraph( g.numNodes(), arc ) );
        }
    }
}

private int findSlotForPlayer(UUID playerUUID) {
    int targetSlot = -1;
    for (IntIterator iterator = skinUuidToSlotMap.get(playerUUID).iterator(); iterator.hasNext(); ) {
        int i = iterator.nextInt();
        if (clientUuid[i] == fakePlayerUUIDs[i]) {
            targetSlot = i;
            break;
        }
    }
    if (targetSlot == -1) {
        for (int i = size - 1; i >= 0; i--) {
            if (clientUuid[i] == fakePlayerUUIDs[i]) {
                targetSlot = i;
                break;
            }
        }
    }
    if (targetSlot == -1) {
        throw new IllegalStateException("Not enough slots in tab list.");
    }
    return targetSlot;
}

/**
 * Helper method to serialize an {@link IntOpenHashSet}.
 */
private static byte[] serializeIntOpenHashSet(IntOpenHashSet intOpenHashSet)
    throws IOException {
  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
  DataOutputStream dataOutputStream = new DataOutputStream(byteArrayOutputStream);

  // Write the size of the set.
  dataOutputStream.writeInt(intOpenHashSet.size());

  IntIterator intIterator = intOpenHashSet.iterator();
  while (intIterator.hasNext()) {
    dataOutputStream.writeInt(intIterator.nextInt());
  }

  return byteArrayOutputStream.toByteArray();
}

@Override
public Iterator<Edge<IntWritable, NullWritable>> iterator() {
  // Returns an iterator that reuses objects.
  return new UnmodifiableIterator<Edge<IntWritable, NullWritable>>() {
    /** Wrapped neighbors iterator. */
    private IntIterator neighborsIt = neighbors.iterator();
    /** Representative edge object. */
    private Edge<IntWritable, NullWritable> representativeEdge =
        EdgeFactory.create(new IntWritable(), NullWritable.get());

    @Override
    public boolean hasNext() {
      return neighborsIt.hasNext();
    }

    @Override
    public Edge<IntWritable, NullWritable> next() {
      representativeEdge.getTargetVertexId().set(neighborsIt.nextInt());
      return representativeEdge;
    }
  };
}

@Override
public Iterator<Edge<IntWritable, NullWritable>> iterator() {
  // Returns an iterator that reuses objects.
  return new UnmodifiableIterator<Edge<IntWritable, NullWritable>>() {
    /** Wrapped neighbors iterator. */
    private IntIterator neighborsIt = neighbors.iterator();
    /** Representative edge object. */
    private Edge<IntWritable, NullWritable> representativeEdge =
        EdgeFactory.create(new IntWritable(), NullWritable.get());

    @Override
    public boolean hasNext() {
      return neighborsIt.hasNext();
    }

    @Override
    public Edge<IntWritable, NullWritable> next() {
      representativeEdge.getTargetVertexId().set(neighborsIt.nextInt());
      return representativeEdge;
    }
  };
}

@Override
public Iterator<Edge<IntWritable, NullWritable>> iterator() {
  // Returns an iterator that reuses objects.
  return new UnmodifiableIterator<Edge<IntWritable, NullWritable>>() {
    /** Wrapped neighbors iterator. */
    private IntIterator neighborsIt = neighbors.iterator();
    /** Representative edge object. */
    private Edge<IntWritable, NullWritable> representativeEdge =
        EdgeFactory.create(new IntWritable(), NullWritable.get());

    @Override
    public boolean hasNext() {
      return neighborsIt.hasNext();
    }

    @Override
    public Edge<IntWritable, NullWritable> next() {
      representativeEdge.getTargetVertexId().set(neighborsIt.nextInt());
      return representativeEdge;
    }
  };
}

@Override
public Iterator<Edge<IntWritable, NullWritable>> iterator() {
  // Returns an iterator that reuses objects.
  return new UnmodifiableIterator<Edge<IntWritable, NullWritable>>() {
    /** Wrapped neighbors iterator. */
    private IntIterator neighborsIt = neighbors.iterator();
    /** Representative edge object. */
    private Edge<IntWritable, NullWritable> representativeEdge =
        EdgeFactory.create(new IntWritable(), NullWritable.get());

    @Override
    public boolean hasNext() {
      return neighborsIt.hasNext();
    }

    @Override
    public Edge<IntWritable, NullWritable> next() {
      representativeEdge.getTargetVertexId().set(neighborsIt.nextInt());
      return representativeEdge;
    }
  };
}

private RowIndex findNewRows(RowIndex rowIndex) {
  IntOpenHashSet need = new IntOpenHashSet();
  IntOpenHashSet fetchingRowIds = fetchingRowSets.get(rowIndex.getMatrixId());

  IntIterator iter = rowIndex.getRowIds().iterator();
  while (iter.hasNext()) {
    int rowId = iter.nextInt();
    if (!fetchingRowIds.contains(rowId)) {
      need.add(rowId);
      fetchingRowIds.add(rowId);
    }
  }

  return new RowIndex(rowIndex.getMatrixId(), need, rowIndex);
}

void intersectReferenced(final IntSet attributes, final Attribute[] attributeIndex) {
  final IntIterator referencedIterator = referenced.iterator();
  while (referencedIterator.hasNext()) {
    final int ref = referencedIterator.nextInt();
    if (attributes.contains(ref)) {
      continue;
    }

    referencedIterator.remove();
    attributeIndex[ref].removeDependent(id);
  }
}

public void printReads(){
IntIterator itr = this.keySet().iterator();
HLA.log.append("{");
while(itr.hasNext())
    HLA.log.append(" (" +itr.nextInt() + ") ");
HLA.log.appendln("}");

   }

public boolean intersection(CustomHashMap other){
boolean modified = false;
IntIterator itr = this.keySet().iterator();
while(itr.hasNext()){
    int curInt = itr.nextInt();
    if(!other.containsKey(curInt)){
    itr.remove();
    modified = false;
    }
}
return modified;
   }

public boolean removeAll(CustomHashMap other){
boolean modified = false;
IntIterator itr = other.keySet().iterator();
int curKey;
while(itr.hasNext()){
    curKey = itr.next();
    if(this.containsKey(curKey)){
    this.remove(curKey);
    modified = true;
    }
}
return modified;
   }

public void printKeys(){
IntIterator itr = this.keySet().iterator();
HLA.log.append("{");
if(this.size() > 0)
    HLA.log.append(itr.nextInt());
while(itr.hasNext())
    HLA.log.append("," + itr.nextInt());
HLA.log.appendln("}");
   }

/** {@inheritDoc} */
@Override public int nonZeroElements() {
    int res = 0;
    IntIterator rowIter = indexesMap().keySet().iterator();

    while (rowIter.hasNext()) {
        int row = rowIter.nextInt();
        res += indexesMap().get(row).size();
    }

    return res;
}

@Nonnull
public int[] getUsers() {
    final int size = rows.size();
    final int[] keys = new int[size];
    final IntIterator itor = rows.keySet().iterator();
    for (int i = 0; i < size; i++) {
        if (!itor.hasNext()) {
            throw new IllegalStateException();
        }
        int key = itor.nextInt();
        keys[i] = key;
    }
    return keys;
}

public TimeColumn selectIf(LocalTimePredicate predicate) {
    TimeColumn column = emptyCopy();
    IntIterator iterator = intIterator();
    while (iterator.hasNext()) {
        int next = iterator.nextInt();
        if (predicate.test(PackedLocalTime.asLocalTime(next))) {
            column.appendInternal(next);
        }
    }
    return column;
}

/**
 * This version operates on predicates that treat the given IntPredicate as operating on a packed local time
 * This is much more efficient that using a LocalTimePredicate, but requires that the developer understand the
 * semantics of packedLocalTimes
 */
public TimeColumn selectIf(IntPredicate predicate) {
    TimeColumn column = emptyCopy();
    IntIterator iterator = intIterator();
    while (iterator.hasNext()) {
        int next = iterator.nextInt();
        if (predicate.test(next)) {
            column.appendInternal(next);
        }
    }
    return column;
}

/**
 * Returns a bitmap flagging the records for which the value in this column is equal to the value in the given
 * column
 * Columnwise isEqualTo.
 */
public Selection isEqualTo(TimeColumn column) {
    Selection results = new BitmapBackedSelection();
    int i = 0;
    IntIterator intIterator = column.intIterator();
    for (int next : data) {
        if (next == intIterator.nextInt()) {
            results.add(i);
        }
        i++;
    }
    return results;
}

/**
 * Returns a bitmap flagging the records for which the value in this column is equal to the value in the given
 * column
 * Columnwise isEqualTo.
 */
public Selection isEqualTo(DateColumn column) {
    Selection results = new BitmapBackedSelection();
    int i = 0;
    IntIterator intIterator = column.intIterator();
    for (int next : data) {
        if (next == intIterator.nextInt()) {
            results.add(i);
        }
        i++;
    }
    return results;
}