if containerSc.WindowsOptions.HostProcess != nil {
			effectiveSc.WindowsOptions.HostProcess = containerSc.WindowsOptions.HostProcess
		}
	}

	if containerSc.Capabilities != nil {
		effectiveSc.Capabilities = new(v1.Capabilities)
		*effectiveSc.Capabilities = *containerSc.Capabilities
	}

	if containerSc.Privileged != nil {
		effectiveSc.Privileged = new(bool)
		*effectiveSc.Privileged = *containerSc.Privileged
	}

import org.gradle.api.capabilities.Capability;
import org.gradle.internal.component.resolution.failure.ResolutionCandidateAssessor.AssessedCandidate;

import java.util.Collection;
import java.util.List;

/**
 * A {@link ResolutionFailure} that represents the situation when no variants can
 * be found in the list of candidates that have the requested capabilities.
 */

 */

package org.gradle.api.artifacts.result;

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.api.attributes.AttributeContainer;
import org.gradle.api.capabilities.Capability;

import java.util.List;
import java.util.Optional;

/**
 * The result of successfully resolving a component variant.
 *
 * @since 3.5
 */
public interface ResolvedVariantResult {
    /**

            cpu: "2"
            memory: 1Gi
          requests:
            cpu: 100m
            memory: 128Mi
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop:
            - ALL
          privileged: false
          readOnlyRootFilesystem: false
          runAsGroup: 1337
          runAsNonRoot: true
          runAsUser: 1337

        AttributeContainer attributes = attributeContainerSerializer.read(decoder);
        List<Capability> capabilities = capabilitySerializer.read(decoder);
        visitor.visitSelectedVariant(nodeId, new DefaultResolvedVariantResult(ownerId, Describables.of(displayName), attributes, ImmutableCapabilities.of(capabilities), null));
    }

    private VariantGraphResolveState readVariantReference(Decoder decoder) throws IOException {

    }

    protected ImmutableCapabilities capabilitiesFor(ImmutableCapabilities capabilities) {
        if (capabilities.asSet().isEmpty()) {
            return ImmutableCapabilities.of(DefaultImmutableCapability.defaultCapabilityForComponent(getMetadata().getModuleVersionId()));
        } else {
            return capabilities;
        }
    }

        delegate.artifact(configureAction)

    override fun getAttributes(): AttributeContainer =
        delegate.attributes

    override fun capabilities(configureAction: Action<in ModuleDependencyCapabilitiesHandler>): ModuleDependency =
        delegate.capabilities(configureAction)

    override fun version(configureAction: Action<in MutableVersionConstraint>) =
        delegate.version(configureAction)

        return delegate.attributes(configureAction);
    }

    @Override
    public ModuleDependency capabilities(Action<? super ModuleDependencyCapabilitiesHandler> configureAction) {
        return delegate.capabilities(configureAction);
    }

    @Override
    public List<Capability> getRequestedCapabilities() {
        return delegate.getRequestedCapabilities();
    }

 * limitations under the License.
 */

package org.gradle.api.internal.artifacts.ivyservice.resolveengine.result;

import org.gradle.api.capabilities.Capability;
import org.gradle.api.internal.capabilities.ImmutableCapability;
import org.gradle.internal.component.external.model.DefaultImmutableCapability;
import org.gradle.internal.serialize.Decoder;
import org.gradle.internal.serialize.Encoder;

     * values for some of which have been changed by the transform.
     */
    Map<String, String> getTargetAttributes();

    /**
     * Capabilities of the variant of the transformed artifact.
     * <p>
     * Artifact transforms can only change attributes, so the capabilities remain unchanged throughout the transform chain.
     */
    List<? extends Capability> getCapabilities();

    /**