}
        s.addField("inputPaths", inputPathsArray);

        NSArray outputPathsArray = new NSArray(outputPaths.size());
        for (int i = 0; i < outputPaths.size(); i++) {
            outputPathsArray.setValue(i, new NSString(outputPaths.get(i)));
        }
        s.addField("outputPaths", outputPathsArray);

        NSString shellPathString;
        if (shellPath == null) {

        } else {
            throw new ResourceDoesNotExistException("No content provided for " + resource.getName());
        }
    }

    @Override
    public void fillOutputData(OutputData outputData) throws TransferFailedException {
        outputData.setOutputStream(new ByteArrayOutputStream());
    }

    @Override
    protected void openConnectionInternal() throws ConnectionException, AuthenticationException {}

  return GenerateOneFile(cpp::RendererContext::kSource);
}

string CppGenerator::HeaderFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.h");
}

string CppGenerator::SourceFileName() const {
  return io::JoinPath(path_config_.output_path, cpp_config_.unit + "_ops.cc");
}

void CppGenerator::WriteHeaderFile() const {
  controller_.WriteFile(HeaderFileName(), HeaderFileContents());
}

#define TENSORFLOW_C_EXPERIMENTAL_OPS_GEN_COMMON_PATH_CONFIG_H_

#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {

struct PathConfig {
  string output_path;
  std::vector<string> op_names;
  std::vector<string> api_dirs;
  string tf_prefix_dir;
  string tf_root_dir;
  string tf_output_dir;

  explicit PathConfig() = default;

 */

package org.gradle.execution.plan;

import java.util.HashSet;
import java.util.Set;

class MutationInfo {
    private final Set<Node> nodesYetToConsumeOutput = new HashSet<>();
    final Set<String> outputPaths = new HashSet<>();
    final Set<String> destroyablePaths = new HashSet<>();
    boolean hasFileInputs;
    boolean hasOutputs;
    boolean hasLocalState;
    boolean hasValidationProblem;

namespace generator {

PathConfig::PathConfig(const string& output_dir, const string& source_dir,
                       const string& api_dir_list,
                       const std::vector<string> op_names)
    : output_path(output_dir), op_names(op_names) {
  api_dirs = str_util::Split(api_dir_list, ",", str_util::SkipEmpty());

  // Decompose the directory components given the output/source directories.
  //

        node.resolveMutations();
        mutations.hasValidationProblem = nodeValidator.hasValidationProblems(node);
        accessHierarchies.getOutputHierarchy().recordNodeAccessingLocations(node, mutations.outputPaths);
        accessHierarchies.getDestroyableHierarchy().recordNodeAccessingLocations(node, mutations.destroyablePaths);
    }

  /// to feed them with. See `Input::Initializer` for details on what can be
  /// used as feed values.
  typedef std::unordered_map<Output, Input::Initializer, OutputHash> FeedType;

  /// Create a new session to evaluate the graph contained in `scope` by
  /// connecting to the TensorFlow runtime specified by `target`.
  ClientSession(const Scope& scope, const string& target);