@Override
    public void pack(List<DataSource> inputs, DataTarget output) throws IOException {
        ZipOutputStream zipOutput = new ZipOutputStream(output.openOutput());
        for (DataSource input : inputs) {
            ZipEntry entry = new ZipEntry(input.getName());
            entry.setSize(input.getLength());
            zipOutput.putNextEntry(entry);
            PackerUtils.packEntry(input, zipOutput, buffer);

  }
}
node {
  name: "z"
  op: "IdentityN"
  input: "w"
  input: "x"
  input: "y"
  input: "^var_add"
  attr {
    key: "T"
    value {
      list {
        type: DT_FLOAT
        type: DT_FLOAT
        type: DT_FLOAT
      }
    }
  }
}
node {
  name: "a"
  op: "Add"
  input: "z:1"
  input: "z:2"
  attr {
    key: "T"
    value {

  const llvm::MemoryBuffer* input =
      source_mgr->getMemoryBuffer(source_mgr->getMainFileID());
  std::string error;
  auto loc =
      mlir::FileLineColLoc::get(context, input->getBufferIdentifier(), 0, 0);
  std::vector<std::string> inputs;
  std::vector<std::string> outputs;
  return tflite::FlatBufferToMlir(
      absl::string_view(input->getBufferStart(), input->getBufferSize()),

        def actualDir = file("actualDir").createDir()
        file("symlink1").createLink(actualDir)
        file("symlink2").createLink(actualDir)

        buildFile << """
            task myTask {
                def outputFile = file("build/output.txt")
                inputs.dir("symlink1")
                inputs.dir("symlink2")

 */
public interface InputChanges {
    /**
     * Indicates if it was possible for Gradle to determine which input files were out of date compared to a previous execution.
     * Incremental inputs are unavailable when history is unavailable (i.e. this piece of work has never been executed before), or if there are changes to non-file input properties, or output files.
     * <p>
     * When <code>true</code>:
     * </p>
     * <ul>

import spock.lang.Issue

class TaskEnumTypesInputPropertyIntegrationTest extends AbstractIntegrationSpec {
    @Issue("GRADLE-3018")
    def "task can take an input with enum type and task action defined in the build script"() {
        buildFile """
task someTask {
    inputs.property "someEnum", SomeEnum.E1
    def f = file("build/e1")
    outputs.dir f
    doLast {
        f.mkdirs()
    }
}

enum SomeEnum {
    E1, E2

    }

    /**
     * The hashes of the inputs.
     * <p>
     * If the inputs were not snapshotted, all fields are null.
     * This may occur if the task had no outputs.
     */
    public interface Result {

        /**
         * The overall hash value for the inputs.
         * <p>
         * Null if the overall key was not calculated because the inputs were invalid.
         */
        @Nullable

               op_name,
               inputs=None,
               attrs=None,
               derived_attrs=None,
               outputs=None):
    self._op_name = op_name
    self._inputs = inputs
    self._attrs = attrs
    self._derived_attrs = derived_attrs
    self._outputs = outputs

  def __call__(self, compose_fn):
    # TODO(fengliuai): more sanity check of the input function and make sure

        super(taskDependencyFactory);
        this.taskPath = taskPath;
        this.calculatedFiles = calculatedFiles;
        targets = new ArrayList<>(1 + inputs.length);
        for (Object input : inputs) {
            if (input instanceof LifecycleAwareValue) {
                targets.add((LifecycleAwareValue) input);
            }
        }

Anis Eleuch <******@****.***> 1712232280 +0100