Java > Open Source Codes > org > enhydra > apache > xerces > readers > XMLEntityHandler


1 /*
2  * The Apache Software License, Version 1.1
3  *
4  *
5  * Copyright (c) 1999,2000 The Apache Software Foundation. All rights
6  * reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  * notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  * notice, this list of conditions and the following disclaimer in
17  * the documentation and/or other materials provided with the
18  * distribution.
19  *
20  * 3. The end-user documentation included with the redistribution,
21  * if any, must include the following acknowledgment:
22  * "This product includes software developed by the
23  * Apache Software Foundation (http://www.apache.org/)."
24  * Alternately, this acknowledgment may appear in the software itself,
25  * if and wherever such third-party acknowledgments normally appear.
26  *
27  * 4. The names "Xerces" and "Apache Software Foundation" must
28  * not be used to endorse or promote products derived from this
29  * software without prior written permission. For written
30  * permission, please contact apache@apache.org.
31  *
32  * 5. Products derived from this software may not be called "Apache",
33  * nor may "Apache" appear in their name, without prior written
34  * permission of the Apache Software Foundation.
35  *
36  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
37  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
38  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
39  * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
42  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
43  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
44  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
45  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
46  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
47  * SUCH DAMAGE.
48  * ====================================================================
49  *
50  * This software consists of voluntary contributions made by many
51  * individuals on behalf of the Apache Software Foundation and was
52  * originally based on software copyright (c) 1999, International
53  * Business Machines, Inc., http://www.apache.org. For more
54  * information on the Apache Software Foundation, please see
55  * <http://www.apache.org/>.
56  */
57
58 package org.enhydra.apache.xerces.readers;
59
60 import org.enhydra.apache.xerces.utils.QName;
61 import org.enhydra.apache.xerces.utils.StringPool;
62 import org.xml.sax.InputSource ;
63 import org.xml.sax.Locator ;
64
65 /**
66  * This is the interface used for entity management. This interface
67  * is typically implemented by the "parser" class to provide entity
68  * management services for the scanner classes.
69  *
70  * @version $Id: XMLEntityHandler.java,v 1.2 2005/01/26 08:28:44 jkjome Exp $
71  */
72 public interface XMLEntityHandler extends Locator {
73
74     /**
75      * Special return values for scanCharRef method. The normal return
76      * value is a unicode character. These error conditions are defined
77      * using invalid XML unicode code points.
78      */
79     public static final int
80         CHARREF_RESULT_SEMICOLON_REQUIRED = -1,
81         CHARREF_RESULT_INVALID_CHAR = -2,
82         CHARREF_RESULT_OUT_OF_RANGE = -3;
83
84     /**
85      * Special return values for scanStringLiteral method. The normal
86      * return value is a StringPool handle. These error conditions are
87      * defined using invalid indices.
88      */
89     public static final int
90         STRINGLIT_RESULT_QUOTE_REQUIRED = -1,
91         STRINGLIT_RESULT_INVALID_CHAR = -2;
92
93     /**
94      * Special return values for scanAttValue method. The normal return
95      * value is a StringPool handle for a simple AttValue that was already
96      * correctly normalized for CDATA in the original document. These
97      * other return values either indicate an error or that the AttValue
98      * needs further processing.
99      */
100     public static final int
101         ATTVALUE_RESULT_COMPLEX = -1,
102         ATTVALUE_RESULT_LESSTHAN = -2,
103         ATTVALUE_RESULT_INVALID_CHAR = -3;
104
105     /**
106      * Special return values for scanEntityValue method. The normal return
107      * value is a StringPool handle for a simple EntityValue that was entirely
108      * contained within the original document. These other return values can
109      * either indicate an error or that the EntityValue needs further processing.
110      */
111     public static final int
112         ENTITYVALUE_RESULT_FINISHED = -1,
113         ENTITYVALUE_RESULT_REFERENCE = -2,
114         ENTITYVALUE_RESULT_PEREF = -3,
115         ENTITYVALUE_RESULT_INVALID_CHAR = -4,
116         ENTITYVALUE_RESULT_END_OF_INPUT = -5;
117
118     /**
119      * Return values for the scanContent method.
120      */
121     public static final int
122         CONTENT_RESULT_START_OF_PI = 0,
123         CONTENT_RESULT_START_OF_COMMENT = 1,
124         CONTENT_RESULT_START_OF_CDSECT = 2,
125         CONTENT_RESULT_END_OF_CDSECT = 3,
126         CONTENT_RESULT_START_OF_ETAG = 4,
127         CONTENT_RESULT_MATCHING_ETAG = 5,
128         CONTENT_RESULT_START_OF_ELEMENT = 6,
129         CONTENT_RESULT_START_OF_CHARREF = 7,
130         CONTENT_RESULT_START_OF_ENTITYREF = 8,
131         CONTENT_RESULT_INVALID_CHAR = 9,
132         CONTENT_RESULT_MARKUP_NOT_RECOGNIZED = 10,
133         CONTENT_RESULT_MARKUP_END_OF_INPUT = 11,
134         CONTENT_RESULT_REFERENCE_END_OF_INPUT = 12;
135
136     /**
137      * This is an enumeration of all the defined entity types.
138      * These are provided to communicate state information to
139      * the clients of the parser.
140      */
141     public static final int
142         ENTITYTYPE_INTERNAL_PE = 0,
143         ENTITYTYPE_EXTERNAL_PE = 1,
144         ENTITYTYPE_INTERNAL = 2,
145         ENTITYTYPE_EXTERNAL = 3,
146         ENTITYTYPE_UNPARSED = 4,
147         ENTITYTYPE_DOCUMENT = 5,
148         ENTITYTYPE_EXTERNAL_SUBSET = 6;
149
150     /**
151      * This is an enumeration of all the defined contexts in which
152      * an entity reference may appear. The order is important, as
153      * all explicit general entity references must appear first and
154      * the last of these must be ENTITYREF_IN_CONTENT. This permits
155      * the test "(context <= ENTITYREF_IN_CONTENT)" to be used as a
156      * quick check for a general entity reference.
157      *
158      * @see #startReadingFromEntity
159      */
160     public static final int
161         ENTITYREF_IN_ATTVALUE = 0,
162         ENTITYREF_IN_DEFAULTATTVALUE = 1,
163         ENTITYREF_IN_CONTENT = 2,
164         ENTITYREF_IN_DTD_AS_MARKUP = 3,
165         ENTITYREF_IN_ENTITYVALUE = 4,
166         ENTITYREF_IN_DTD_WITHIN_MARKUP = 5,
167         ENTITYREF_DOCUMENT = 6,
168         ENTITYREF_EXTERNAL_SUBSET = 7;
169
170     /**
171      * Start reading document from an InputSource.
172      *
173      * @param source The input source for the document to process.
174      * @return <code>true</code> if we were able to open the document source;
175      * <code>false</code> otherwise.
176      * @exception java.lang.Exception
177      */
178     public boolean startReadingFromDocument(InputSource source) throws Exception ;
179
180     /**
181      * Start reading from this entity.
182      *
183      * Note that the reader depth is not used by the reader, but is made
184      * available so that it may be retrieved at end of input to test that
185      * gramatical structures are properly nested within entities.
186      *
187      * @param entityName The entity name handle in the string pool.
188      * @param readerDepth The depth to associate with the reader for this entity.
189      * @param context The context of the entity reference; see ENTITYREF_IN_*.
190      * @return <code>true</code> if the entity might start with a TextDecl;
191      * <code>false</code> otherwise.
192      * @exception java.lang.Exception
193      */
194     public boolean startReadingFromEntity(int entityName, int readerDepth, int entityContext) throws Exception ;
195
196     /**
197      * Expand the system identifier relative to the entity that we are processing.
198      *
199      * @return The expanded system identifier.
200      */
201     public String expandSystemId(String systemId);
202
203     /**
204      * DTD specific entity handler
205      */
206     public interface DTDHandler {
207         /**
208          * Start reading from the external subset of the DTD.
209          *
210          * @param publicId The public identifier for the external subset.
211          * @param systemId The system identifier for the external subset.
212          * @param readerDepth The depth to associate with the reader for the external subset.
213          * @exception java.lang.Exception
214          */
215         public void startReadingFromExternalSubset(String publicId, String systemId, int readerDepth) throws Exception ;
216
217         /**
218          * Finished reading from the external subset of the DTD.
219          * @exception java.lang.Exception
220          */
221         public void stopReadingFromExternalSubset() throws Exception ;
222
223         /**
224          * Start the scope of an entity declaration.
225          *
226          * @return <code>true</code> on success; otherwise
227          * <code>false</code> if the entity declaration is recursive.
228          * @exception java.lang.Exception
229          */
230         public boolean startEntityDecl(boolean isPE, int entityName) throws Exception ;
231
232         /**
233          * End the scope of an entity declaration.
234          * @exception java.lang.Exception
235          */
236         public void endEntityDecl() throws Exception ;
237
238         /**
239          * Declare entities and notations.
240          */
241         public int addInternalPEDecl(int entityName, int value, boolean isExternal) throws Exception ;
242         public int addExternalPEDecl(int entityName, int publicId, int systemId, boolean isExternal) throws Exception ;
243         public int addInternalEntityDecl(int entityName, int value, boolean isExternal) throws Exception ;
244         public int addExternalEntityDecl(int entityName, int publicId, int systemId, boolean isExternal) throws Exception ;
245         public int addUnparsedEntityDecl(int entityName, int publicId, int systemId, int notationName, boolean isExternal) throws Exception ;
246         public int addNotationDecl(int notationName, int publicId, int systemId, boolean isExternal) throws Exception ;
247
248         /**
249          * Check for unparsed entity.
250          *
251          * @param entityName The string handle for the entity name.
252          * @return <code>true</code> if entityName is an unparsed entity; otherwise
253          * <code>false</code> if entityName is not declared or not an unparsed entity.
254          */
255         public boolean isUnparsedEntity(int entityName);
256
257         /**
258          * Check for declared notation.
259          *
260          * @param notationName The string handle for the notation name.
261          * @return <code>true</code> if notationName is a declared notation; otherwise
262          * <code>false</code> if notationName is not declared.
263          */
264         public boolean isNotationDeclared(int entityName);
265
266         /**
267          * Remember a required but undeclared notation.
268          */
269         public void addRequiredNotation(int notationName, Locator locator, int majorCode, int minorCode, Object [] args);
270
271         /**
272          * Check required but undeclared notations.
273          */
274         public void checkRequiredNotations() throws Exception ;
275     }
276
277     /**
278      * Return a unique identifier for the current reader.
279      */
280     public int getReaderId();
281
282     /**
283      * Set the depth for the current reader.
284      */
285     public void setReaderDepth(int depth);
286
287     /**
288      * Return the depth set for the current reader.
289      */
290     public int getReaderDepth();
291
292     /**
293      * Return the current reader.
294      */
295     public EntityReader getEntityReader();
296
297     /**
298      * This method is called by the reader subclasses at the
299      * end of input.
300      *
301      * @return The reader to use next.
302      * @exception java.lang.Exception
303      */
304     public EntityReader changeReaders() throws Exception ;
305
306     /**
307      * This interface is used to store and retrieve character
308      * sequences. The primary use is for a literal data buffer
309      * where we can construct the values for literal entity
310      * replacement text. When all of the characters for the
311      * replacement text have been added to the buffer, the
312      * contents are added to the string pool for later use
313      * in constructing a StringReader if the entity is referenced.
314      */
315     public interface CharBuffer {
316         /**
317          * Append a character to this buffer.
318          *
319          * @param ch The character.
320          */
321         public void append(char ch);
322
323         /**
324          * Append characters to this buffer.
325          *
326          * @param chars The char array containing the characters.
327          * @param offset The offset within the char array of the first character to append.
328          * @param length The number of characters to append.
329          */
330         public void append(char[] chars, int offset, int length);
331
332         /**
333          * Get the current length of the buffer. This is also the
334          * offset of the next character that is added to the buffer.
335          *
336          * @return The length of the buffer.
337          */
338         public int length();
339
340         /**
341          * Add a region of this buffer to the string pool.
342          *
343          * @param offset The offset within this buffer of the first character of the string.
344          * @param length The number of characters in the string.
345          * @return The <code>StringPool</code> handle of the string.
346          */
347         public int addString(int offset, int length);
348     }
349
350     /**
351      * Set the character data handler.
352      */
353     public void setCharDataHandler(XMLEntityHandler.CharDataHandler charDataHandler);
354
355     /**
356      * Get the character data handler.
357      */
358     public XMLEntityHandler.CharDataHandler getCharDataHandler();
359
360     /**
361      * Interface for passing character data.
362      */
363     public interface CharDataHandler {
364         /**
365          * Process character data, character array version
366          *
367          * @param chars character buffer to be processed
368          * @param offset offset in buffer where the data starts
369          * @param length length of characters to be processed
370          * @exception java.lang.Exception
371          */
372         public void processCharacters(char[] chars, int offset, int length) throws Exception ;
373
374         /**
375          * Process character data, <code>StringPool</code> handle version
376          *
377          * @param stringHandle <code>StringPool</code> handle to the character data
378          * @exception java.lang.Exception
379          */
380         public void processCharacters(int stringHandle) throws Exception ;
381
382         /**
383          * Process white space data, character array version
384          *
385          * @param chars character buffer to be processed
386          * @param offset offset in buffer where the data starts
387          * @param length length of whitespace to be processed
388          * @exception java.lang.Exception
389          */
390         public void processWhitespace(char[] chars, int offset, int length) throws Exception ;
391
392         /**
393          * Process white space data, <code>StringPool</code> handle version
394          *
395          * @param stringHandle <code>StringPool</code> handle to the whitespace
396          * @exception java.lang.Exception
397          */
398         public void processWhitespace(int stringHandle) throws Exception ;
399     }
400
401     /**
402      * This is the interface for scanners to process input data
403      * from entities without needing to know the details of the
404      * underlying storage of those entities, or their encodings.
405      *
406      * The methods in this interface have been refined over time
407      * to a rough balance between keeping the XML grammar dependent
408      * code within the scanner classes, and allowing high performance
409      * processing of XML documents.
410      */
411     public interface EntityReader {
412         /**
413          * Return the current offset within this reader.
414          *
415          * @return The offset.
416          */
417         public int currentOffset();
418
419         /**
420          * Return the line number of the current position within the document that we are processing.
421          *
422          * @return The current line number.
423          */
424         public int getLineNumber();
425
426         /**
427          * Return the column number of the current position within the document that we are processing.
428          *
429          * @return The current column number.
430          */
431         public int getColumnNumber();
432
433         /**
434          * This method is provided for scanner implementations.
435          */
436         public void setInCDSect(boolean inCDSect);
437
438         /**
439          * This method is provided for scanner implementations.
440          */
441         public boolean getInCDSect();
442
443         /**
444          * Append the characters processed by this reader associated with <code>offset</code> and
445          * <code>length</code> to the <code>CharBuffer</code>.
446          *
447          * @param charBuffer The <code>CharBuffer</code> to append the characters to.
448          * @param offset The offset within this reader where the copy should start.
449          * @param length The length within this reader where the copy should stop.
450          */
451         public void append(XMLEntityHandler.CharBuffer charBuffer, int offset, int length);
452
453         /**
454          * Add a string to the <code>StringPool</code> from the characters scanned using this
455          * reader as described by <code>offset</code> and <code>length</code>.
456          *
457          * @param offset The offset within this reader where the characters start.
458          * @param length The length within this reader where the characters end.
459          * @return The <code>StringPool</code> handle for the string.
460          */
461         public int addString(int offset, int length);
462
463         /**
464          * Add a symbol to the <code>StringPool</code> from the characters scanned using this
465          * reader as described by <code>offset</code> and <code>length</code>.
466          *
467          * @param offset The offset within this reader where the characters start.
468          * @param length The length within this reader where the characters end.
469          * @return The <code>StringPool</code> handle for the symbol.
470          */
471         public int addSymbol(int offset, int length);
472
473         /**
474          * Test that the current character is a <code>ch</code> character.
475          *
476          * @param ch The character to match against.
477          * @param skipPastChar If <code>true</code>, we advance past the matched character.
478          * @return <code>true</code> if the current character is a <code>ch</code> character;
479          * <code>false</code> otherwise.
480          * @exception java.lang.Exception
481          */
482         public boolean lookingAtChar(char ch, boolean skipPastChar) throws Exception ;
483
484         /**
485          * Test that the current character is valid.
486          *
487          * @param skipPastChar If <code>true</code>, we advance past the valid character.
488          * @return <code>true</code> if the current character is valid;
489          * <code>false</code> otherwise.
490          * @exception java.lang.Exception
491          */
492         public boolean lookingAtValidChar(boolean skipPastChar) throws Exception ;
493
494         /**
495          * Test that the current character is a whitespace character.
496          *
497          * @param skipPastChar If <code>true</code>, we advance past the whitespace character.
498          * @return <code>true</code> if the current character is whitespace;
499          * <code>false</code> otherwise.
500          * @exception java.lang.Exception
501          */
502         public boolean lookingAtSpace(boolean skipPastChar) throws Exception ;
503
504         /**
505          * Advance through the input data up to the next <code>ch</code> character.
506          *
507          * @param ch The character to search for.
508          * @exception java.lang.Exception
509          */
510         public void skipToChar(char ch) throws Exception ;
511
512         /**
513          * Skip past whitespace characters starting at the current position.
514          * @exception java.lang.Exception
515          */
516         public void skipPastSpaces() throws Exception ;
517
518         /**
519          * Skip past a sequence of characters that match the XML definition of a Name.
520          * @exception java.lang.Exception
521          */
522         public void skipPastName(char fastcheck) throws Exception ;
523
524         /**
525          * Skip past a sequence of characters that match the XML definition of an Nmtoken.
526          * @exception java.lang.Exception
527          */
528         public void skipPastNmtoken(char fastcheck) throws Exception ;
529
530         /**
531          * Skip past a sequence of characters that matches the specified character array.
532          *
533          * @param s The characters to match.
534          * @return <code>true</code> if the current character is valid;
535          * <code>false</code> otherwise.
536          * @exception java.lang.Exception
537          */
538         public boolean skippedString(char[] s) throws Exception ;
539
540         /**
541          * Scan an invalid character.
542          *
543          * @return The invalid character as an integer, or -1 if there was a bad encoding.
544          * @exception java.lang.Exception
545          */
546         public int scanInvalidChar() throws Exception ;
547
548         /**
549          * Scan a character reference.
550          *
551          * @return The value of the character, or one of the following error codes:
552          *
553          * CHARREF_RESULT_SEMICOLON_REQUIRED
554          * CHARREF_RESULT_INVALID_CHAR
555          * CHARREF_RESULT_OUT_OF_RANGE
556          * @exception java.lang.Exception
557          */
558         public int scanCharRef(boolean isHexadecimal) throws Exception ;
559
560         /**
561          * Scan a string literal.
562          *
563          * @return The <code>StringPool</code> handle for the string that
564          * was scanned, or one of the following error codes:
565          *
566          * STRINGLIT_RESULT_QUOTE_REQUIRED
567          * STRINGLIT_RESULT_INVALID_CHAR
568          * @exception java.lang.Exception
569          */
570         public int scanStringLiteral() throws Exception ;
571
572         /**
573          * Scan an attribute value.
574          *
575          * @param qchar The initial quote character, either a single or double quote.
576          * @return The <code>StringPool</code> handle for the string that
577          * was scanned, or one of the following error codes:
578          *
579          * ATTVALUE_RESULT_COMPLEX
580          * ATTVALUE_RESULT_LESSTHAN
581          * ATTVALUE_RESULT_INVALID_CHAR
582          * @exception java.lang.Exception
583          */
584         public int scanAttValue(char qchar, boolean asSymbol) throws Exception ;
585
586         /**
587          * Scan an entity value.
588          *
589          * @param qchar The initial quote character, either a single or double quote.
590          * @return The <code>StringPool</code> handle for the string that
591          * was scanned, or one of the following error codes:
592          *
593          * ENTITYVALUE_RESULT_FINISHED
594          * ENTITYVALUE_RESULT_REFERENCE
595          * ENTITYVALUE_RESULT_PEREF
596          * ENTITYVALUE_RESULT_INVALID_CHAR
597          * ENTITYVALUE_RESULT_END_OF_INPUT
598          * @exception java.lang.Exception
599          */
600         public int scanEntityValue(int qchar, boolean createString) throws Exception ;
601
602         /**
603          * Add a sequence of characters that match the XML definition of a Name to the <code>StringPool</code>.
604          *
605          * If we find a name at the current position we will add it to the <code>StringPool</code>
606          * as a symbol and will return the string pool handle for that symbol to the caller.
607          *
608          * @param fastcheck A character that is not a legal name character that is provided as a
609          * hint to the reader of a character likely to terminate the Name.
610          * @return The <code>StringPool</code> handle for the name that was scanned,
611          * or -1 if a name was not found at the current position within the input data.
612          * @exception java.lang.Exception
613          */
614         public int scanName(char fastcheck) throws Exception ;
615
616         /**
617          * Scan the name that is expected at the current position in the document.
618          *
619          * This method is invoked when we are scanning the element type in an end tag
620          * that must match the element type in the corresponding start tag.
621          *
622          * @param fastcheck A character that is not a legal name character that is provided as a
623          * hint to the reader of a character likely to terminate the Name.
624          * @param expectedName The characters of the name we expect.
625          * @return <code>true</code> if we scanned the name we expected to find; otherwise
626          * <code>false</code> if we did not.
627          * @exception java.lang.Exception
628          */
629         public boolean scanExpectedName(char fastcheck, StringPool.CharArrayRange expectedName) throws Exception ;
630
631         /**
632          * Add a sequence of characters that match the XML Namespaces definition of a QName
633          * to the <code>StringPool</code>.
634          *
635          * If we find a QName at the current position we will add it to the <code>StringPool</code>
636          * and will return the string pool handle of that QName to the caller.
637          *
638          * @param fastcheck A character that is not a legal name character that is provided as a
639          * hint to the reader of a character likely to terminate the Name.
640          * <!--
641          * @return The <code>StringPool</code> handle for the QName that was scanned,
642          * or -1 if a name was not found at the current position within the input data.
643          * -->
644          * @exception java.lang.Exception
645          */
646         public void scanQName(char fastcheck, QName qname) throws Exception ;
647
648         /**
649          * Skip through the input while we are looking at character data.
650          *
651          * @param elementType The element type handle in the StringPool.
652          * @return One of the following result codes:
653          *
654          * CONTENT_RESULT_START_OF_PI
655          * CONTENT_RESULT_START_OF_COMMENT
656          * CONTENT_RESULT_START_OF_CDSECT
657          * CONTENT_RESULT_END_OF_CDSECT
658          * CONTENT_RESULT_START_OF_ETAG
659          * CONTENT_RESULT_MATCHING_ETAG
660          * CONTENT_RESULT_START_OF_ELEMENT
661          * CONTENT_RESULT_START_OF_CHARREF
662          * CONTENT_RESULT_START_OF_ENTITYREF
663          * CONTENT_RESULT_INVALID_CHAR
664          * CONTENT_RESULT_MARKUP_NOT_RECOGNIZED
665          * CONTENT_RESULT_MARKUP_END_OF_INPUT
666          * CONTENT_RESULT_REFERENCE_END_OF_INPUT
667          * @exception java.lang.Exception
668          */
669         public int scanContent(QName element) throws Exception ;
670     }
671 }
672

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags