import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
private int discardHead(ColumnFamily cf, int toDiscard, ColumnFamily copy, Iterator<Cell> iter, DeletionInfo.InOrderTester tester)
{
    ColumnCounter counter = columnCounter();

    // Discard the first 'toDiscard' live
    while (iter.hasNext())
    {
        Cell c = iter.next();
        counter.count(c, tester);
        if (counter.live() > toDiscard)
        {
            copy.addColumn(c);
            while (iter.hasNext())
                copy.addColumn(iter.next());
        }
    }
    return Math.min(counter.live(), toDiscard);
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
private int discardTail(ColumnFamily cf, int toDiscard, ColumnFamily copy, Iterator<Cell> iter, DeletionInfo.InOrderTester tester)
{
    // Redoing the counting like that is not extremely efficient.
    // This is called only for reversed slices or in the case of a race between
    // paging and a deletion (pretty unlikely), so this is probably acceptable.
    int liveCount = columnCounter().countAll(cf).live();

    ColumnCounter counter = columnCounter();
    // Discard the last 'toDiscard' live (so stop adding as sound as we're past 'liveCount - toDiscard')
    while (iter.hasNext())
    {
        Cell c = iter.next();
        counter.count(c, tester);
        if (counter.live() > liveCount - toDiscard)
            break;

        copy.addColumn(c);
    }
    return Math.min(liveCount, toDiscard);
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
/**
 * Convenience method that count (live) cells/rows for a given slice of a row, but page underneath.
 */
public static int countPaged(String keyspace,
                             String columnFamily,
                             ByteBuffer key,
                             SliceQueryFilter filter,
                             ConsistencyLevel consistencyLevel,
                             ClientState cState,
                             final int pageSize,
                             long now) throws RequestValidationException, RequestExecutionException
{
    SliceFromReadCommand command = new SliceFromReadCommand(keyspace, key, columnFamily, now, filter);
    final SliceQueryPager pager = new SliceQueryPager(command, consistencyLevel, cState, false);

    ColumnCounter counter = filter.columnCounter(Schema.instance.getCFMetaData(keyspace, columnFamily).comparator, now);
    while (!pager.isExhausted())
    {
        List<Row> next = pager.fetchPage(pageSize);
        if (!next.isEmpty())
            counter.countAll(next.get(0).cf);
    }
    return counter.live();
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
private ColumnFamily discardFirst(ColumnFamily cf)
{
    ColumnFamily copy = cf.cloneMeShallow();
    ColumnCounter counter = columnCounter();

    Iterator<Column> iter = cf.iterator();
    DeletionInfo.InOrderTester tester = cf.inOrderDeletionTester();
    // Discard the first live
    while (iter.hasNext())
    {
        Column c = iter.next();
        counter.count(c, tester);
        if (counter.live() > 1)
        {
            copy.addColumn(c);
            while (iter.hasNext())
                copy.addColumn(iter.next());
        }
    }
    return copy;
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
private ColumnFamily discardLast(ColumnFamily cf)
{
    ColumnFamily copy = cf.cloneMeShallow();
    // Redoing the counting like that is not extremely efficient, but
    // discardLast is only called in case of a race between paging and
    // a deletion, which is pretty unlikely, so probably not a big deal
    int liveCount = columnCounter().countAll(cf).live();

    ColumnCounter counter = columnCounter();
    DeletionInfo.InOrderTester tester = cf.inOrderDeletionTester();
    // Discard the first live
    for (Column c : cf)
    {
        counter.count(c, tester);
        if (counter.live() < liveCount)
            copy.addColumn(c);
    }
    return copy;
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
/**
 * Convenience method that count (live) cells/rows for a given slice of a row, but page underneath.
 */
public static int countPaged(String keyspace,
                             String columnFamily,
                             ByteBuffer key,
                             SliceQueryFilter filter,
                             ConsistencyLevel consistencyLevel,
                             final int pageSize,
                             long now) throws RequestValidationException, RequestExecutionException
{
    SliceFromReadCommand command = new SliceFromReadCommand(keyspace, key, columnFamily, now, filter);
    final SliceQueryPager pager = new SliceQueryPager(command, consistencyLevel, false);

    ColumnCounter counter = filter.columnCounter(Schema.instance.getComparator(keyspace, columnFamily), now);
    while (!pager.isExhausted())
    {
        List<Row> next = pager.fetchPage(pageSize);
        if (!next.isEmpty())
            counter.countAll(next.get(0).cf);
    }
    return counter.live();
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
/**
 * Convenience method that count (live) cells/rows for a given slice of a row, but page underneath.
 */
public static int countPaged(String keyspace,
                             String columnFamily,
                             ByteBuffer key,
                             SliceQueryFilter filter,
                             ConsistencyLevel consistencyLevel,
                             final int pageSize,
                             long now) throws RequestValidationException, RequestExecutionException
{
    SliceFromReadCommand command = new SliceFromReadCommand(keyspace, key, columnFamily, now, filter);
    final SliceQueryPager pager = new SliceQueryPager(command, consistencyLevel, false);

    ColumnCounter counter = filter.columnCounter(Schema.instance.getCFMetaData(keyspace, columnFamily).comparator, now);
    while (!pager.isExhausted())
    {
        List<Row> next = pager.fetchPage(pageSize);
        if (!next.isEmpty())
            counter.countAll(next.get(0).cf);
    }
    return counter.live();
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
public int liveCQL3RowCount(long now)
{
    ColumnCounter counter = getComparator().isDense()
                          ? new ColumnCounter(now)
                          : new ColumnCounter.GroupByPrefix(now, getComparator(), metadata.clusteringColumns().size());
    return counter.countAll(this).live();
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
public ColumnCounter columnCounter()
{
    return columnFilter.columnCounter(cfm.comparator, timestamp);
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
public ColumnCounter columnCounter()
{
    // We know NamesQueryFilter.columnCounter don't care about his argument
    return command.filter.columnCounter(null, command.timestamp);
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
@Override
public ColumnCounter columnCounter()
{
    return new ColumnCounter(0);
}
 

import org.apache.cassandra.db.filter.ColumnCounter; //导入依赖的package包/类
public ColumnCounter columnCounter();