if i == nil {
		return "{}"
	}

	ba, err := json.Marshal(i)
	if err != nil {
		log.Warnf("Unable to marshal %v: %v", i, err)
		return "{}"
	}

	return string(ba)
}

// GetEffectiveTemplatePath gets the template file that should be used for bootstrap
func GetEffectiveTemplatePath(pc *model.NodeMetaProxyConfig) string {
	var templateFilePath string
	switch {
	case pc.CustomConfigFile != "":

	err := json.Unmarshal(b, rawDump)
	if err != nil {
		return fmt.Errorf("error unmarshalling config dump response from ztunnel: %v", err)
	}
	// ensure that data gets unmarshalled into the right data type
	if err := unmarshalListOrMap(rawDump.Services, &zDump.Services); err != nil {
		return err
	}
	if err := unmarshalListOrMap(rawDump.Workloads, &zDump.Workloads); err != nil {
		return err

		}

		return true
	}

	tmpfsNoswapOptionAvailabilityOnce.Do(func() {
		tmpfsNoswapOptionSupported = isTmpfsNoswapOptionSupportedHelper()
	})

	return tmpfsNoswapOptionSupported
}

// gets /proc/swaps's content as an input, returns true if swap is enabled.
func isSwapOnAccordingToProcSwaps(procSwapsContent []byte) bool {
	procSwapsContent = bytes.TrimSpace(procSwapsContent) // extra trailing \n

// to UDP Service IPs. When a service has no endpoints and we drop traffic to it, conntrack
// may create "black hole" entries for that IP+port. When the service gets endpoints we
// need to delete those entries so further traffic doesn't get dropped.
func deleteStaleServiceConntrackEntries(ct Interface, svcPortMap proxy.ServicePortMap, serviceUpdateResult proxy.UpdateServiceMapResult, endpointsUpdateResult proxy.UpdateEndpointsMapResult) {

	}, exclude(excluded...))
}

// IsExternalControlPlane indicates whether the clusters are set up in an enternal
// control plane configuration. An external control plane is a primary cluster that
// gets its Istio configuration from a different cluster.
func (c Clusters) IsExternalControlPlane() bool {
	for _, cc := range c {
		if cc.IsExternalControlPlane() {
			return true
		}
	}
	return false
}

// instead of overriding the old value.  In other words, appending scope B to
// scope A creates the conjunction of the scopes A and B (i.e, A & B) and,
// in effect, the node gets both the old and new scopes.  As a unique scope
// disallows a node being merged with nodes in other scopes, the scope
// conjunction preserves the semantic of the old scope (i.e., the node still

    /**
     * Gets the session data associated with the specified key.
     *
     * @param key the key for which to retrieve the session data, must not be {@code null}
     * @return the session data associated with the key or {@code null} if none
     */
    @Nullable
    <T> T get(@Nonnull Key<T> key);

    /**

            return b.toString();
        }).collect(Collectors.joining(",")));
        buf.append("},");
        final GarbageCollectors gc = jvmStats.getGc();
        buf.append("\"gc\":{");
        buf.append(Arrays.stream(gc.getCollectors()).map(c -> {
            final StringBuilder b = new StringBuilder();

			// different values, then both nodes will *always* get inserted,
			// because the equality checking below will always fail.
			//
			// Performance note: contention on insertion is likely to be
			// higher for small maps, but since this data structure is
			// append-only, either the map stays small because there isn't
			// much activity, or the map gets big and races to insert on
			// the same node are much less likely.

            // Note that according to the documentation of `Files.move()`, whether this exception is thrown
            // is implementation specific: it can also happen that the target file gets overwritten, as if
            // `REPLACE_EXISTING` was specified. This seems to match the behavior exhibited by `File.renameTo()`.
        } catch (IOException e) {