View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.eclipse.aether.util.graph.manager;
20  
21  import org.eclipse.aether.collection.DependencyCollectionContext;
22  import org.eclipse.aether.collection.DependencyManagement;
23  import org.eclipse.aether.collection.DependencyManager;
24  import org.eclipse.aether.graph.Dependency;
25  
26  import static java.util.Objects.requireNonNull;
27  
28  /**
29   * A dependency manager that performs no dependency management operations.
30   *
31   * <h2>Overview</h2>
32   * <p>
33   * This is a null-object implementation of {@link DependencyManager} that effectively
34   * disables all dependency management. It always returns null for management operations
35   * and returns itself for child manager derivation, making it a true no-op implementation.
36   * </p>
37   *
38   * <h2>When to Use</h2>
39   * <ul>
40   * <li><strong>Testing:</strong> When you want to disable dependency management for tests</li>
41   * <li><strong>Simple Resolution:</strong> When you want pure dependency resolution without management</li>
42   * <li><strong>Performance:</strong> When dependency management overhead is not needed</li>
43   * <li><strong>Legacy Systems:</strong> When working with systems that handle management externally</li>
44   * </ul>
45   *
46   * <h2>Thread Safety</h2>
47   * <p>
48   * This implementation is completely thread-safe and stateless. The {@link #INSTANCE} can be
49   * safely shared across multiple threads and throughout the entire application lifecycle.
50   * </p>
51   *
52   * <h2>Comparison with Other Managers</h2>
53   * <ul>
54   * <li>{@link ClassicDependencyManager}: Maven 2.x compatibility with limited management</li>
55   * <li>{@link TransitiveDependencyManager}: Modern transitive management</li>
56   * <li>{@link DefaultDependencyManager}: Aggressive management at all levels</li>
57   * <li><strong>This manager:</strong> No management at all (fastest, simplest)</li>
58   * </ul>
59   *
60   * @see ClassicDependencyManager
61   * @see TransitiveDependencyManager
62   * @see DefaultDependencyManager
63   */
64  public final class NoopDependencyManager implements DependencyManager {
65  
66      /**
67       * A ready-made singleton instance of this dependency manager.
68       * <p>
69       * This instance can be safely reused throughout an entire application regardless of
70       * multi-threading, as this implementation is completely stateless and thread-safe.
71       * Using this instance is preferred over creating new instances for performance reasons.
72       * </p>
73       */
74      public static final DependencyManager INSTANCE = new NoopDependencyManager();
75  
76      /**
77       * Creates a new instance of this dependency manager.
78       * <p>
79       * <strong>Note:</strong> Usually, {@link #INSTANCE} should be used instead of creating
80       * new instances, as this implementation is stateless and the singleton provides better
81       * performance characteristics.
82       * </p>
83       */
84      public NoopDependencyManager() {}
85  
86      /**
87       * Returns this same instance as the child manager (no-op behavior).
88       *
89       * @param context the dependency collection context (validated but not used)
90       * @return this same instance
91       * @throws NullPointerException if context is null
92       */
93      public DependencyManager deriveChildManager(DependencyCollectionContext context) {
94          requireNonNull(context, "context cannot be null");
95          return this;
96      }
97  
98      /**
99       * Returns null, indicating no dependency management should be applied.
100      *
101      * @param dependency the dependency to manage (validated but not used)
102      * @return null (no management)
103      * @throws NullPointerException if dependency is null
104      */
105     public DependencyManagement manageDependency(Dependency dependency) {
106         requireNonNull(dependency, "dependency cannot be null");
107         return null;
108     }
109 
110     @Override
111     public boolean equals(Object obj) {
112         if (this == obj) {
113             return true;
114         } else if (null == obj || !getClass().equals(obj.getClass())) {
115             return false;
116         }
117         return true;
118     }
119 
120     @Override
121     public int hashCode() {
122         return getClass().hashCode();
123     }
124 }