import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
public TermSource(SortedKeyValueIterator<Key,Value> iter, Text dataLocation, Text term, boolean notFlag) {
  this.iter = iter;
  this.dataLocation = dataLocation;
  ByteSequence bs = new ArrayByteSequence(dataLocation.getBytes(), 0, dataLocation.getLength());
  this.seekColumnFamilies = Collections.singletonList(bs);
  this.term = term;
  this.notFlag = notFlag;
}
 

import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
public TermSource(SortedKeyValueIterator<Key, Value> iter, TextColumn column) {
   
    this.iter = iter;
    this.column = column;
    this.term = column.getColumnFamily();
    this.termCond = column.getColumnQualifier();
    this.currentCQ = new Text(emptyByteArray);
    this.seekColfams = Collections.<ByteSequence> singletonList(new ArrayByteSequence(term
            .getBytes(), 0, term.getLength()));
   
}
 

import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
public TermSource(final SortedKeyValueIterator<Key, Value> iter, final Text term, final boolean notFlag) {
	this.iter = iter;
	this.term = term;
	this.notFlag = notFlag;
	// The desired column families for this source is the term itself

	// handle the case where the term is null.
	if (term == null) {
		this.seekColfams = Collections.<ByteSequence> emptyList();
	} else {
		this.seekColfams = Collections.<ByteSequence> singletonList(new ArrayByteSequence(term.getBytes(), 0, term.getLength()));
	}
}
 

import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
@Test
public void testByteSequence() {
  String s2 = "test2";
  ByteSequence bs2 = new ArrayByteSequence(s2);
  Bytes b2 = ByteUtil.toBytes(bs2);
  Assert.assertEquals(Bytes.of(s2), b2);
  Assert.assertEquals(bs2, ByteUtil.toByteSequence(b2));
}
 

import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
public TermSource(SortedKeyValueIterator<Key, Value> iter, Text dataLocation, Text term, boolean notFlag) {
    this.iter = iter;
    this.dataLocation = dataLocation;
    ByteSequence bs = new ArrayByteSequence(dataLocation.getBytes(), 0, dataLocation.getLength());
    this.seekColumnFamilies = Collections.singletonList(bs);
    this.term = term;
    this.notFlag = notFlag;
}
 

import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
private void init() throws IOException {
    final AccumuloTablet accumuloTablet = (AccumuloTablet) partition;
    LOGGER.info("Initialising RFileReaderIterator for files {}", StringUtils.join(accumuloTablet.getFiles(), ','));
    final AccumuloConfiguration accumuloConfiguration = SiteConfiguration.getInstance(DefaultConfiguration.getInstance());

    // Required column families according to the configuration
    final Set<ByteSequence> requiredColumnFamilies = InputConfigurator
            .getFetchedColumns(AccumuloInputFormat.class, configuration)
            .stream()
            .map(Pair::getFirst)
            .map(c -> new ArrayByteSequence(c.toString()))
            .collect(Collectors.toSet());
    LOGGER.info("RFileReaderIterator will read column families of {}", StringUtils.join(requiredColumnFamilies, ','));

    // Column families
    final List<SortedKeyValueIterator<Key, Value>> iterators = new ArrayList<>();
    for (final String filename : accumuloTablet.getFiles()) {
        final Path path = new Path(filename);
        final FileSystem fs = path.getFileSystem(configuration);

        final RFile.Reader rFileReader = new RFile.Reader(
                new CachableBlockFile.Reader(fs, path, configuration, null, null, accumuloConfiguration));
        iterators.add(rFileReader);
    }
    mergedIterator = new MultiIterator(iterators, true);

    // Apply visibility filtering iterator
    if (null != auths) {
        final Authorizations authorizations = new Authorizations(auths.toArray(new String[auths.size()]));
        final VisibilityFilter visibilityFilter = new VisibilityFilter(mergedIterator, authorizations, new byte[]{});
        final IteratorSetting visibilityIteratorSetting = new IteratorSetting(1, "auth", VisibilityFilter.class);
        visibilityFilter.init(mergedIterator, visibilityIteratorSetting.getOptions(), null);
        iteratorAfterIterators = visibilityFilter;
        LOGGER.info("Set authorizations to {}", authorizations);
    } else {
        iteratorAfterIterators = mergedIterator;
    }

    // Apply iterator stack
    final List<IteratorSetting> iteratorSettings = getIteratorSettings();
    iteratorSettings.sort(Comparator.comparingInt(IteratorSetting::getPriority));
    for (final IteratorSetting is : iteratorSettings) {
        iteratorAfterIterators = applyIterator(iteratorAfterIterators, is);
    }

    taskContext.addTaskCompletionListener(context -> close());

    final Range range = new Range(accumuloTablet.getStartRow(), true, accumuloTablet.getEndRow(), false);
    iteratorAfterIterators.seek(range, requiredColumnFamilies, true);
    LOGGER.info("Initialised iterator");
}
 

import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
/**
 * Convert from Bytes to ByteSequence
 */
public static ByteSequence toByteSequence(Bytes b) {
  return new ArrayByteSequence(b.toArray());
}
 

import org.apache.accumulo.core.data.ArrayByteSequence; //导入依赖的package包/类
@VisibleForTesting
static boolean shouldProcess(Notification notification, int divisor, int remainder) {
  byte[] cfcq = NotificationUtil.encodeCol(notification.getColumn());
  return NotificationHashFilter.accept(ByteUtil.toByteSequence(notification.getRow()),
      new ArrayByteSequence(cfcq), divisor, remainder);
}