guard_ = toUpperSnake(with_underscores) + "_";
}

void GuardRenderer::Open() {
  CodeLine("#ifndef $0", guard_);
  CodeLine("#define $0", guard_);
  BlankLine();
}

void GuardRenderer::Close() {
  BlankLine();
  CodeLine("#endif  // $0", guard_);
}

}  // namespace cpp
}  // namespace generator

      CommentLine("File level comment.");
      CodeLine("#include \"header.h\"");
      BlankLine();
      BlockOpen("void TestFunction()");
      {
        Statement("int i = 1");
        BlankLine();
        BlockOpen("while (i == 1)");
        {
          CommentLine("Do nothing, really....");
          CodeLine("#if 0");
          Statement("call()");
          CodeLine("#endif");
          BlockClose();
        }

void NamespaceRenderer::Open() {
  for (const string& ns : context_.cpp_config.namespaces) {
    CodeLine("namespace " + ns + " {");
  }
}

void NamespaceRenderer::Close() {
  for (auto it = context_.cpp_config.namespaces.rbegin();
       it != context_.cpp_config.namespaces.rend(); ++it) {
    CodeLine("}  // namespace " + *it);
  }
}

}  // namespace cpp
}  // namespace generator

  // Append a line of source code, left-justified (not indented).
  // Use for preprocessors directives ("#include"), namespaces, etc.
  Renderer &CodeLine(const string &text);
  template <typename... Args>
  Renderer CodeLine(absl::string_view text, const Args &...args) {
    return CodeLine(absl::Substitute(text, args...));
  }

  // Append a multiline string of source code, left-justified (not indented).

                      context_.path_config.tf_output_dir,
                      context_.cpp_config.unit + "_ops.h");
}

void IncludeRenderer::Include(const string &tf_file_path) {
  CodeLine("#include \"$0\"",
           io::JoinPath(context_.path_config.tf_prefix_dir, tf_file_path));
}

void IncludeRenderer::Headers() {
  Include("tensorflow/c/eager/abstract_context.h");

namespace cpp {

Renderer::Renderer(RendererContext context) : context_(context) {}

Renderer& Renderer::BlankLine() {
  context_.code.AddLineWithoutIndent("");
  return *this;
}

Renderer& Renderer::CodeLine(const string& text) {
  context_.code.AddLineWithoutIndent(text);
  return *this;
}

Renderer& Renderer::CodeLines(const string& text) {
  StringPiece trimmed_text(text);

    : Renderer(context),
      guard_(context),
      name_space_(context),
      includes_(context),
      ops_(ops) {}

void CppFileRenderer::Render() {
  CodeLines(copyright);
  BlankLine();
  CodeLine(machine_generated);
  BlankLine();

  if (context_.mode == RendererContext::kHeader) {
    guard_.Open();
  } else {
    includes_.SelfHeader();
  }

  includes_.Headers();
  name_space_.Open();