* limitations under the License.
 */
package org.gradle.api.internal.capabilities;

/**
 * This special kind of capability is here only because of derived
 * variants: in case of platforms we want to make sure we can select
 * both the platform and library. For this we use different capabilities.
 * However, we still want to make sure we can select the platform component

    public DefaultResolvedArtifactResult(ComponentArtifactIdentifier identifier,
                                         AttributeContainer variantAttributes,
                                         ImmutableCapabilities capabilities,
                                         DisplayName variantDisplayName,
                                         Class<? extends Artifact> type,
                                         File file) {

 *
 * <p>Features are classified by their capabilities. Each variant of a feature provides at least
 * the same set of capabilities as the feature itself. Since all variants of a feature are derived
 * from the same sources, they all expose the same API or "content" and thus provide the same
 * capabilities. Some variants may expose additional capabilities than those of its owning feature,
 * for example with fat jars.</p>
 *

          "url": "producer-1.0.jar",
          "size": 261,
          "sha1": "29acdaf26447e93ce0c8af7357e6fd4e2d1db71d",
          "md5": "6c53fdd588deb0abfc636c382e25d92e"
        }
      ],
      "capabilities": [
        {
          "group": "org.gradle.demo",
          "name": "producer-mongodb-support",
          "version": "1.0"
        }
      ]
    },
    {
      "name": "mongodbSupportRuntime",

        ImmutableAttributes target,
        ImmutableCapabilities capabilities,
        TransformChain transformChain,
        TransformUpstreamDependenciesResolverFactory dependenciesResolverFactory,
        CalculatedValueContainerFactory calculatedValueContainerFactory
    ) {
        super(componentIdentifier, delegate, target, capabilities, transformChain, dependenciesResolverFactory, calculatedValueContainerFactory);
    }

 */
package org.gradle.api.internal.artifacts.ivyservice.resolveengine.graph.conflicts;

import com.google.common.collect.Sets;
import org.gradle.api.capabilities.Capability;
import org.gradle.internal.Describables;
import org.gradle.internal.DisplayName;
import org.gradle.api.internal.capabilities.CapabilityInternal;
import org.gradle.util.internal.VersionNumber;

import java.util.Collection;
import java.util.Set;

/**

        try {
            if (seenArtifacts.add(artifact.getId())) {
                File file = artifact.getFile();
                this.artifacts.add(new DefaultResolvedArtifactResult(artifact.getId(), variantAttributes, capabilities, variantName, Artifact.class, file));
            }
        } catch (Exception t) {

                    break;
                case "dependencyConstraints":
                    dependencyConstraints = consumeDependencyConstraints(reader);
                    break;
                case "capabilities":
                    capabilities = consumeCapabilities(reader, true);
                    break;
                case "available-at":
                    availableExternally = true;

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.
 */

		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
	}