WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package resourceclaim

import (
	"sync"

	"github.com/golang/groupcache/lru"

	"k8s.io/apimachinery/pkg/types"
)

// uidCache is an LRU cache for uid.
type uidCache struct {
	mutex sync.Mutex
	cache *lru.Cache

	for _, obj := range objs {
		claim, ok := obj.(*resourcev1alpha2.ResourceClaim)
		if !ok {
			return nil, fmt.Errorf("got unexpected object of type %T from claim assume cache", obj)
		}
		if obj, ok := inFlightAllocations.Load(claim.UID); ok {
			// If the allocation is in-flight, then we have to use the allocation
			// from that claim.
			claim = obj.(*resourcev1alpha2.ResourceClaim)
		}
		if claim.Status.Allocation == nil {
			continue

        "description": "PodSchedulingContextStatus describes where resources for the Pod can be allocated.",
        "properties": {
          "resourceClaims": {
            "description": "ResourceClaims describes resource availability for each pod.spec.resourceClaim entry where the corresponding ResourceClaim uses \"WaitForFirstConsumer\" allocation mode.",
            "items": {
              "allOf": [
                {

func newClaimInfoFromClaim(claim *resourcev1alpha2.ResourceClaim) *ClaimInfo {
	// Grab the allocation.resourceHandles. If there are no
	// allocation.resourceHandles, create a single resourceHandle with no
	// content. This will trigger processing of this claim by a single
	// kubelet plugin whose name matches resourceClaim.Status.DriverName.
	resourceHandles := claim.Status.Allocation.ResourceHandles

              ]
            },
            {
              "resource": "resourceclaims",
              "responseKind": {
                "group": "",
                "kind": "ResourceClaim",
                "version": ""
              },
              "scope": "Namespaced",
              "singularResource": "resourceclaim",
              "subresources": [
                {

	resourceclaimstore "k8s.io/kubernetes/pkg/registry/resource/resourceclaim/storage"
	resourceclaimparametersstore "k8s.io/kubernetes/pkg/registry/resource/resourceclaimparameters/storage"
	resourceclaimtemplatestore "k8s.io/kubernetes/pkg/registry/resource/resourceclaimtemplate/storage"
	resourceclassstore "k8s.io/kubernetes/pkg/registry/resource/resourceclass/storage"

              ]
            },
            {
              "resource": "resourceclaims",
              "responseKind": {
                "group": "",
                "kind": "ResourceClaim",
                "version": ""
              },
              "scope": "Namespaced",
              "singularResource": "resourceclaim",
              "subresources": [
                {

func GetAttrs(obj runtime.Object) (labels.Set, fields.Set, error) {
	parameters, ok := obj.(*resource.ResourceClaimParameters)
	if !ok {
		return nil, nil, errors.New("not a resourceclaim")
	}
	return labels.Set(parameters.Labels), toSelectableFields(parameters), nil
}

// toSelectableFields returns a field set that represents the object

			e := newDestinationEdge(pvcVertex, podVertex, nodeVertex)
			g.graph.SetEdge(e)
			g.addEdgeToDestinationIndex_locked(e)
		}
	}

	for _, podResourceClaim := range pod.Spec.ResourceClaims {
		claimName, _, err := resourceclaim.Name(pod, &podResourceClaim)
		// Do we have a valid claim name? If yes, add an edge that grants
		// kubelet access to that claim. An error indicates that a claim

				}
				handlers = append(handlers, handlerRegistration)
			}
		case framework.ResourceClaim:
			if utilfeature.DefaultFeatureGate.Enabled(features.DynamicResourceAllocation) {
				if handlerRegistration, err = informerFactory.Resource().V1alpha2().ResourceClaims().Informer().AddEventHandler(
					buildEvtResHandler(at, framework.ResourceClaim, "ResourceClaim"),
				); err != nil {
					return err
				}