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

jdkSrc/jdk8/com/sun/jndi/toolkit/ctx/PartialCompositeDirContext.java

@@ -0,0 +1,576 @@
+/*
+ * Copyright (c) 1999, 2011, 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.ctx;
+
+import java.util.Hashtable;
+
+import javax.naming.*;
+import javax.naming.directory.*;
+import javax.naming.spi.DirectoryManager;
+
+/*
+ * Inherit from AtomicContext so that subclasses of PartialCompositeDirContext
+ * can get the ns methods defined in subclasses of PartialCompositeContext.
+ *
+ * Direct subclasses of DirContext should provide implementations for
+ * the p_ abstract DirContext methods and override the p_ Context methods
+ * (not abstract anymore because they are overridden by ComponentContext
+ * (the superclass of AtomicContext)).
+ *
+ * @author Rosanna Lee
+ */
+
+public abstract class PartialCompositeDirContext
+        extends AtomicContext implements DirContext {
+
+    protected PartialCompositeDirContext() {
+        _contextType = _PARTIAL;
+    }
+
+// ------ Abstract methods whose implementation come from subclasses
+
+     /* Equivalent to DirContext methods */
+     protected abstract Attributes p_getAttributes(Name name, String[] attrIds,
+                                                     Continuation cont)
+         throws NamingException;
+
+     protected abstract void p_modifyAttributes(Name name, int mod_op,
+                                                Attributes attrs,
+                                                Continuation cont)
+         throws NamingException;
+
+     protected abstract void p_modifyAttributes(Name name,
+                                                ModificationItem[] mods,
+                                                Continuation cont)
+         throws NamingException;
+
+     protected abstract void p_bind(Name name, Object obj,
+                                    Attributes attrs,
+                                    Continuation cont)
+         throws NamingException;
+
+     protected abstract void p_rebind(Name name, Object obj,
+                                      Attributes attrs,
+                                      Continuation cont)
+         throws NamingException;
+
+     protected abstract DirContext p_createSubcontext(Name name,
+                                                     Attributes attrs,
+                                                     Continuation cont)
+         throws NamingException;
+
+     protected abstract NamingEnumeration<SearchResult> p_search(
+                            Name name,
+                            Attributes matchingAttributes,
+                            String[] attributesToReturn,
+                            Continuation cont)
+         throws NamingException;
+
+     protected abstract NamingEnumeration<SearchResult> p_search(
+                            Name name,
+                            String filter,
+                            SearchControls cons,
+                            Continuation cont)
+         throws NamingException;
+
+     protected abstract NamingEnumeration<SearchResult> p_search(
+                            Name name,
+                            String filterExpr,
+                            Object[] filterArgs,
+                            SearchControls cons,
+                            Continuation cont)
+         throws NamingException;
+
+     protected abstract DirContext p_getSchema(Name name, Continuation cont)
+         throws NamingException;
+
+     protected abstract DirContext p_getSchemaClassDefinition(Name name,
+                                                             Continuation cont)
+         throws NamingException;
+
+// ------ implementation for DirContext methods using
+// ------ corresponding p_ methods
+
+    public Attributes getAttributes(String name)
+            throws NamingException {
+        return getAttributes(name, null);
+    }
+
+    public Attributes getAttributes(Name name)
+            throws NamingException {
+        return getAttributes(name, null);
+    }
+
+    public Attributes getAttributes(String name, String[] attrIds)
+            throws NamingException {
+        return getAttributes(new CompositeName(name), attrIds);
+    }
+
+    public Attributes getAttributes(Name name, String[] attrIds)
+            throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        Attributes answer;
+        Name nm = name;
+
+        try {
+            answer = ctx.p_getAttributes(nm, attrIds, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                answer = ctx.p_getAttributes(nm, attrIds, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            answer = cctx.getAttributes(e.getRemainingName(), attrIds);
+        }
+        return answer;
+    }
+
+    public void modifyAttributes(String name, int mod_op, Attributes attrs)
+            throws NamingException {
+        modifyAttributes(new CompositeName(name), mod_op, attrs);
+    }
+
+    public void modifyAttributes(Name name, int mod_op, Attributes attrs)
+            throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        Name nm = name;
+
+        try {
+            ctx.p_modifyAttributes(nm, mod_op, attrs, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                ctx.p_modifyAttributes(nm, mod_op, attrs, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            cctx.modifyAttributes(e.getRemainingName(), mod_op, attrs);
+        }
+    }
+
+    public void modifyAttributes(String name, ModificationItem[] mods)
+            throws NamingException {
+        modifyAttributes(new CompositeName(name), mods);
+    }
+
+    public void modifyAttributes(Name name, ModificationItem[] mods)
+            throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        Name nm = name;
+
+        try {
+            ctx.p_modifyAttributes(nm, mods, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                ctx.p_modifyAttributes(nm, mods, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            cctx.modifyAttributes(e.getRemainingName(), mods);
+        }
+    }
+
+    public void bind(String name, Object obj, Attributes attrs)
+            throws NamingException {
+        bind(new CompositeName(name), obj, attrs);
+    }
+
+    public void bind(Name name, Object obj, Attributes attrs)
+            throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        Name nm = name;
+
+        try {
+            ctx.p_bind(nm, obj, attrs, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                ctx.p_bind(nm, obj, attrs, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            cctx.bind(e.getRemainingName(), obj, attrs);
+        }
+    }
+
+    public void rebind(String name, Object obj, Attributes attrs)
+            throws NamingException {
+        rebind(new CompositeName(name), obj, attrs);
+    }
+
+    public void rebind(Name name, Object obj, Attributes attrs)
+            throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        Name nm = name;
+
+        try {
+            ctx.p_rebind(nm, obj, attrs, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                ctx.p_rebind(nm, obj, attrs, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            cctx.rebind(e.getRemainingName(), obj, attrs);
+        }
+    }
+
+    public DirContext createSubcontext(String name, Attributes attrs)
+            throws NamingException {
+        return createSubcontext(new CompositeName(name), attrs);
+    }
+
+    public DirContext createSubcontext(Name name, Attributes attrs)
+            throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        DirContext answer;
+        Name nm = name;
+
+        try {
+            answer = ctx.p_createSubcontext(nm, attrs, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                answer = ctx.p_createSubcontext(nm, attrs, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            answer = cctx.createSubcontext(e.getRemainingName(), attrs);
+        }
+        return answer;
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(String name, Attributes matchingAttributes)
+        throws NamingException
+    {
+        return search(name, matchingAttributes, null);
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(Name name, Attributes matchingAttributes)
+        throws NamingException
+    {
+        return search(name, matchingAttributes, null);
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(String name,
+               Attributes matchingAttributes,
+               String[] attributesToReturn)
+        throws NamingException
+    {
+        return search(new CompositeName(name),
+                      matchingAttributes, attributesToReturn);
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(Name name,
+               Attributes matchingAttributes,
+               String[] attributesToReturn)
+        throws NamingException
+    {
+
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        NamingEnumeration<SearchResult> answer;
+        Name nm = name;
+
+        try {
+            answer = ctx.p_search(nm, matchingAttributes,
+                                  attributesToReturn, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                answer = ctx.p_search(nm, matchingAttributes,
+                                      attributesToReturn, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            answer = cctx.search(e.getRemainingName(), matchingAttributes,
+                                 attributesToReturn);
+        }
+        return answer;
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(String name,
+               String filter,
+               SearchControls cons)
+        throws NamingException
+    {
+        return search(new CompositeName(name), filter, cons);
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(Name name,
+               String filter,
+               SearchControls cons)
+        throws NamingException
+    {
+
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        NamingEnumeration<SearchResult> answer;
+        Name nm = name;
+
+        try {
+            answer = ctx.p_search(nm, filter, cons, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                answer = ctx.p_search(nm, filter, cons, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            answer = cctx.search(e.getRemainingName(), filter, cons);
+        }
+        return answer;
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(String name,
+               String filterExpr,
+               Object[] filterArgs,
+               SearchControls cons)
+        throws NamingException
+    {
+        return search(new CompositeName(name), filterExpr, filterArgs, cons);
+    }
+
+    public NamingEnumeration<SearchResult>
+        search(Name name,
+               String filterExpr,
+               Object[] filterArgs,
+               SearchControls cons)
+        throws NamingException
+    {
+
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        NamingEnumeration<SearchResult> answer;
+        Name nm = name;
+
+        try {
+            answer = ctx.p_search(nm, filterExpr, filterArgs, cons, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                answer = ctx.p_search(nm, filterExpr, filterArgs, cons, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            answer = cctx.search(e.getRemainingName(), filterExpr, filterArgs,
+                                 cons);
+        }
+        return answer;
+    }
+
+    public DirContext getSchema(String name) throws NamingException {
+        return getSchema(new CompositeName(name));
+    }
+
+    public DirContext getSchema(Name name) throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        DirContext answer;
+        Name nm = name;
+
+        try {
+            answer = ctx.p_getSchema(nm, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                answer = ctx.p_getSchema(nm, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            answer = cctx.getSchema(e.getRemainingName());
+        }
+        return answer;
+    }
+
+    public DirContext getSchemaClassDefinition(String name)
+            throws NamingException {
+        return getSchemaClassDefinition(new CompositeName(name));
+    }
+
+    public DirContext getSchemaClassDefinition(Name name)
+            throws NamingException {
+        PartialCompositeDirContext ctx = this;
+        Hashtable<?,?> env = p_getEnvironment();
+        Continuation cont = new Continuation(name, env);
+        DirContext answer;
+        Name nm = name;
+
+        try {
+            answer = ctx.p_getSchemaClassDefinition(nm, cont);
+            while (cont.isContinue()) {
+                nm = cont.getRemainingName();
+                ctx = getPCDirContext(cont);
+                answer = ctx.p_getSchemaClassDefinition(nm, cont);
+            }
+        } catch (CannotProceedException e) {
+            DirContext cctx = DirectoryManager.getContinuationDirContext(e);
+            answer = cctx.getSchemaClassDefinition(e.getRemainingName());
+        }
+        return answer;
+    }
+
+// ------ internal method used by PartialCompositeDirContext
+
+    /**
+     * Retrieves a PartialCompositeDirContext for the resolved object in
+     * cont.  Throws CannotProceedException if not successful.
+     */
+    protected static PartialCompositeDirContext getPCDirContext(Continuation cont)
+            throws NamingException {
+
+        PartialCompositeContext pctx =
+            PartialCompositeContext.getPCContext(cont);
+
+        if (!(pctx instanceof PartialCompositeDirContext)) {
+            throw cont.fillInException(
+                    new NotContextException(
+                            "Resolved object is not a DirContext."));
+        }
+
+        return (PartialCompositeDirContext)pctx;
+    }
+
+
+//------ Compensation for inheriting from AtomicContext
+
+    /*
+     * Dummy implementations defined here so that direct subclasses
+     * of PartialCompositeDirContext or ComponentDirContext do not
+     * have to provide dummy implementations for these.
+     * Override these for subclasses of AtomicDirContext.
+     */
+
+    protected StringHeadTail c_parseComponent(String inputName,
+        Continuation cont) throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected Object a_lookup(String name, Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected Object a_lookupLink(String name, Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected NamingEnumeration<NameClassPair> a_list(
+        Continuation cont) throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected NamingEnumeration<Binding> a_listBindings(
+        Continuation cont) throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected void a_bind(String name, Object obj, Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected void a_rebind(String name, Object obj, Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected void a_unbind(String name, Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected void a_destroySubcontext(String name, Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected Context a_createSubcontext(String name, Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected void a_rename(String oldname, Name newname,
+        Continuation cont) throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+
+    protected NameParser a_getNameParser(Continuation cont)
+        throws NamingException {
+            OperationNotSupportedException e = new
+                OperationNotSupportedException();
+            throw cont.fillInException(e);
+        }
+}