// An attribute for an Op, such as an input/output type or for passing options.
//
// Essentially, this represents an OpDef::AttrDef and its context within the Op.
class AttrSpec {
 public:
  AttrSpec() = default;
  AttrSpec(const AttrSpec& other) = default;
  static AttrSpec Create(const OpDef::AttrDef& attr_def);

  const string& name() const { return name_; }
  const string& description() const { return description_; }

#include "tensorflow/c/experimental/ops/gen/model/attr_spec.h"

#include "tensorflow/core/lib/strings/str_util.h"

namespace tensorflow {
namespace generator {

AttrSpec AttrSpec::Create(const OpDef::AttrDef& attr_def) {
  return AttrSpec(attr_def);
}

AttrSpec::AttrSpec(const OpDef::AttrDef& attr_def) {
  name_ = attr_def.name();
  description_ = attr_def.description();
  full_type_ = attr_def.type();

  const std::vector<AttrSpec>& Attributes() const { return argument_attrs_; }

 private:
  explicit OpSpec(const OpDef& op_def, const ApiDef& api_def);

 private:
  string name_;
  string summary_;
  string description_;
  std::vector<ArgSpec> input_args_;
  std::vector<ArgSpec> output_args_;
  std::vector<AttrSpec> argument_attrs_;
  std::map<string, AttrSpec> type_attrs_;
};

#include "tensorflow/c/experimental/ops/gen/model/attr_spec.h"
#include "tensorflow/core/platform/types.h"

namespace tensorflow {
namespace generator {
namespace cpp {

class AttrView {
 public:
  explicit AttrView(AttrSpec attr) : attr_(attr) {}

  string VariableName() const;
  string VariableType() const;
  string AttrNameString() const;
  string VariableStrLen() const;
  string VariableSpanData() const;

    ArgSpec arg = ArgSpec::CreateOutput(arg_def, output_args_.size());
    output_args_.push_back(arg);
  }
  // Parse the attributes.
  for (const OpDef::AttrDef& attr_def : op_def.attr()) {
    AttrSpec attr = AttrSpec::Create(attr_def);
    // Only non-inferred args are added as arguments.
    if (inferred_attrs.find(attr_def.name()) == inferred_attrs.end()) {
      argument_attrs_.push_back(attr);
    }
  }
}

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

namespace tensorflow {
namespace generator {
namespace cpp {

class OpArgumentView {
 public:
  explicit OpArgumentView(ArgSpec arg);
  explicit OpArgumentView(AttrSpec attr);
  explicit OpArgumentView(string type, string var, string def = "");

  string Declaration() const;
  string Initializer() const;
  bool HasDefaultValue() const;

 private:
  string type_name_;

OpArgumentView::OpArgumentView(ArgSpec arg)
    : type_name_(ArgTypeView(arg.arg_type()).TypeName()),
      variable_name_(ArgView(arg).VariableName()) {}

OpArgumentView::OpArgumentView(AttrSpec attr)
    : type_name_(AttrView(attr).VariableType()),
      variable_name_(AttrView(attr).VariableName()),
      default_value_(AttrView(attr).DefaultValue()) {}

}  // namespace cpp
}  // namespace generator

the model and provides utilities for the language generators.

The *View* and rendering classes map the language-independent Model classes
(`OpSpec`, `ArgSpec`, `AttrSpec`, etc.) to language-specific `SourceCode`. The
framework does not impose any design on the language-specific generators, but
provides some utilities, and the C++ generator is a complete example.

### C++ Generator