/*
Copyright The Kubernetes Authors.

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
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.
*/

// Code generated by applyconfiguration-gen. DO NOT EDIT.

package v1

import (
	resourcev1 "k8s.io/api/resource/v1"
	resource "k8s.io/apimachinery/pkg/api/resource"
)

// NodeAllocatableResourceMappingApplyConfiguration represents a declarative configuration of the NodeAllocatableResourceMapping type for use
// with apply.
//
// NodeAllocatableResourceMapping defines the translation between the DRA device/capacity
// units requested to the corresponding quantity of the node allocatable resource.
type NodeAllocatableResourceMappingApplyConfiguration struct {
	// CapacityKey references a capacity name defined as a key in the
	// `spec.devices[*].capacity` map. When this field is set, the value associated with
	// this key in the `status.allocation.devices.results[*].consumedCapacity` map
	// (for a specific claim allocation) determines the base quantity for
	// the node allocatable resource. If `allocationMultiplier` is also set, it is
	// multiplied with the base quantity.
	// For example, if `spec.devices[*].capacity` has an entry "dra.example.com/memory": "128Gi",
	// and this field is set to "dra.example.com/memory", then for a claim allocation
	// that consumes { "dra.example.com/memory": "4Gi" } the base quantity for the
	// node allocatable resource mapping will be "4Gi", and `allocationMultiplier` should
	// be omitted or set to "1".
	CapacityKey *resourcev1.QualifiedName `json:"capacityKey,omitempty"`
	// AllocationMultiplier is used as a multiplier for the allocated device count or the allocated capacity in the claim.
	// It defaults to 1 if not specified. How the field is used also depends on whether `capacityKey` is set.
	// 1.  If `capacityKey` is NOT set: `allocationMultiplier` multiplies the device count allocated to the claim.
	// a. A DRA driver representing each CPU core as a device would have
	// {ResourceName: "cpu", allocationMultiplier: "2"} in its
	// `nodeAllocatableResourceMappings`. If 4 devices are allocated to the claim,
	// 4 * 2 CPUs would be considered as allocated and subtracted from the node's capacity.
	// b. A GPU device that needs additional node memory per GPU allocation would
	// have {ResourceName: "memory", allocationMultiplier: "2Gi"}.  Each allocated
	// GPU device instance of this type will account for 2Gi of memory.
	//
	// 2.  If `capacityKey` IS set: `allocationMultiplier` is multiplied by the amount of that capacity consumed.
	// The final node allocatable resource amount is `consumedCapacity[capacityKey]` * `allocationMultiplier`.
	// For example, if a Device's capacity "dra.example.com/cores" is consumed,
	// and each "core" provides 2 "cpu"s, the mapping would be:
	// {ResourceName: "cpu", capacityKey: "dra.example.com/cores", allocationMultiplier: "2"}.
	// If a claim consumes 8 "dra.example.com/cores", the CPU footprint is 8 * 2 = 16.
	AllocationMultiplier *resource.Quantity `json:"allocationMultiplier,omitempty"`
}

// NodeAllocatableResourceMappingApplyConfiguration constructs a declarative configuration of the NodeAllocatableResourceMapping type for use with
// apply.
func NodeAllocatableResourceMapping() *NodeAllocatableResourceMappingApplyConfiguration {
	return &NodeAllocatableResourceMappingApplyConfiguration{}
}

// WithCapacityKey sets the CapacityKey field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the CapacityKey field is set to the value of the last call.
func (b *NodeAllocatableResourceMappingApplyConfiguration) WithCapacityKey(value resourcev1.QualifiedName) *NodeAllocatableResourceMappingApplyConfiguration {
	b.CapacityKey = &value
	return b
}

// WithAllocationMultiplier sets the AllocationMultiplier field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the AllocationMultiplier field is set to the value of the last call.
func (b *NodeAllocatableResourceMappingApplyConfiguration) WithAllocationMultiplier(value resource.Quantity) *NodeAllocatableResourceMappingApplyConfiguration {
	b.AllocationMultiplier = &value
	return b
}
