this.buffer = new byte[bufferSizeInKBytes * 1024];
    }

    @Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        TarArchiveOutputStream tarOutput = new TarArchiveOutputStream(output.openOutput());
        for (DataSource input : inputs) {
            TarArchiveEntry entry = new TarArchiveEntry(input.getName());
            entry.setSize(input.getLength());

     */
    ModelMap<LanguageSourceSet> getSources();

    /**
     * Returns all inputs of the binary. This includes source sets owned by the binary,
     * and other source sets created elsewhere (e.g. inherited from the binary's component).
     *
     * @return all inputs of the binary.
     */
    DomainObjectSet<LanguageSourceSet> getInputs();

    /**

## Derived Collections

The core of the framework is in the ability to derive collections from others.

In general, these are built by providing some `func(inputs...) outputs...` (called "transformation" functions).
While more could be expressed, there are currently three forms implemented.

* `func() *O` via `NewSingleton`

    full_output_types.push_back(output.getType());
  }

  // Convert split sharded inputs to MANUAL sharded inputs.
  // common_split_sharding is the split sharding that is common to all inputs
  // and outputs.
  llvm::SmallVector<Value, 4> manual_inputs;
  manual_inputs.reserve(inputs.size());
  for (Value in : inputs) {
    Type shard_type;
    if (failed(GetShardShapedType(original_op, num_cores_per_replica,

// CHECK-NEXT:       quantization: {
// CHECK-EMPTY:
// CHECK-NEXT:      },
// CHECK-NEXT:      has_rank: true
// CHECK-NEXT:     } ],
// CHECK-NEXT:     inputs: [ 0 ],
// CHECK-NEXT:     outputs: [ 2 ],
// CHECK-NEXT:     operators: [ {
// CHECK-NEXT:       inputs: [ 0, 1 ],
// CHECK-NEXT:       outputs: [ 2 ]
// CHECK-NEXT:     } ]
// CHECK-NEXT:    name: "main"
// CHECK-NEXT:   } ],

----

[[config_cache:usage:invalidate]]
=== Invalidating the cache

The configuration cache is automatically invalidated when inputs to the configuration phase change.
However, certain inputs are not tracked yet, so you may have to manually invalidate the configuration cache when untracked inputs to the configuration phase change.
This can happen if you <<configuration_cache#config_cache:usage:ignore_problems,ignored problems>>.

  LogicalResult matchAndRewrite(mhlo::BatchNormTrainingOp bn_op,
                                PatternRewriter &rewriter) const override {
    auto inputs = bn_op.getOperand();
    auto input_type = mlir::dyn_cast<RankedTensorType>(inputs.getType());
    if (!input_type) {
      return failure();
    }
    auto feature_index = bn_op.getFeatureIndex();

    // Compute mean

        """

        expect:
        succeeds "model"
        def buildType = ModelReportOutput.from(output).modelNode.buildType

        buildType.inputs.@type[0] == 'CustomSourceSet'
        buildType.inputs.@nodeValue[0] == 'null'
        buildType.inputs.@creator[0] == 'Rules#buildType(BuildType)'

        buildType.sources.@type[0] == 'CustomSourceSet'
        buildType.sources.@nodeValue[0] == "Custom source 'sources'"

	"istio.io/istio/pkg/config/schema/collections"
	"istio.io/istio/pkg/config/schema/resource"
)

func ConvertInputsToSchemas(inputs []config.GroupVersionKind) collection.Schemas {
	resultBuilder := collection.NewSchemasBuilder()
	for _, gv := range inputs {
		s, f := collections.All.FindByGroupVersionKind(gv)
		if !f {
			continue
		}
		_ = resultBuilder.Add(s)
	}

	return resultBuilder.Build()
}

    }
}
// end::copy-method[]

// tag::copy-method-with-dependency[]
tasks.register('copyMethodWithExplicitDependencies') {
    // up-to-date check for inputs, plus add copyTask as dependency
    inputs.files(copyTask)
        .withPropertyName("inputs")
        .withPathSensitivity(PathSensitivity.RELATIVE)
    outputs.dir('some-dir') // up-to-date check for outputs
        .withPropertyName("outputDir")
    doLast {