1 /*
2 * Copyright (c) 1999, 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
26 package com.sun.jndi.toolkit.ctx;
27
28 import javax.naming.*;
29 import 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
43 public 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 }