*
 * @see ArtifactVersion#compareTo
 * @since 3.0
 */
@Named("oldest")
@Singleton
@Deprecated
public class OldestConflictResolver implements ConflictResolver {
    // ConflictResolver methods -----------------------------------------------

    /*

import org.codehaus.plexus.component.annotations.Configuration;

/**
 *
 */
@Named
@Singleton
@Deprecated
public class DefaultGraphConflictResolutionPolicy implements GraphConflictResolutionPolicy {
    /**
     * artifact, closer to the entry point, is selected
     */
    @Configuration(name = "closer-first", value = "true")
    private boolean closerFirst = true;

    /**

 * packaging types will be available throughout the Maven build process.
 * <p>
 * Example usage:
 * <pre>
 * public class CustomPackagingProvider implements PackagingProvider {
 *     public Collection&lt;Packaging&gt; provides() {
 *         return Arrays.asList(
 *             packaging("docker-image"),
 *             packaging("flatpak")
 *         );
 *     }
 * }

import org.eclipse.aether.transfer.TransferCancelledException;
import org.eclipse.aether.transfer.TransferEvent;
import org.eclipse.aether.transfer.TransferListener;

public class MavenTransferListener implements TransferListener {

    private final TransferListener delegate;
    private final BuildEventListener dispatcher;

    public MavenTransferListener(TransferListener delegate, BuildEventListener dispatcher) {

                (ms, o) -> {
                  int unused = ms.count(o);
                },
                Math::log)));
  }

  /** All the ways to create an ImmutableMultiset. */
  enum ConstructionPathway implements Construction<Multiset<Object>> {
    COPY_OF_COLLECTION {
      @Override
      public ImmutableMultiset<Object> create(List<?> keys) {
        return ImmutableMultiset.copyOf(keys);
      }
    },

// TODO remove the coreArtifactFilterManager

/**
 * DefaultBuildPluginManager
 */
@Named
@Singleton
public class DefaultBuildPluginManager implements BuildPluginManager {

    private final MavenPluginManager mavenPluginManager;
    private final LegacySupport legacySupport;
    private final MojoExecutionScope scope;

import java.nio.ByteBuffer;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicInteger;

public abstract class RdmaConnection implements AutoCloseable {
    protected final InetSocketAddress remoteAddress;
    protected final InetSocketAddress localAddress;
    protected final AtomicInteger sendCredits;
    protected final AtomicInteger receiveCredits;

  }

  static final class ImmutableCell<
          R extends @Nullable Object, C extends @Nullable Object, V extends @Nullable Object>
      extends AbstractCell<R, C, V> implements Serializable {
    @ParametricNullness private final R rowKey;
    @ParametricNullness private final C columnKey;
    @ParametricNullness private final V value;

    ImmutableCell(

type FilterRule struct {
	Name  string `xml:"Name"`
	Value string `xml:"Value"`
}

func (filter FilterRule) isEmpty() bool {
	return filter.Name == "" && filter.Value == ""
}

// MarshalXML implements a custom marshaller to support `omitempty` feature.
func (filter FilterRule) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
	if filter.isEmpty() {
		return nil
	}
	type filterRuleWrapper FilterRule

            return true;
        }
    };

    /**
     * Helper filter that records the last file passed to it. Useful for
     * verifying interaction.
     */
    private class RecordingFilter implements SmbFileFilter {
        private SmbFile lastFile;
        private String lastPath;

        @Override
        public boolean accept(SmbFile file) throws SmbException {
            lastFile = file;