XPathMatcher


1   /*
2    * The Apache Software License, Version 1.1
3    *
4    *
5    * Copyright (c) 2001 The Apache Software Foundation.  
6    * All rights 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.validators.schema.identity;
59  
60  import org.enhydra.apache.xerces.framework.XMLAttrList;
61  import org.enhydra.apache.xerces.utils.IntStack;
62  import org.enhydra.apache.xerces.utils.NamespacesScope;
63  import org.enhydra.apache.xerces.utils.QName;
64  import org.enhydra.apache.xerces.utils.StringPool;
65  import org.enhydra.apache.xerces.validators.common.XMLAttributeDecl;
66  import org.enhydra.apache.xerces.validators.common.XMLElementDecl;
67  import org.enhydra.apache.xerces.validators.datatype.DatatypeValidator;
68  import org.enhydra.apache.xerces.validators.schema.SchemaGrammar;
69  import org.enhydra.apache.xerces.validators.schema.SchemaSymbols;
70  import org.xml.sax.SAXException  ;
71  
72  /***
73  import org.xml.sax.SAXException;
74  import org.xml.sax.SAXNotRecognizedException;
75  import org.xml.sax.SAXNotSupportedException;
76  /***/
77  
78  /**
79   * XPath matcher.
80   *
81   * @author Andy Clark, IBM
82   *
83   * @version $Id: XPathMatcher.java,v 1.2 2005/01/26 08:28:45 jkjome Exp $
84   */
85  public class XPathMatcher {
86  
87      //
88      // Constants
89      //
90  
91      // debugging
92  
93      /** Compile to true to debug everything. */
94      protected static final boolean DEBUG_ALL = false;
95  
96      /** Compile to true to debug method callbacks. */
97      protected static final boolean DEBUG_METHODS = false || DEBUG_ALL;
98  
99      /** Compile to true to debug important method callbacks. */
100     protected static final boolean DEBUG_METHODS2 = false || DEBUG_METHODS || DEBUG_ALL;
101 
102     /** Compile to true to debug the <em>really</em> important methods. */
103     protected static final boolean DEBUG_METHODS3 = false || DEBUG_METHODS || DEBUG_ALL;
104                                                       
105     /** Compile to true to debug match. */
106     protected static final boolean DEBUG_MATCH = false || DEBUG_ALL;
107 
108     /** Compile to true to debug step index stack. */
109     protected static final boolean DEBUG_STACK = false || DEBUG_ALL;
110 
111     /** Don't touch this value unless you add more debug constants. */
112     protected static final boolean DEBUG_ANY = DEBUG_METHODS || 
113                                                DEBUG_METHODS2 ||
114                                                DEBUG_METHODS3 ||
115                                                DEBUG_MATCH ||
116                                                DEBUG_STACK;
117 
118     //
119     // Data
120     //
121 
122     /** XPath location path. */
123     private XPath.LocationPath[] fLocationPaths;
124 
125     /** Application preference to buffer content or not. */
126     private boolean fShouldBufferContent;
127 
128     /** True if should buffer character content <em>at this time</em>. */
129     private boolean fBufferContent;
130 
131     /** Buffer to hold match text. */
132     private StringBuffer   fMatchedBuffer = new StringBuffer  ();
133 
134     /** True if XPath has been matched. */
135     private boolean[] fMatched;
136 
137     /** The matching string. */
138     private String   fMatchedString;
139 
140     /** Integer stack of step indexes. */
141     private IntStack[] fStepIndexes;
142 
143     /** Current step. */
144     private int[] fCurrentStep;
145 
146     /** 
147      * No match depth. The value of this field will be zero while
148      * matching is successful for the given xpath expression.
149      */
150     private int [] fNoMatchDepth;
151 
152     // Xerces 1.x framework
153 
154     /** String pool. */
155     protected StringPool fStringPool;
156 
157     /** Namespace scope. */
158     protected NamespacesScope fNamespacesScope;
159 
160     // the Identity constraint we're the matcher for.  Only
161     // used for selectors!  
162     protected IdentityConstraint fIDConstraint;
163 
164     //
165     // Constructors
166     //
167 
168     /** 
169      * Constructs an XPath matcher that implements a document fragment 
170      * handler. 
171      *
172      * @param xpath   The xpath.
173      */
174     public XPathMatcher(XPath xpath) {
175         this(xpath, false, null);
176     } // <init>(XPath)
177 
178     /** 
179      * Constructs an XPath matcher that implements a document fragment 
180      * handler. 
181      *
182      * @param xpath   The xpath.
183      * @param shouldBufferContent True if the matcher should buffer the
184      *                            matched content.
185      * @param idConstraint:  the identity constraint we're matching for; 
186      *      null unless it's a Selector.
187      */
188     public XPathMatcher(XPath xpath, boolean shouldBufferContent, IdentityConstraint idConstraint) {
189         fLocationPaths = xpath.getLocationPaths();
190         fShouldBufferContent = shouldBufferContent;
191         fIDConstraint = idConstraint;
192         fStepIndexes = new IntStack[fLocationPaths.length];
193         for(int i=0; i<fStepIndexes.length; i++) fStepIndexes[i] = new IntStack();
194         fCurrentStep = new int[fLocationPaths.length];
195         fNoMatchDepth = new int[fLocationPaths.length];
196         fMatched = new boolean[fLocationPaths.length];
197         if (DEBUG_METHODS) {
198             System.out.println(toString()+"#<init>()");
199         }
200     } // <init>(XPath,boolean)
201 
202     //
203     // Public methods
204     //
205 
206     /** Returns true if XPath has been matched. */
207     public boolean isMatched() {
208         // xpath has been matched if any one of the members of the union have matched.
209         for (int i=0; i < fLocationPaths.length; i++) 
210             if (fMatched[i]) return true;
211         return false;
212     } // isMatched():boolean
213 
214     // returns whether this XPathMatcher was matching a Selector
215     public boolean getIsSelector() {
216         return (fIDConstraint == null);
217     } // end getIsSelector():boolean
218 
219     // returns the ID constraint
220     public IdentityConstraint getIDConstraint() {
221         return fIDConstraint; 
222     } // end getIDConstraint():IdentityConstraint
223 
224     /** Returns the matched string. */
225     public String   getMatchedString() {
226         return fMatchedString;
227     } // getMatchedString():String
228 
229     //
230     // Protected methods
231     //
232 
233     /**
234      * This method is called when the XPath handler matches the
235      * XPath expression. Subclasses can override this method to
236      * provide default handling upon a match.
237      */
238     protected void matched(String   content, DatatypeValidator val, boolean isNil) throws Exception   {
239         if (DEBUG_METHODS3) {
240             System.out.println(toString()+"#matched(\""+normalize(content)+"\")");
241         }
242     } // matched(String content, DatatypeValidator val)
243 
244     //
245     // XMLDocumentFragmentHandler methods
246     //
247 
248     /**
249      * The start of the document fragment.
250      *
251      * @param namespaceScope The namespace scope in effect at the
252      *                       start of this document fragment.
253      * @param grammar:  the schema grammar we're validating against.
254      *
255      * @throws SAXException Thrown by handler to signal an error.
256      */
257     public void startDocumentFragment(StringPool stringPool) 
258         throws Exception   {
259         if (DEBUG_METHODS) {
260             System.out.println(toString()+"#startDocumentFragment("+
261                                "stringPool="+stringPool+','+
262                                ")");
263         }
264 
265         // reset state
266         clear();
267         for(int i = 0; i < fLocationPaths.length; i++) {
268             fStepIndexes[i].clear();
269             fCurrentStep[i] = 0;
270             fNoMatchDepth[i] = 0;
271             fMatched[i]=false;
272         }
273 
274         // keep values
275         fStringPool = stringPool;
276 
277     } // startDocumentFragment(StringPool,SchemaGrammar)
278 
279     /**
280      * The start of an element. If the document specifies the start element
281      * by using an empty tag, then the startElement method will immediately
282      * be followed by the endElement method, with no intervening methods.
283      * 
284      * @param element    The name of the element.
285      * @param attributes The element attributes.
286      * @param eIndex:  the element index of the current element
287      * @param grammar:  the currently-active Schema Grammar
288      *
289      * @throws SAXException Thrown by handler to signal an error.
290      */
291     public void startElement(QName element, XMLAttrList attributes, int handle, 
292                 int eIndex, SchemaGrammar grammar)
293         throws Exception   {
294         if (DEBUG_METHODS2) {
295             System.out.println(toString()+"#startElement("+
296                                "element={"+
297                                "prefix="+fStringPool.toString(element.prefix)+','+
298                                "localpart="+fStringPool.toString(element.localpart)+','+
299                                "rawname="+fStringPool.toString(element.rawname)+','+
300                                "uri="+fStringPool.toString(element.uri)+
301                                "},"+
302                                "attributes=..."+//attributes+
303                                ")");
304         }
305 
306         for(int i = 0; i < fLocationPaths.length; i++) {
307             // push context 
308             int startStep = fCurrentStep[i];
309             fStepIndexes[i].push(startStep);
310 
311             // try next xpath, if not matching
312             if (fMatched[i] || fNoMatchDepth[i] > 0) {
313                 fNoMatchDepth[i]++;
314                 continue;
315             }
316 
317             if (DEBUG_STACK) {
318                 System.out.println(toString()+": "+fStepIndexes[i]);
319             }
320 
321             // consume self::node() steps
322             XPath.Step[] steps = fLocationPaths[i].steps;
323             while (fCurrentStep[i] < steps.length && 
324                     steps[fCurrentStep[i]].axis.type == XPath.Axis.SELF) {
325                 if (DEBUG_MATCH) {
326                     XPath.Step step = steps[fCurrentStep[i]];
327                     System.out.println(toString()+" [SELF] MATCHED!");
328                 }
329                 fCurrentStep[i]++;
330             }
331             if (fCurrentStep[i] == steps.length) {
332                 if (DEBUG_MATCH) {
333                     System.out.println(toString()+" XPath MATCHED!");
334                 }
335                 fMatched[i] = true;
336                 int j=0;
337                 for(; j<i && !fMatched[j]; j++);
338                 if(j==i)
339                     fBufferContent = fShouldBufferContent;
340                 continue;
341             }
342         
343             // now if the current step is a descendant step, we let the next
344             // step do its thing; if it fails, we reset ourselves
345             // to look at this step for next time we're called.
346             // so first consume all descendants:
347             int descendantStep = fCurrentStep[i];
348             while(fCurrentStep[i] < steps.length && steps[fCurrentStep[i]].axis.type == XPath.Axis.DESCENDANT) {
349                 if (DEBUG_MATCH) {
350                     XPath.Step step = steps[fCurrentStep[i]];
351                     System.out.println(toString()+" [DESCENDANT] MATCHED!");
352                 }
353                 fCurrentStep[i]++;
354             }
355             if (fCurrentStep[i] == steps.length) {
356                 if (DEBUG_MATCH) {
357                     System.out.println(toString()+" XPath DIDN'T MATCH!");
358                 }
359                 fNoMatchDepth[i]++;
360                 if (DEBUG_MATCH) {
361                     System.out.println(toString()+" [CHILD] after NO MATCH");
362                 }
363                 continue;
364             }
365 
366             // match child::... step, if haven't consumed any self::node()
367             if ((fCurrentStep[i] == startStep || fCurrentStep[i] > descendantStep) &&
368                 steps[fCurrentStep[i]].axis.type == XPath.Axis.CHILD) {
369                 XPath.Step step = steps[fCurrentStep[i]];
370                 XPath.NodeTest nodeTest = step.nodeTest;
371                 if (DEBUG_MATCH) {
372                     System.out.println(toString()+" [CHILD] before");
373                 }
374                 if (nodeTest.type == XPath.NodeTest.QNAME) {
375                     if (!nodeTest.name.equals(element)) {
376                         if(fCurrentStep[i] > descendantStep) {
377                             fCurrentStep[i] = descendantStep;
378                             continue;
379                         }
380                         fNoMatchDepth[i]++;
381                         if (DEBUG_MATCH) {
382                             System.out.println(toString()+" [CHILD] after NO MATCH");
383                         }
384                         continue;
385                     }
386                 }
387                 fCurrentStep[i]++;
388                 if (DEBUG_MATCH) {
389                     System.out.println(toString()+" [CHILD] after MATCHED!");
390                 }
391             }
392             if (fCurrentStep[i] == steps.length) {
393                 fMatched[i] = true;
394                 int j=0;
395                 for(; j<i && !fMatched[j]; j++);
396                 if(j==i)
397                     fBufferContent = fShouldBufferContent;
398                 continue;
399             }
400 
401             // match attribute::... step
402             if (fCurrentStep[i] < steps.length &&
403                 steps[fCurrentStep[i]].axis.type == XPath.Axis.ATTRIBUTE) {
404                 if (DEBUG_MATCH) {
405                     System.out.println(toString()+" [ATTRIBUTE] before");
406                 }
407                 int aindex = attributes.getFirstAttr(handle);
408                 if (aindex != -1) {
409                     XPath.NodeTest nodeTest = steps[fCurrentStep[i]].nodeTest;
410                     QName aname = new QName(); // REVISIT: cache this
411                     while (aindex != -1) {
412                         int aprefix = attributes.getAttrPrefix(aindex);
413                         int alocalpart = attributes.getAttrLocalpart(aindex);
414                         int arawname = attributes.getAttrName(aindex);
415                         int auri = attributes.getAttrURI(aindex);
416                         aname.setValues(aprefix, alocalpart, arawname, auri);
417                         if (nodeTest.type != XPath.NodeTest.QNAME ||
418                             nodeTest.name.equals(aname)) {
419                             fCurrentStep[i]++;
420                             if (fCurrentStep[i] == steps.length) {
421                                 fMatched[i] = true;
422                                 int j=0;
423                                 for(; j<i && !fMatched[j]; j++);
424                                 if(j==i) {
425                                     int avalue = attributes.getAttValue(aindex);
426                                     fMatchedString = fStringPool.toString(avalue);
427                                     // now, we have to go on the hunt for 
428                                     // datatype validator; not an easy or pleasant task...
429                                     int attIndex = grammar.getAttributeDeclIndex(eIndex, aname);
430                                     XMLAttributeDecl tempAttDecl = new XMLAttributeDecl();
431                                     grammar.getAttributeDecl(attIndex, tempAttDecl);
432                                     DatatypeValidator aValidator = tempAttDecl.datatypeValidator;
433                                     matched(fMatchedString, aValidator, false);
434                                 }
435                             }
436                             break;
437                         }
438                         aindex = attributes.getNextAttr(aindex);
439                     }
440                 }
441                 if (!fMatched[i]) {
442                     if(fCurrentStep[i] > descendantStep) {
443                         fCurrentStep[i] = descendantStep;
444                         continue;
445                     }
446                     fNoMatchDepth[i]++;
447                     if (DEBUG_MATCH) {
448                         System.out.println(toString()+" [ATTRIBUTE] after");
449                     }
450                     continue;
451                 }
452                 if (DEBUG_MATCH) {
453                     System.out.println(toString()+" [ATTRIBUTE] after MATCHED!");
454                 }
455             }
456         }
457 
458     } // startElement(QName,XMLAttrList,int)
459 
460     /** Character content. */
461     public void characters(char[] ch, int offset, int length) 
462         throws Exception   {
463         if (DEBUG_METHODS) {
464             System.out.println(toString()+"#characters("+
465                                "text="+normalize(new String  (ch, offset, length))+
466                                ")");
467         }
468 
469         // collect match content
470         // so long as one of our paths is matching, store the content
471         for(int i=0; i<fLocationPaths.length; i++) 
472             if (fBufferContent && fNoMatchDepth[i] == 0) {
473                 if (!DEBUG_METHODS && DEBUG_METHODS2) {
474                     System.out.println(toString()+"#characters("+
475                                    "text="+normalize(new String  (ch, offset, length))+
476                                    ")");
477                 }
478                 fMatchedBuffer.append(ch, offset, length);
479                 break;
480             }
481         
482     } // characters(char[],int,int)
483 
484     /**
485      * The end of an element.
486      * 
487      * @param element The name of the element.
488      * @param eIndex:  the elementDeclIndex of the current element;
489      *      needed so that we can look up its datatypeValidator.
490      *
491      * @throws SAXException Thrown by handler to signal an error.
492      */
493     public void endElement(QName element, int eIndex, SchemaGrammar grammar) throws Exception   {
494         if (DEBUG_METHODS2) {
495             System.out.println(toString()+"#endElement("+
496                                "element={"+
497                                "prefix="+fStringPool.toString(element.prefix)+','+
498                                "localpart="+fStringPool.toString(element.localpart)+','+
499                                "rawname="+fStringPool.toString(element.rawname)+','+
500                                "uri="+fStringPool.toString(element.uri)+
501                                "ID constraint="+fIDConstraint+
502                                "})");
503         }
504         
505         for(int i = 0; i<fLocationPaths.length; i++) {
506             // don't do anything, if not matching
507             if (fNoMatchDepth[i] > 0) {
508                 fNoMatchDepth[i]--;
509             }
510 
511             // signal match, if appropriate
512             else {
513                 int j=0;
514                 for(; j<i && !fMatched[j]; j++);
515                 if (j<i) continue;
516                 if (fBufferContent) {
517                     fBufferContent = false;
518                     fMatchedString = fMatchedBuffer.toString();
519                     XMLElementDecl temp = new XMLElementDecl();
520                     grammar.getElementDecl(eIndex, temp);
521                     DatatypeValidator val = temp.datatypeValidator;
522                     if(temp != null) {
523                         matched(fMatchedString, val, (grammar.getElementDeclMiscFlags(eIndex) & SchemaSymbols.NILLABLE) != 0);
524                     } else 
525                         matched(fMatchedString, null, false);
526                 }
527                 clear();
528             }
529 
530             // go back a step
531             fCurrentStep[i] = fStepIndexes[i].pop();
532         
533             if (DEBUG_STACK) {
534                 System.out.println(toString()+": "+fStepIndexes[i]);
535             }
536         }
537 
538     } // endElement(QName)
539 
540     /**
541      * The end of the document fragment.
542      *
543      * @throws SAXException Thrown by handler to signal an error.
544      */
545     public void endDocumentFragment() throws Exception   {
546         if (DEBUG_METHODS) {
547             System.out.println(toString()+"#endDocumentFragment()");
548         }
549         clear();
550     } // endDocumentFragment()
551 
552     //
553     // Object methods
554     //
555     
556     /** Returns a string representation of this object. */
557     public String   toString() {
558         /***
559         return fLocationPath.toString();
560         /***/
561         StringBuffer   str = new StringBuffer  ();
562         String   s = super.toString();
563         int index2 = s.lastIndexOf('.');
564         if (index2 != -1) {
565             s = s.substring(index2 + 1);
566         }
567         str.append(s);
568         for(int i =0;i<fLocationPaths.length; i++) {
569             str.append('[');
570             XPath.Step[] steps = fLocationPaths[i].steps;
571             for (int j = 0; j < steps.length; j++) {
572                 if (j == fCurrentStep[i]) {
573                     str.append('^');
574                 }
575                 str.append(steps[i].toString());
576                 if (j < steps.length - 1) {
577                     str.append('/');
578                 }
579             }
580             if (fCurrentStep[i] == steps.length) {
581                 str.append('^');
582             }
583             str.append(']');
584             str.append(',');
585         }
586         return str.toString();
587     } // toString():String
588 
589     //
590     // Private methods
591     //
592 
593     /** Clears the match values. */
594     private void clear() {
595         fBufferContent = false;
596         fMatchedBuffer.setLength(0);
597         fMatchedString = null;
598         for(int i = 0; i<fLocationPaths.length; i++)
599             fMatched[i] = false;
600     } // clear()
601 
602     /** Normalizes text. */
603     private String   normalize(String   s) {
604         StringBuffer   str = new StringBuffer  ();
605         int length = s.length();
606         for (int i = 0; i < length; i++) {
607             char c = s.charAt(i);
608             switch (c) {
609                 case '\n': {
610                     str.append("\\n");
611                     break;
612                 }
613                 default: {
614                     str.append(c);
615                 }
616             }
617         }
618         return str.toString();
619     } // normalize(String):String
620 
621     //
622     // MAIN
623     //
624 
625     // NOTE: The main of this class is here for debugging purposes.
626     //       However, javac (JDK 1.1.8) has an internal compiler
627     //       error when compiling. Jikes has no problem, though.
628     //
629     //       If you want to use this main, use Jikes to compile but
630     //       *never* check in this code to CVS without commenting it
631     //       out. -Ac
632     
633     /** Main program. */
634     /***
635     public static void main(String[] argv) throws Exception {
636 
637         if (DEBUG_ANY) {
638             for (int i = 0; i < argv.length; i++) {
639                 final String expr = argv[i];
640                 final StringPool symbols = new StringPool();
641                 final XPath xpath = new XPath(expr, symbols, null);
642                 final XPathMatcher matcher = new XPathMatcher(xpath, true);
643                 org.enhydra.apache.xerces.parsers.SAXParser parser = 
644                     new org.enhydra.apache.xerces.parsers.SAXParser(symbols) {
645                     public void startDocument() throws Exception {
646                         matcher.startDocumentFragment(symbols, null);
647                     }
648                     public void startElement(QName element, XMLAttrList attributes, int handle) throws Exception {
649                         matcher.startElement(element, attributes, handle);
650                     }
651                     public void characters(char[] ch, int offset, int length) throws Exception {
652                         matcher.characters(ch, offset, length);
653                     }
654                     public void endElement(QName element) throws Exception {
655                         matcher.endElement(element);
656                     }
657                     public void endDocument() throws Exception {
658                         matcher.endDocumentFragment();
659                     }
660                 };
661                 System.out.println("#### argv["+i+"]: \""+expr+"\" -> \""+xpath.toString()+'"');
662                 final String uri = argv[++i];
663                 System.out.println("#### argv["+i+"]: "+uri);
664                 parser.parse(uri);
665             }
666         }
667 
668     } // main(String[])
669     /***/
670 
671 } // class XPathMatcher
672
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags