)

// jsonpathEval evaluates a JSON path and returns the value at the path.
// If the value should be considered flat (from wildcards) any array returned should be considered individual values.
func jsonpathEval(p []*JSONPathElement, v interface{}) (r interface{}, flat bool, err error) {
	// fmt.Printf("JPATHexpr: %v jsonobj: %v\n\n", p, v)
	if len(p) == 0 || v == nil {
		return v, false, nil
	}

	switch {

    Initializer(const T& v) {  // NOLINT(runtime/explicit)
      typedef typename RealType<T>::type RealT;
      Tensor t(DataTypeToEnum<RealT>::v(), TensorShape());
      t.flat<RealT>()(0) = RealT(v);
      tensor = t;
    }

    Initializer(const Tensor& t) : tensor(t) {}  // NOLINT(runtime/explicit)

    /// Construct from a scalar value and an explicit shape

  }

  if (t.dtype() == ::tensorflow::DT_QINT8) {
    const auto arr = t.flat<::tensorflow::qint8>();
    return mlir::DenseElementsAttr::get(
        tensor_type.clone(IntegerType::get(tensor_type.getContext(), 8)),
        llvm::ArrayRef(arr.data(), arr.size()));
  } else if (t.dtype() == ::tensorflow::DT_QINT32) {
    const auto arr = t.flat<::tensorflow::qint32>();
    return mlir::DenseElementsAttr::get(

import "istio.io/istio/pkg/cluster"

// Origin of a resource. This is source-implementation dependent.
type Origin interface {
	FriendlyName() string
	Namespace() Namespace
	Reference() Reference

	// FieldMap returns the flat map containing paths of the fields in the resource as keys,
	// and their corresponding line numbers as values
	FieldMap() map[string]int
	Comparator() string

using tf::libtf::runtime::Runtime;

// TODO(danielellis): Fill in with implementations.

// Builds a vector of runtime representations of `SavedObject`s from a
// SavedModel. These are returned as a flat list.  The full hierarchy building
// and initialization should be done in a later pass.
tensorflow::StatusOr<std::vector<Handle>> BuildObjects(TFPackage& tf_package) {
  std::vector<Handle> objects;

			f.newCache.deleteRecursive(thisHash)
			f.newCache.replaceHashed(thisHash, folder.parent, *flat)
			total := map[string]string{
				"objects": strconv.FormatUint(flat.Objects, 10),
				"size":    strconv.FormatInt(flat.Size, 10),
			}
			if flat.Versions > 0 {
				total["versions"] = strconv.FormatUint(flat.Versions, 10)
			}
			stop(total)
		}

	}
	// Compact if too many children...

     */
    ComponentSpecIdentifier child(String name);

    /**
     * Returns a name that can be used to identify this component uniquely within its project. The name belongs to a flat namespace and does not include any
     * hierarchy delimiters. As such, it can be safely used for task or file names.
     *
     * Implementation should attempt to produce a somewhat human consumable name (eg not a uuid).

      return false;
    }
  }

  for (int64_t i = 0, e = actual.NumElements(); i < e; i++) {
    if (actual.flat<T>()(i) != expected.flat<T>()(i)) {
      *listener << "\nmismatch in constant tensor at index " << i
                << " expected = " << expected.flat<T>()(i)
                << " actual = " << actual.flat<T>()(i);
      return false;
    }
  }

  return true;
}

      <name>SupplementalDataModel</name>
      <version>1.0.0</version>
      <description>Root element of the supplemental-models.xml file.</description>
      <fields>
        <field xml.listStyle="flat">
          <name>supplement</name>
          <version>1.0.0</version>
          <description>Snippets of POM xml files used to supplement the data model.</description>
          <association>

		}
		t.Fatal("got nil root.")
	}

	// Test dirs
	want := []struct {
		path       string
		isNil      bool
		size, objs int
		oSizes     sizeHistogram
	}{
		{
			path:   "flat",
			size:   1322310 + expectSize,
			objs:   8 + expectSize,
			oSizes: sizeHistogram{0: 2 + expectSize, 1: 3, 2: 2, 4: 1},
		},
		{
			path:   "bucket/",
			size:   20000,
			objs:   2,