"istio.io/istio/pkg/slices"
)

func FetchOne[T any](ctx HandlerContext, c Collection[T], opts ...FetchOption) *T {
	res := Fetch[T](ctx, c, opts...)
	switch len(res) {
	case 0:
		return nil
	case 1:
		return &res[0]
	default:
		panic("FetchOne found for more than 1 item")
	}
}

func Fetch[T any](ctx HandlerContext, cc Collection[T], opts ...FetchOption) []T {
	h := ctx.(registerDependency)
	c := cc.(internalCollection[T])

        ) {
            int id = nextId++;
            return new ArtifactsForNode(id, new VariantResolvingArtifactSet(variantResolver, component, variant, dependency, graphVariantSelector, consumerSchema));
        }

        return artifactsByNodeId.computeIfAbsent(toNode.getNodeId(), (LongFunction<ArtifactsForNode>) value -> {
            int id = nextId++;

@ServiceScope(Scope.BuildTree.class)
public class ComponentIdGenerator {
    private final AtomicLong nextId = new AtomicLong();

    public long nextComponentId() {
        return nextId.getAndIncrement();
    }

    public long nextVariantId() {
        return nextId.getAndIncrement();
    }

    public long nextGraphNodeId() {
        return nextId.getAndIncrement();
    }

	// maps function to index in slice above (index acts as function ID)
	funcTable map[fnfile]uint32

	// A table storing coverage counts for each coverable unit.
	unitTable map[extcu]uint32
}

// extcu encapsulates a coverable unit within some function.
type extcu struct {
	fnfid uint32 // index into p.funcs slice
	coverage.CoverableUnit
}

// fnfile is a function-name/file-name tuple.
type fnfile struct {
	file  string

}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
	// Always increment lastID, even if it is not used.
	id := nextID()
	if check != nil {
		check.nextID++
		id = check.nextID
	}
	typ := &TypeParam{check: check, id: id, obj: obj, index: -1, bound: constraint}
	if obj.typ == nil {
		obj.typ = typ
	}

}

// check may be nil
func (check *Checker) newTypeParam(obj *TypeName, constraint Type) *TypeParam {
	// Always increment lastID, even if it is not used.
	id := nextID()
	if check != nil {
		check.nextID++
		id = check.nextID
	}
	typ := &TypeParam{check: check, id: id, obj: obj, index: -1, bound: constraint}
	if obj.typ == nil {
		obj.typ = typ
	}

}

// getID returns a unique ID for the type t.
func (ctxt *Context) getID(t Type) int {
	ctxt.mu.Lock()
	defer ctxt.mu.Unlock()
	id, ok := ctxt.originIDs[t]
	if !ok {
		id = ctxt.nextID
		ctxt.originIDs[t] = id
		ctxt.nextID++
	}
	return id

  }

  @JvmStatic
  fun threadFactory(name: String): ThreadFactory {
    return object : ThreadFactory {
      private var nextId = 1

      override fun newThread(runnable: Runnable): Thread {
        return Thread(runnable, "$name-${nextId++}")
      }
    }
  }
}

fun getEnv(name: String) = System.getenv(name)

val SYSTEM_FILE_SYSTEM = FileSystem.SYSTEM

            return true;
        }

        int optionalOpen = 0;
        for (int i = 0; i < tokenIndex; i++) {
            char nextChar = patternString.charAt(i);
            if (nextChar == '(') {
                optionalOpen++;
            } else if (nextChar == ')') {
                optionalOpen = Math.max(0, optionalOpen - 1);
            }
        }
        return optionalOpen > 0;
    }

/**
 * Provides an id unique within the global scope a build VM.
 */
@ServiceScope(Scope.Global.class)
public interface BuildOperationIdFactory {

    /**
     * @return the next unique ID
     */
    long nextId();