/**
     * Snapshots and stores the result in the VFS.
     *
     * If the snapshotted location is invalidated while snapshotting,
     * then the snapshot is not stored in the VFS to avoid inconsistent state.
     */
    FileSystemLocationSnapshot store(String absolutePath, Supplier<FileSystemLocationSnapshot> snapshotSupplier);


    /**

}

// SetMachineState stores NUMANodeMap in State
func (sc *stateCheckpoint) SetMachineState(memoryMap NUMANodeMap) {
	sc.Lock()
	defer sc.Unlock()

	sc.cache.SetMachineState(memoryMap)
	err := sc.storeState()
	if err != nil {
		klog.InfoS("Store state to checkpoint error", "err", err)
	}
}

// SetMemoryBlocks stores memory assignments of container

}

// reset clears stored data and configures window size.
func (w *window) reset(size int) {
	b := w.data[:0]
	if cap(b) < size {
		b = make([]byte, 0, size)
	}
	w.data = b
	w.off = 0
	w.size = size
}

// len returns the number of stored bytes.
func (w *window) len() uint32 {
	return uint32(len(w.data))
}

// save stores up to size last bytes from the buf.
func (w *window) save(buf []byte) {
	if w.size == 0 {

// ReadForm parses an entire multipart message whose parts have
// a Content-Disposition of "form-data".
// It stores up to maxMemory bytes + 10MB (reserved for non-file parts)
// in memory. File parts which can't be stored in memory will be stored on
// disk in temporary files.
// It returns [ErrMessageTooLarge] if all non-file parts can't be stored in
// memory.
func (r *Reader) ReadForm(maxMemory int64) (*Form, error) {
	return r.readForm(maxMemory)
}

func LoadPointer(addr *unsafe.Pointer) (val unsafe.Pointer)

// StoreInt32 atomically stores val into *addr.
// Consider using the more ergonomic and less error-prone [Int32.Store] instead.
func StoreInt32(addr *int32, val int32)

// StoreInt64 atomically stores val into *addr.
// Consider using the more ergonomic and less error-prone [Int64.Store] instead
// (particularly if you target 32-bit platforms; see the bugs section).

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.cache.internal;

import java.util.function.Supplier;

public interface Store<T> {
    T load(Supplier<T> createIfNotPresent);

Laura Kassovic <******@****.***> 1701107622 -0800

Laura Kassovic <******@****.***> 1701107622 -0800

	IsControllerOf(wle *config.Config) bool
}

// NewStore returns a new Store instance.
func NewStore(store model.ConfigStoreController, cb StoreCallbacks) *Store {
	return &Store{
		store: store,
		cb:    cb,
	}
}

// UpdateHealth updates the associated WorkloadEntries health status
// based on the corresponding health check performed by istio-agent.

)

const ResourceVersion string = "ResourceVersion"

// Make creates an in-memory config store from a config schemas
// It is with validation
func Make(schemas collection.Schemas) model.ConfigStore {
	return newStore(schemas, false)
}

// MakeSkipValidation creates an in-memory config store from a config schemas
// It is without validation
func MakeSkipValidation(schemas collection.Schemas) model.ConfigStore {