001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: package org.apache.catalina;
019:
020: import javax.servlet.ServletContext;
021:
022: import org.apache.tomcat.util.http.mapper.Mapper;
023:
024: import org.apache.catalina.deploy.ApplicationParameter;
025: import org.apache.catalina.deploy.ErrorPage;
026: import org.apache.catalina.deploy.FilterDef;
027: import org.apache.catalina.deploy.FilterMap;
028: import org.apache.catalina.deploy.LoginConfig;
029: import org.apache.catalina.deploy.NamingResources;
030: import org.apache.catalina.deploy.SecurityConstraint;
031: import org.apache.catalina.util.CharsetMapper;
032:
033: /**
034: * A <b>Context</b> is a Container that represents a servlet context, and
035: * therefore an individual web application, in the Catalina servlet engine.
036: * It is therefore useful in almost every deployment of Catalina (even if a
037: * Connector attached to a web server (such as Apache) uses the web server's
038: * facilities to identify the appropriate Wrapper to handle this request.
039: * It also provides a convenient mechanism to use Interceptors that see
040: * every request processed by this particular web application.
041: * <p>
042: * The parent Container attached to a Context is generally a Host, but may
043: * be some other implementation, or may be omitted if it is not necessary.
044: * <p>
045: * The child containers attached to a Context are generally implementations
046: * of Wrapper (representing individual servlet definitions).
047: * <p>
048: *
049: * @author Craig R. McClanahan
050: * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
051: */
052:
053: public interface Context extends Container {
054:
055: // ----------------------------------------------------- Manifest Constants
056:
057: /**
058: * The LifecycleEvent type sent when a context is reloaded.
059: */
060: public static final String RELOAD_EVENT = "reload";
061:
062: // ------------------------------------------------------------- Properties
063:
064: /**
065: * Return the set of initialized application event listener objects,
066: * in the order they were specified in the web application deployment
067: * descriptor, for this application.
068: *
069: * @exception IllegalStateException if this method is called before
070: * this application has started, or after it has been stopped
071: */
072: public Object[] getApplicationEventListeners();
073:
074: /**
075: * Store the set of initialized application event listener objects,
076: * in the order they were specified in the web application deployment
077: * descriptor, for this application.
078: *
079: * @param listeners The set of instantiated listener objects.
080: */
081: public void setApplicationEventListeners(Object listeners[]);
082:
083: /**
084: * Return the set of initialized application lifecycle listener objects,
085: * in the order they were specified in the web application deployment
086: * descriptor, for this application.
087: *
088: * @exception IllegalStateException if this method is called before
089: * this application has started, or after it has been stopped
090: */
091: public Object[] getApplicationLifecycleListeners();
092:
093: /**
094: * Store the set of initialized application lifecycle listener objects,
095: * in the order they were specified in the web application deployment
096: * descriptor, for this application.
097: *
098: * @param listeners The set of instantiated listener objects.
099: */
100: public void setApplicationLifecycleListeners(Object listeners[]);
101:
102: /**
103: * Return the application available flag for this Context.
104: */
105: public boolean getAvailable();
106:
107: /**
108: * Set the application available flag for this Context.
109: *
110: * @param available The new application available flag
111: */
112: public void setAvailable(boolean available);
113:
114: /**
115: * Return the Locale to character set mapper for this Context.
116: */
117: public CharsetMapper getCharsetMapper();
118:
119: /**
120: * Set the Locale to character set mapper for this Context.
121: *
122: * @param mapper The new mapper
123: */
124: public void setCharsetMapper(CharsetMapper mapper);
125:
126: /**
127: * Return the path to a file to save this Context information.
128: */
129: public String getConfigFile();
130:
131: /**
132: * Set the path to a file to save this Context information.
133: *
134: * @param configFile The path to a file to save this Context information.
135: */
136: public void setConfigFile(String configFile);
137:
138: /**
139: * Return the "correctly configured" flag for this Context.
140: */
141: public boolean getConfigured();
142:
143: /**
144: * Set the "correctly configured" flag for this Context. This can be
145: * set to false by startup listeners that detect a fatal configuration
146: * error to avoid the application from being made available.
147: *
148: * @param configured The new correctly configured flag
149: */
150: public void setConfigured(boolean configured);
151:
152: /**
153: * Return the "use cookies for session ids" flag.
154: */
155: public boolean getCookies();
156:
157: /**
158: * Set the "use cookies for session ids" flag.
159: *
160: * @param cookies The new flag
161: */
162: public void setCookies(boolean cookies);
163:
164: /**
165: * Return the "allow crossing servlet contexts" flag.
166: */
167: public boolean getCrossContext();
168:
169: /**
170: * Return the alternate Deployment Descriptor name.
171: */
172: public String getAltDDName();
173:
174: /**
175: * Set an alternate Deployment Descriptor name.
176: */
177: public void setAltDDName(String altDDName);
178:
179: /**
180: * Set the "allow crossing servlet contexts" flag.
181: *
182: * @param crossContext The new cross contexts flag
183: */
184: public void setCrossContext(boolean crossContext);
185:
186: /**
187: * Return the display name of this web application.
188: */
189: public String getDisplayName();
190:
191: /**
192: * Set the display name of this web application.
193: *
194: * @param displayName The new display name
195: */
196: public void setDisplayName(String displayName);
197:
198: /**
199: * Return the distributable flag for this web application.
200: */
201: public boolean getDistributable();
202:
203: /**
204: * Set the distributable flag for this web application.
205: *
206: * @param distributable The new distributable flag
207: */
208: public void setDistributable(boolean distributable);
209:
210: /**
211: * Return the document root for this Context. This can be an absolute
212: * pathname, a relative pathname, or a URL.
213: */
214: public String getDocBase();
215:
216: /**
217: * Set the document root for this Context. This can be an absolute
218: * pathname, a relative pathname, or a URL.
219: *
220: * @param docBase The new document root
221: */
222: public void setDocBase(String docBase);
223:
224: /**
225: * Return the URL encoded context path, using UTF-8.
226: */
227: public String getEncodedPath();
228:
229: /**
230: * Return the boolean on the annotations parsing.
231: */
232: public boolean getIgnoreAnnotations();
233:
234: /**
235: * Set the boolean on the annotations parsing for this web
236: * application.
237: *
238: * @param ignoreAnnotations The boolean on the annotations parsing
239: */
240: public void setIgnoreAnnotations(boolean ignoreAnnotations);
241:
242: /**
243: * Return the login configuration descriptor for this web application.
244: */
245: public LoginConfig getLoginConfig();
246:
247: /**
248: * Set the login configuration descriptor for this web application.
249: *
250: * @param config The new login configuration
251: */
252: public void setLoginConfig(LoginConfig config);
253:
254: /**
255: * Get the request dispatcher mapper.
256: */
257: public Mapper getMapper();
258:
259: /**
260: * Return the naming resources associated with this web application.
261: */
262: public NamingResources getNamingResources();
263:
264: /**
265: * Set the naming resources for this web application.
266: *
267: * @param namingResources The new naming resources
268: */
269: public void setNamingResources(NamingResources namingResources);
270:
271: /**
272: * Return the context path for this web application.
273: */
274: public String getPath();
275:
276: /**
277: * Set the context path for this web application.
278: *
279: * @param path The new context path
280: */
281: public void setPath(String path);
282:
283: /**
284: * Return the public identifier of the deployment descriptor DTD that is
285: * currently being parsed.
286: */
287: public String getPublicId();
288:
289: /**
290: * Set the public identifier of the deployment descriptor DTD that is
291: * currently being parsed.
292: *
293: * @param publicId The public identifier
294: */
295: public void setPublicId(String publicId);
296:
297: /**
298: * Return the reloadable flag for this web application.
299: */
300: public boolean getReloadable();
301:
302: /**
303: * Set the reloadable flag for this web application.
304: *
305: * @param reloadable The new reloadable flag
306: */
307: public void setReloadable(boolean reloadable);
308:
309: /**
310: * Return the override flag for this web application.
311: */
312: public boolean getOverride();
313:
314: /**
315: * Set the override flag for this web application.
316: *
317: * @param override The new override flag
318: */
319: public void setOverride(boolean override);
320:
321: /**
322: * Return the privileged flag for this web application.
323: */
324: public boolean getPrivileged();
325:
326: /**
327: * Set the privileged flag for this web application.
328: *
329: * @param privileged The new privileged flag
330: */
331: public void setPrivileged(boolean privileged);
332:
333: /**
334: * Return the servlet context for which this Context is a facade.
335: */
336: public ServletContext getServletContext();
337:
338: /**
339: * Return the default session timeout (in minutes) for this
340: * web application.
341: */
342: public int getSessionTimeout();
343:
344: /**
345: * Set the default session timeout (in minutes) for this
346: * web application.
347: *
348: * @param timeout The new default session timeout
349: */
350: public void setSessionTimeout(int timeout);
351:
352: /**
353: * Return the value of the swallowOutput flag.
354: */
355: public boolean getSwallowOutput();
356:
357: /**
358: * Set the value of the swallowOutput flag. If set to true, the system.out
359: * and system.err will be redirected to the logger during a servlet
360: * execution.
361: *
362: * @param swallowOutput The new value
363: */
364: public void setSwallowOutput(boolean swallowOutput);
365:
366: /**
367: * Return the Java class name of the Wrapper implementation used
368: * for servlets registered in this Context.
369: */
370: public String getWrapperClass();
371:
372: /**
373: * Set the Java class name of the Wrapper implementation used
374: * for servlets registered in this Context.
375: *
376: * @param wrapperClass The new wrapper class
377: */
378: public void setWrapperClass(String wrapperClass);
379:
380: // --------------------------------------------------------- Public Methods
381:
382: /**
383: * Add a new Listener class name to the set of Listeners
384: * configured for this application.
385: *
386: * @param listener Java class name of a listener class
387: */
388: public void addApplicationListener(String listener);
389:
390: /**
391: * Add a new application parameter for this application.
392: *
393: * @param parameter The new application parameter
394: */
395: public void addApplicationParameter(ApplicationParameter parameter);
396:
397: /**
398: * Add a security constraint to the set for this web application.
399: */
400: public void addConstraint(SecurityConstraint constraint);
401:
402: /**
403: * Add an error page for the specified error or Java exception.
404: *
405: * @param errorPage The error page definition to be added
406: */
407: public void addErrorPage(ErrorPage errorPage);
408:
409: /**
410: * Add a filter definition to this Context.
411: *
412: * @param filterDef The filter definition to be added
413: */
414: public void addFilterDef(FilterDef filterDef);
415:
416: /**
417: * Add a filter mapping to this Context.
418: *
419: * @param filterMap The filter mapping to be added
420: */
421: public void addFilterMap(FilterMap filterMap);
422:
423: /**
424: * Add the classname of an InstanceListener to be added to each
425: * Wrapper appended to this Context.
426: *
427: * @param listener Java class name of an InstanceListener class
428: */
429: public void addInstanceListener(String listener);
430:
431: /**
432: * Add the given URL pattern as a jsp-property-group. This maps
433: * resources that match the given pattern so they will be passed
434: * to the JSP container. Though there are other elements in the
435: * property group, we only care about the URL pattern here. The
436: * JSP container will parse the rest.
437: *
438: * @param pattern URL pattern to be mapped
439: */
440: public void addJspMapping(String pattern);
441:
442: /**
443: * Add a Locale Encoding Mapping (see Sec 5.4 of Servlet spec 2.4)
444: *
445: * @param locale locale to map an encoding for
446: * @param encoding encoding to be used for a give locale
447: */
448: public void addLocaleEncodingMappingParameter(String locale,
449: String encoding);
450:
451: /**
452: * Add a new MIME mapping, replacing any existing mapping for
453: * the specified extension.
454: *
455: * @param extension Filename extension being mapped
456: * @param mimeType Corresponding MIME type
457: */
458: public void addMimeMapping(String extension, String mimeType);
459:
460: /**
461: * Add a new context initialization parameter, replacing any existing
462: * value for the specified name.
463: *
464: * @param name Name of the new parameter
465: * @param value Value of the new parameter
466: */
467: public void addParameter(String name, String value);
468:
469: /**
470: * Add a security role reference for this web application.
471: *
472: * @param role Security role used in the application
473: * @param link Actual security role to check for
474: */
475: public void addRoleMapping(String role, String link);
476:
477: /**
478: * Add a new security role for this web application.
479: *
480: * @param role New security role
481: */
482: public void addSecurityRole(String role);
483:
484: /**
485: * Add a new servlet mapping, replacing any existing mapping for
486: * the specified pattern.
487: *
488: * @param pattern URL pattern to be mapped
489: * @param name Name of the corresponding servlet to execute
490: */
491: public void addServletMapping(String pattern, String name);
492:
493: /**
494: * Add a JSP tag library for the specified URI.
495: *
496: * @param uri URI, relative to the web.xml file, of this tag library
497: * @param location Location of the tag library descriptor
498: */
499: public void addTaglib(String uri, String location);
500:
501: /**
502: * Add a resource which will be watched for reloading by the host auto
503: * deployer. Note: this will not be used in embedded mode.
504: *
505: * @param name Path to the resource, relative to docBase
506: */
507: public void addWatchedResource(String name);
508:
509: /**
510: * Add a new welcome file to the set recognized by this Context.
511: *
512: * @param name New welcome file name
513: */
514: public void addWelcomeFile(String name);
515:
516: /**
517: * Add the classname of a LifecycleListener to be added to each
518: * Wrapper appended to this Context.
519: *
520: * @param listener Java class name of a LifecycleListener class
521: */
522: public void addWrapperLifecycle(String listener);
523:
524: /**
525: * Add the classname of a ContainerListener to be added to each
526: * Wrapper appended to this Context.
527: *
528: * @param listener Java class name of a ContainerListener class
529: */
530: public void addWrapperListener(String listener);
531:
532: /**
533: * Factory method to create and return a new Wrapper instance, of
534: * the Java implementation class appropriate for this Context
535: * implementation. The constructor of the instantiated Wrapper
536: * will have been called, but no properties will have been set.
537: */
538: public Wrapper createWrapper();
539:
540: /**
541: * Return the set of application listener class names configured
542: * for this application.
543: */
544: public String[] findApplicationListeners();
545:
546: /**
547: * Return the set of application parameters for this application.
548: */
549: public ApplicationParameter[] findApplicationParameters();
550:
551: /**
552: * Return the set of security constraints for this web application.
553: * If there are none, a zero-length array is returned.
554: */
555: public SecurityConstraint[] findConstraints();
556:
557: /**
558: * Return the error page entry for the specified HTTP error code,
559: * if any; otherwise return <code>null</code>.
560: *
561: * @param errorCode Error code to look up
562: */
563: public ErrorPage findErrorPage(int errorCode);
564:
565: /**
566: * Return the error page entry for the specified Java exception type,
567: * if any; otherwise return <code>null</code>.
568: *
569: * @param exceptionType Exception type to look up
570: */
571: public ErrorPage findErrorPage(String exceptionType);
572:
573: /**
574: * Return the set of defined error pages for all specified error codes
575: * and exception types.
576: */
577: public ErrorPage[] findErrorPages();
578:
579: /**
580: * Return the filter definition for the specified filter name, if any;
581: * otherwise return <code>null</code>.
582: *
583: * @param filterName Filter name to look up
584: */
585: public FilterDef findFilterDef(String filterName);
586:
587: /**
588: * Return the set of defined filters for this Context.
589: */
590: public FilterDef[] findFilterDefs();
591:
592: /**
593: * Return the set of filter mappings for this Context.
594: */
595: public FilterMap[] findFilterMaps();
596:
597: /**
598: * Return the set of InstanceListener classes that will be added to
599: * newly created Wrappers automatically.
600: */
601: public String[] findInstanceListeners();
602:
603: /**
604: * Return the MIME type to which the specified extension is mapped,
605: * if any; otherwise return <code>null</code>.
606: *
607: * @param extension Extension to map to a MIME type
608: */
609: public String findMimeMapping(String extension);
610:
611: /**
612: * Return the extensions for which MIME mappings are defined. If there
613: * are none, a zero-length array is returned.
614: */
615: public String[] findMimeMappings();
616:
617: /**
618: * Return the value for the specified context initialization
619: * parameter name, if any; otherwise return <code>null</code>.
620: *
621: * @param name Name of the parameter to return
622: */
623: public String findParameter(String name);
624:
625: /**
626: * Return the names of all defined context initialization parameters
627: * for this Context. If no parameters are defined, a zero-length
628: * array is returned.
629: */
630: public String[] findParameters();
631:
632: /**
633: * For the given security role (as used by an application), return the
634: * corresponding role name (as defined by the underlying Realm) if there
635: * is one. Otherwise, return the specified role unchanged.
636: *
637: * @param role Security role to map
638: */
639: public String findRoleMapping(String role);
640:
641: /**
642: * Return <code>true</code> if the specified security role is defined
643: * for this application; otherwise return <code>false</code>.
644: *
645: * @param role Security role to verify
646: */
647: public boolean findSecurityRole(String role);
648:
649: /**
650: * Return the security roles defined for this application. If none
651: * have been defined, a zero-length array is returned.
652: */
653: public String[] findSecurityRoles();
654:
655: /**
656: * Return the servlet name mapped by the specified pattern (if any);
657: * otherwise return <code>null</code>.
658: *
659: * @param pattern Pattern for which a mapping is requested
660: */
661: public String findServletMapping(String pattern);
662:
663: /**
664: * Return the patterns of all defined servlet mappings for this
665: * Context. If no mappings are defined, a zero-length array is returned.
666: */
667: public String[] findServletMappings();
668:
669: /**
670: * Return the context-relative URI of the error page for the specified
671: * HTTP status code, if any; otherwise return <code>null</code>.
672: *
673: * @param status HTTP status code to look up
674: */
675: public String findStatusPage(int status);
676:
677: /**
678: * Return the set of HTTP status codes for which error pages have
679: * been specified. If none are specified, a zero-length array
680: * is returned.
681: */
682: public int[] findStatusPages();
683:
684: /**
685: * Return the tag library descriptor location for the specified taglib
686: * URI, if any; otherwise, return <code>null</code>.
687: *
688: * @param uri URI, relative to the web.xml file
689: */
690: public String findTaglib(String uri);
691:
692: /**
693: * Return the URIs of all tag libraries for which a tag library
694: * descriptor location has been specified. If none are specified,
695: * a zero-length array is returned.
696: */
697: public String[] findTaglibs();
698:
699: /**
700: * Return the set of watched resources for this Context. If none are
701: * defined, a zero length array will be returned.
702: */
703: public String[] findWatchedResources();
704:
705: /**
706: * Return <code>true</code> if the specified welcome file is defined
707: * for this Context; otherwise return <code>false</code>.
708: *
709: * @param name Welcome file to verify
710: */
711: public boolean findWelcomeFile(String name);
712:
713: /**
714: * Return the set of welcome files defined for this Context. If none are
715: * defined, a zero-length array is returned.
716: */
717: public String[] findWelcomeFiles();
718:
719: /**
720: * Return the set of LifecycleListener classes that will be added to
721: * newly created Wrappers automatically.
722: */
723: public String[] findWrapperLifecycles();
724:
725: /**
726: * Return the set of ContainerListener classes that will be added to
727: * newly created Wrappers automatically.
728: */
729: public String[] findWrapperListeners();
730:
731: /**
732: * Reload this web application, if reloading is supported.
733: *
734: * @exception IllegalStateException if the <code>reloadable</code>
735: * property is set to <code>false</code>.
736: */
737: public void reload();
738:
739: /**
740: * Remove the specified application listener class from the set of
741: * listeners for this application.
742: *
743: * @param listener Java class name of the listener to be removed
744: */
745: public void removeApplicationListener(String listener);
746:
747: /**
748: * Remove the application parameter with the specified name from
749: * the set for this application.
750: *
751: * @param name Name of the application parameter to remove
752: */
753: public void removeApplicationParameter(String name);
754:
755: /**
756: * Remove the specified security constraint from this web application.
757: *
758: * @param constraint Constraint to be removed
759: */
760: public void removeConstraint(SecurityConstraint constraint);
761:
762: /**
763: * Remove the error page for the specified error code or
764: * Java language exception, if it exists; otherwise, no action is taken.
765: *
766: * @param errorPage The error page definition to be removed
767: */
768: public void removeErrorPage(ErrorPage errorPage);
769:
770: /**
771: * Remove the specified filter definition from this Context, if it exists;
772: * otherwise, no action is taken.
773: *
774: * @param filterDef Filter definition to be removed
775: */
776: public void removeFilterDef(FilterDef filterDef);
777:
778: /**
779: * Remove a filter mapping from this Context.
780: *
781: * @param filterMap The filter mapping to be removed
782: */
783: public void removeFilterMap(FilterMap filterMap);
784:
785: /**
786: * Remove a class name from the set of InstanceListener classes that
787: * will be added to newly created Wrappers.
788: *
789: * @param listener Class name of an InstanceListener class to be removed
790: */
791: public void removeInstanceListener(String listener);
792:
793: /**
794: * Remove the MIME mapping for the specified extension, if it exists;
795: * otherwise, no action is taken.
796: *
797: * @param extension Extension to remove the mapping for
798: */
799: public void removeMimeMapping(String extension);
800:
801: /**
802: * Remove the context initialization parameter with the specified
803: * name, if it exists; otherwise, no action is taken.
804: *
805: * @param name Name of the parameter to remove
806: */
807: public void removeParameter(String name);
808:
809: /**
810: * Remove any security role reference for the specified name
811: *
812: * @param role Security role (as used in the application) to remove
813: */
814: public void removeRoleMapping(String role);
815:
816: /**
817: * Remove any security role with the specified name.
818: *
819: * @param role Security role to remove
820: */
821: public void removeSecurityRole(String role);
822:
823: /**
824: * Remove any servlet mapping for the specified pattern, if it exists;
825: * otherwise, no action is taken.
826: *
827: * @param pattern URL pattern of the mapping to remove
828: */
829: public void removeServletMapping(String pattern);
830:
831: /**
832: * Remove the tag library location forthe specified tag library URI.
833: *
834: * @param uri URI, relative to the web.xml file
835: */
836: public void removeTaglib(String uri);
837:
838: /**
839: * Remove the specified watched resource name from the list associated
840: * with this Context.
841: *
842: * @param name Name of the watched resource to be removed
843: */
844: public void removeWatchedResource(String name);
845:
846: /**
847: * Remove the specified welcome file name from the list recognized
848: * by this Context.
849: *
850: * @param name Name of the welcome file to be removed
851: */
852: public void removeWelcomeFile(String name);
853:
854: /**
855: * Remove a class name from the set of LifecycleListener classes that
856: * will be added to newly created Wrappers.
857: *
858: * @param listener Class name of a LifecycleListener class to be removed
859: */
860: public void removeWrapperLifecycle(String listener);
861:
862: /**
863: * Remove a class name from the set of ContainerListener classes that
864: * will be added to newly created Wrappers.
865: *
866: * @param listener Class name of a ContainerListener class to be removed
867: */
868: public void removeWrapperListener(String listener);
869:
870: /**
871: * Get the server.xml <context> attribute's xmlNamespaceAware.
872: * @return true if namespace awarenes is enabled.
873: *
874: */
875: public boolean getXmlNamespaceAware();
876:
877: /**
878: * Get the server.xml <context> attribute's xmlValidation.
879: * @return true if validation is enabled.
880: *
881: */
882: public boolean getXmlValidation();
883:
884: /**
885: * Set the validation feature of the XML parser used when
886: * parsing xml instances.
887: * @param xmlValidation true to enable xml instance validation
888: */
889: public void setXmlValidation(boolean xmlValidation);
890:
891: /**
892: * Set the namespace aware feature of the XML parser used when
893: * parsing xml instances.
894: * @param xmlNamespaceAware true to enable namespace awareness
895: */
896: public void setXmlNamespaceAware(boolean xmlNamespaceAware);
897:
898: /**
899: * Get the server.xml <context> attribute's xmlValidation.
900: * @return true if validation is enabled.
901: */
902:
903: /**
904: * Set the validation feature of the XML parser used when
905: * parsing tlds files.
906: * @param tldValidation true to enable xml instance validation
907: */
908: public void setTldValidation(boolean tldValidation);
909:
910: /**
911: * Get the server.xml <context> attribute's webXmlValidation.
912: * @return true if validation is enabled.
913: *
914: */
915: public boolean getTldValidation();
916:
917: /**
918: * Get the server.xml <host> attribute's xmlNamespaceAware.
919: * @return true if namespace awarenes is enabled.
920: */
921: public boolean getTldNamespaceAware();
922:
923: /**
924: * Set the namespace aware feature of the XML parser used when
925: * parsing xml instances.
926: * @param tldNamespaceAware true to enable namespace awareness
927: */
928: public void setTldNamespaceAware(boolean tldNamespaceAware);
929:
930: }
|