* KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.artifact.handler;

import static java.util.Objects.requireNonNull;

/**
 */
public class DefaultArtifactHandler implements ArtifactHandler {
    private final String type;

    private String extension;

     *            ルートディレクトリ。{@literal null}であってはいけません
     * @param handler
     *            クラスを処理するハンドラ。{@literal null}であってはいけません
     */
    public static void forEach(final File rootDir, final ClassHandler handler) {
        assertArgumentNotNull("rootDir", rootDir);
        assertArgumentNotNull("handler", handler);

        forEach(rootDir, null, handler);
    }

    /**
     * ファイルシステムに含まれるクラスをトラバースします。
     *

        MojoExecution mojoExecution = new MojoExecution(mojoDescriptor);
        Throwable exception = new PluginExecutionException(mojoExecution, null, cause);

        DefaultExceptionHandler handler = new DefaultExceptionHandler();
        ExceptionSummary summary = handler.handleException(exception);

        String expectedReference = "http://cwiki.apache.org/confluence/display/MAVEN/AetherClassNotFound";

     * @param handler
     *            使用するSAX {@link DefaultHandler}。{@literal null}であってはいけません
     */
    public static void parse(final SAXParser parser, final InputSource inputSource, final DefaultHandler handler) {
        assertArgumentNotNull("parser", parser);
        assertArgumentNotNull("inputSource", inputSource);
        assertArgumentNotNull("handler", handler);

        try {

   *     interface
   */
  public static <T> T newProxy(Class<T> interfaceType, InvocationHandler handler) {
    checkNotNull(handler);
    checkArgument(interfaceType.isInterface(), "%s is not an interface", interfaceType);
    Object object =
        Proxy.newProxyInstance(
            interfaceType.getClassLoader(), new Class<?>[] {interfaceType}, handler);
    return interfaceType.cast(object);
  }

  private Reflection() {}

        }

        @Override
        public void forEach(final ClassHandler handler) {
            ClassTraversalUtil.forEach(baseDir, rootPackage, handler);
        }

        @Override
        public void forEach(final ResourceHandler handler) {
            ResourceTraversalUtil.forEach(baseDir, rootDir, handler);
        }

        @Override
        public void close() {
        }

    }

            }
            final CorsHandlerFactory factory = ComponentUtil.getCorsHandlerFactory();
            final CorsHandler handler = factory.get(origin);
            if (handler != null) {
                handler.process(origin, request, response);

                if (OPTIONS.equals(httpRequest.getMethod())) {

import jcifs.SmbResource;
import jcifs.SmbTransportPool;
import jcifs.netbios.NameServiceClientImpl;
import jcifs.smb.BufferCacheImpl;
import jcifs.smb.CredentialsInternal;
import jcifs.smb.DfsImpl;
import jcifs.smb.Handler;
import jcifs.smb.NtlmPasswordAuthenticator;
import jcifs.smb.SIDCacheImpl;
import jcifs.smb.SmbFile;
import jcifs.smb.SmbNamedPipe;
import jcifs.smb.SmbTransportPoolImpl;


/**
 * @author mbechler
 *

    }

    // TODO let the scope handler deal with this
    private static boolean isCompilePathElement(final String scope) {
        return Artifact.SCOPE_COMPILE.equals(scope)
                || Artifact.SCOPE_PROVIDED.equals(scope)
                || Artifact.SCOPE_SYSTEM.equals(scope);
    }

    // TODO let the scope handler deal with this

 * created for testing should have Integer node and String edge objects.
 *
 * <p>Test cases that should be handled similarly in any graph implementation are included in this
 * class. For example, testing that {@code nodes()} method returns the set of the nodes in the
 * graph. The following test cases are left for the subclasses to handle:
 *
 * <ul>
 *   <li>Test cases related to whether the graph is directed or undirected.