*/

    public ResolutionNode resolveConflict(ResolutionNode node1, ResolutionNode node2) {
        try {
            ArtifactVersion version1 = node1.getArtifact().getSelectedVersion();
            ArtifactVersion version2 = node2.getArtifact().getSelectedVersion();

            return version1.compareTo(version2) > 0 ? node1 : node2;
        } catch (OverConstrainedVersionException exception) {

     */
    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    /**

type NUMAInfo struct {
	Nodes         []int
	NUMADistances NUMADistances
}

func NewNUMAInfo(topology []cadvisorapi.Node, opts PolicyOptions) (*NUMAInfo, error) {
	var numaNodes []int
	distances := map[int][]uint64{}
	for _, node := range topology {
		numaNodes = append(numaNodes, node.Id)

		var nodeDistance []uint64
		if opts.PreferClosestNUMA {
			nodeDistance = node.Distances
			if nodeDistance == nil {

# A library of helper functions and constants for Windows nodes.

function get-windows-node-instance-metadata-from-file {
  local metadata=""
  metadata+="cluster-name=${KUBE_TEMP}/cluster-name.txt,"
  metadata+="cluster-location=${KUBE_TEMP}/cluster-location.txt,"
  metadata+="kube-env=${KUBE_TEMP}/windows-node-kube-env.yaml,"
  metadata+="kubelet-config=${KUBE_TEMP}/windows-node-kubelet-config.yaml,"

func taintNodes(t resource.Context) error {
	nodeC := t.Clusters().Default().Kube().CoreV1().Nodes()
	nodes, err := nodeC.List(context.TODO(), metav1.ListOptions{})
	if err != nil {
		return err
	}

Outer:
	for _, node := range nodes.Items {
		for _, taint := range node.Spec.Taints {
			if taint.Key == "cni.istio.io/not-ready" {
				continue Outer
			}
		}
		node.Spec.Taints = append(node.Spec.Taints, corev1.Taint{

// ----------------------------------------------------------------------------
// Nodes

type Node interface {
	// Pos() returns the position associated with the node as follows:
	// 1) The position of a node representing a terminal syntax production
	//    (Name, BasicLit, etc.) is the position of the respective production
	//    in the source.
	// 2) The position of a node representing a non-terminal production

     *
     * @param node1 the first artifact declaration
     * @param node2 the second artifact declaration
     * @return the artifact declaration to use: <code>node1</code>; <code>node2</code>; or <code>null</code>if
     *         this conflict cannot be resolved
     * @since 3.0
     */
    ResolutionNode resolveConflict(ResolutionNode node1, ResolutionNode node2);

func (nodes Nodes) Latency() *timeseries.Instance {
	var out timeseries.Instance
	for _, n := range nodes {
		out.AddAll(n.Latency())
	}
	return &out
}

func (nodes Nodes) QueueLatency() *timeseries.Instance {
	var out timeseries.Instance
	for _, n := range nodes {
		out.AddAll(n.QueueLatency())
	}
	return &out
}

func (nodes Nodes) TotalRequests() uint64 {
	var out uint64
	for _, n := range nodes {

  // the xla_launch_node's immediate downstream nodes would be attached to the
  // generated xla node. For example, if the original graph is
  // StatefulPartitionedCall{_xla_compile_id=1} -> XlaClusterOutput -> NodeA
  // The output graph of this function would look like the following when
  // add_edges_to_output_of_downstream_nodes is true:
  // XlaLaunch -> NodeA
  static Status BuildXlaLaunchOps(
      Graph* graph,

	r.Lock()
	defer r.Unlock()
	r.Node = node.Name
	r.Nodes.Items = append(r.Nodes.Items, *node)
	return r.Err
}

func (r *NodeRegistry) UpdateNode(ctx context.Context, node *api.Node) error {
	r.Lock()
	defer r.Unlock()
	for i, item := range r.Nodes.Items {
		if item.Name == node.Name {
			r.Nodes.Items[i] = *node
			return r.Err
		}
	}
	return r.Err
}