Map<String, String> attrs = dominant.getAttributes();
            List<XmlNode> children = null;

            for (Map.Entry<String, String> attr : recessive.getAttributes().entrySet()) {
                String key = attr.getKey();
                if (isEmpty(attrs.get(key))) {
                    if (attrs == dominant.getAttributes()) {
                        attrs = new HashMap<>(attrs);
                    }

    llvm::SmallVectorImpl<mlir::NamedAttribute> &output) {
  for (mlir::NamedAttribute attr : attrs) {
    if (attr.getName().strref().contains(
            mlir::tfg::TFGraphDialect::getDeviceAttrKey())) {
      tensorflow::DeviceNameUtils::ParsedName parsed_name;
      if (!tensorflow::DeviceNameUtils::ParseFullName(
              mlir::cast<mlir::StringAttr>(attr.getValue()).getValue().str(),

  for (it = attrs.begin(); it != attrs.end(); it++) {
    if (count == i) {
      return it->first.length();
    }
    count++;
  }
  return -1;
}

void TF_OperationGetAttrName(TF_Operation* oper, int i, char* output,
                             TF_Status* status) {
  auto attrs = oper->node.attrs();
  int count = 0;
  AttrValueMap::const_iterator it;
  for (it = attrs.begin(); it != attrs.end(); it++) {

    absl::Span<
        const std::pair<std::string, FunctionDefHelper::AttrValueWrapper>>
        attrs) {
  NodeDef node;
  node.set_name(std::string(name));
  node.set_op(std::string(op));
  for (const auto& input : inputs) node.add_input(input);
  for (const auto& attr : attrs)
    node.mutable_attr()->insert({attr.first, attr.second.proto});
  return node;
}

}  // namespace

    }

    def "can serialize/deserialize isolated Attribute values"() {
        Attribute attr1 = Attribute.of("foo", String.class)
        Attribute attr2 = Attribute.of("bar", SomeType.class)
        Isolatable<?>[] isolatables = [isolatableFactory.isolate(attr1), isolatableFactory.isolate(attr2)]

        when:
        serialize(isolatables)

        and:

	BFalse bool    `xml:",attr"`
	BTrue  bool    `xml:",attr"`
	I      int     `xml:",attr"`
	INeg   int     `xml:",attr"`
	I8     int8    `xml:",attr"`
	I8Neg  int8    `xml:",attr"`
	I16    int16   `xml:",attr"`
	I16Neg int16   `xml:",attr"`
	I32    int32   `xml:",attr"`
	I32Neg int32   `xml:",attr"`
	I64    int64   `xml:",attr"`
	I64Neg int64   `xml:",attr"`
	UI     uint    `xml:",attr"`

bool EnsureAttribute(const DictionaryAttr& composite_attributes,
                     const std::string& attr_name, AttrType* out_attr) {
  Attribute attr = composite_attributes.get(attr_name);
  if (!mlir::isa_and_nonnull<AttrType>(attr)) {
    return false;
  }
  if (AttrType content = mlir::dyn_cast<AttrType>(attr)) {
    *out_attr = content;
    return true;
  } else {
    return false;
  }
}

}

Status ConvertAttribute(const mlir::BoolAttr& attr, AttrValue* value) {
  value->set_b(attr.getValue());
  return absl::OkStatus();
}

Status ConvertAttribute(const mlir::IntegerAttr& attr, AttrValue* value) {
  value->set_i(attr.getInt());
  return absl::OkStatus();
}

Status ConvertAttribute(const mlir::FloatAttr& attr, AttrValue* value) {
  value->set_f(attr.getValueAsDouble());
  return absl::OkStatus();
}

    op_state.addOperands(op.getOperands());
    op_state.addTypes(op.getResultTypes());

    SmallVector<NamedAttribute, 2> attrs;
    std::string parsed_op_name;
    tensorflow::NodeDef node_def;
    if (failed(ParseCustomOption(op.getCustomOption().getValue(), op.getLoc(),
                                 parsed_op_name, attrs, node_def))) {
      return failure();
    }
    if (parsed_op_name != tf_op_name) {
      return op.emitOpError(

def _impl(ctx):
    classes = ",".join(
        [_AsClassName(x) for x in ctx.attr.srcs],
    )
    ctx.actions.write(output = ctx.outputs.out, content = _OUTPUT % (
        classes,
        ctx.attr.outname,
    ))

_GenSuite = rule(
    attrs = {
        "srcs": attr.label_list(allow_files = True),
        "outname": attr.string(),
    },
    outputs = {"out": "%{name}.java"},
    implementation = _impl,