KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > de > susebox > jtopas > TokenizerProperties


1 /*
2  * TokenizerProperties.java: store for tokenizer characteristics.
3  *
4  * Copyright (C) 2002 Heiko Blau
5  *
6  * This file belongs to the JTopas Library.
7  * JTopas is free software; you can redistribute it and/or modify it
8  * under the terms of the GNU Lesser General Public License as published by the
9  * Free Software Foundation; either version 2.1 of the License, or (at your
10  * option) any later version.
11  *
12  * This software is distributed in the hope that it will be useful, but WITHOUT
13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14  * FITNESS FOR A PARTICULAR PURPOSE.
15  * See the GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public License along
18  * with JTopas. If not, write to the
19  *
20  * Free Software Foundation, Inc.
21  * 59 Temple Place, Suite 330,
22  * Boston, MA 02111-1307
23  * USA
24  *
25  * or check the Internet: http://www.fsf.org
26  *
27  * Contact:
28  * email: heiko@susebox.de
29  */

30
31 package de.susebox.jtopas;
32
33 //-----------------------------------------------------------------------------
34
// Imports
35
//
36
import java.util.Iterator JavaDoc;
37
38
39 //-----------------------------------------------------------------------------
40
// Interface TokenizerProperties
41
//
42

43 /**<p>
44  * The interface <code>TokenizerProperties</code> declares constants and methods
45  * to maintain the characteristics of a {@link Tokenizer}, e. g. comments, keywords
46  * and special sequences. A <code>TokenizerProperties</code> implementation instance
47  * can be used by one or more {@link Tokenizer} instances.
48  *</p><p>
49  * A <code>TokenizerProperties</code> object that is used to parse Java or C code
50  * including line and column information, would be setup like this:
51  *<pre>
52  * TokenizerProperties props = new StandardTokenizerProperties();
53  *
54  * props.setParseFlags(Flags.F_COUNT_LINES);
55  * props.addLineComment("//");
56  * props.addBlockComment(TokenizerProperties.DEFAULT_BLOCK_COMMENT_START,
57  * TokenizerProperties.DEFAULT_BLOCK_COMMENT_END);
58  * props.addString("\"", "\"", "\\");
59  * props.addString("'", "'", "\\");
60  * props.addSpecialSequence(">>");
61  * props.addSpecialSequence("<<");
62  * props.addSpecialSequence("++");
63  * props.addSpecialSequence("--");
64  * ...
65  * props.addKeyword("class");
66  * props.addKeyword("if");
67  * props.addKeyword("then");
68  * props.addKeyword("while");
69  * props.addKeyword("do");
70  * ...
71  *</pre>
72  *</p><p>
73  * Beside the dedicated method groups for comments, strings, keywords and
74  * special sequences (e.g. {@link #addKeyword}, {@link #removeKeyword} and
75  * {@link #keywordExists}) there is a set of generic methods working with
76  * {@link TokenizerProperty} objects:
77  *<ul><li>
78  * {@link #addProperty},
79  *</li><li>
80  * {@link #removeProperty} and
81  *</li><li>
82  * {@link #propertyExists}.
83  *</li></ul>
84  *</p><p>
85  * When adding a property through one of the <code>add...</code> calls without
86  * the <code>flags</code> parameter, the currently active flags of the
87  * <code>TokenizerProperties</code> instance will be used for the property.
88  *</p><p>
89  * This interface is separated from the {@link Tokenizer} interface mainly to
90  * distinguish between the more static information, the actual source of data
91  * and the tokenizing process. Especially in multithreaded environments where
92  * multible instances of "equal" tokenizers are run at the same time, it saves
93  * both memory resources and setup effort to have one <code>TokenizerProperties</code>
94  * instance for all {@link Tokenizer} instances.
95  *</p><p>
96  * Beside its function as a store for lexical element descriptions, this interface
97  * also provides an event mechanism to notify all interested objects about changes
98  * (additions, modifications and removals) of such lexical element descriptions.
99  *</p><p>
100  * This interface partly replaces the older {@link de.susebox.java.util.Tokenizer}
101  * interface which is deprecated.
102  *</p>
103  *
104  * @see Token
105  * @see Tokenizer
106  * @see TokenizerProperty
107  * @author Heiko Blau
108  */

109 public interface TokenizerProperties {
110   
111   //---------------------------------------------------------------------------
112
// default character classes
113
//
114

115   /**
116    * Whitespaces are portions of the text, that contain one or more characters
117    * that separate the significant parts of the text. Generally, a sequence of
118    * whitespaces is equally represented by one single whitespace character. That
119    * is the difference to separators.
120    *<br>
121    * The value of this constant contains the ASCII characters space, tab, carriage
122    * return and linefeed.
123    */

124   public static final String JavaDoc DEFAULT_WHITESPACES = " \t\r\n";
125   
126   /**
127    * Separators are otherwise not remarkable characters. An opening parenthesis
128    * might be nessecary for a syntactically correct text, but without any special
129    * meaning to the compiler, interpreter etc. after it has been detected.
130    *<br>
131    * The value of this constant includes all printable characters that are not
132    * alphanumeric and not whitespaces. Note, that adding one of the separator
133    * characters as a special sequence ({@link #addSpecialSequence}) takes
134    * precedence.
135    */

136   public static final String JavaDoc DEFAULT_SEPARATORS = "\u0021\u0023-\u002f\u003a-\u0040\u005b-\u005e\u0060\u007b-\u007e";
137   
138   /**
139    * Default starting sequence of a block comment (Java, C/C++).
140    */

141   public static final String JavaDoc DEFAULT_BLOCK_COMMENT_START = "/*";
142
143   /**
144    * Default end sequence of a block comment (Java, C/C++).
145    */

146   public static final String JavaDoc DEFAULT_BLOCK_COMMENT_END = "*/";
147   
148   /**
149    * Default line comment seqence (Java, C++)
150    */

151   public static final String JavaDoc DEFAULT_LINE_COMMENT = "//";
152   
153   /**
154    * The well-known string starting sequence " of C/C++, Java and other languages.
155    */

156   public static final String JavaDoc DEFAULT_STRING_START = "\"";
157   
158   /**
159    * The well-known string ending sequence of C/C++, Java and other languages.
160    */

161   public static final String JavaDoc DEFAULT_STRING_END = DEFAULT_STRING_START;
162   
163   /**
164    * The well-known escape sequence for strings in C/C++, Java and other languages.
165    */

166   public static final String JavaDoc DEFAULT_STRING_ESCAPE = "\\";
167   
168   /**
169    * The well-known character starting sequence of C/C++, Java and other languages.
170    */

171   public static final String JavaDoc DEFAULT_CHAR_START = "'";
172   
173   /**
174    * The well-known character ending sequence of C/C++, Java and other languages.
175    */

176   public static final String JavaDoc DEFAULT_CHAR_END = DEFAULT_CHAR_START;
177
178   /**
179    * The well-known escape sequence for character literals in C/C++, Java and other
180    * languages.
181    */

182   public static final String JavaDoc DEFAULT_CHAR_ESCAPE = DEFAULT_STRING_ESCAPE;
183   
184   
185   //---------------------------------------------------------------------------
186
// trivial property methods
187
//
188

189   /**
190    * Setting the control flags of the <code>TokenizerProperties</code>. Use a
191    * combination of the {@link Flags} for the parameter.
192    *<br>
193    * This method sets the parse flags globally for all {@link Tokenizer} objects
194    * sharing this <code>TokenizerProperties</code> instance. Some flags can be set
195    * for single tokenizers separately.
196    *<br>
197    * When adding a property like a keyword without explicitely specifying flags,
198    * these properties are handled with the flags that were effective at the time
199    * of adding.
200    *<br>
201    * The method fires a {@link TokenizerPropertyEvent} of type {@link TokenizerPropertyEvent#PROPERTY_MODIFIED}
202    * each time it is called with different flag masks. The passed {@link TokenizerProperty}
203    * has the type {@link TokenizerProperty#PARSE_FLAG_MASK}.
204    *
205    * @param flags the parser control flags
206    */

207   public void setParseFlags(int flags);
208
209    /**
210     * Retrieving the parser control flags. A bitmask containing the {@link Flags}
211     * constants is returned. These flags are the ones set for all {@link Tokenizer}
212     * instances sharing this <code>TokenizerProperties</code> object and may be
213     * partially overridden in these tokenizers.
214     *
215     * @return the globally set parser control flags
216     * @see #setParseFlags
217     */

218   public int getParseFlags();
219   
220   /**
221    * Returns <code>true</code> if a given flag is set in the current parse flags.
222    * If the parameter contains more than one bit the method returns only
223    * <code>true</code> if all bits are set.
224    *
225    * @param flag the flag to test
226    * @return <code>true</code> if all bits in flag are set.
227    * @see #setParseFlags
228    * @see #getParseFlags
229    * @see #isFlagSet(TokenizerProperty, int)
230    */

231   public boolean isFlagSet(int flag);
232     
233   /**
234    * Checks if a given flag (see {@link Flags}) is set for the given {@link TokenizerProperty}
235    * in the context of this <code>TokenizerProperties</code> instance.
236    *<br>
237    * The method uses the flag state of the <code>TokenizerProperty</code> object
238    * if it is contained in the flag mask of the property (see {@link TokenizerProperty#containsFlag}).
239    * Otherwise it falls back to the flag state set globally for this
240    * <code>TokenizerProperties</code> instance.
241    *
242    * @param prop the {@link TokenizerProperty} concerned
243    * @param flag the flag to check (may contain more than one bit)
244    * @return <code>true</code> if the flag is set either explicit in the property
245    * or globally for this <code>TokenizerProperties</code> object,
246    * <code>false</code> otherwise
247    * @throws NullPointerException if no property is given
248    */

249   public boolean isFlagSet(TokenizerProperty prop, int flag) throws NullPointerException JavaDoc;
250   
251   
252   //---------------------------------------------------------------------------
253
// whitespaces and single-character separators
254
//
255

256   /**
257    * Setting the whitespace character set of the tokenizer. Implementations should
258    * be able to operate on ranges like "a-z" when more than two whitespace characters
259    * are neighbours in the UNICODE character set.
260    *<br>
261    * Whitespaces are sequences that have the same syntactical meaning as one
262    * single whitespace character would have. That means " " (many spaces) is
263    * the same as " " (one space).
264    *<br>
265    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
266    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} or
267    * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} to all registered listeners
268    * (see {@link #addTokenizerPropertyListener}).
269    *<br>
270    * The method accepts an empty string to describe "no whitespaces".
271    *
272    * @param whitespaces the whitespace set
273    * @throws IllegalArgumentException when <code>null</code> is passed or incomplete
274    * ranges are specified (e.g. <code>"a-"</code>)
275    * @see #getWhitespaces
276    * @see #addWhitespaces
277    * @see #removeWhitespaces
278    */

279   public void setWhitespaces(String JavaDoc whitespaces) throws IllegalArgumentException JavaDoc;
280   
281   /**
282    * Adding new whitespaces to the existing set. This is a convenience method to
283    * complete the whitespace set without having to include the already known
284    * whitespaces (for instance the {@link #DEFAULT_WHITESPACES} set).
285    *<br>
286    * Whitespaces that are already known, are ignored (the new whitespaces are
287    * "merged" into the known set).
288    *<br>
289    * For more information see {@link #setWhitespaces}.
290    *
291    * @param whitespaces additional whitespaces for the whitespace set
292    * @throws IllegalArgumentException when <code>null</code> is passed or incomplete
293    * ranges are specified (e.g. <code>"a-"</code>)
294    * @see #getWhitespaces
295    * @see #setWhitespaces
296    * @see #removeWhitespaces
297    */

298   public void addWhitespaces(String JavaDoc whitespaces) throws IllegalArgumentException JavaDoc;
299   
300   /**
301    * Removing whitespaces from the existing set. This is a convenience method to
302    * modify the whitespace set without having to reconstruct the probably major
303    * part of the whitespaces (for instance the {@link #DEFAULT_WHITESPACES} set).
304    * Especially, this method can be used to remove a known single whitespace
305    * without bothering about the other whitespaces
306    *<br>
307    * Whitespaces that are not known, are ignored.
308    *<br>
309    * For more information see {@link #setWhitespaces}.
310    *
311    * @param whitespaces whitespaces to remove from the whitespace set
312    * @throws IllegalArgumentException when <code>null</code> is passed or incomplete
313    * ranges are specified (e.g. <code>"a-"</code>)
314    * @see #getWhitespaces
315    * @see #setWhitespaces
316    * @see #addWhitespaces
317    */

318   public void removeWhitespaces(String JavaDoc whitespaces) throws IllegalArgumentException JavaDoc;
319   
320   /**
321    * Obtaining the whitespace character set. The set may contain ranges. The
322    * method may return an emtpy string, if no whitespaces are known.
323    *
324    * @see #setWhitespaces
325    * @return the currently active whitespace set
326    */

327   public String JavaDoc getWhitespaces();
328   
329   /**
330    * Setting the separator set. This set may contain ranges. A range is a
331    * character (lower limit) followed by a '-' (minus) followed by a
332    * second character (upper limit). A range of "a-z" means: all characters in
333    * the UNICODE character set between and including 'a' and 'z'. The character
334    * '-' itself should be preceded by an escape character. Ranges should
335    * be used whenever possible since they speed up the parsing process.
336    *<br>
337    * Separators are characters that are significant for the syntax. A sequence
338    * of separators is <strong>NOT</strong> equal to one single separator. Thats
339    * the difference to whitespaces.
340    *<br>
341    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
342    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} or
343    * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} to all registered listeners
344    * (see {@link #addTokenizerPropertyListener}).
345    *<br>
346    * The method accepts an empty string to describe "no separators".
347    *
348    * @param separators the set of separating characters
349    * @throws IllegalArgumentException when <code>null</code> is passed or incomplete
350    * ranges are specified (e.g. <code>"[-"</code>)
351    * @see #getSeparators
352    */

353   public void setSeparators(String JavaDoc separators)
354     throws IllegalArgumentException JavaDoc;
355   
356   /**
357    * Adding new separators to the existing set. This is a convenience method to
358    * complete the separator set without having to include the already known
359    * separators (for instance the {@link #DEFAULT_SEPARATORS} set).
360    *<br>
361    * Separators that are already known, are ignored (the new separators are
362    * "merged" into the known set).
363    *<br>
364    * For more information see {@link #setSeparators}.
365    *
366    * @param separators additional set of separating characters
367    * @throws IllegalArgumentException when <code>null</code> is passed or incomplete
368    * ranges are specified (e.g. <code>"a-"</code>)
369    * @see #getSeparators
370    * @see #setSeparators
371    * @see #removeSeparators
372    */

373   public void addSeparators(String JavaDoc separators) throws IllegalArgumentException JavaDoc;
374   
375   /**
376    * Removing separators from the existing set. This is a convenience method to
377    * modify the separator set without having to reconstruct the probably major
378    * part of the separators (for instance the {@link #DEFAULT_SEPARATORS} set).
379    * Especially, this method can be used to remove a known single separator
380    * without bothering about the other separators.
381    *<br>
382    * Separators that are not known, are ignored.
383    *<br>
384    * For more information see {@link #setSeparators}.
385    *
386    * @param separators separating characters to remove from the separator set
387    * @throws IllegalArgumentException when <code>null</code> is passed or incomplete
388    * ranges are specified (e.g. <code>"a-"</code>)
389    * @see #getSeparators
390    * @see #setSeparators
391    * @see #addSeparators
392    */

393   public void removeSeparators(String JavaDoc separators) throws IllegalArgumentException JavaDoc;
394   
395   /**
396    * Obtaining the separator set of the <code>TokenizerProperties</code>. The set
397    * may contain ranges or may be empty.
398    *
399    * @return the currently used set of separating characters
400    * @see #setSeparators
401    */

402   public String JavaDoc getSeparators();
403   
404
405   //---------------------------------------------------------------------------
406
// string properties
407
//
408

409   /**
410    * Registering a string description. Strings are things like the primitive string
411    * literals in C/C++, SQL varchar literals, but also the character literals
412    * of C/C++ and Java.
413    *<br>
414    * If the given string starting sequence is already known to the parser,
415    * it will simply be re-registered. Using this method on a known string
416    * with an associated companion will remove that companion.
417    *<br>
418    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
419    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
420    * (see {@link #addTokenizerPropertyListener}) with the new string {@link TokenizerProperty}
421    * if the string is a new one, or of type {@link TokenizerPropertyEvent#PROPERTY_MODIFIED}
422    * if the string is re-registered.
423    *<br>
424    * Passing <code>null</code> or an empty string for the escape sequence means
425    * that no escapes are used in the described string element.
426    *
427    * @param start the starting sequence of a string
428    * @param end the finishing sequence of a string
429    * @param escape the escape sequence inside the string
430    * @throws IllegalArgumentException when <code>null</code> or an empty string
431    * is passed for start or end
432    * @throws UnsupportedOperationException if the method is not available for an
433    * implementation of the <code>TokenizerProperties</code> interface
434    * @see #addString(String, String, String, Object)
435    * @see #addString(String, String, String, Object, int)
436    * @see #removeString
437    */

438   public void addString(String JavaDoc start, String JavaDoc end, String JavaDoc escape)
439     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
440
441   /**
442    * Registering a the sequences that are used for string-like text parts.
443    * This method supports also an information associated with the string,
444    * called the companion.
445    *<br>
446    * If the given string starting sequence is already known to the parser,
447    * it will simply be re-registered. Using this method on a known string
448    * with an associated companion will replace that companion against the given
449    * one.
450    *<br>
451    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
452    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
453    * (see {@link #addTokenizerPropertyListener}) with the new string {@link TokenizerProperty}
454    * if the string is a new one, or of type {@link TokenizerPropertyEvent#PROPERTY_MODIFIED}
455    * if the string is re-registered.
456    *<br>
457    * Passing <code>null</code> or an empty string for the escape sequence means
458    * that no escapes are used in the described string element.
459    *
460    * @param start the starting sequence of a string
461    * @param end the finishing sequence of a string
462    * @param escape the escape sequence inside the string
463    * @param companion the associated information
464    * @throws IllegalArgumentException when <code>null</code> or an empty string
465    * is passed for start or end
466    * @throws UnsupportedOperationException if the method is not available for an
467    * implementation of the <code>TokenizerProperties</code> interface
468    * @see #addString(String, String, String)
469    * @see #addString(String, String, String, Object, int)
470    * @see #removeString
471    */

472   public void addString(String JavaDoc start, String JavaDoc end, String JavaDoc escape, Object JavaDoc companion)
473     throws IllegalArgumentException JavaDoc;
474   
475   /**
476    * Registering a the sequences that are used for string-like text parts.
477    * This method supports also an information associated with the string,
478    * called the companion.
479    *<br>
480    * If the given string starting sequence is already known to the parser,
481    * it will simply be re-registered. Using this method on a known string
482    * with an associated companion will replace that companion against the given
483    * one.
484    *<br>
485    * This version of <code>addString</code> supports a bitmask of the
486    * {@link Flags} to modify the general tokenizer settings (see
487    * {@link #setParseFlags} for this special element.
488    *<br>
489    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
490    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
491    * (see {@link #addTokenizerPropertyListener}) with the new string {@link TokenizerProperty}
492    * if the string is a new one, or of type {@link TokenizerPropertyEvent#PROPERTY_MODIFIED}
493    * if the string is re-registered.
494    *<br>
495    * Passing <code>null</code> or an empty string for the escape sequence means
496    * that no escapes are used in the described string element.
497    *<br>
498    * A call to this method is equivalent to
499    * <code>addString(start, end, escape, flags, flags)</code>.
500    *
501    * @param start the starting sequence of a string
502    * @param end the finishing sequence of a string
503    * @param escape the escape sequence inside the string
504    * @param companion the associated information
505    * @param flags modification flags
506    * @throws IllegalArgumentException when <code>null</code> or an empty string
507    * is passed for start or end
508    * @throws UnsupportedOperationException if the method is not available for an
509    * implementation of the <code>TokenizerProperties</code> interface
510    * @see #addString(String, String, String)
511    * @see #addString(String, String, String, Object)
512    * @see #addString(String, String, String, Object, int, int)
513    * @see #removeString
514    */

515   public void addString(String JavaDoc start, String JavaDoc end, String JavaDoc escape, Object JavaDoc companion, int flags)
516     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
517   
518   /**
519    * Registering a string with a set of flags and an associated flag mask.
520    *<br>
521    * The method is an extension to {@link #addString(String, Object, int)}
522    * having a bitmask for the flags that are explicitely specified for the block
523    * comment property. All other flag values (states) should be taken from the
524    * <code>TokenizerProperty</code> instance or from the {@link Tokenizer}.
525    *
526    * @param start the starting sequence of a string
527    * @param end the finishing sequence of a string
528    * @param escape the escape sequence inside the string
529    * @param companion the associated information
530    * @param flags modification flags
531    * @param flagMask flags that have valid values in the parameter <code>flags</code>
532    * @throws IllegalArgumentException when <code>null</code> or an empty string
533    * is passed for keyword
534    * @throws UnsupportedOperationException if the method is not available for an
535    * implementation of the <code>TokenizerProperties</code> interface
536    * @see #addString(String, String, String)
537    * @see #addString(String, String, String, Object)
538    * @see #addString(String, String, String, Object, int)
539    * @see #removeString
540    */

541   public void addString(String JavaDoc start, String JavaDoc end, String JavaDoc escape, Object JavaDoc companion, int flags, int flagMask)
542     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
543
544   /**
545    * Removing a string description. The method does nothing if the string description
546    * identified by the given <code>start</code> sequence is not known to this
547    * <code>TokenizerProperties</code> instance. The method may throw an
548    * {@link java.lang.IllegalArgumentException} if the given string start is
549    * <code>null</code> or empty.
550    *<br>
551    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
552    * of type {@link TokenizerPropertyEvent#PROPERTY_REMOVED} to all registered
553    * listeners (see {@link #addTokenizerPropertyListener}) if a string is actually
554    * removed.
555    *
556    * @param start the starting sequence of a string
557    * @throws IllegalArgumentException when <code>null</code> or an empty string
558    * is passed
559    */

560   public void removeString(String JavaDoc start)
561     throws IllegalArgumentException JavaDoc;
562   
563   /**
564    * Retrieving the information associated with a certain string. Only the
565    * starting sequence is nessecary to identify the string. If the string is not
566    * known to the parser, <code>null</code> will be returned.<br>
567    * If one needs to know if a string exists without a companion or if the string
568    * is unknown so far, use also the method {@link #stringExists}.
569    *
570    * @param start the starting sequence of a string
571    * @return the associated information or <code>null</code>
572    * @throws IllegalArgumentException when <code>null</code> or an emtpy string
573    * is passed
574    */

575   public Object JavaDoc getStringCompanion(String JavaDoc start)
576     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
577   
578   /**
579    * Checks if the given starting sequence of the string is known to the parser.
580    * The method accepts both empty and <code>null</code> strings for <code>start</code>
581    * by returning <code>false</code>.
582    *<br>
583    * Note that there is no choice of parsing flags (different to the
584    * {@link #addString(String, String, String, Object, int)} method), since it
585    * makes generally no sense to "overload" properties. A string might be introduced
586    * by the starting case-insensitive sequence <code>STR</code>, but there shouldn't
587    * be a case-sensitive start <code>str</code>.
588    *
589    * @param start the starting sequence of a string
590    * @return <code>true</code> if the string is registered,
591    * <code>false</code> otherwise
592    */

593   public boolean stringExists(String JavaDoc start);
594   
595   /**
596    * Get the full description of a string property starting with the given
597    * prefix. The method returns <code>null</code> if the passed <code>start</code>
598    * parameter cannot be mapped to a known string description ({@link #stringExists}
599    * would return <code>false</code>).
600    *
601    * @param start the starting sequence of a string
602    * @return the full string description or <code>null</code>
603    * @throws IllegalArgumentException when <code>null</code> is passed
604    */

605   public TokenizerProperty getString(String JavaDoc start)
606     throws IllegalArgumentException JavaDoc;
607
608   /**
609    * This method returns an {@link java.util.Iterator} of {@link TokenizerProperty}
610    * objects. Each <code>TokenizerProperty</code> object contains the starting,
611    * finishing and escaping sequence of a string description and the companion if
612    * it exists.
613    *
614    * @return enumeration of {@link TokenizerProperty} objects
615    */

616   public Iterator JavaDoc getStrings();
617   
618
619   //---------------------------------------------------------------------------
620
// line and block comments
621
//
622

623   /**
624    * Registering a the starting sequence of a line comment. The line comment is
625    * a special type of whitespace. It starts with the given character sequence
626    * and contains all characters up to and including the next end-of-line
627    * character(s).<br>
628    * Although most languages have only one line comment sequence, it is possible
629    * to use more than one.<br>
630    * If the given line comment starting sequence is already known to the parser,
631    * it will simply be re-registered. Using this method on a known line comment
632    * with an associated companion will effectively remove the companion.
633    *
634    * @param lineComment the starting sequence of the line comment
635    * @throws IllegalArgumentException when <code>null</code> or an empty string
636    * is passed
637    * @throws UnsupportedOperationException if the method is not available for an
638    * implementation of the <code>TokenizerProperties</code> interface
639    * @see #addLineComment(String, Object)
640    * @see #addLineComment(String, Object, int)
641    * @see #removeLineComment
642    */

643   public void addLineComment(String JavaDoc lineComment)
644     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
645
646   /**
647    * Registering a the starting sequence of a line comment. The line comment is
648    * a special type of whitespace. It starts with the given character sequence
649    * and contains all characters up to and including the next end-of-line
650    * character(s).<br>
651    * Although most languages have only one line comment sequence, it is possible
652    * to use more than one.<br>
653    * This method supports also an information associated with the line comment,
654    * called the companion.<br>
655    * If the given line comment starting sequence is already known to the parser,
656    * it will simply be re-registered. Using this method on a known line comment
657    * with an associated companion will replace that companion against the given
658    * one.
659    *<br>
660    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
661    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
662    * (see {@link #addTokenizerPropertyListener}) with the new line comment
663    * {@link TokenizerProperty} if the line comment is a new one, or of type
664    * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the line comment is
665    * re-registered.
666    *
667    * @param lineComment the starting sequence of a line comment
668    * @param companion the associated information
669    * @throws IllegalArgumentException when <code>null</code> or an empty string
670    * is passed for lineComment
671    * @throws UnsupportedOperationException if the method is not available for an
672    * implementation of the <code>TokenizerProperties</code> interface
673    * @see #addLineComment(String)
674    * @see #addLineComment(String, Object, int)
675    * @see #removeLineComment
676    */

677   public void addLineComment(String JavaDoc lineComment, Object JavaDoc companion)
678     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
679
680   /**
681    * Registering a the starting sequence of a line comment. The line comment is
682    * a special type of whitespace. It starts with the given character sequence
683    * and contains all characters up to and including the next end-of-line
684    * character(s).
685    *<br>
686    * Although most languages have only one line comment sequence, it is possible
687    * to use more than one.
688    *<br>
689    * This method supports also an information associated with the line comment,
690    * called the companion.
691    *<br>
692    * If the given line comment starting sequence is already known to the parser,
693    * it will simply be re-registered. Using this method on a known line comment
694    * with an associated companion will replace that companion against the given
695    * one.
696    *<br>
697    * This version of <code>addLineComment</code> supports a bitmask of the
698    * {@link Flags} to modify the general tokenizer settings (see
699    * {@link #setParseFlags}) for this special element.
700    *<br>
701    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
702    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
703    * (see {@link #addTokenizerPropertyListener}) with the new line comment
704    * {@link TokenizerProperty} if the line comment is a new one, or of type
705    * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the line comment is
706    * re-registered.
707    *<br>
708    * A call to this method is equivalent to
709    * <code>addLineComment(lineComment, companion, flags, flags)</code>.
710    *
711    * @param lineComment the starting sequence of a line comment
712    * @param companion the associated information
713    * @param flags modification flags
714    * @throws IllegalArgumentException when <code>null</code> or an empty string
715    * is passed for lineComment
716    * @throws UnsupportedOperationException if the method is not available for an
717    * implementation of the <code>TokenizerProperties</code> interface
718    * @see #addLineComment(String)
719    * @see #addLineComment(String, Object)
720    * @see #addLineComment(String, Object, int, int)
721    * @see #removeLineComment
722    */

723   public void addLineComment(String JavaDoc lineComment, Object JavaDoc companion, int flags)
724    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
725   
726   /**
727    * Registering a line comment with a set of flags and an associated flag mask.
728    *<br>
729    * The method is an extension to {@link #addLineComment(String, Object, int)}
730    * having a bitmask for the flags that are explicitely specified for the block
731    * comment property. All other flag values (states) should be taken from the
732    * <code>TokenizerProperty</code> instance or from the {@link Tokenizer}.
733    *
734    * @param lineComment the starting sequence of a line comment
735    * @param companion the associated information
736    * @param flags modification flags
737    * @param flagMask flags that have valid values in the parameter <code>flags</code>
738    * @throws IllegalArgumentException when <code>null</code> or an empty string
739    * is passed for keyword
740    * @throws UnsupportedOperationException if the method is not available for an
741    * implementation of the <code>TokenizerProperties</code> interface
742    * @see #addLineComment(String)
743    * @see #addLineComment(String, Object)
744    * @see #addLineComment(String, Object, int)
745    * @see #removeLineComment
746    */

747   public void addLineComment(String JavaDoc lineComment, Object JavaDoc companion, int flags, int flagMask)
748     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
749
750   /**
751    * Removing a certain line comment. If the given comment is not known to this
752    * <code>TokenizerProperties</code> instance, the method does nothing.
753    *<br>
754    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
755    * of type {@link TokenizerPropertyEvent#PROPERTY_REMOVED} to all registered
756    * listeners if a line comment property is actually removed.
757    *
758    * @param lineComment the starting sequence of the line comment
759    * @throws IllegalArgumentException when <code>null</code> or an empty string
760    * is passed
761    * @see #addLineComment(String)
762    * @see #addLineComment(String, Object)
763    * @see #addLineComment(String, Object, int)
764    */

765   public void removeLineComment(String JavaDoc lineComment)
766     throws IllegalArgumentException JavaDoc;
767   
768   /**
769    * Retrieving the associated object of a certain line comment. If the given
770    * starting sequence of a line comment is not known to the parser, then the
771    * method returns <code>null</code>.<br>
772    * To distinguish between an unknown line comment and companion-less line
773    * comment, use the method {@link #lineCommentExists}.
774    *
775    * @param lineComment the starting sequence of the line comment
776    * @return the object associated with the line comment
777    * @throws IllegalArgumentException when <code>null</code> or an empty string
778    * is passed for lineComment
779    * @see #lineCommentExists
780    */

781   public Object JavaDoc getLineCommentCompanion(String JavaDoc lineComment)
782     throws IllegalArgumentException JavaDoc;
783
784   /**
785    * Checks if the give line comment is known. The method accepts both empty and
786    * <code>null</code> strings for <code>lineComment</code> by returning
787    * <code>false</code>.
788    *
789    * @param lineComment the starting sequence of the line comment
790    * @return <code>true</code> if the line comment is known,
791    * <code>false</code> otherwise
792    */

793   public boolean lineCommentExists(String JavaDoc lineComment);
794   
795   /**
796    * Get the full description of a line comment property starting with the given
797    * prefix. The method returns <code>null</code> if the passed <code>lineComment</code>
798    * parameter cannot be mapped to a known line comment description ({@link #lineCommentExists}
799    * would return <code>false</code>).
800    *
801    * @param lineComment the starting sequence of the line comment
802    * @return the full line comment description or <code>null</code>
803    * @throws IllegalArgumentException when <code>null</code> or an empty string
804    * is passed
805    * @see #lineCommentExists
806    */

807   public TokenizerProperty getLineComment(String JavaDoc lineComment)
808     throws IllegalArgumentException JavaDoc;
809
810   /**
811    * This method returns an {@link java.util.Iterator} of {@link TokenizerProperty}
812    * objects. Each <code>TokenizerProperty</code> object contains one starting
813    * sequence of a line comment and its companion if it exists.
814    *
815    * @return enumeration of {@link TokenizerProperty} objects
816    */

817   public Iterator JavaDoc getLineComments();
818   
819   /**
820    * Registering a block comment with the parser. This version takes only the starting
821    * and finishing sequence of the block comment.<br>
822    * If the given starting sequence is already known to the parser, the block
823    * comment is simply re-registered. Using this method on a known block comment
824    * with an associated companion will remove that companion.
825    *<br>
826    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
827    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
828    * (see {@link #addTokenizerPropertyListener}) with the new block comment
829    * {@link TokenizerProperty} if the comment is a new one, or of type
830    * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the comment is
831    * re-registered.
832    *
833    * @param start the starting sequence of the block comment
834    * @param end the finishing sequence of the block comment
835    * @throws IllegalArgumentException when <code>null</code> or an empty string
836    * is passed for start or end
837    * @throws UnsupportedOperationException if the method is not available for an
838    * implementation of the <code>TokenizerProperties</code> interface
839    * @see #addBlockComment(String, String, Object)
840    * @see #addBlockComment(String, String, Object, int)
841    * @see #removeBlockComment
842    */

843   public void addBlockComment(String JavaDoc start, String JavaDoc end)
844     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
845   
846   /**
847    * Registering a block comment with the parser. Beside the obviously nessecary
848    * starting and finishing sequence of the block comment, it takes an object that
849    * is associated with the block comment, called the companion.<br>
850    * If the given starting sequence is already known to the parser, the block
851    * comment is simply re-registered. Using this method on a known block comment
852    * with an associated companion will replace that companion against the given
853    * one.
854    *<br>
855    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
856    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
857    * (see {@link #addTokenizerPropertyListener}) with the new block comment
858    * {@link TokenizerProperty} if the comment is a new one, or of type
859    * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the comment is
860    * re-registered.
861    *
862    * @param start the starting sequence of the block comment
863    * @param end the finishing sequence of the block comment
864    * @param companion information object associated with this block comment
865    * @throws IllegalArgumentException when <code>null</code> or an empty string
866    * is passed for start or end
867    * @throws UnsupportedOperationException if the method is not available for an
868    * implementation of the <code>TokenizerProperties</code> interface
869    * @see #addBlockComment(String, String)
870    * @see #addBlockComment(String, String, Object, int)
871    * @see #removeBlockComment
872    */

873   public void addBlockComment(String JavaDoc start, String JavaDoc end, Object JavaDoc companion)
874     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
875   
876   /**
877    * Registering a block comment. Beside the obviously nessecary
878    * starting and finishing sequence of the block comment, it takes an object that
879    * is associated with the block comment, called the companion.
880    *<br>
881    * If the given starting sequence is already known to the parser, the block
882    * comment is simply re-registered. Using this method on a known block comment
883    * with an associated companion will replace that companion against the given
884    * one.
885    *<br>
886    * This version of <code>addBlockComment</code> supports a bitmask of the
887    * {@link Flags} to modify the general tokenizer settings (see
888    * {@link #setParseFlags}) for this special element.
889    *<br>
890    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
891    * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
892    * (see {@link #addTokenizerPropertyListener}) with the new block comment
893    * {@link TokenizerProperty} if the comment is a new one, or of type
894    * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the comment is
895    * re-registered.
896    *<br>
897    * A call to this method is equivalent to
898    * <code>addBlockComment(start, end, companion, flags, flags)</code>.
899    *
900    * @param start the starting sequence of the block comment
901    * @param end the finishing sequence of the block comment
902    * @param companion information object associated with this block comment
903    * @param flags modification flags
904    * @throws IllegalArgumentException when <code>null</code> or an empty string
905    * is passed for start or end
906    * @throws UnsupportedOperationException if the method is not available for an
907    * implementation of the <code>TokenizerProperties</code> interface
908    * @see #addBlockComment(String, String)
909    * @see #addBlockComment(String, String, Object)
910    * @see #addBlockComment(String, String, Object, int, int)
911    * @see #removeBlockComment
912    */

913   public void addBlockComment(String JavaDoc start, String JavaDoc end, Object JavaDoc companion, int flags)
914     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
915   
916   /**
917    * Registering a block comment with a set of flags and an associated flag mask.
918    *<br>
919    * The method is an extension to {@link #addBlockComment(String, String, Object, int)}
920    * having a bitmask for the flags that are explicitely specified for the block
921    * comment property. All other flag values (states) should be taken from the
922    * <code>TokenizerProperty</code> instance or from the {@link Tokenizer}.
923    *
924    * @param start the starting sequence of the block comment
925    * @param end the finishing sequence of the block comment
926    * @param companion information object associated with this block comment
927    * @param flags modification flags
928    * @param flagMask flags that have valid values in the parameter <code>flags</code>
929    * @throws IllegalArgumentException when <code>null</code> or an empty string
930    * is passed for keyword
931    * @throws UnsupportedOperationException if the method is not available for an
932    * implementation of the <code>TokenizerProperties</code> interface
933    * @see #addBlockComment(String, String)
934    * @see #addBlockComment(String, String, Object)
935    * @see #addBlockComment(String, String, Object, int)
936    * @see #removeBlockComment
937    */

938   public void addBlockComment(String JavaDoc start, String JavaDoc end, Object JavaDoc companion, int flags, int flagMask)
939     throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
940
941   /**
942    * Removing a certain block comment. Only the starting sequence is nessecary
943    * to identify the block comment.
944    *<br>
945    * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
946    * of type {@link TokenizerPropertyEvent#PROPERTY_REMOVED} to all registered
947    * listeners if a block comment property is actually removed.
948    *
949    * @param start the starting sequence of the block comment
950    * @throws IllegalArgumentException when <code>null</code> or an empty string
951    * is passed
952    */

953   public void removeBlockComment(String JavaDoc start)
954     throws IllegalArgumentException JavaDoc;
955   
956   /**
957    * Retrieving a certain block comment. Only the starting sequence is nessecary
958    * to identify the block comment. If the block comment is not known to the
959    * parser, then <code>null</code> is returned.<br>
960    * To distinguish between an unknown line comment and companion-less line
961    * comment, use the method {@link #lineCommentExists}.
962    *
963    * @param start the starting sequence of the block comment
964    * @return the associated object of the block comment
965    * @throws IllegalArgumentException when <code>null</code> or an empty string
966    * is passed
967    */

968   public Object JavaDoc getBlockCommentCompanion(String JavaDoc start)
969     throws IllegalArgumentException JavaDoc;
970   
971   /**
972    * Checks if the give block comment is known. Only the starting sequence is
973    * nessecary to identify the block comment.
974    * The method accepts both empty and <code>null</code> strings for <code>start</code>
975    * by returning <code>false</code>.
976    *
977    * @param start the starting sequence of the block comment
978    * @return <code>true</code> if the block comment is known,
979    * <code>false</code> otherwise
980    */

981   public boolean blockCommentExists(String JavaDoc start);
982   
983   /**
984    * Get the full description of a block comment property starting with the given
985    * prefix. The method returns <code>null</code> if the passed <code>start</code>
986    * parameter cannot be mapped to a known block comment description ({@link #blockCommentExists}
987    * would return <code>false</code>).
988    *
989    * @param start the starting sequence of the block comment
990    * @return the full block comment description or <code>null</code>
991    * @throws IllegalArgumentException when <code>null</code> or an empty string
992    * is passed
993    */

994   public TokenizerProperty getBlockComment(String JavaDoc start)
995     throws IllegalArgumentException JavaDoc;
996
997   /**
998    * This method returns an {@link java.util.Iterator} of {@link TokenizerProperty}
999    * objects. Each <code>TokenizerProperty</code> object contains the starting and
1000   * finishing sequence of a block comment and the companion if it exists.
1001   *
1002   * @return enumeration of {@link TokenizerProperty} objects
1003   */

1004  public Iterator JavaDoc getBlockComments();
1005  
1006
1007  //---------------------------------------------------------------------------
1008
// special sequences
1009
//
1010

1011  /**
1012   * Registering a special sequence of characters. Such sequences may be multicharacter
1013   * operators like the shift operators in Java.
1014   *<br>
1015   * Unlike keywords, special sequences act also as separators between other tokens.
1016   * If one special sequence is the prefix of other special sequences (in Java the
1017   * shift operator <code>&gt;&gt;</code> is the prefix of the shift operator
1018   * <code>&gt;&gt;&gt;</code>), always the longest possible match is returned.
1019   * Testing on special sequences takes place after whitespaces and comments are ruled
1020   * out, but before ordinary separators are tested.
1021   *<br>
1022   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1023   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1024   * (see {@link #addTokenizerPropertyListener}) with the new special sequence
1025   * {@link TokenizerProperty} if the sequence is a new one, or of type
1026   * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the sequence is
1027   * re-registered.
1028   *
1029   * @param specSeq special sequence to register
1030   * @throws IllegalArgumentException when <code>null</code> or an empty string
1031   * is passed
1032   * @throws UnsupportedOperationException if the method is not available for an
1033   * implementation of the <code>TokenizerProperties</code> interface
1034   * @see #addSpecialSequence(String, Object)
1035   * @see #addSpecialSequence(String, Object, int)
1036   * @see #removeSpecialSequence
1037   */

1038  public void addSpecialSequence(String JavaDoc specSeq)
1039    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1040  
1041  /**
1042   * Registering a special sequence of characters. Such sequences may be multicharacter
1043   * operators like the shift operators in Java.
1044   *<br>
1045   * Unlike keywords, special sequences act also as separators between other tokens.
1046   * If one special sequence is the prefix of other special sequences (in Java the
1047   * shift operator <code>&gt;&gt;</code> is the prefix of the shift operator
1048   * <code>&gt;&gt;&gt;</code>), always the longest possible match is returned.
1049   * Testing on special sequences takes place after whitespaces and comments are ruled
1050   * out, but before ordinary separators are tested.
1051   * This form of <code>addSpecialSequence</code> also takes an object associated with
1052   * the special sequence, called the companion.
1053   *<br>
1054   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1055   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1056   * (see {@link #addTokenizerPropertyListener}) with the new special sequence
1057   * {@link TokenizerProperty} if the sequence is a new one, or of type
1058   * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the sequence is
1059   * re-registered.
1060   *
1061   * @param specSeq special sequence to register
1062   * @param companion information object associated with this special sequence
1063   * @throws IllegalArgumentException when <code>null</code> or an empty string
1064   * is passed for specSeq
1065   * @throws UnsupportedOperationException if the method is not available for an
1066   * implementation of the <code>TokenizerProperties</code> interface
1067   * @see #addSpecialSequence(String)
1068   * @see #addSpecialSequence(String, Object, int)
1069   * @see #removeSpecialSequence
1070   */

1071  public void addSpecialSequence(String JavaDoc specSeq, Object JavaDoc companion)
1072    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1073  
1074  /**
1075   * Registering a special sequence of characters. Such sequences may be multicharacter
1076   * operators like the shift operators in Java.
1077   *<br>
1078   * Unlike keywords, special sequences act also as separators between other tokens.
1079   * If one special sequence is the prefix of other special sequences (in Java the
1080   * shift operator <code>&gt;&gt;</code> is the prefix of the shift operator
1081   * <code>&gt;&gt;&gt;</code>), always the longest possible match is returned.
1082   * Testing on special sequences takes place after whitespaces and comments are ruled
1083   * out, but before ordinary separators are tested.
1084   * This form of <code>addSpecialSequence</code> also takes an object associated with
1085   * the special sequence, called the companion.
1086   *<br>
1087   * This version of <code>addSpecialSequence</code> supports a bitmask of the
1088   * {@link Flags} to modify the general tokenizer settings (see
1089   * {@link #setParseFlags}) for this special element.
1090   *<br>
1091   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1092   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1093   * (see {@link #addTokenizerPropertyListener}) with the new special sequence
1094   * {@link TokenizerProperty} if the sequence is a new one, or of type
1095   * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the sequence is
1096   * re-registered.
1097   *<br>
1098   * A call to this method is equivalent to <code>addSpecialSequence(keyword, companion, flags, flags)</code>.
1099   *
1100   * @param specSeq special sequence to register
1101   * @param companion information object associated with this special sequence
1102   * @param flags modification flags
1103   * @throws IllegalArgumentException when <code>null</code> or an empty string
1104   * is passed for specSeq
1105   * @throws UnsupportedOperationException if the method is not available for an
1106   * implementation of the <code>TokenizerProperties</code> interface
1107   * @see #addSpecialSequence(String)
1108   * @see #addSpecialSequence(String, Object)
1109   * @see #addSpecialSequence(String, Object, int, int)
1110   * @see #removeSpecialSequence
1111   */

1112  public void addSpecialSequence(String JavaDoc specSeq, Object JavaDoc companion, int flags)
1113    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1114  
1115  /**
1116   * Registering a special sequence with a set of flags and an associated flag mask.
1117   *<br>
1118   * The method is an extension to {@link #addSpecialSequence(String, Object, int)} having
1119   * a bitmask for the flags that are explicitely specified for the special sequence
1120   * property. All other flag values (states) should be taken from the
1121   * <code>TokenizerProperty</code> instance or from the {@link Tokenizer}.
1122   *
1123   * @param specSeq special sequence to register
1124   * @param companion information object associated with this special sequence
1125   * @param flags modification flags
1126   * @param flagMask flags that have valid values in the parameter <code>flags</code>
1127   * @throws IllegalArgumentException when <code>null</code> or an empty string
1128   * is passed for keyword
1129   * @throws UnsupportedOperationException if the method is not available for an
1130   * implementation of the <code>TokenizerProperties</code> interface
1131   * @see #addSpecialSequence(String)
1132   * @see #addSpecialSequence(String, Object)
1133   * @see #addSpecialSequence(String, Object, int)
1134   * @see #removeSpecialSequence
1135   */

1136  public void addSpecialSequence(String JavaDoc specSeq, Object JavaDoc companion, int flags, int flagMask)
1137    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1138
1139  /**
1140   * Removing a special sequence property from the store. If the special sequence
1141   * is not known, the method does nothing.
1142   *<br>
1143   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1144   * of type {@link TokenizerPropertyEvent#PROPERTY_REMOVED} to all registered
1145   * listeners if a special sequence property is actually removed.
1146   *
1147   * @param specSeq sequence to remove
1148   * @throws IllegalArgumentException when <code>null</code> or an empty string
1149   * is passed
1150   * @see #addSpecialSequence(String)
1151   * @see #addSpecialSequence(String, Object)
1152   * @see #addSpecialSequence(String, Object, int)
1153   */

1154  public void removeSpecialSequence(String JavaDoc specSeq)
1155    throws IllegalArgumentException JavaDoc;
1156  
1157  /**
1158   * Retrieving the companion of the given special sequence. If the special
1159   * sequence doesn't exist the method returns <code>null</code>.
1160   *
1161   * @param specSeq sequence to remove
1162   * @return the object associated with the special sequence
1163   * @throws IllegalArgumentException when <code>null</code> or an empty string
1164   * is passed
1165   */

1166  public Object JavaDoc getSpecialSequenceCompanion(String JavaDoc specSeq)
1167    throws IllegalArgumentException JavaDoc;
1168
1169  /**
1170   * This method returns an {@link java.util.Iterator} of {@link TokenizerProperty}
1171   * objects. Each <code>TokenizerProperty</code> object contains a special
1172   * sequence and the companion if it exists.
1173   *
1174   * @return enumeration of {@link TokenizerProperty} objects
1175   */

1176  public Iterator JavaDoc getSpecialSequences();
1177  
1178  /**
1179   * Checks if the given special sequence is known to the <code>TokenizerProperties</code>.
1180   * The method accepts both empty and <code>null</code> strings for <code>specSeq</code>
1181   * by returning <code>false</code>.
1182   *
1183   * @param specSeq sequence to check
1184   * @return <code>true</code> if the block comment is known,
1185   * <code>false</code> otherwise
1186   */

1187  public boolean specialSequenceExists(String JavaDoc specSeq);
1188  
1189  /**
1190   * Get the full description of a special sequence property. The method returns
1191   * <code>null</code> if the passed <code>specSeq</code> image is unknown
1192   * ({@link #specialSequenceExists} would return <code>false</code>).
1193   *
1194   * @param specSeq sequence to find
1195   * @return the full sequence description or <code>null</code>
1196   * @throws IllegalArgumentException when <code>null</code> or an empty string
1197   * is passed
1198   */

1199  public TokenizerProperty getSpecialSequence(String JavaDoc specSeq)
1200    throws IllegalArgumentException JavaDoc;
1201
1202
1203  //---------------------------------------------------------------------------
1204
// keyword properties
1205
//
1206

1207  /**
1208   * Registering a keyword. If the keyword is already known to the <code>TokenizerProperties</code>
1209   * then it is simply re-registered. If the known keyword has an associated
1210   * companion it will be removed.
1211   *<br>
1212   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1213   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1214   * (see {@link #addTokenizerPropertyListener}) with the new keyword
1215   * {@link TokenizerProperty} if the keyword is a new one, or of type
1216   * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the keyword is
1217   * re-registered.
1218   *
1219   * @param keyword keyword to register
1220   * @throws IllegalArgumentException when <code>null</code> or an empty string
1221   * is passed
1222   * @throws UnsupportedOperationException if the method is not available for an
1223   * implementation of the <code>TokenizerProperties</code> interface
1224   * @see #addKeyword(String, Object)
1225   * @see #addKeyword(String, Object, int)
1226   * @see #removeKeyword
1227   */

1228  public void addKeyword(String JavaDoc keyword)
1229    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1230  
1231  /**
1232   * Registering a keyword. If the keyword is already known to the <code>TokenizerProperties</code>
1233   * then it is simply re-registered. If the known keyword has an associated
1234   * companion it will be replaced against the given one.
1235   *<br>
1236   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1237   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1238   * (see {@link #addTokenizerPropertyListener}) with the new keyword
1239   * {@link TokenizerProperty} if the keyword is a new one, or of type
1240   * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the keyword is
1241   * re-registered.
1242   *
1243   * @param keyword keyword to register
1244   * @param companion information object associated with this keyword
1245   * @throws IllegalArgumentException when <code>null</code> or an empty string
1246   * is passed for <code>keyword</code>
1247   * @throws UnsupportedOperationException if the method is not available for an
1248   * implementation of the <code>TokenizerProperties</code> interface
1249   * @see #addKeyword(String)
1250   * @see #addKeyword(String, Object, int)
1251   * @see #removeKeyword
1252   */

1253  public void addKeyword(String JavaDoc keyword, Object JavaDoc companion)
1254    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1255  
1256  /**
1257   * Registering a keyword. If the keyword is already known to the <code>TokenizerProperties</code>
1258   * then it is simply re-registered. If the known keyword has an associated
1259   * companion it will be replaced against the given one.
1260   *<br>
1261   * This version of <code>addKeyword</code> supports a bitmask of the
1262   * {@link Flags} to modify the general tokenizer settings (see
1263   * {@link #setParseFlags}) for this special element.
1264   *<br>
1265   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1266   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1267   * (see {@link #addTokenizerPropertyListener}) with the new keyword
1268   * {@link TokenizerProperty} if the keyword is a new one, or of type
1269   * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} if the keyword is
1270   * re-registered.
1271   *<br>
1272   * A call to this method is equivalent to <code>addKeyword(keyword, companion, flags, flags)</code>.
1273   *
1274   * @param keyword keyword to register
1275   * @param companion information object associated with this keyword
1276   * @param flags modification flags
1277   * @throws IllegalArgumentException when <code>null</code> or an empty string
1278   * is passed for keyword
1279   * @throws UnsupportedOperationException if the method is not available for an
1280   * implementation of the <code>TokenizerProperties</code> interface
1281   * @see #addKeyword(String)
1282   * @see #addKeyword(String, Object)
1283   * @see #removeKeyword
1284   */

1285  public void addKeyword(String JavaDoc keyword, Object JavaDoc companion, int flags)
1286    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1287  
1288  /**
1289   * Registering a keyword with a set of flags and an associated flag mask..
1290   *<br>
1291   * The method is an extension to {@link #addKeyword(String, Object, int)} having
1292   * a bitmask for the flags that are explicitely specified for the pattern
1293   * property. All other flag values (states) should be taken from the
1294   * <code>TokenizerProperty</code> instance or from the {@link Tokenizer}.
1295   *
1296   * @param keyword keyword to register
1297   * @param companion information object associated with this keyword
1298   * @param flags modification flags
1299   * @param flagMask flags that have valid values in the parameter <code>flags</code>
1300   * @throws IllegalArgumentException when <code>null</code> or an empty string
1301   * is passed for keyword
1302   * @throws UnsupportedOperationException if the method is not available for an
1303   * implementation of the <code>TokenizerProperties</code> interface
1304   * @see #addKeyword(String)
1305   * @see #addKeyword(String, Object)
1306   * @see #removeKeyword
1307   */

1308  public void addKeyword(String JavaDoc keyword, Object JavaDoc companion, int flags, int flagMask)
1309    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1310
1311  /**
1312   * Removing a keyword property from the store. If the keyword is not known
1313   * then the method does nothing.
1314   *<br>
1315   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1316   * of type {@link TokenizerPropertyEvent#PROPERTY_REMOVED} to all registered
1317   * listeners if a keyword property is actually removed.
1318   *
1319   * @param keyword keyword to remove
1320   * @throws IllegalArgumentException when <code>null</code> or an empty string
1321   * is passed
1322   * @see #addKeyword(String)
1323   * @see #addKeyword(String, Object)
1324   * @see #addKeyword(String, Object, int)
1325   */

1326  public void removeKeyword(String JavaDoc keyword)
1327    throws IllegalArgumentException JavaDoc;
1328  
1329  /**
1330   * Retrieving the companion of the given special sequence. If the special
1331   * sequence doesn't exist the method returns <code>null</code>.
1332   *
1333   * @param keyword keyword thats companion is sought
1334   * @return the object associated with the keyword
1335   * @throws IllegalArgumentException when <code>null</code> or an empty string
1336   * is passed
1337   */

1338  public Object JavaDoc getKeywordCompanion(String JavaDoc keyword)
1339    throws IllegalArgumentException JavaDoc;
1340
1341  /**
1342   * This method returns an {@link java.util.Iterator} of {@link TokenizerProperty}
1343   * objects. Each <code>TokenizerProperty</code> object contains a keyword and
1344   * the companion if it exists.
1345   *
1346   * @return enumeration of {@link TokenizerProperty} objects
1347   */

1348  public Iterator JavaDoc getKeywords();
1349  
1350  /**
1351   * Checks if the given keyword is known to the <code>TokenizerProperties</code>.
1352   * The method accepts both empty and <code>null</code> strings for <code>keyword</code>
1353   * by returning <code>false</code>.
1354   *
1355   * @param keyword keyword to search
1356   * @return <code>true</code> if the keyword is known,
1357   * <code>false</code> otherwise
1358   */

1359  public boolean keywordExists(String JavaDoc keyword);
1360
1361  /**
1362   * Get the full description of a keyword property. The method returns
1363   * <code>null</code> if the passed <code>keyword</code> image is unknown
1364   * ({@link #keywordExists} would return <code>false</code>).
1365   *
1366   * @param keyword keyword to search
1367   * @return the full sequence description or <code>null</code>
1368   * @throws IllegalArgumentException when <code>null</code> or an empty string
1369   * is passed
1370   */

1371  public TokenizerProperty getKeyword(String JavaDoc keyword)
1372    throws IllegalArgumentException JavaDoc;
1373
1374
1375  //---------------------------------------------------------------------------
1376
// pattern properties
1377
//
1378

1379  /**
1380   * Registering a pattern. Pattern can describe identifiers, numbers etc. They
1381   * provide a way to deal with token that cannot be enumerated like keywords.
1382   *<br>
1383   * A pattern is usually a regular expression that is used by {@link java.util.regex.Pattern}.
1384   * But implementations of {@link de.susebox.jtopas.spi.PatternHandler} may use
1385   * other pattern syntaxes, for example the simpler syntax used for file path
1386   * matching.
1387   *<br>
1388   * Pattern are applied to input data in the order of their registration. The
1389   * first matching pattern stops the iteration.
1390   *<br>
1391   * Pattern matching is a rather complex operation that may have a significant
1392   * impact on the speed of a {@link Tokenizer}. On the other hand, pattern may
1393   * be used instead of string or comment descriptions (see {@link #addString} etc.)
1394   * or if a pattern matching would be performed after the return of a token of
1395   * type {@link Token#NORMAL}.
1396   *<br>
1397   * If the given pattern is already known to the parser, it will simply be
1398   * re-registered. Using this method on a known pattern with an associated companion
1399   * will remove that companion.
1400   *<br>
1401   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1402   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1403   * (see {@link #addTokenizerPropertyListener}) with the new pattern {@link TokenizerProperty}
1404   * if the pattern is a new one, or of type {@link TokenizerPropertyEvent#PROPERTY_MODIFIED}
1405   * if the pattern is re-registered.
1406   *
1407   * @param pattern the regular expression to be added
1408   * @throws IllegalArgumentException when <code>null</code> or an empty pattern
1409   * is passed
1410   * @throws UnsupportedOperationException if the method is not available for an
1411   * implementation of the <code>TokenizerProperties</code> interface
1412   * @see #removePattern
1413   * @see #addPattern(String, Object)
1414   * @see #addPattern(String, Object, int)
1415   */

1416  public void addPattern(String JavaDoc pattern)
1417    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1418
1419  /**
1420   * Registering a pattern with an associated object. See the description of the
1421   * {@link #addPattern(String)} for details on pattern.
1422   *<br>
1423   * If the given pattern is already known to the parser, it will simply be
1424   * re-registered. The associated companion will be replaced against the new one.
1425   *<br>
1426   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1427   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1428   * (see {@link #addTokenizerPropertyListener}) with the new pattern {@link TokenizerProperty}
1429   * if the pattern is a new one, or of type {@link TokenizerPropertyEvent#PROPERTY_MODIFIED}
1430   * if the pattern is re-registered.
1431   *
1432   * @param pattern the regular expression to be added
1433   * @param companion information object associated with this pattern
1434   * @throws IllegalArgumentException when <code>null</code> or an empty pattern
1435   * is passed
1436   * @throws UnsupportedOperationException if the method is not available for an
1437   * implementation of the <code>TokenizerProperties</code> interface
1438   * @see #removePattern
1439   * @see #addPattern(String)
1440   * @see #addPattern(String, Object, int)
1441   */

1442  public void addPattern(String JavaDoc pattern, Object JavaDoc companion)
1443    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1444  
1445  /**
1446   * Registering a pattern with an associated object. See the description of the
1447   * {@link #addPattern(String)} for details on pattern.
1448   *<br>
1449   * If the given pattern is already known to the parser, it will simply be
1450   * re-registered. The associated companion will be replaced against the new one.
1451   *<br>
1452   * This version of <code>addPattern</code> supports a bitmask of the
1453   * {@link Flags} to modify the general tokenizer settings (see
1454   * {@link #setParseFlags}) for this special pattern.
1455   *<br>
1456   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1457   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} to all registered listeners
1458   * (see {@link #addTokenizerPropertyListener}) with the new pattern {@link TokenizerProperty}
1459   * if the pattern is a new one, or of type {@link TokenizerPropertyEvent#PROPERTY_MODIFIED}
1460   * if the pattern is re-registered.
1461   *<br>
1462   * A call to this method is equivalent to <code>addPattern(pattern, companion, flags, flags)</code>.
1463   *
1464   * @param pattern the regular expression to be added
1465   * @param companion information object associated with this keyword
1466   * @param flags modification flags
1467   * @throws IllegalArgumentException when <code>null</code> or an empty pattern
1468   * is passed
1469   * @throws UnsupportedOperationException if the method is not available for an
1470   * implementation of the <code>TokenizerProperties</code> interface
1471   * @see #removePattern
1472   * @see #addPattern(String)
1473   * @see #addPattern(String, Object)
1474   */

1475  public void addPattern(String JavaDoc pattern, Object JavaDoc companion, int flags)
1476    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1477  
1478  /**
1479   * Registering a pattern with an associated object and explicitely given flags.
1480   * See the description of the {@link #addPattern(String)} for details on pattern.
1481   *<br>
1482   * The method is an extension to {@link #addPattern(String, Object, int)} having
1483   * a bitmask for the flags that are specified for the pattern property.
1484   * All other flag values (states) should be taken from the
1485   * <code>TokenizerProperty</code> instance or from the {@link Tokenizer}.
1486   *
1487   * @param pattern the regular expression to be added
1488   * @param companion information object associated with this keyword
1489   * @param flags values for modification flags
1490   * @param flagMask flags that have valid values in the parameter <code>flags</code>
1491   * @throws IllegalArgumentException when <code>null</code> or an empty pattern
1492   * is passed
1493   * @throws UnsupportedOperationException if the method is not available for an
1494   * implementation of the <code>TokenizerProperties</code> interface
1495   * @see #removePattern
1496   * @see #addPattern(String)
1497   * @see #addPattern(String, Object)
1498   * @see #addPattern(String, Object, int)
1499   */

1500  public void addPattern(String JavaDoc pattern, Object JavaDoc companion, int flags, int flagMask)
1501    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1502  
1503  /**
1504   * Removing a pattern. The method does nothing if the given pattern is not known
1505   * to this <code>TokenizerProperties</code> instance. The method may throw an
1506   * {@link java.lang.IllegalArgumentException} if the given pattern is
1507   * <code>null</code> or empty.
1508   *<br>
1509   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1510   * of type {@link TokenizerPropertyEvent#PROPERTY_REMOVED} to all registered
1511   * listeners (see {@link #addTokenizerPropertyListener}) if a pattern is actually
1512   * removed.
1513   *
1514   * @param pattern the regular expression to be removed
1515   * @throws IllegalArgumentException when <code>null</code> or an empty string
1516   * is passed
1517   */

1518  public void removePattern(String JavaDoc pattern)
1519    throws IllegalArgumentException JavaDoc;
1520  
1521  /**
1522   * Retrieving the information associated with a given pattern. If the pattern
1523   * is not known to the parser, <code>null</code> will be returned.
1524   *<br>
1525   * If You need to know if a pattern is known to this <code>TokenizerProperties</code>
1526   * instance with or without a companion, use the method {@link #patternExists}
1527   * instead.
1528   *
1529   * @param pattern the regular expression to be removed
1530   * @return the associated information or <code>null</code>
1531   * @throws IllegalArgumentException when <code>null</code> or an emtpy pattern
1532   * is passed
1533   */

1534  public Object JavaDoc getPatternCompanion(String JavaDoc pattern)
1535    throws IllegalArgumentException JavaDoc;
1536  
1537  /**
1538   * Checks if the given pattern is known to the parser. The method accepts both
1539   * empty and <code>null</code> strings for <code>pattern</code> by returning
1540   * <code>false</code>.
1541   *<br>
1542   * Note that there is no choice of parsing flags (different to the
1543   * {@link #addString(String, String, String, Object, int)} method), since it
1544   * makes generally no sense to "overload" properties.
1545   *
1546   * @param pattern the regular expression to be looked for
1547   * @return <code>true</code> if the pattern is registered,
1548   * <code>false</code> otherwise
1549   */

1550  public boolean patternExists(String JavaDoc pattern);
1551  
1552  /**
1553   * Get the full description of a pattern property. The method returns <code>null</code>
1554   * if the passed <code>pattern</code> parameter cannot be mapped to a known
1555   * pattern description ({@link #patternExists} would return <code>false</code>).
1556   *
1557   * @param pattern the regular expression to be looked for
1558   * @return the full pattern description or <code>null</code>
1559   * @throws IllegalArgumentException when <code>null</code> or an emtpy pattern
1560   * is passed
1561   */

1562  public TokenizerProperty getPattern(String JavaDoc pattern)
1563    throws IllegalArgumentException JavaDoc;
1564
1565  /**
1566   * This method returns an {@link java.util.Iterator} of {@link TokenizerProperty}
1567   * objects. Each <code>TokenizerProperty</code> object contains a pattern and
1568   * its companion if such an associated object exists.
1569   *
1570   * @return enumeration of {@link TokenizerProperty} objects
1571   */

1572  public Iterator JavaDoc getPatterns();
1573  
1574
1575  //---------------------------------------------------------------------------
1576
// generic property methods
1577
//
1578

1579  /**
1580   * Registering a {@link TokenizerProperty}. This can be a keyword, comment etc.,
1581   * even whitespaces, separators and property types not defined in {@link Token}.
1582   *<br>
1583   * If the property is already known to this <code>TokenizerProperties</code>
1584   * instance then it is simply re-registered.
1585   *<br>
1586   * An implementation of this interface should fire a {@link TokenizerPropertyEvent}
1587   * of type {@link TokenizerPropertyEvent#PROPERTY_ADDED} or
1588   * {@link TokenizerPropertyEvent#PROPERTY_MODIFIED} to all registered listeners
1589   * (see {@link #addTokenizerPropertyListener}).
1590   *<br>
1591   * An implementation of this interface may or may not support adding of
1592   * whitespaces and separators.
1593   *
1594   * @param property property to register
1595   * @throws IllegalArgumentException when <code>null</code>, an incomplete or
1596   * otherwise unusable property is passed
1597   * @throws UnsupportedOperationException if the method is not available for an
1598   * implementation of the <code>TokenizerProperties</code> interface
1599   */

1600  public void addProperty(TokenizerProperty property)
1601    throws IllegalArgumentException JavaDoc, UnsupportedOperationException JavaDoc;
1602  
1603  /**
1604   * Deregistering a {@link TokenizerProperty} from the store. If the property is
1605   * not known the method does nothing.
1606   *
1607   * @param property property to register
1608   * @throws IllegalArgumentException when <code>null</code>, an incomplete or
1609   * otherwise unusable property is passed
1610   */

1611  public void removeProperty(TokenizerProperty property)
1612    throws IllegalArgumentException JavaDoc;
1613  
1614  /**
1615   * This method returns an {@link java.util.Iterator} of {@link TokenizerProperty}
1616   * objects.
1617   *
1618   * @return enumeration of {@link TokenizerProperty} objects
1619   */

1620  public Iterator JavaDoc getProperties();
1621  
1622  /**
1623   * Checks if the given {@link TokenizerProperty} is known to this <code>TokenizerProperties</code>
1624   * instance. The method compares the characteristics given in <code>property</code>
1625   * against all known properties.
1626   *<br>
1627   * The method accepts <code>null</code> for <code>property</code> by returning
1628   * <code>false</code>.
1629   *
1630   * @param property the property to search
1631   * @return <code>true</code> if the property is known,
1632   * <code>false</code> otherwise
1633   */

1634  public boolean propertyExists(TokenizerProperty property);
1635
1636  
1637  //---------------------------------------------------------------------------
1638
// property change event handling
1639
//
1640

1641  /**
1642   * Registering a new {@link TokenizerPropertyListener}. An implementation of
1643   * the <code>TokenizerProperties</code> interface should call the approbriate
1644   * methods in the <code>TokenizerPropertyListener</code> interface for all
1645   * registered listeners whenever a {@link TokenizerProperty} is added, removed
1646   * or modified.
1647   *<br>
1648   * Adding is done by one of the <code>add...</code> calls like {@link #addKeyword}
1649   * or {@link #addString}.
1650   *<br>
1651   * Modifications are re-registering of keywords, comments etc. regardless if
1652   * companions or parse flags actually changed. Also, {@link #setWhitespaces}
1653   * and {@link #setSeparators} are modifications.
1654   *<br>
1655   * Removals are performed by the <code>remove...</code> calls, for instance
1656   * {@link #removeKeyword}.
1657   *<br>
1658   * Similar to the policy of event listener registration in the JDK, passing
1659   * <code>null</code> does nothing.
1660   *
1661   * @param listener the new {@link TokenizerPropertyListener}
1662   * @see #removeTokenizerPropertyListener
1663   */

1664  public void addTokenizerPropertyListener(TokenizerPropertyListener listener);
1665  
1666  /**
1667   * Removing a listener from the list of registered {@link TokenizerPropertyListener}
1668   * instances. If the given listener is <code>null</code> or unknown, nothing
1669   * is done.
1670   *
1671   * @param listener the {@link TokenizerPropertyListener} to deregister
1672   * @see #addTokenizerPropertyListener
1673   */

1674  public void removeTokenizerPropertyListener(TokenizerPropertyListener listener);
1675}
1676
Popular Tags