1/*
2 * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.  Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26package com.sun.jndi.toolkit.ctx;
27
28import javax.naming.*;
29import javax.naming.directory.*;
30
31/* Direct subclasses of ComponentDirContext must provide implementations for
32 * the abstract c_ DirContext methods, and override the c_ Context methods
33 * (which are no longer abstract because they have been overriden by
34 * AtomicContext, the direct superclass of PartialDSCompositeContext).
35 *
36 * If the subclass is supports implicit nns, it must override all the
37 * c_*_nns methods corresponding to those in DirContext and Context.
38 * See ComponentContext for details.
39 *
40 * @author Rosanna Lee
41 */
42
43public abstract class ComponentDirContext extends PartialCompositeDirContext {
44
45    protected ComponentDirContext () {
46        _contextType = _COMPONENT;
47    }
48
49// ------ Abstract methods whose implementations are provided by subclass
50
51    /* Equivalent to methods in DirContext */
52    protected abstract Attributes c_getAttributes(Name name,
53                                                 String[] attrIds,
54                                                 Continuation cont)
55        throws NamingException;
56
57    protected abstract void c_modifyAttributes(Name name, int mod_op,
58                                            Attributes attrs,
59                                            Continuation cont)
60            throws NamingException;
61
62    protected abstract void c_modifyAttributes(Name name,
63                                            ModificationItem[] mods,
64                                            Continuation cont)
65        throws NamingException;
66
67    protected abstract void c_bind(Name name, Object obj,
68                                   Attributes attrs,
69                                   Continuation cont)
70        throws NamingException;
71
72    protected abstract void c_rebind(Name name, Object obj,
73                                     Attributes attrs,
74                                     Continuation cont)
75        throws NamingException;
76
77    protected abstract DirContext c_createSubcontext(Name name,
78                                                    Attributes attrs,
79                                                    Continuation cont)
80        throws NamingException;
81
82    protected abstract NamingEnumeration<SearchResult> c_search(
83                            Name name,
84                            Attributes matchingAttributes,
85                            String[] attributesToReturn,
86                            Continuation cont)
87        throws NamingException;
88
89    protected abstract NamingEnumeration<SearchResult> c_search(
90                            Name name,
91                            String filter,
92                            SearchControls cons,
93                            Continuation cont)
94        throws NamingException;
95
96    protected abstract NamingEnumeration<SearchResult> c_search(
97                            Name name,
98                            String filterExpr,
99                            Object[] filterArgs,
100                            SearchControls cons,
101                            Continuation cont)
102        throws NamingException;
103
104    protected abstract DirContext c_getSchema(Name name, Continuation cont)
105        throws NamingException;
106
107    protected abstract DirContext c_getSchemaClassDefinition(Name name,
108                                                            Continuation cont)
109        throws NamingException;
110
111// ------- default implementations of c_*_nns methods from DirContext
112
113    // The following methods are called when the DirContext methods
114    // are invoked with a name that has a trailing slash.
115    // For naming systems that support implicit nns,
116    // the trailing slash signifies the implicit nns.
117    // For such naming systems, override these c_*_nns methods.
118    //
119    // For naming systems that support junctions (explicit nns),
120    // the trailing slash is meaningless because a junction does not
121    // have an implicit nns.  The default implementation here
122    // throws a NameNotFoundException for such names.
123    // If a context wants to accept a trailing slash as having
124    // the same meaning as the same name without a trailing slash,
125    // then it should override these c_*_nns methods.
126
127    // See ComponentContext for details.
128
129    protected Attributes c_getAttributes_nns(Name name,
130                                            String[] attrIds,
131                                            Continuation cont)
132        throws NamingException {
133            c_processJunction_nns(name, cont);
134            return null;
135        }
136
137    protected void c_modifyAttributes_nns(Name name,
138                                       int mod_op,
139                                       Attributes attrs,
140                                       Continuation cont)
141        throws NamingException {
142            c_processJunction_nns(name, cont);
143        }
144
145    protected void c_modifyAttributes_nns(Name name,
146                                       ModificationItem[] mods,
147                                       Continuation cont)
148        throws NamingException {
149            c_processJunction_nns(name, cont);
150        }
151
152    protected void c_bind_nns(Name name,
153                              Object obj,
154                              Attributes attrs,
155                              Continuation cont)
156        throws NamingException  {
157            c_processJunction_nns(name, cont);
158        }
159
160    protected void c_rebind_nns(Name name,
161                                Object obj,
162                                Attributes attrs,
163                                Continuation cont)
164        throws NamingException  {
165            c_processJunction_nns(name, cont);
166        }
167
168    protected DirContext c_createSubcontext_nns(Name name,
169                                               Attributes attrs,
170                                               Continuation cont)
171        throws NamingException  {
172            c_processJunction_nns(name, cont);
173            return null;
174        }
175
176    protected NamingEnumeration<SearchResult> c_search_nns(
177                        Name name,
178                        Attributes matchingAttributes,
179                        String[] attributesToReturn,
180                        Continuation cont)
181        throws NamingException {
182            c_processJunction_nns(name, cont);
183            return null;
184        }
185
186    protected NamingEnumeration<SearchResult> c_search_nns(
187                        Name name,
188                        String filter,
189                        SearchControls cons,
190                        Continuation cont)
191        throws NamingException  {
192            c_processJunction_nns(name, cont);
193            return null;
194        }
195
196    protected NamingEnumeration<SearchResult> c_search_nns(
197                        Name name,
198                        String filterExpr,
199                        Object[] filterArgs,
200                        SearchControls cons,
201                        Continuation cont)
202        throws NamingException  {
203            c_processJunction_nns(name, cont);
204            return null;
205        }
206
207    protected DirContext c_getSchema_nns(Name name, Continuation cont)
208        throws NamingException {
209            c_processJunction_nns(name, cont);
210            return null;
211        }
212
213    protected DirContext c_getSchemaClassDefinition_nns(Name name, Continuation cont)
214        throws NamingException {
215            c_processJunction_nns(name, cont);
216            return null;
217        }
218
219// ------- implementations of p_ DirContext methods using corresponding
220// ------- DirContext c_ and c_*_nns methods
221
222    /* Implements for abstract methods declared in PartialCompositeDirContext */
223    protected Attributes p_getAttributes(Name name,
224                                        String[] attrIds,
225                                        Continuation cont)
226        throws NamingException  {
227        HeadTail res = p_resolveIntermediate(name, cont);
228        Attributes answer = null;
229        switch (res.getStatus()) {
230            case TERMINAL_NNS_COMPONENT:
231                answer = c_getAttributes_nns(res.getHead(), attrIds, cont);
232                break;
233
234            case TERMINAL_COMPONENT:
235                answer = c_getAttributes(res.getHead(), attrIds, cont);
236                break;
237
238            default:
239                /* USE_CONTINUATION */
240                /* cont already set or exception thrown */
241                break;
242            }
243        return answer;
244    }
245
246    protected void p_modifyAttributes(Name name, int mod_op,
247                                   Attributes attrs,
248                                   Continuation cont)
249        throws NamingException {
250        HeadTail res = p_resolveIntermediate(name, cont);
251        switch (res.getStatus()) {
252            case TERMINAL_NNS_COMPONENT:
253                c_modifyAttributes_nns(res.getHead(), mod_op, attrs, cont);
254                break;
255
256            case TERMINAL_COMPONENT:
257                c_modifyAttributes(res.getHead(), mod_op, attrs, cont);
258                break;
259
260            default:
261                /* USE_CONTINUATION */
262                /* cont already set or exception thrown */
263                break;
264            }
265    }
266    protected void p_modifyAttributes(Name name,
267                                   ModificationItem[] mods,
268                                   Continuation cont)
269        throws NamingException {
270        HeadTail res = p_resolveIntermediate(name, cont);
271        switch (res.getStatus()) {
272            case TERMINAL_NNS_COMPONENT:
273                c_modifyAttributes_nns(res.getHead(), mods, cont);
274                break;
275
276            case TERMINAL_COMPONENT:
277                c_modifyAttributes(res.getHead(), mods, cont);
278                break;
279
280            default:
281                /* USE_CONTINUATION */
282                /* cont already set or exception thrown */
283                break;
284            }
285    }
286
287    protected void p_bind(Name name,
288                          Object obj,
289                          Attributes attrs,
290                          Continuation cont)
291        throws NamingException {
292        HeadTail res = p_resolveIntermediate(name, cont);
293        switch (res.getStatus()) {
294            case TERMINAL_NNS_COMPONENT:
295                c_bind_nns(res.getHead(), obj, attrs, cont);
296                break;
297
298            case TERMINAL_COMPONENT:
299                c_bind(res.getHead(), obj, attrs, cont);
300                break;
301
302            default:
303                /* USE_CONTINUATION */
304                /* cont already set or exception thrown */
305                break;
306            }
307    }
308
309    protected void p_rebind(Name name, Object obj,
310                            Attributes attrs, Continuation cont)
311        throws NamingException {
312        HeadTail res = p_resolveIntermediate(name, cont);
313        switch (res.getStatus()) {
314            case TERMINAL_NNS_COMPONENT:
315                c_rebind_nns(res.getHead(), obj, attrs, cont);
316                break;
317
318            case TERMINAL_COMPONENT:
319                c_rebind(res.getHead(), obj, attrs, cont);
320                break;
321
322            default:
323                /* USE_CONTINUATION */
324                /* cont already set or exception thrown */
325                break;
326            }
327    }
328
329    protected DirContext p_createSubcontext(Name name,
330                                           Attributes attrs,
331                                           Continuation cont)
332        throws NamingException {
333        HeadTail res = p_resolveIntermediate(name, cont);
334        DirContext answer = null;
335        switch (res.getStatus()) {
336            case TERMINAL_NNS_COMPONENT:
337                answer = c_createSubcontext_nns(res.getHead(), attrs, cont);
338                break;
339
340            case TERMINAL_COMPONENT:
341                answer = c_createSubcontext(res.getHead(), attrs, cont);
342                break;
343
344            default:
345                /* USE_CONTINUATION */
346                /* cont already set or exception thrown */
347                break;
348            }
349        return answer;
350    }
351
352    protected NamingEnumeration<SearchResult> p_search(
353                    Name name,
354                    Attributes matchingAttributes,
355                    String[] attributesToReturn,
356                    Continuation cont)
357        throws NamingException {
358        HeadTail res = p_resolveIntermediate(name, cont);
359        NamingEnumeration<SearchResult> answer = null;
360        switch (res.getStatus()) {
361            case TERMINAL_NNS_COMPONENT:
362                answer = c_search_nns(res.getHead(), matchingAttributes,
363                                      attributesToReturn, cont);
364                break;
365
366            case TERMINAL_COMPONENT:
367                answer = c_search(res.getHead(), matchingAttributes,
368                                  attributesToReturn, cont);
369                break;
370
371            default:
372                /* USE_CONTINUATION */
373                /* cont already set or exception thrown */
374                break;
375            }
376        return answer;
377    }
378
379    protected NamingEnumeration<SearchResult> p_search(Name name,
380                                                       String filter,
381                                                       SearchControls cons,
382                                                       Continuation cont)
383        throws NamingException {
384        HeadTail res = p_resolveIntermediate(name, cont);
385        NamingEnumeration<SearchResult> answer = null;
386        switch (res.getStatus()) {
387            case TERMINAL_NNS_COMPONENT:
388                answer = c_search_nns(res.getHead(), filter, cons, cont);
389                break;
390
391            case TERMINAL_COMPONENT:
392                answer = c_search(res.getHead(), filter, cons, cont);
393                break;
394
395            default:
396                /* USE_CONTINUATION */
397                /* cont already set or exception thrown */
398                break;
399            }
400        return answer;
401    }
402
403    protected NamingEnumeration<SearchResult> p_search(Name name,
404                                                       String filterExpr,
405                                                       Object[] filterArgs,
406                                                       SearchControls cons,
407                                                       Continuation cont)
408            throws NamingException {
409        HeadTail res = p_resolveIntermediate(name, cont);
410        NamingEnumeration<SearchResult> answer = null;
411        switch (res.getStatus()) {
412            case TERMINAL_NNS_COMPONENT:
413                answer = c_search_nns(res.getHead(),
414                                      filterExpr, filterArgs, cons, cont);
415                break;
416
417            case TERMINAL_COMPONENT:
418                answer = c_search(res.getHead(), filterExpr, filterArgs, cons, cont);
419                break;
420
421            default:
422                /* USE_CONTINUATION */
423                /* cont already set or exception thrown */
424                break;
425            }
426        return answer;
427    }
428
429    protected DirContext p_getSchema(Name name, Continuation cont)
430        throws NamingException  {
431            DirContext answer = null;
432            HeadTail res = p_resolveIntermediate(name, cont);
433            switch (res.getStatus()) {
434            case TERMINAL_NNS_COMPONENT:
435                answer = c_getSchema_nns(res.getHead(), cont);
436                break;
437
438            case TERMINAL_COMPONENT:
439                answer = c_getSchema(res.getHead(), cont);
440                break;
441
442            default:
443                /* USE_CONTINUATION */
444                /* cont already set or exception thrown */
445                break;
446            }
447            return answer;
448        }
449
450    protected DirContext p_getSchemaClassDefinition(Name name, Continuation cont)
451        throws NamingException  {
452            DirContext answer = null;
453            HeadTail res = p_resolveIntermediate(name, cont);
454            switch (res.getStatus()) {
455            case TERMINAL_NNS_COMPONENT:
456                answer = c_getSchemaClassDefinition_nns(res.getHead(), cont);
457                break;
458
459            case TERMINAL_COMPONENT:
460                answer = c_getSchemaClassDefinition(res.getHead(), cont);
461                break;
462
463            default:
464                /* USE_CONTINUATION */
465                /* cont already set or exception thrown */
466                break;
467            }
468            return answer;
469        }
470}
471