return osddFile != null;
    }

    public StreamResponse asStream() {
        if (osddFile == null) {
            throw ComponentUtil.getResponseManager().new404("Unsupported Open Search Description Document response.");
        }

        return new StreamResponse(osddFile.getName()).contentType(contentType + "; charset=" + encoding).stream(out -> {
            try (InputStream ins = new FileInputStream(osddFile)) {

inline void PrintTo(const signed char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(signed char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(unsigned char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);

inline void PrintTo(const signed char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(signed char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(const unsigned char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);
}
inline void PrintTo(unsigned char* s, ::std::ostream* os) {
  PrintTo(ImplicitCast_<const void*>(s), os);

                        std::unique_ptr<llvm::raw_ostream> file)
      : name(name), ostream(std::move(file)) {}

  llvm::StringRef description() override { return name; }
  raw_ostream& os() override { return *ostream; }

 private:
  std::string name;
  std::unique_ptr<llvm::raw_ostream> ostream;
};

// MLIR crash reproducer which reports failures to the crash analysis system.

	var buf bytes.Buffer
	e := json.NewEncoder(&buf)
	d := jstream.NewDecoder(r, 0).ObjectAsKVS()
	sset := set.NewStringSet()
	for mv := range d.Stream() {
		var kvs jstream.KVS
		if mv.ValueType == jstream.Object {
			// This is a JSON object type (that preserves key order)
			kvs = mv.Value.(jstream.KVS)
			for _, kv := range kvs {
				if sset.Contains(kv.Key) {

  }
  return 0;
}

static void EmitOptionBuilders(const RecordKeeper &record_keeper,
                               const std::vector<Record *> &defs,
                               raw_ostream *ostream) {
  raw_ostream &os = *ostream;

  const auto attr_type = record_keeper.getClass("Attr");
  for (const auto *def : defs) {
    const int has_options = HasOptions(*def);
    // TFLite ops without options are skipped over.

        if (StringUtil.isEmpty(pi.getName())) {
            throwValidationErrorApi(messages -> messages.addErrorsStorageFileNotFound(GLOBAL));
        }
        return asStream(pi.getName()).contentTypeOctetStream().stream(out -> {
            try {
                downloadObject(getObjectName(pi.getPath(), pi.getName()), out);
            } catch (final StorageException e) {

                    }
                    throw e1;
                }
                return asStream("es_" + ComponentUtil.getSystemHelper().getCurrentTimeAsLong() + ".json").contentTypeOctetStream()
                        .stream(out -> {
                            try (final InputStream in = new FileInputStream(tempFile)) {
                                out.write(in);

}

class TaggedValueIOStreamVisitor {
  std::ostream& o_;

 public:
  explicit TaggedValueIOStreamVisitor(std::ostream& o) : o_(o) {}

  std::ostream& operator()(const ListPtr& x) {
    OutList(o_, x->begin(), x->end(), '[', ']');
    return o_;
  }
  std::ostream& operator()(const TuplePtr& x) {
    OutList(o_, x->begin(), x->end(), '(', ')');
    return o_;
  }
  std::ostream& operator()(const DictPtr& x) {
    o_ << *x;

  LoggableAttribute(mlir::Attribute& v) : v(v) {}
};
std::ostream& operator<<(std::ostream& o, const LoggableAttribute& attr);

struct LoggableStringRef {
  const llvm::StringRef& v;
  // NOLINTNEXTLINE(google-explicit-constructor)
  LoggableStringRef(const llvm::StringRef& v) : v(v) {}
};
std::ostream& operator<<(std::ostream& o, const LoggableStringRef& ref);

}  // namespace tensorflow