java类com.google.common.collect.ImmutableTable的实例源码

public void buildPropertyValueTable(Map<Map<IProperty, Comparable>, BlockState.StateImplementation> map)
{
    if (this.propertyValueTable != null)
    {
        throw new IllegalStateException();
    }
    else
    {
        Table<IProperty, Comparable, IBlockState> table = HashBasedTable.<IProperty, Comparable, IBlockState>create();

        for (IProperty <? extends Comparable > iproperty : this.properties.keySet())
        {
            for (Comparable comparable : iproperty.getAllowedValues())
            {
                if (comparable != this.properties.get(iproperty))
                {
                    table.put(iproperty, comparable, map.get(this.getPropertiesWithValue(iproperty, comparable)));
                }
            }
        }

        this.propertyValueTable = ImmutableTable.<IProperty, Comparable, IBlockState>copyOf(table);
    }
}

public void buildPropertyValueTable(Map<Map<IProperty, Comparable>, BlockState.StateImplementation> map)
{
    if (this.propertyValueTable != null)
    {
        throw new IllegalStateException();
    }
    else
    {
        Table<IProperty, Comparable, IBlockState> table = HashBasedTable.<IProperty, Comparable, IBlockState>create();

        for (IProperty <? extends Comparable > iproperty : this.properties.keySet())
        {
            for (Comparable comparable : iproperty.getAllowedValues())
            {
                if (comparable != this.properties.get(iproperty))
                {
                    table.put(iproperty, comparable, map.get(this.getPropertiesWithValue(iproperty, comparable)));
                }
            }
        }

        this.propertyValueTable = ImmutableTable.<IProperty, Comparable, IBlockState>copyOf(table);
    }
}

public void buildPropertyValueTable(Map<Map<IProperty, Comparable>, BlockState.StateImplementation> map)
{
    if (this.propertyValueTable != null)
    {
        throw new IllegalStateException();
    }
    else
    {
        Table<IProperty, Comparable, IBlockState> table = HashBasedTable.<IProperty, Comparable, IBlockState>create();

        for (IProperty <? extends Comparable > iproperty : this.properties.keySet())
        {
            for (Comparable comparable : iproperty.getAllowedValues())
            {
                if (comparable != this.properties.get(iproperty))
                {
                    table.put(iproperty, comparable, map.get(this.getPropertiesWithValue(iproperty, comparable)));
                }
            }
        }

        this.propertyValueTable = ImmutableTable.<IProperty, Comparable, IBlockState>copyOf(table);
    }
}

public void buildPropertyValueTable(Map<Map<IProperty, Comparable>, BlockState.StateImplementation> map)
{
    if (this.propertyValueTable != null)
    {
        throw new IllegalStateException();
    }
    else
    {
        Table<IProperty, Comparable, IBlockState> table = HashBasedTable.<IProperty, Comparable, IBlockState>create();

        for (IProperty <? extends Comparable > iproperty : this.properties.keySet())
        {
            for (Comparable comparable : iproperty.getAllowedValues())
            {
                if (comparable != this.properties.get(iproperty))
                {
                    table.put(iproperty, comparable, map.get(this.getPropertiesWithValue(iproperty, comparable)));
                }
            }
        }

        this.propertyValueTable = ImmutableTable.<IProperty, Comparable, IBlockState>copyOf(table);
    }
}

MediaTypeClassifierImpl(Iterable<? extends MediaType> mts) {
  Table<String, String, Set<MediaType>> typeTable =
      HashBasedTable.<String, String, Set<MediaType>>create();
  for (MediaType mt : mts) {
    String type = mt.type();
    String subtype = mt.subtype();
    Set<MediaType> typeSet = typeTable.get(type, subtype);
    if (typeSet == null) {
      typeSet = Sets.newLinkedHashSet();
      typeTable.put(type, subtype, typeSet);
    }
    typeSet.add(mt);
  }

  ImmutableTable.Builder<String, String, ImmutableSet<MediaType>> b =
      ImmutableTable.builder();
  for (Table.Cell<String, String, Set<MediaType>> cell
       : typeTable.cellSet()) {
    b.put(cell.getRowKey(), cell.getColumnKey(), ImmutableSet.copyOf(cell.getValue()));
  }
  this.types = b.build();
}

public static void register(final Kryo kryo) {
  // register list
  final ImmutableListSerializer serializer = new ImmutableListSerializer();
  kryo.register(ImmutableList.class, serializer);
  kryo.register(ImmutableList.of().getClass(), serializer);
  kryo.register(ImmutableList.of(Integer.valueOf(1)).getClass(), serializer);
  kryo.register(ImmutableList.of(Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3)).subList(1, 2).getClass(), serializer);
  kryo.register(ImmutableList.of().reverse().getClass(), serializer);
  kryo.register(Lists.charactersOf("dremio").getClass(), serializer);

  final HashBasedTable baseTable = HashBasedTable.create();
  baseTable.put(Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3));
  baseTable.put(Integer.valueOf(4), Integer.valueOf(5), Integer.valueOf(6));
  ImmutableTable table = ImmutableTable.copyOf(baseTable);
  kryo.register(table.values().getClass(), serializer);
}

public void buildPropertyValueTable(Map < Map < IProperty<?>, Comparable<? >> , BlockStateContainer.StateImplementation > map)
{
    if (this.propertyValueTable != null)
    {
        throw new IllegalStateException();
    }
    else
    {
        Table < IProperty<?>, Comparable<?>, IBlockState > table = HashBasedTable. < IProperty<?>, Comparable<?>, IBlockState > create();

        for (Entry < IProperty<?>, Comparable<? >> entry : this.properties.entrySet())
        {
            IProperty<?> iproperty = (IProperty)entry.getKey();

            for (Comparable<?> comparable : iproperty.getAllowedValues())
            {
                if (comparable != entry.getValue())
                {
                    table.put(iproperty, comparable, map.get(this.getPropertiesWithValue(iproperty, comparable)));
                }
            }
        }

        this.propertyValueTable = ImmutableTable. < IProperty<?>, Comparable<?>, IBlockState > copyOf(table);
    }
}

/**
 * Creates and stores reports of a given type on GCS.
 *
 * <p>This is factored out to facilitate choosing which reports to upload,
 */
ImmutableList<String> stageReports(ReportType reportType) throws Exception {
  QueryBuilder queryBuilder =
      (reportType == ReportType.ACTIVITY) ? activityQueryBuilder : transactionsQueryBuilder;


  ImmutableMap<String, String> viewQueryMap = queryBuilder.getViewQueryMap();
  // Generate intermediary views
  for (Entry<String, String> entry : viewQueryMap.entrySet()) {
    createIntermediaryTableView(entry.getKey(), entry.getValue(), reportType);
  }

  // Get an in-memory table of the aggregate query's result
  ImmutableTable<Integer, TableFieldSchema, Object> reportTable =
      bigquery.queryToLocalTableSync(queryBuilder.getReportQuery());

  // Get report headers from the table schema and convert into CSV format
  String headerRow = constructRow(getHeaders(reportTable.columnKeySet()));

  return (reportType == ReportType.ACTIVITY)
      ? stageActivityReports(headerRow, reportTable.rowMap().values())
      : stageTransactionsReports(headerRow, reportTable.rowMap().values());
}

/**
 * Returns a table of data for the given sets of fields and objects.  The table is row-keyed by
 * object and column-keyed by field, in the same iteration order as the provided sets.
 */
private ImmutableTable<T, String, String>
    extractData(ImmutableSet<String> fields, ImmutableSet<T> objects) {
  ImmutableTable.Builder<T, String, String> builder = new ImmutableTable.Builder<>();
  for (T object : objects) {
    Map<String, Object> fieldMap = new HashMap<>();
    // Base case of the mapping is to use ImmutableObject's toDiffableFieldMap().
    fieldMap.putAll(object.toDiffableFieldMap());
    // Next, overlay any field-level overrides specified by the subclass.
    fieldMap.putAll(getFieldOverrides(object));
    // Next, add to the mapping all the aliases, with their values defined as whatever was in the
    // map under the aliased field's original name.
    fieldMap.putAll(new HashMap<>(Maps.transformValues(getFieldAliases(), fieldMap::get)));
    Set<String> expectedFields = ImmutableSortedSet.copyOf(fieldMap.keySet());
    for (String field : fields) {
      checkArgument(fieldMap.containsKey(field),
          "Field '%s' not found - recognized fields are:\n%s", field, expectedFields);
      builder.put(object, field, Objects.toString(fieldMap.get(field), ""));
    }
  }
  return builder.build();
}

/** Converts the provided table of data to text, formatted using the provided column widths. */
private List<String> generateFormattedData(
    ImmutableTable<T, String, String> data,
    ImmutableMap<String, Integer> columnWidths) {
  Function<Map<String, String>, String> rowFormatter = makeRowFormatter(columnWidths);
  List<String> lines = new ArrayList<>();

  if (isHeaderRowInUse(data)) {
    // Add a row of headers (column names mapping to themselves).
    Map<String, String> headerRow = Maps.asMap(data.columnKeySet(), key -> key);
    lines.add(rowFormatter.apply(headerRow));

    // Add a row of separator lines (column names mapping to '-' * column width).
    Map<String, String> separatorRow =
        Maps.transformValues(columnWidths, width -> Strings.repeat("-", width));
    lines.add(rowFormatter.apply(separatorRow));
  }

  // Add the actual data rows.
  for (Map<String, String> row : data.rowMap().values()) {
    lines.add(rowFormatter.apply(row));
  }

  return lines;
}

@Override
public ImmutableMarkovChain<S> build() {
    // todo: check if sum of transition probabilities in rows are <= 1
    for (final S state : table.rowKeySet()) {
        double sum = 0.0;
        for (final Double value : table.row(state).values()) {
            sum += value;
        }
        if (sum < 0 || sum > 1) {
            final String message = "Sum of transition probabilities from state "
                    + state + " must be in >= 0 and <= 1";
            throw new IllegalArgumentException(message);
        }
    }
    rng = RandomGenerators.rng();
    return new ImmutableMarkovChain<S>(ImmutableTable.copyOf(table), rng);
}

public static ReviewerSet parseReviewerFieldValues(Iterable<String> values) {
  ImmutableTable.Builder<ReviewerStateInternal, Account.Id, Timestamp> b =
      ImmutableTable.builder();
  for (String v : values) {
    int f = v.indexOf(',');
    if (f < 0) {
      continue;
    }
    int l = v.lastIndexOf(',');
    if (l == f) {
      continue;
    }
    b.put(
        ReviewerStateInternal.valueOf(v.substring(0, f)),
        Account.Id.parse(v.substring(f + 1, l)),
        new Timestamp(Long.valueOf(v.substring(l + 1, v.length()))));
  }
  return ReviewerSet.fromTable(b.build());
}

public static ReviewerByEmailSet parseReviewerByEmailFieldValues(Iterable<String> values) {
  ImmutableTable.Builder<ReviewerStateInternal, Address, Timestamp> b = ImmutableTable.builder();
  for (String v : values) {
    int f = v.indexOf(',');
    if (f < 0) {
      continue;
    }
    int l = v.lastIndexOf(',');
    if (l == f) {
      continue;
    }
    b.put(
        ReviewerStateInternal.valueOf(v.substring(0, f)),
        Address.parse(v.substring(f + 1, l)),
        new Timestamp(Long.valueOf(v.substring(l + 1, v.length()))));
  }
  return ReviewerByEmailSet.fromTable(b.build());
}

@Test
public void multipleReviewers() throws Exception {
  Change c = newChange();
  ChangeUpdate update = newUpdate(c, changeOwner);
  update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
  update.putReviewer(otherUser.getAccount().getId(), REVIEWER);
  update.commit();

  ChangeNotes notes = newNotes(c);
  Timestamp ts = new Timestamp(update.getWhen().getTime());
  assertThat(notes.getReviewers())
      .isEqualTo(
          ReviewerSet.fromTable(
              ImmutableTable.<ReviewerStateInternal, Account.Id, Timestamp>builder()
                  .put(REVIEWER, new Account.Id(1), ts)
                  .put(REVIEWER, new Account.Id(2), ts)
                  .build()));
}

@Test
public void reviewerTypes() throws Exception {
  Change c = newChange();
  ChangeUpdate update = newUpdate(c, changeOwner);
  update.putReviewer(changeOwner.getAccount().getId(), REVIEWER);
  update.putReviewer(otherUser.getAccount().getId(), CC);
  update.commit();

  ChangeNotes notes = newNotes(c);
  Timestamp ts = new Timestamp(update.getWhen().getTime());
  assertThat(notes.getReviewers())
      .isEqualTo(
          ReviewerSet.fromTable(
              ImmutableTable.<ReviewerStateInternal, Account.Id, Timestamp>builder()
                  .put(REVIEWER, new Account.Id(1), ts)
                  .put(CC, new Account.Id(2), ts)
                  .build()));
}

@Test
public void oneReviewerMultipleTypes() throws Exception {
  Change c = newChange();
  ChangeUpdate update = newUpdate(c, changeOwner);
  update.putReviewer(otherUser.getAccount().getId(), REVIEWER);
  update.commit();

  ChangeNotes notes = newNotes(c);
  Timestamp ts = new Timestamp(update.getWhen().getTime());
  assertThat(notes.getReviewers())
      .isEqualTo(ReviewerSet.fromTable(ImmutableTable.of(REVIEWER, new Account.Id(2), ts)));

  update = newUpdate(c, otherUser);
  update.putReviewer(otherUser.getAccount().getId(), CC);
  update.commit();

  notes = newNotes(c);
  ts = new Timestamp(update.getWhen().getTime());
  assertThat(notes.getReviewers())
      .isEqualTo(ReviewerSet.fromTable(ImmutableTable.of(CC, new Account.Id(2), ts)));
}

/**
 * Return a new {@code ProvenancedConfusionMatrix} containing only those provenance entries
 * matching the provided predicate.
 */
public ProvenancedConfusionMatrix<CellFiller> filteredCopy(Predicate<CellFiller> predicate) {
  final ImmutableTable.Builder<Symbol, Symbol, List<CellFiller>> newTable =
      ImmutableTable.builder();

  for (final Cell<Symbol, Symbol, List<CellFiller>> curCell : table.cellSet()) {
    final List<CellFiller> newFiller = FluentIterable.from(curCell.getValue())
        .filter(predicate).toList();
    if (!newFiller.isEmpty()) {
      newTable.put(curCell.getRowKey(), curCell.getColumnKey(), newFiller);
    }

  }

  return new ProvenancedConfusionMatrix<CellFiller>(newTable.build());
}

public ImmutableSetMultitable<R, C, V> build() {
  final ImmutableTable.Builder<R, C, Collection<V>> immutableTable =
      ImmutableTable.builder();

  int size = 0;
  ImmutableSet.Builder<R> rowIterationBuilder = ImmutableSet.builder();
  ImmutableSet.Builder<C> columnIterationBuilder = ImmutableSet.builder();

  for (final RowKeyColumnKeyPair<R, C> rowKeyColKey : rowInsertionOrder.build()) {
    final ImmutableSet<V> valuesForPair =
        tableWeCanLookUpIn.get(rowKeyColKey.row(), rowKeyColKey.column()).build();
    size += valuesForPair.size();
    immutableTable.put(rowKeyColKey.row(), rowKeyColKey.column(),
        valuesForPair);
    rowIterationBuilder.add(rowKeyColKey.row());
    columnIterationBuilder.add(rowKeyColKey.column());
  }

  return new ImmutableSetMultitable<>(immutableTable.build(), size, rowIterationBuilder.build(),
      columnIterationBuilder.build());
}

public ImmutableListMultitable<R, C, V> build() {
  final ImmutableTable.Builder<R, C, Collection<V>> immutableTable =
      ImmutableTable.builder();

  int size = 0;
  ImmutableSet.Builder<R> rowIterationBuilder = ImmutableSet.builder();
  ImmutableSet.Builder<C> columnIterationBuilder = ImmutableSet.builder();

  for (final RowKeyColumnKeyPair<R, C> rowKeyColKey : rowInsertionOrder.build()) {
    final ImmutableList<V> valuesForPair =
        tableWeCanLookUpIn.get(rowKeyColKey.row(), rowKeyColKey.column()).build();
    size += valuesForPair.size();
    immutableTable.put(rowKeyColKey.row(), rowKeyColKey.column(),
        valuesForPair);
    rowIterationBuilder.add(rowKeyColKey.row());
    columnIterationBuilder.add(rowKeyColKey.column());
  }

  return new ImmutableListMultitable<>(immutableTable.build(), size,
      rowIterationBuilder.build(),
      columnIterationBuilder.build());
}

public static ImmutableTable<Symbol, Symbol, Symbol> loadSymbolTable(CharSource input)
    throws IOException {
  final ImmutableTable.Builder<Symbol, Symbol, Symbol> ret = ImmutableTable.builder();

  int lineNo = 0;
  for (final String line : input.readLines()) {
    final List<String> parts = StringUtils.onTabs().splitToList(line);
    if (parts.size() != 3) {
      throw new IOException(String.format("Invalid line %d when reading symbol table: %s",
          lineNo, line));
    }
    ret.put(Symbol.from(parts.get(0)), Symbol.from(parts.get(1)), Symbol.from(parts.get(2)));
    ++lineNo;
  }

  return ret.build();
}

final void check() {
  runTester()
      .assertNonNullValues(
          Gender.MALE,
          Integer.valueOf(0),
          0,
          "",
          "",
          ImmutableList.of(),
          ImmutableList.of(),
          ImmutableMap.of(),
          ImmutableMap.of(),
          ImmutableSet.of(),
          ImmutableSet.of(),
          ImmutableSortedSet.of(),
          ImmutableSortedSet.of(),
          ImmutableMultiset.of(),
          ImmutableMultiset.of(),
          ImmutableMultimap.of(),
          ImmutableMultimap.of(),
          ImmutableTable.of(),
          ImmutableTable.of());
}

final void check() {
  runTester()
      .assertNonNullValues(
          Gender.MALE,
          Integer.valueOf(0),
          0,
          "",
          "",
          ImmutableList.of(),
          ImmutableList.of(),
          ImmutableMap.of(),
          ImmutableMap.of(),
          ImmutableSet.of(),
          ImmutableSet.of(),
          ImmutableSortedSet.of(),
          ImmutableSortedSet.of(),
          ImmutableMultiset.of(),
          ImmutableMultiset.of(),
          ImmutableMultimap.of(),
          ImmutableMultimap.of(),
          ImmutableTable.of(),
          ImmutableTable.of());
}

private ImmutableTable<V, V, Double> getPrecedenceVariableValues(
    VariableSet.VariableExtractor variableExtractor) {
  ImmutableTable.Builder<V, V, Double> ans = ImmutableTable.builder();
  List<Cell<V, V, IloNumVar>> varsAsList = Lists
      .newArrayList(this.precedenceVariables.cellSet());
  IloNumVar[] varArray = new IloNumVar[varsAsList.size()];
  int i = 0;
  for (Cell<V, V, IloNumVar> cell : varsAsList) {
    varArray[i++] = cell.getValue();
  }
  double[] varVals;
  try {
    varVals = variableExtractor.getValuesVE(varArray);
  } catch (IloException e) {
    throw new RuntimeException(e);
  }
  for (int j = 0; j < varsAsList.size(); j++) {
    ans.put(varsAsList.get(j).getRowKey(), varsAsList.get(j).getColumnKey(),
        varVals[j]);
  }
  return ans.build();
}

/**
 * 
 * @param nonZeroEdgeValues
 * @return A list of lists of length 3. A returned list of [u,v,w] indicates
 *         that the constraint delta_uv + delta_vw <= delta_uw + 1 should be
 *         added.
 */
public List<List<V>> checkFractionalSolution(
    Map<E, Double> nonZeroEdgeValues,
    ImmutableTable<V, V, Double> precVarVals) {
  Set<V> retainedVertices = Sets.newHashSet(kepInstance.getGraph()
      .getVertices());
  Set<E> retainedEdges = Maps.filterValues(nonZeroEdgeValues,
      Range.<Double> atLeast(.51)).keySet();
  // In the below graph, each node will have in degree and out degree
  // at most one
  DirectedSparseMultigraph<V, E> inUseEdges = SubgraphUtil.subgraph(
      kepInstance.getGraph(), retainedVertices, retainedEdges);
  CycleChainDecomposition<V, E> decomposition = new CycleChainDecomposition<V, E>(
      inUseEdges);
  List<List<V>> ans = checkCycleChainDecomposition(decomposition,
      precVarVals, checkChains);
  fractionalCutsAdded += ans.size();
  return ans;
}

public void buildPropertyValueTable(Map < Map < IProperty<?>, Comparable<? >> , BlockStateContainer.StateImplementation > map)
{
    if (this.propertyValueTable != null)
    {
        throw new IllegalStateException();
    }
    else
    {
        Table < IProperty<?>, Comparable<?>, IBlockState > table = HashBasedTable. < IProperty<?>, Comparable<?>, IBlockState > create();

        for (Entry < IProperty<?>, Comparable<? >> entry : this.properties.entrySet())
        {
            IProperty<?> iproperty = (IProperty)entry.getKey();

            for (Comparable<?> comparable : iproperty.getAllowedValues())
            {
                if (comparable != entry.getValue())
                {
                    table.put(iproperty, comparable, map.get(this.getPropertiesWithValue(iproperty, comparable)));
                }
            }
        }

        this.propertyValueTable = ImmutableTable. < IProperty<?>, Comparable<?>, IBlockState > copyOf(table);
    }
}

private static List<NistInstance> readInstances(CharSource input) throws IOException {
    return input.readLines().stream().map(line -> {
        List<String> tokens = PARSER.splitToList(line);
        List<Integer> values = tokens.stream().map(Integer::parseInt).collect(Collectors.toList());

        List<Integer> instanceInput = values.subList(0, values.size() - 1);
        int instanceOutput = values.get(values.size() - 1);

        ImmutableTable.Builder<Integer, Integer, Integer> instance = ImmutableTable.builder();
        for (int i = 0; i < instanceInput.size(); i++) {
            int value = instanceInput.get(i);
            int row = i / COLUMNS;
            int column = i % COLUMNS;

            instance.put(row, column, value);
        }

        return NistInstance.create(
                instanceInput,
                instance
                        .orderRowsBy(Comparator.<Integer>naturalOrder())
                        .orderColumnsBy(Comparator.<Integer>naturalOrder())
                        .build(),
                instanceOutput);
    }).collect(Collectors.toList());
}

private DelTemplateSelector(Builder<T> builder) {
  ImmutableTable.Builder<String, String, Group<T>> nameAndVariantBuilder =
      ImmutableTable.builder();
  ImmutableListMultimap.Builder<String, T> delTemplateNameToValuesBuilder =
      ImmutableListMultimap.builder();
  for (Table.Cell<String, String, Group.Builder<T>> entry :
      builder.nameAndVariantToGroup.cellSet()) {
    Group<T> group = entry.getValue().build();
    nameAndVariantBuilder.put(entry.getRowKey(), entry.getColumnKey(), group);
    String delTemplateName = entry.getRowKey();
    if (group.defaultValue != null) {
      delTemplateNameToValuesBuilder.put(delTemplateName, group.defaultValue);
    }
    delTemplateNameToValuesBuilder.putAll(delTemplateName, group.delpackageToValue.values());
  }
  this.nameAndVariantToGroup = nameAndVariantBuilder.build();
  this.delTemplateNameToValues = delTemplateNameToValuesBuilder.build();
}

public CompareView(List<KnownColormap> colorMaps)
{
    setLayout(new GridLayout(1, 0));

    List<ColormapQuality> metrics = getMetrics();

    ImmutableTable.Builder<KnownColormap, ColormapQuality, Double> builder = ImmutableTable.builder();

    for (KnownColormap cm : colorMaps)
    {
        for (ColormapQuality metric : metrics)
        {
            builder.put(cm, metric, metric.getQuality(cm));
        }
    }

    Table<KnownColormap, ColormapQuality, Double> infoTable = builder.build();

    add(new CompareViewPanel(infoTable));
    add(new CompareViewPanel(infoTable));
    add(new CompareViewPanel(infoTable));
}

private CashFlowReport(
    LocalDate valuationDate,
    Instant runInstant,
    List<ExplainKey<?>> columnKeys,
    List<String> columnHeaders,
    Table<Integer, Integer, Object> data) {
  JodaBeanUtils.notNull(valuationDate, "valuationDate");
  JodaBeanUtils.notNull(runInstant, "runInstant");
  JodaBeanUtils.notNull(columnKeys, "columnKeys");
  JodaBeanUtils.notNull(columnHeaders, "columnHeaders");
  JodaBeanUtils.notNull(data, "data");
  this.valuationDate = valuationDate;
  this.runInstant = runInstant;
  this.columnKeys = ImmutableList.copyOf(columnKeys);
  this.columnHeaders = ImmutableList.copyOf(columnHeaders);
  this.data = ImmutableTable.copyOf(data);
}

/**
 * Returns a void->void MethodHandle that will run this ActorGroup for the
 * given iterations using the given ConcreteStorage instances.
 * @param iterations the range of iterations to run for
 * @param storage the storage being used
 * @return a void->void method handle
 */
public MethodHandle specialize(Range<Integer> iterations, Map<Storage, ConcreteStorage> storage,
        BiFunction<MethodHandle[], WorkerActor, MethodHandle> switchFactory,
        int unrollFactor,
        ImmutableTable<Actor, Integer, IndexFunctionTransformer> inputTransformers,
        ImmutableTable<Actor, Integer, IndexFunctionTransformer> outputTransformers) {
    //TokenActors are special.
    assert !isTokenGroup() : actors();

    Map<Actor, MethodHandle> withRWHandlesBound =
            bindActorsToStorage(iterations, storage, switchFactory, inputTransformers, outputTransformers);

    int totalIterations = iterations.upperEndpoint() - iterations.lowerEndpoint();
    unrollFactor = Math.min(unrollFactor, totalIterations);
    int unrolls = (totalIterations/unrollFactor);
    int unrollEndpoint = iterations.lowerEndpoint() + unrolls*unrollFactor;
    MethodHandle overall = Combinators.semicolon(
            makeGroupLoop(Range.closedOpen(iterations.lowerEndpoint(), unrollEndpoint), unrollFactor, withRWHandlesBound),
            makeGroupLoop(Range.closedOpen(unrollEndpoint, iterations.upperEndpoint()), 1, withRWHandlesBound)
    );
    return overall;
}