String versionSelectorString = externalDependency.getVersion();
            VersionSelector versionSelector = versionSelectorScheme.parseSelector(versionSelectorString);
            if (versionSelector instanceof LatestVersionSelector) {
                LatestVersionSelector latestVersionSelector = (LatestVersionSelector) versionSelector;
                if (latestVersionSelector.getSelectorStatus().equals("integration")) {

 */
public class UnionVersionSelector implements CompositeVersionSelector {
    private final List<VersionSelector> selectors;

    public static UnionVersionSelector of(List<String> selectors, VersionSelectorScheme scheme) {
        ImmutableList.Builder<VersionSelector> builder = new ImmutableList.Builder<>();
        for (String selector : selectors) {
            builder.add(scheme.parseSelector(selector));

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionSelector;
import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionSelectorScheme;

import java.util.List;

public class DefaultResolvedVersionConstraint implements ResolvedVersionConstraint {
    private final VersionSelector preferredVersionSelector;
    private final VersionSelector requiredVersionSelector;

                break;
            }
        }
    }

    private VersionSelector createAllRejects(ModuleSelectors<? extends ResolvableSelectorState> selectors) {
        List<VersionSelector> rejectSelectors = null;
        for (ResolvableSelectorState selector : selectors) {

    /**
     * Returns an appropriate {@link VersionSelector} for the given selector string.
     *
     * @param selectorString - the string representation of the selector
     * @return the {@link VersionSelector}
     */
    VersionSelector parseSelector(String selectorString);

    /**
     * Renders a {@link VersionSelector} to a selector string.
     */
    String renderSelector(VersionSelector selector);

    /**

     *
     * <p>At some point in the future, this should resolve to a set of candidates rather than a single instance.
     */
    void resolve(DependencyMetadata dependency, VersionSelector acceptor, @Nullable VersionSelector rejector, BuildableComponentIdResolveResult result);

        private final String version;
        private final VersionSelector versionSelector;
        private final boolean inclusive;
        private final boolean includeSubGroups;

        private SimpleSpecMatcher(
            String group, @Nullable String module, @Nullable String version, VersionSelectorScheme versionSelectorScheme,
            ConcurrentHashMap<String, VersionSelector> versionSelectors, boolean inclusive, boolean includeSubGroups

        return metadata.isMissing();
    }

    @Override
    public void selectNewestMatchingComponent(Collection<? extends ModuleComponentResolveState> versions, ComponentSelectionContext result, VersionSelector requestedVersionMatcher, VersionSelector rejectedVersionSelector, ImmutableAttributes consumerAttributes) {
        Collection<SpecRuleAction<? super ComponentSelection>> rules = componentSelectionRules.getRules();

    }

    @Override
    ComponentIdResolveResult resolve(VersionSelector allRejects) {
        def result = new DefaultBuildableComponentIdResolveResult()
        result.resolved(projectId, DefaultModuleVersionIdentifier.newId("org", projectId.projectName, VERSION))
        return result
    }

    @Override
    ComponentIdResolveResult resolvePrefer(VersionSelector allRejects) {
        return null
    }

    @Override

import org.gradle.api.internal.artifacts.ivyservice.ivyresolve.strategy.VersionSelector;

import javax.annotation.Nullable;

public interface ResolvedVersionConstraint {
    @Nullable
    VersionSelector getPreferredSelector();

    @Nullable
    VersionSelector getRequiredSelector();

    @Nullable
    VersionSelector getRejectedSelector();

    boolean isRejectAll();
    boolean isDynamic();