feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/com/sun/jndi/toolkit/dir/ContextEnumerator.java

@@ -0,0 +1,235 @@
+/*
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.sun.jndi.toolkit.dir;
+
+import javax.naming.*;
+import javax.naming.directory.SearchControls;
+import java.util.*;
+
+/**
+  * A class for recursively enumerating the contents of a Context;
+  *
+  * @author Jon Ruiz
+  */
+public class ContextEnumerator implements NamingEnumeration<Binding> {
+
+    private static boolean debug = false;
+    private NamingEnumeration<Binding> children = null;
+    private Binding currentChild = null;
+    private boolean currentReturned = false;
+    private Context root;
+    private ContextEnumerator currentChildEnum = null;
+    private boolean currentChildExpanded = false;
+    private boolean rootProcessed = false;
+    private int scope = SearchControls.SUBTREE_SCOPE;
+    private String contextName = "";
+
+    public ContextEnumerator(Context context) throws NamingException {
+        this(context, SearchControls.SUBTREE_SCOPE);
+    }
+
+    public ContextEnumerator(Context context, int scope)
+        throws NamingException {
+            // return this object except when searching single-level
+        this(context, scope, "", scope != SearchControls.ONELEVEL_SCOPE);
+   }
+
+    protected ContextEnumerator(Context context, int scope, String contextName,
+                             boolean returnSelf)
+        throws NamingException {
+        if(context == null) {
+            throw new IllegalArgumentException("null context passed");
+        }
+
+        root = context;
+
+        // No need to list children if we're only searching object
+        if (scope != SearchControls.OBJECT_SCOPE) {
+            children = getImmediateChildren(context);
+        }
+        this.scope = scope;
+        this.contextName = contextName;
+        // pretend root is processed, if we're not supposed to return ourself
+        rootProcessed = !returnSelf;
+        prepNextChild();
+    }
+
+    // Subclass should override if it wants to avoid calling obj factory
+    protected NamingEnumeration<Binding> getImmediateChildren(Context ctx)
+        throws NamingException {
+            return ctx.listBindings("");
+    }
+
+    // Subclass should override so that instance is of same type as subclass
+    protected ContextEnumerator newEnumerator(Context ctx, int scope,
+        String contextName, boolean returnSelf) throws NamingException {
+            return new ContextEnumerator(ctx, scope, contextName, returnSelf);
+    }
+
+    public boolean hasMore() throws NamingException {
+        return !rootProcessed ||
+            (scope != SearchControls.OBJECT_SCOPE && hasMoreDescendants());
+    }
+
+    public boolean hasMoreElements() {
+        try {
+            return hasMore();
+        } catch (NamingException e) {
+            return false;
+        }
+    }
+
+    public Binding nextElement() {
+        try {
+            return next();
+        } catch (NamingException e) {
+            throw new NoSuchElementException(e.toString());
+        }
+    }
+
+    public Binding next() throws NamingException {
+        if (!rootProcessed) {
+            rootProcessed = true;
+            return new Binding("", root.getClass().getName(),
+                               root, true);
+        }
+
+        if (scope != SearchControls.OBJECT_SCOPE && hasMoreDescendants()) {
+            return getNextDescendant();
+        }
+
+        throw new NoSuchElementException();
+    }
+
+    public void close() throws NamingException {
+        root = null;
+    }
+
+    private boolean hasMoreChildren() throws NamingException {
+        return children != null && children.hasMore();
+    }
+
+    private Binding getNextChild() throws NamingException {
+        Binding oldBinding = children.next();
+        Binding newBinding = null;
+
+        // if the name is relative, we need to add it to the name of this
+        // context to keep it relative w.r.t. the root context we are
+        // enumerating
+        if(oldBinding.isRelative() && !contextName.equals("")) {
+            NameParser parser = root.getNameParser("");
+            Name newName = parser.parse(contextName);
+            newName.add(oldBinding.getName());
+            if(debug) {
+                System.out.println("ContextEnumerator: adding " + newName);
+            }
+            newBinding = new Binding(newName.toString(),
+                                     oldBinding.getClassName(),
+                                     oldBinding.getObject(),
+                                     oldBinding.isRelative());
+        } else {
+            if(debug) {
+                System.out.println("ContextEnumerator: using old binding");
+            }
+            newBinding = oldBinding;
+        }
+
+        return newBinding;
+    }
+
+    private boolean hasMoreDescendants() throws NamingException {
+        // if the current child is expanded, see if it has more elements
+        if (!currentReturned) {
+            if(debug) {System.out.println("hasMoreDescendants returning " +
+                                          (currentChild != null) ); }
+            return currentChild != null;
+        } else if (currentChildExpanded && currentChildEnum.hasMore()) {
+
+            if(debug) {System.out.println("hasMoreDescendants returning " +
+                "true");}
+
+            return true;
+        } else {
+            if(debug) {System.out.println("hasMoreDescendants returning " +
+                "hasMoreChildren");}
+            return hasMoreChildren();
+        }
+    }
+
+    private Binding getNextDescendant() throws NamingException {
+
+        if (!currentReturned) {
+            // returning parent
+            if(debug) {System.out.println("getNextDescedant: simple case");}
+
+            currentReturned = true;
+            return currentChild;
+
+        } else if (currentChildExpanded && currentChildEnum.hasMore()) {
+
+            if(debug) {System.out.println("getNextDescedant: expanded case");}
+
+            // if the current child is expanded, use it's enumerator
+            return currentChildEnum.next();
+
+        } else {
+
+            // Ready to go onto next child
+            if(debug) {System.out.println("getNextDescedant: next case");}
+
+            prepNextChild();
+            return getNextDescendant();
+        }
+    }
+
+    private void prepNextChild() throws NamingException {
+        if(hasMoreChildren()) {
+            try {
+                currentChild = getNextChild();
+                currentReturned = false;
+            } catch (NamingException e){
+                if (debug) System.out.println(e);
+                if (debug) e.printStackTrace();
+            }
+        } else {
+            currentChild = null;
+            return;
+        }
+
+        if(scope == SearchControls.SUBTREE_SCOPE &&
+           currentChild.getObject() instanceof Context) {
+            currentChildEnum = newEnumerator(
+                                          (Context)(currentChild.getObject()),
+                                          scope, currentChild.getName(),
+                                          false);
+            currentChildExpanded = true;
+            if(debug) {System.out.println("prepNextChild: expanded");}
+        } else {
+            currentChildExpanded = false;
+            currentChildEnum = null;
+            if(debug) {System.out.println("prepNextChild: normal");}
+        }
+    }
+}