public static void main(String[] args) throws Exception {
  QueryOpts opts = new QueryOpts();
  opts.parseArgs(Query.class.getName(), args);

  try (AccumuloClient client = Accumulo.newClient().from(opts.getClientPropsPath()).build();
      BatchScanner bs = client.createBatchScanner(opts.tableName, Authorizations.EMPTY, 10)) {
    if (opts.useSample) {
      SamplerConfiguration samplerConfig = client.tableOperations()
          .getSamplerConfiguration(opts.tableName);
      CutoffIntersectingIterator.validateSamplerConfig(
          client.tableOperations().getSamplerConfiguration(opts.tableName));
      bs.setSamplerConfiguration(samplerConfig);
    }
    for (String entry : query(bs, opts.terms, opts.sampleCutoff)) {
      System.out.println("  " + entry);
    }
  }
}
 

static void validateSamplerConfig(SamplerConfiguration sampleConfig) {
  requireNonNull(sampleConfig);
  checkArgument(sampleConfig.getSamplerClassName().equals(RowColumnSampler.class.getName()),
      "Unexpected Sampler " + sampleConfig.getSamplerClassName());
  checkArgument(sampleConfig.getOptions().get("qualifier").equals("true"),
      "Expected sample on column qualifier");
  checkArgument(isNullOrFalse(sampleConfig.getOptions(), "row", "family", "visibility"),
      "Expected sample on column qualifier only");
}
 

private void setMax(IteratorEnvironment sampleEnv, Map<String,String> options) {
  String cutoffValue = options.get("cutoff");
  SamplerConfiguration sampleConfig = sampleEnv.getSamplerConfiguration();

  // Ensure the sample was constructed in an expected way. If the sample is not built as expected,
  // then can not draw conclusions based on sample.
  requireNonNull(cutoffValue, "Expected cutoff option is missing");
  validateSamplerConfig(sampleConfig);

  int modulus = Integer.parseInt(sampleConfig.getOptions().get("modulus"));

  sampleMax = Math.round(Float.parseFloat(cutoffValue) / modulus);
}
 

public CustomColumnToClassMapping(Map<String,Entry<Map<String,String>,String>> columnMap, Integer priority) {
    super();
    
    // This logic is copied from the parent constructor, but we need to since the parent
    // uses AccumuloClassLoader and we don't have that available on our class path.
    for (Entry<String,Entry<Map<String,String>,String>> entry : columnMap.entrySet()) {
        String column = entry.getKey();
        Entry<Map<String,String>,String> clazzOptions = entry.getValue();
        
        final String className = clazzOptions.getValue();
        
        Pair<Text,Text> pcic;
        if (ALL_CF_STR.equals(column)) {
            pcic = new Pair<>(ALL_CF_KEY.getColumnFamily(), null);
        } else {
            pcic = ColumnSet.decodeColumns(column);
        }
        
        Combiner agg = null;
        
        try {
            Class<? extends Combiner> clazz = Class.forName(className).asSubclass(Combiner.class);
            
            agg = clazz.newInstance();
            // init with a stubbed-out class so that an upcoming call to env.getConfig in Combiner will not throw a NPE
            agg.init(null, clazzOptions.getKey(), new IteratorEnvironment() {
                @Override
                public AccumuloConfiguration getConfig() {
                    return null;
                }
                
                @Override
                public SortedKeyValueIterator<Key,Value> reserveMapFileReader(String mapFileName) throws IOException {
                    return null;
                }
                
                @Override
                public IteratorUtil.IteratorScope getIteratorScope() {
                    return null;
                }
                
                @Override
                public boolean isFullMajorCompaction() {
                    return false;
                }
                
                @Override
                public Authorizations getAuthorizations() {
                    throw new UnsupportedOperationException();
                }
                
                @Override
                public IteratorEnvironment cloneWithSamplingEnabled() {
                    throw new SampleNotPresentException();
                }
                
                @Override
                public boolean isSamplingEnabled() {
                    return false;
                }
                
                @Override
                public SamplerConfiguration getSamplerConfiguration() {
                    return null;
                }
                
                @Override
                public void registerSideChannel(SortedKeyValueIterator<Key,Value> iter) {
                    
                }
            });
            
        } catch (InstantiationException | IllegalAccessException | ClassNotFoundException | IOException e) {
            throw new RuntimeException(e);
        }
        
        if (pcic.getSecond() == null) {
            addObject(pcic.getFirst(), agg);
        } else {
            addObject(pcic.getFirst(), pcic.getSecond(), agg);
        }
    }
    
    this.priority = priority;
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    return null;
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    return null;
}
 

@Override
public void setSamplerConfiguration(SamplerConfiguration samplerConfig) {
    delegate.setSamplerConfiguration(samplerConfig);
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    return delegate.getSamplerConfiguration();
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    return null;
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    return null;
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    return null;
}
 

@Override
public void setSamplerConfiguration(SamplerConfiguration samplerConfiguration) {
    delegate.setSamplerConfiguration(samplerConfiguration);
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    return delegate.getSamplerConfiguration();
}
 

@Override
public SamplerConfiguration getSamplerConfiguration() {
    throw new UnsupportedOperationException();
}