instIDPath     = metaPrefix + "/instance/id"
	instancePath   = metaPrefix + "/instance/name"
	zonePath       = metaPrefix + "/instance/zone"
	attrKey        = "attribute"
	attrPath       = metaPrefix + "/instance/attributes/{" + attrKey + "}"
)

var instAttrs = map[string]string{
	"instance-template": "some-template",
	"created-by":        "some-creator",
	"cluster-name":      "test-cluster",
}

          device.has_job && device.job == jobType) {
        for (const auto& attr : node->attrs()) {
          auto attr_key = attr.first;
          auto attr_value = attr.second;
          if (attr_key == attrKey &&
              attr_value.value_case() == AttrValue::kType &&
              attr_value.type() == DT_RESOURCE) {
            return true;
            break;
          }
        }
      }
    }

// 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/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();
  default_value_ = attr_def.default_value();

  let cppStorageType = "::llvm::SmallVector<int32_t>";
  let parser = "::mlir::TFL::parseI32Array($_parser)";
  let printer = "$_printer << '[' << $_self << ']'";
}

def DimensionMetadataAttr : AttrDef<TFL_Dialect, "DimensionMetadata"> {
  let mnemonic = "dimension_metadata";
  let parameters = (ins
      TFL_DimensionTypeAttr:$format,
      "int32_t":$dense_size,
      I32ArrayParameter:$segments,

> _For example, an `OpDef` proto's `ArgDef` members contain a type string, which
> must be dereferenced to an `AttrDef` by name to determine its type. This
> `AttrDef` proto message in turn contains a type string which may need to be
> parsed as "list(type)". Other `AttrDef` messages are not types, but instead
> argument-like modifiers. In contrast, the generator model `ArgSpec` contains a

		// Close all open groups.
		for range s.h.groups[:nOpenGroups] {
			s.buf.WriteByte('}')
		}
		// Close the top-level object.
		s.buf.WriteByte('}')
	}
}

// attrSep returns the separator between attributes.
func (h *commonHandler) attrSep() string {
	if h.json {
		return ","
	}
	return " "
}

// handleState holds state for a single call to commonHandler.handle.

func nlmAlignOf(msglen int) int {
	return (msglen + NLMSG_ALIGNTO - 1) & ^(NLMSG_ALIGNTO - 1)
}

// Round the length of a netlink route attribute up to align it
// properly.
func rtaAlignOf(attrlen int) int {
	return (attrlen + RTA_ALIGNTO - 1) & ^(RTA_ALIGNTO - 1)
}

// NetlinkRouteRequest represents a request message to receive routing
// and link states from the kernel.
type NetlinkRouteRequest struct {
	Header NlMsghdr

  }
  for (const OpDef::ArgDef& arg_def : op_def.output_arg()) {
    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()) {

      auto attr_key = tensor_type.getAttrKeys().front();
      Builder builder(signature.getContext());
      if (auto attr = attrs.lookup(attr_key.getValue())) {
        output_types->push_back(
            UnrankedTensorType::get(mlir::cast<TypeAttr>(attr).getValue()));
      } else if (Type element_type =
                     GetFixedElementType(attr_key.getValue(), builder)) {