From 48a21d20aad2899fcfea54f4665c1ce7e5c0356f Mon Sep 17 00:00:00 2001
From: jackie_wu
Date: Mon, 26 Apr 2021 17:35:11 +0800
Subject: [PATCH] xmlpull package init
---
LICENSE.txt | 16 +
LICENSE_TESTS.txt | 419 +++++++
doc/.cvsignore | 29 +
doc/ABOUT.txt | 4 +
doc/README_DOWNLOAD.html | 47 +
doc/THANKS.txt | 6 +
doc/addons.html | 299 +++++
doc/build.txt | 54 +
doc/changes.html | 305 +++++
doc/faq.html | 304 +++++
doc/features.html | 317 +++++
doc/javadoc_stylesheet.css | 41 +
doc/properties.html | 192 +++
doc/quick_intro.html | 218 ++++
doc/quick_write.html | 236 ++++
doc/run.txt | 75 ++
lib/ant/LICENSE.txt | 48 +
lib/ant/README.txt | 2 +
lib/ant/ant-1.4.1.jar | Bin 0 -> 417110 bytes
lib/ant/crimson.jar | Bin 0 -> 196399 bytes
lib/ant/jakarta-regexp-1.3-dev.jar | Bin 0 -> 29952 bytes
lib/ant/jaxp.jar | Bin 0 -> 33323 bytes
lib/ant/lcp.bat | 9 +
lib/impl_xmlpull_v1_api/README.txt | 4 +
lib/junit/LICENSE.txt | 104 ++
lib/junit/README.txt | 1 +
lib/junit/junit3.8.1.jar | Bin 0 -> 121070 bytes
pom.xml | 209 ++++
xmlpull/.gitignore | 5 +
xmlpull/pom.xml | 16 +
.../java/org/xmlpull/v1/XmlPullParser.java | 1109 +++++++++++++++++
.../xmlpull/v1/XmlPullParserException.java | 76 ++
.../org/xmlpull/v1/XmlPullParserFactory.java | 354 ++++++
.../java/org/xmlpull/v1/XmlSerializer.java | 272 ++++
34 files changed, 4771 insertions(+)
create mode 100644 LICENSE.txt
create mode 100644 LICENSE_TESTS.txt
create mode 100644 doc/.cvsignore
create mode 100644 doc/ABOUT.txt
create mode 100644 doc/README_DOWNLOAD.html
create mode 100644 doc/THANKS.txt
create mode 100644 doc/addons.html
create mode 100644 doc/build.txt
create mode 100644 doc/changes.html
create mode 100644 doc/faq.html
create mode 100644 doc/features.html
create mode 100644 doc/javadoc_stylesheet.css
create mode 100644 doc/properties.html
create mode 100644 doc/quick_intro.html
create mode 100644 doc/quick_write.html
create mode 100644 doc/run.txt
create mode 100644 lib/ant/LICENSE.txt
create mode 100644 lib/ant/README.txt
create mode 100644 lib/ant/ant-1.4.1.jar
create mode 100644 lib/ant/crimson.jar
create mode 100644 lib/ant/jakarta-regexp-1.3-dev.jar
create mode 100644 lib/ant/jaxp.jar
create mode 100755 lib/ant/lcp.bat
create mode 100644 lib/impl_xmlpull_v1_api/README.txt
create mode 100644 lib/junit/LICENSE.txt
create mode 100644 lib/junit/README.txt
create mode 100644 lib/junit/junit3.8.1.jar
create mode 100644 pom.xml
create mode 100644 xmlpull/.gitignore
create mode 100644 xmlpull/pom.xml
create mode 100644 xmlpull/src/main/java/org/xmlpull/v1/XmlPullParser.java
create mode 100644 xmlpull/src/main/java/org/xmlpull/v1/XmlPullParserException.java
create mode 100644 xmlpull/src/main/java/org/xmlpull/v1/XmlPullParserFactory.java
create mode 100644 xmlpull/src/main/java/org/xmlpull/v1/XmlSerializer.java
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..8e662e8
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,16 @@
+XMLPULL API IS FREE
+-------------------
+
+All of the XMLPULL API source code, compiled code, and documentation
+contained in this distribution *except* for tests (see separate LICENSE_TESTS.txt)
+are in the Public Domain.
+
+XMLPULL API comes with NO WARRANTY or guarantee of fitness for any purpose.
+
+Initial authors:
+
+ Stefan Haustein
+ Aleksander Slominski
+
+2001-12-12
+
diff --git a/LICENSE_TESTS.txt b/LICENSE_TESTS.txt
new file mode 100644
index 0000000..59f0d29
--- /dev/null
+++ b/LICENSE_TESTS.txt
@@ -0,0 +1,419 @@
+XMLPULL API TESTS LICENSE
+--------------------------------------
+
+XMLPULL V1 API TESTS
+Copyright (C) 2002 Aleksander Slominski
+
+XMLPULL V1 API TESTS are free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+XMLPULL V1 API TESTS are distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+(see below and at http://www.gnu.org/copyleft/lesser.html).
+
+
+NOTE: XMLPULL V1 API TESTS are released under the Lesser GPL (LGPL) license,
+granting you permission to use them in commercial and non-commercial applications for
+free. Unlike regular GPL, LGPL does not force you to license your own software under GPL.
+
+-------------------------------------------------------------------------------
+GNU Lesser Public License
+
+Version 2.1, February 1999
+
+Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+as the successor of the GNU Library Public License, version 2, hence
+the version number 2.1.]
+
+Preamble
+
+The licenses for most software are designed to take away your freedom to share and
+change it. By contrast, the GNU General Public Licenses are intended to guarantee your
+freedom to share and change free software--to make sure the software is free for all its
+users.
+
+This license, the Lesser General Public License, applies to some specially designated
+software packages--typically libraries--of the Free Software Foundation and other authors
+who decide to use it. You can use it too, but we suggest you first think carefully about
+whether this license or the ordinary General Public License is the better strategy to use in
+any particular case, based on the explanations below.
+
+When we speak of free software, we are referring to freedom of use, not price. Our
+General Public Licenses are designed to make sure that you have the freedom to
+distribute copies of free software (and charge for this service if you wish); that you receive
+source code or can get it if you want it; that you can change the software and use pieces
+of it in new free programs; and that you are informed that you can do these things.
+
+To protect your rights, we need to make restrictions that forbid distributors to deny you
+these rights or to ask you to surrender these rights. These restrictions translate to certain
+responsibilities for you if you distribute copies of the library or if you modify it.
+
+For example, if you distribute copies of the library, whether gratis or for a fee, you must
+give the recipients all the rights that we gave you. You must make sure that they, too,
+receive or can get the source code. If you link other code with the library, you must
+provide complete object files to the recipients, so that they can relink them with the library
+after making changes to the library and recompiling it. And you must show them these
+terms so they know their rights.
+
+We protect your rights with a two-step method: (1) we copyright the library, and (2) we
+offer you this license, which gives you legal permission to copy, distribute and/or modify
+the library.
+
+To protect each distributor, we want to make it very clear that there is no warranty for the
+free library. Also, if the library is modified by someone else and passed on, the recipients
+should know that what they have is not the original version, so that the original author's
+reputation will not be affected by problems that might be introduced by others.
+
+Finally, software patents pose a constant threat to the existence of any free program. We
+wish to make sure that a company cannot effectively restrict the users of a free program
+by obtaining a restrictive license from a patent holder. Therefore, we insist that any patent
+license obtained for a version of the library must be consistent with the full freedom of use
+specified in this license.
+
+Most GNU software, including some libraries, is covered by the ordinary GNU General
+Public License. This license, the GNU Lesser General Public License, applies to certain
+designated libraries, and is quite different from the ordinary General Public License. We
+use this license for certain libraries in order to permit linking those libraries into non-free
+programs.
+
+When a program is linked with a library, whether statically or using a shared library, the
+combination of the two is legally speaking a combined work, a derivative of the original
+library. The ordinary General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General Public License permits
+more lax criteria for linking other code with the library.
+
+We call this license the "Lesser" General Public License because it does Less to protect
+the user's freedom than the ordinary General Public License. It also provides other free
+software developers Less of an advantage over competing non-free programs. These
+disadvantages are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain special
+circumstances.
+
+For example, on rare occasions, there may be a special need to encourage the widest
+possible use of a certain library, so that it becomes a de-facto standard. To achieve this,
+non-free programs must be allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this case, there is little to
+gain by limiting the free library to free software only, so we use the Lesser General Public
+License.
+
+In other cases, permission to use a particular library in non-free programs enables a
+greater number of people to use a large body of free software. For example, permission
+to use the GNU C Library in non-free programs enables many more people to use the
+whole GNU operating system, as well as its variant, the GNU/Linux operating system.
+
+Although the Lesser General Public License is Less protective of the users' freedom, it
+does ensure that the user of a program that is linked with the Library has the freedom
+and the wherewithal to run that program using a modified version of the Library.
+
+The precise terms and conditions for copying, distribution and modification follow. Pay
+close attention to the difference between a "work based on the library" and a "work that
+uses the library". The former contains code derived from the library, whereas the latter
+must be combined with the library in order to run.
+
+TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND
+MODIFICATION
+
+0. This License Agreement applies to any software library or other program which
+contains a notice placed by the copyright holder or other authorized party saying it may
+be distributed under the terms of this Lesser General Public License (also called "this
+License"). Each licensee is addressed as "you".
+
+A "library" means a collection of software functions and/or data prepared so as to be
+conveniently linked with application programs (which use some of those functions and
+data) to form executables.
+
+The "Library", below, refers to any such software library or work which has been
+distributed under these terms. A "work based on the Library" means either the Library or
+any derivative work under copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated straightforwardly into
+another language. (Hereinafter, translation is included without limitation in the term
+"modification".)
+
+"Source code" for a work means the preferred form of the work for making modifications
+to it. For a library, complete source code means all the source code for all modules it
+contains, plus any associated interface definition files, plus the scripts used to control
+compilation and installation of the library.
+
+Activities other than copying, distribution and modification are not covered by this
+License; they are outside its scope. The act of running a program using the Library is not
+restricted, and output from such a program is covered only if its contents constitute a
+work based on the Library (independent of the use of the Library in a tool for writing it).
+Whether that is true depends on what the Library does and what the program that uses
+the Library does.
+
+1. You may copy and distribute verbatim copies of the Library's complete source code as
+you receive it, in any medium, provided that you conspicuously and appropriately publish
+on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all
+the notices that refer to this License and to the absence of any warranty; and distribute a
+copy of this License along with the Library.
+
+You may charge a fee for the physical act of transferring a copy, and you may at your
+option offer warranty protection in exchange for a fee.
+
+2. You may modify your copy or copies of the Library or any portion of it, thus forming a
+work based on the Library, and copy and distribute such modifications or work under the
+terms of Section 1 above, provided that you also meet all of these conditions:
+
+a) The modified work must itself be a software library.
+
+b) You must cause the files modified to carry prominent notices stating that
+you changed the files and the date of any change.
+
+c) You must cause the whole of the work to be licensed at no charge to all
+third parties under the terms of this License.
+
+d) If a facility in the modified Library refers to a function or a table of data to
+be supplied by an application program that uses the facility, other than as an
+argument passed when the facility is invoked, then you must make a good
+faith effort to ensure that, in the event an application does not supply such
+function or table, the facility still operates, and performs whatever part of its
+purpose remains meaningful.
+
+(For example, a function in a library to compute square roots has a purpose
+that is entirely well-defined independent of the application. Therefore,
+Subsection 2d requires that any application-supplied function or table used
+by this function must be optional: if the application does not supply it, the
+square root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If identifiable
+sections of that work are not derived from the Library, and can be
+reasonably considered independent and separate works in themselves, then
+this License, and its terms, do not apply to those sections when you
+distribute them as separate works. But when you distribute the same sections
+as part of a whole which is a work based on the Library, the distribution of
+the whole must be on the terms of this License, whose permissions for other
+licensees extend to the entire whole, and thus to each and every part
+regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest your rights to
+work written entirely by you; rather, the intent is to exercise the right to
+control the distribution of derivative or collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library with
+the Library (or with a work based on the Library) on a volume of a storage or
+distribution medium does not bring the other work under the scope of this
+License.
+
+3. You may opt to apply the terms of the ordinary GNU General Public License instead of
+this License to a given copy of the Library. To do this, you must alter all the notices that
+refer to this License, so that they refer to the ordinary GNU General Public License,
+version 2, instead of to this License. (If a newer version than version 2 of the ordinary
+GNU General Public License has appeared, then you can specify that version instead if
+you wish.) Do not make any other change in these notices.
+
+Once this change is made in a given copy, it is irreversible for that copy, so the ordinary
+GNU General Public License applies to all subsequent copies and derivative works made
+from that copy.
+
+This option is useful when you wish to copy part of the code of the Library into a program
+that is not a library.
+
+4. You may copy and distribute the Library (or a portion or derivative of it, under Section
+2) in object code or executable form under the terms of Sections 1 and 2 above provided
+that you accompany it with the complete corresponding machine-readable source code,
+which must be distributed under the terms of Sections 1 and 2 above on a medium
+customarily used for software interchange.
+
+If distribution of object code is made by offering access to copy from a designated place,
+then offering equivalent access to copy the source code from the same place satisfies the
+requirement to distribute the source code, even though third parties are not compelled to
+copy the source along with the object code.
+
+5. A program that contains no derivative of any portion of the Library, but is designed to
+work with the Library by being compiled or linked with it, is called a "work that uses the
+Library". Such a work, in isolation, is not a derivative work of the Library, and therefore
+falls outside the scope of this License.
+
+However, linking a "work that uses the Library" with the Library creates an executable that
+is a derivative of the Library (because it contains portions of the Library), rather than a
+"work that uses the library". The executable is therefore covered by this License. Section
+6 states terms for distribution of such executables.
+
+When a "work that uses the Library" uses material from a header file that is part of the
+Library, the object code for the work may be a derivative work of the Library even though
+the source code is not. Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The threshold for this to be true
+is not precisely defined by law.
+
+If such an object file uses only numerical parameters, data structure layouts and
+accessors, and small macros and small inline functions (ten lines or less in length), then
+the use of the object file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the Library will still fall
+under Section 6.)
+
+Otherwise, if the work is a derivative of the Library, you may distribute the object code for
+the work under the terms of Section 6. Any executables containing that work also fall
+under Section 6, whether or not they are linked directly with the Library itself.
+
+6. As an exception to the Sections above, you may also combine or link a "work that uses
+the Library" with the Library to produce a work containing portions of the Library, and
+distribute that work under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse engineering for
+debugging such modifications.
+
+You must give prominent notice with each copy of the work that the Library is used in it
+and that the Library and its use are covered by this License. You must supply a copy of
+this License. If the work during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference directing the user to
+the copy of this License. Also, you must do one of these things:
+
+a) Accompany the work with the complete corresponding machine-readable
+source code for the Library including whatever changes were used in the
+work (which must be distributed under Sections 1 and 2 above); and, if the
+work is an executable linked with the Library, with the complete
+machine-readable "work that uses the Library", as object code and/or source
+code, so that the user can modify the Library and then relink to produce a
+modified executable containing the modified Library. (It is understood that the
+user who changes the contents of definitions files in the Library will not
+necessarily be able to recompile the application to use the modified
+definitions.)
+
+b) Use a suitable shared library mechanism for linking with the Library. A
+suitable mechanism is one that (1) uses at run time a copy of the library
+already present on the user's computer system, rather than copying library
+functions into the executable, and (2) will operate properly with a modified
+version of the library, if the user installs one, as long as the modified version
+is interface-compatible with the version that the work was made with.
+
+c) Accompany the work with a written offer, valid for at least three years, to
+give the same user the materials specified in Subsection 6a, above, for a
+charge no more than the cost of performing this distribution.
+
+d) If distribution of the work is made by offering access to copy from a
+designated place, offer equivalent access to copy the above specified
+materials from the same place.
+
+e) Verify that the user has already received a copy of these materials or that
+you have already sent this user a copy.
+
+For an executable, the required form of the "work that uses the Library" must include any
+data and utility programs needed for reproducing the executable from it. However, as a
+special exception, the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major components (compiler,
+kernel, and so on) of the operating system on which the executable runs, unless that
+component itself accompanies the executable.
+
+It may happen that this requirement contradicts the license restrictions of other
+proprietary libraries that do not normally accompany the operating system. Such a
+contradiction means you cannot use both them and the Library together in an executable
+that you distribute.
+
+7. You may place library facilities that are a work based on the Library side-by-side in a
+single library together with other library facilities not covered by this License, and
+distribute such a combined library, provided that the separate distribution of the work
+based on the Library and of the other library facilities is otherwise permitted, and provided
+that you do these two things:
+
+a) Accompany the combined library with a copy of the same work based on
+the Library, uncombined with any other library facilities. This must be
+distributed under the terms of the Sections above.
+
+b) Give prominent notice with the combined library of the fact that part of it is
+a work based on the Library, and explaining where to find the accompanying
+uncombined form of the same work.
+
+8. You may not copy, modify, sublicense, link with, or distribute the Library except as
+expressly provided under this License. Any attempt otherwise to copy, modify, sublicense,
+link with, or distribute the Library is void, and will automatically terminate your rights under
+this License. However, parties who have received copies, or rights, from you under this
+License will not have their licenses terminated so long as such parties remain in full
+compliance.
+
+9. You are not required to accept this License, since you have not signed it. However,
+nothing else grants you permission to modify or distribute the Library or its derivative
+works. These actions are prohibited by law if you do not accept this License. Therefore,
+by modifying or distributing the Library (or any work based on the Library), you indicate
+your acceptance of this License to do so, and all its terms and conditions for copying,
+distributing or modifying the Library or works based on it.
+
+10. Each time you redistribute the Library (or any work based on the Library), the
+recipient automatically receives a license from the original licensor to copy, distribute, link
+with or modify the Library subject to these terms and conditions. You may not impose any
+further restrictions on the recipients' exercise of the rights granted herein. You are not
+responsible for enforcing compliance by third parties with this License.
+
+11. If, as a consequence of a court judgment or allegation of patent infringement or for
+any other reason (not limited to patent issues), conditions are imposed on you (whether
+by court order, agreement or otherwise) that contradict the conditions of this License,
+they do not excuse you from the conditions of this License. If you cannot distribute so as
+to satisfy simultaneously your obligations under this License and any other pertinent
+obligations, then as a consequence you may not distribute the Library at all. For example,
+if a patent license would not permit royalty-free redistribution of the Library by all those
+who receive copies directly or indirectly through you, then the only way you could satisfy
+both it and this License would be to refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any particular
+circumstance, the balance of the section is intended to apply, and the section as a whole
+is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any patents or other property
+right claims or to contest validity of any such claims; this section has the sole purpose of
+protecting the integrity of the free software distribution system which is implemented by
+public license practices. Many people have made generous contributions to the wide
+range of software distributed through that system in reliance on consistent application of
+that system; it is up to the author/donor to decide if he or she is willing to distribute
+software through any other system and a licensee cannot impose that choice.
+
+This section is intended to make thoroughly clear what is believed to be a consequence
+of the rest of this License.
+
+12. If the distribution and/or use of the Library is restricted in certain countries either by
+patents or by copyrighted interfaces, the original copyright holder who places the Library
+under this License may add an explicit geographical distribution limitation excluding those
+countries, so that distribution is permitted only in or among countries not thus excluded. In
+such case, this License incorporates the limitation as if written in the body of this License.
+
+13. The Free Software Foundation may publish revised and/or new versions of the Lesser
+General Public License from time to time. Such new versions will be similar in spirit to the
+present version, but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Library specifies a version
+number of this License which applies to it and "any later version", you have the option of
+following the terms and conditions either of that version or of any later version published
+by the Free Software Foundation. If the Library does not specify a license version
+number, you may choose any version ever published by the Free Software Foundation.
+
+14. If you wish to incorporate parts of the Library into other free programs whose
+distribution conditions are incompatible with these, write to the author to ask for
+permission. For software which is copyrighted by the Free Software Foundation, write to
+the Free Software Foundation; we sometimes make exceptions for this. Our decision will
+be guided by the two goals of preserving the free status of all derivatives of our free
+software and of promoting the sharing and reuse of software generally.
+
+NO WARRANTY
+
+15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY KIND,
+EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE LIBRARY IS
+WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+END OF TERMS AND CONDITIONS
diff --git a/doc/.cvsignore b/doc/.cvsignore
new file mode 100644
index 0000000..c9ce79d
--- /dev/null
+++ b/doc/.cvsignore
@@ -0,0 +1,29 @@
+Java*Classes
+*_Data
+classes
+*.mcp
+*.jar
+bin
+build
+demo
+dist
+org
+javadoc
+test
+*.dsw
+*.dsp
+*.ncb
+*.plg
+*.opt
+Debug
+Release
+SunWS_cache
+ir.out
+execs
+*.exe
+*.dll
+*.bat
+*.cpr
+*_classes
+classpath*
+api*
diff --git a/doc/ABOUT.txt b/doc/ABOUT.txt
new file mode 100644
index 0000000..a02903f
--- /dev/null
+++ b/doc/ABOUT.txt
@@ -0,0 +1,4 @@
+XMLPULL V1 API
+
+for more information please see:
+http://www.xmlpull.org/
diff --git a/doc/README_DOWNLOAD.html b/doc/README_DOWNLOAD.html
new file mode 100644
index 0000000..56ce45d
--- /dev/null
+++ b/doc/README_DOWNLOAD.html
@@ -0,0 +1,47 @@
+
+
+XMLPULL FAQ
+
+
+
+
+
+
+XmlPull downloads
+
There are following file available for
+XmlPull V1 API that contains XMLPULL V1 API source, samples, JUnit tests,
+documentation and required build scripts to rebuild API and TESTS jar and rerun
+tests.
+
+ - unpacked/ contains directory with unpacked current distribution
+ tarball (xmlpull_VERSION_all.tgz) so you
+ can browse its content before downloading (typically it is development branch,
+ see ddescription of versions below)
+ - xmlpull-tests_VERSION.jar: pre-compiled .JAR files with JUnit API
+ tests that can verify that XMLPULL implementation is conforming to API defined
+ in VERSION of XMLPULL
+ - xmlpull_VERSION.jar: pre-compiled .JAR files with API (required if
+ XMLPULL implementation did not provide it)
+ - xmlpull_VERSION_all.tgz and xmlpull_VERSION_all.zip:
+ contains everything needed to regenerate XMLPULL V1 API distribution including
+ all source files, documentation, build scripts, precompiled .class files and
+ JAR files, and required ANT and JUnit .jar files
+ - xmlpull_VERSION_src.tgz and xmlpull_VERSION_src.zip:
+ contains only API source, documentation and build scripts - it is necessary to
+ download ANT to build source and JUnit to execute conformance tests
+
+NOTE: version 1.0.x (1_0_x) is current stable version of
+API and 1.1.x (1_1_x) is current development version
+
+NOTE: tarball and ZIP download contains everything but actual XMLPULL
+parser implementation that must be
+downloaded separately.
+
+For more information about XmlPull V1 API please visit
+http://www.xmlpull.org/.
+
+
+Aleksander Slominski
+
+
+
\ No newline at end of file
diff --git a/doc/THANKS.txt b/doc/THANKS.txt
new file mode 100644
index 0000000..10a9580
--- /dev/null
+++ b/doc/THANKS.txt
@@ -0,0 +1,6 @@
+* Elliotte Rusty Harold
+ asking great questions about XMLPULL API on xmlpull-dev mailing list
+
+*
+
+
diff --git a/doc/addons.html b/doc/addons.html
new file mode 100644
index 0000000..3fb3da4
--- /dev/null
+++ b/doc/addons.html
@@ -0,0 +1,299 @@
+
+XmlPull API Addons
+
+
+
+
+
+XmlPull API Addons
+
+
+What is it?
+
+Addons are reusable components that built on top of XmlPull API.
+
+
+All addons can be compiled by build target addons (use: ant addons)
+
+
+
+
+Wrapper: Extended Pull Parser and Serializer Interfaces
+
+
+This package provides extended XmlPullParser and XmlSerializer interfaces
+called XmlPullParserWrapper and XmlSerializerWrapper that has additional
+methods that make it more convenient and more concise to write parsing and serialzing
+code by providing seemlesly integrated additional methods.
+
+
+Wrappers can be uesd exactly the same as XmlPullParser and XmlSerialzier as those
+interface extend them.
+
+
Here is example usage:
+import org.xmlpull.v1.wrapper.*;
+
+XmlPullWrapperFactory wf = XmlPullWrapperFactory.newInstance();
+
+XmlPullParserWrapper pw = wf.newPullParserWrapper();
+pw.setInput( ... );
+pw.require(XmlPullParser.START_TAG, ..., ...);
+pw.skipSubTree();
+
+XmlSerializerWrapper ser = wf.newSerializerWrapper();
+ser.setOutput(out);
+ser.setCurrentNamespaceForElements("http://www.w3.org/1999/xhtml");
+ser.startTag("p").attribute("class", "abstract").text("Hello");
+ser.endTag("p");
+ser.fragment("<p class=\"hint\">write blog title below</p>");
+
+
+Another example is how to quickly copy XML input to output:
+
+while (pp.nextToken() != XmlPullParser.END_DOCUMENT) {
+ ser.event(pp);
+}
+
+
+It can be compiled by build target wrapper
+
+
Source code is available in
+addons/java/wrapper
+(view
+CVS).
+TODO: add link to JavaDoc
+
+
+
+
+
+
+
+
+Util Addon
+
+
+This class provides set of static utility methods for XmlPull parser and
+serializer.
+
+
+Here is example usage:
+import org.xmlpull.v1.util.XmlPullUtil;
+
+XmlPullParser parser = ...
+parser.require(XmlPullParser.START_TAG, ..., ...);
+XmlPullUtil.skipSubTree(pp);
+
+
+It can be compiled by build target util
+
+
Source code is available in
+addons/java/util
+(view
+CVS).
+TODO: add link to JavaDoc
+
+
+
+
+
+
+
+
+
+
+
+
+DOM2 builder
+
+
+This is very simple class to build DOM2 tree using XmlPull parser.
+
+
+Here is example usage:
+import org.xmlpull.v1.dom2_builder.DOM2XmlPullBuilder;
+
+Reader reader = ...
+DOM2XmlPullBuilder builder = new DOM2XmlPullBuilder();
+dom2builder.parse(reader);
+
+
+It can be compiled by build target dom2_builder
+
+
Source code is available in addons/java/dom2_builder.
+
+
+NOTE: this is very simple class and builds DOM2 tree that contains only elements
+and text content (collated).
+
+
+
+
+
+
+
+
+
+
+
+
+Parser pool
+
+
+This class provides simple parser pool to facilitate parser reuse.
+
+
Example usage:
+
+import org.xmlpull.v1.parser_pool.XmlPullParserPool;
+
+XmlPullParserPool pool = new XmlPullParserPool();
+XmlPullParser parser = pool.getPullParserFromPool();
+// use parser ...
+pool.returnPullParserToPool(p1);
+
+
+It can be compiled by build target parser_pool
+
+
Source code is available in addons/java/parser_pool.
+
+
+
+NOTE: parser pool is safe to share between multiple threads but parser
+instances are not safe to share.
+
+
+
+
+
+
+
+
+SAX2 driver
+
+
+This addon allows to use SAX2 API with XmlPull parser. This driver implements
+SAX2
+
+
+
+To use simply set system property
+-Dorg.xml.sax.driver=org.xmlpull.v1.sax2.Driver and then SAX2
+standard API:
+
+XMLReader parser = XMLReaderFactory.createXMLReader ();
+
+or manually create driver:
+
+
+XMLReader parser = new org.xmlpull.v1.sax2.Driver();
+
+
+
+This addon can be compiled by build target sax2
+
+
Source code is available in addons/java/sax2_driver.
+
+
+NOTE: this driver is not going to work in MIDP environments. To port it to J2ME
+MIDP it is required to change also SAX2 API and to modify Driver not to use URL
+class that is not available in MIDP (check Driver.parse() method).
+
+
+
+
+
+
+XML RPC parser
+
+It can be compiled by build target xmlrpc
+
+
Source code is available in addons/java/xmlrpc.
+
+
+
+Additional notes
+
+
+
+How to extend SAX2 driver to provide Attributes that are safe to keep after
+startElement?
+
+
+If you want to extend SAX2 Driver to provides a separate Attributes object
+for each startElement call (so it is safe to keep the reference to Attributes)
+then create class AttributesCachingDriver that extends current SAX2 driver
+(need to do it was requested by Holger Krug), for example:
+
+import org.xml.sax.SAXException;
+import org.xml.sax.helpers.AttributesImpl;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import org.xmlpull.v1.sax2.Driver;
+
+public class AttributesCachingDriver extends Driver
+{
+ public AttributesCachingDriver() throws XmlPullParserException {
+ super();
+ }
+
+ public AttributesCachingDriver(XmlPullParser pp) throws XmlPullParserException {
+ super(pp);
+ }
+
+ /**
+ * Calls startElement(String, String, String, Attributes) startElement} on the
+ * ContentHandlerwith copied attribute values. The Attributes object may
+ * be stored as each call gets a new copy of Attributes.
+ */
+ protected void startElement(String namespace, String localName, String qName) throws SAXException {
+ contentHandler.startElement(namespace, localName, qName, new AttributesImpl(this));
+ }
+
+}
+
+
+
+
+
+
+
+
Aleksander Slominski
+ and Stefan Haustein
+
+
+
+
+Last modified $Id: addons.html,v 1.7 2003/05/19 14:43:03 aslom Exp $
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/build.txt b/doc/build.txt
new file mode 100644
index 0000000..70e9d1b
--- /dev/null
+++ b/doc/build.txt
@@ -0,0 +1,54 @@
+Building XMLPULL V1 API and tests
+---------------------------------
+
+
+XMLPULL uses simply scripted build system on top ANT
+that will work if ANT jar files are copied ot lib/ant direcotry
+(see this directory for instructions how to get ANT files).
+If ant is already available on CLASSPATH it can be used directly.
+
+First make sure that JAVA_HOME environment variable points
+to your installation of JDK version 1.3 or above.
+
+If you want to use other JAR files simply replace already existing
+files in lib subdirectory (check README.txt files there for description).
+
+To build everything (API, samples and tests) from scratch use build script
+on UNIX it is ./build.sh and on WINDOWS build.bat refered here as "build":
+
+
+ build all
+
+to build just samples use:
+
+ build samples
+
+
+
+Building and executing automatic tests
+--------------------------------------
+
+NOTE: before executing tests an implementation of XMLPULL V1 API must
+be on CLASSPATH or JAR file with the implementation must be copied
+to lib/impl_xmlpull_v1_directory.
+
+when build finished execute automatic tests to verify XMLPULL integrity
+
+ build junit
+
+
+
+NOTE: this will only succeed if optional JUnit tasks for ANT are
+in lib/ant and if they are not available see run.txt to see how to execute
+tests without use of ANT.
+
+and you should see all tests passed successfully, similarly to:
+
+junit:
+ [junit] Testsuite: org.xmlpull.v1.tests.PackageTests
+ [junit] Tests run: 14, Failures: 0, Errors: 0, Time elapsed: 1.632 sec
+ [junit]
+ ....
+
+
+Now check run.txt for details on how to run samples.
diff --git a/doc/changes.html b/doc/changes.html
new file mode 100644
index 0000000..fe3e075
--- /dev/null
+++ b/doc/changes.html
@@ -0,0 +1,305 @@
+
+
+XmlPull v1 API Changes
+
+
+
+
+
+
+Changes to XmlPull v1 API
+
+
IN PROGRESS: 2003-06-... (XMLPULL_1_2_1)
+
+- this will be next official stable release (based on last of 1.1.x) to
+incorporate all changes since 1.0.x in stable version
+
+IN PROGRESS INTERIM RELEASE:
+
+2003-05-19 (XMLPULL_1_1_3_1)
+
+- added set of addons that add new functionality
+or extend existing interfaces in XmlPull API
+
+
- updated tests to look for boundary cases with PI/comments and next() (thanks to Henry Minsky)
+
- marked all supported optional features and properties as such in unit tests summary
+
+
+
- changed XmlPullParserFactory.newInstance() to use XmlPullParserFactory class
+as default class context and not String.class because when using String we will never
+find /META-INF/services/org.xmlpull.v1.XmlPullParserFactory resource ...
+
+
+
+2003-02-26 (XMLPULL_1_1_2_1)
+
+
+- minor release to make available the latest tests and documentation chnages
+
+
- added quick introduction to using XmlSerializer
+
+
- added test to check that generating namespae prefix for attributes is allowed
+(method getPrefix(uri, true) called after startTag() shoul dadd new prefix to
+current start tag elements and not next start tag)
+
+
- added tests to check optional support for formatting XML output from XML serializer
+
+
- SAX2 driver moved to addons,
+removed AttributesCachingDriver but left documented how to achieve this functionality
+
- added to addons XML RPC implementation
+
+
+
+2002-10-16 (XMLPULL_1_1_2)
+
+
+- NOTE: potentially backward incompatible change to nextToken():
+XMLDecl (<?xml ... ?>) will no longer be reported as PROCESSING_INSTRUCTION
+but instead content of XMLDecl is made available as set of properties
+XMLDECL VERSION
+XMLDECL STANDALONE
+and
+XMLDECL CONTENT.
+
+
- J2ME compatibility issue fixed: changed to use instanceof instead
+of .class in XmlPullParserFactory
+
+
- added to XmlSerializer three new utility methods:
+getDepth(), getName(), and getNamespace()
+to allows intelligent closing of serialized output for example
+when writing error/fault information into serialized XML stream
+from inside exception handler
+
+
- changed tests to reflect changed handling of XMLDecl
+and added tests to check for optional XMLDecl properties
+
+
- XmlSerializer is now required to throw exception when user tries to
+write startTag() in default namespace ("") and default namespace is bound
+to non-empty string, added test to check for it
+
+
- added patch by Holger Krug to SAX2 Driver to allow modification in sub classes
+of how Attributes in startElement() are kept. Added also AttributesCachingDriver
+that extends SAX2 Driver to create a new copy of Attributes for each startElement()
+so Attributes provided in startTag() will not change during parsing and can be kept
+indefinitely (not that Attributes object is created for each startTag() and this
+is expensive both perfromance and memory wise and is not required by SAX2.
+
+
- more tests to check for CDATA end-of-line normalization
+
+
- changed tests to require support for ROUNDTRIP==false
+and additional checks for EOL normalization of tokens
+
+
+
+
+
+2002-08-27 (XMLPULL_1_1_1)
+
+- NEW! XmlSerializer API that is now required part of XMLPULL
+API on J2SE (on J2ME typically factory is not used and only implementation of
+serializer or parser may be available).
+
+
- NOTE: potentially backward incompatible change to nextToken():
+content returned by getText()/getTextCharacters() is end-of-line normalized and
+also IGNORABLE_WHITESPACE for content outside element root and end-of-line
+unnormalized content for elements MAY not reported by nextToken() (unless optional
+XML ROUNDTRIP
+feature is false). However if
+XML ROUNDTRIP
+feature is true parser behavior is exactly the same as in previous XmlPull
+API version . This change is made to improve compatibility with XML
+by requiring normalized content as described in
+XML 1.0 End-of-Line
+Handling and with XML infoset Document
+Information Item properties which only contain comments and processing
+instructions but not white space content (so now reporting IGNORABLE_WHITESPACE
+event outside is optional).
+
+
- added optional features EXPAND ENTITY REF and SERIALIZER ATTVALUE USE
+APOSTROPHE
- added optional properties related to indenting serializer output
+(pretty printing): SERIALIZER INDENTATION, SERIALIZER LINE SEPARATOR
- added clarification to nextToken() that there is no requirement for reported
+token events to be coalesced (for example nextToken() may report multiple
+consecutive TEXT or IGNORABLE_WHITESPACE events). This is different from next()
+that always report exactly one TEXT event
- conformance tests can be now described in XML allowing to keep tests in
+format independent from Java (and potentially to use the same XML tests with
+other XmlPull API bindings such as C++ or PHP) XML files with tests are read
+from CLASSPATH
- added newSerializer() method to XmlPullParserFactory
+
+
- added new FAQ entries:
+
+
+
+
+
+
- list of class names with factory, serializer and/or parser must be now
+separated by colon in XMLPULL tests property (
org.xmlpull.v1.tests), for example:
+-Dorg.xmlpull.v1.tests=DEFAULT:org.xmlpull.mxp1.MXParser,org.xmlpull.mxp1_serializer.MXSerializer
+
+ - changed XmlPullParser constants to be all consistently int (few were declared as
+byte ...)
+
+
+
+2002-04-24 (XMLPULL_1_0_8)
+
+- two API changes are not backward compatible with 1.0.7:
+
+- readText() function was removed, please use nextText() instead
+
- require() is changed - no longer will skip white space content
+
+ - added new functions:
+- getAttributeType(index)
+
- isAttributeDefault(index)
+
- setInput(InputStream is, String inputEncoding)
+
- getInputEncoding()
+
- nextText()
+
- nextTag()
+
+ - modified tests to allow -1 for column or line number and updated Javadoc to reflect it
+
-
+updated all tests to check new functions
-
+modified test driver PackageTest to accept list of XMLPULL factories or parsers
+to check from system property org.xmlpull.v1.test, DEFAULT can be used to
+indicate using of default parser factory (taken from system property or resource
+from CLASSPATH), for example:
+-Dorg.xmlpull.v1.tests=DEFAULT,org.xmlpull.mxp1.MXParser -
+modified XmlPullParserFactory to use resource from CLASSPATH when not only classNames is null
+but also if classNames is empty String or if it is equal to "DEFAULT"
-
+improved error messages in XmlPullParserFactory to better diagnose why new pull
+parser can not be created
-
+added test to check that when on END_TAG namespaces that were declared in
+corresponding START_TAG are still accessible even though they are not in scope
-
+added tests to check that setInput() does not read any bytes from input stream
+or characters from reader until first call to next()
+
+2002-04-20 (XMLPULL_1_0_7_1)
+
+-
+fixed Quick Introduction to use correct API for getTextCharacters and
+getEventType (instead of getType)
-
+added requirement to getNamespace(prefix) to have 'xml' and 'xmlns' pre-declared
-
+removed from getNamespace(prefiix) exception XmlPullParserException as this
+function simply returns null when namespace is not declared ...
-
+updated tests:
+- updated header with license pointer to
+http://www.xmlpull.org
+
- added printing test summary (parser used, supported features)
+
- added one test to check that tokens are equivalent to events (next() <->
+nextToken())
+
+
+
+2002-04-08 (XMLPULL_1_0_7)
+
+-
+changed default namespace semantics: the prefix must be reported as null and not
+empty string from getNamespacePrefix(depth) and getNamespace(null) must return
+default namespace if declared in XML
-
+modified getText() method behavior for ENTITY_REF: in this case getText() must
+return entity replacement text and getTextCharacters() returns actual input
+buffer with entity name the same as getName()
-
+for ENTITY_REF token getName() must return entity name
-
+added specific requirement that attribute values MUST be normalized
+
+2002-04-06 (XMLPULL_1_0_6)
+
+-
+changed hard coded parser factory in XmlPullParserFactory name for KXML2 to
+org.kxml2.io.KXmlParserFactory
-
+clarified required semantics in features description
+
-
+refactored XmlPullParserFactory:
+- reduced in size as much as possible,
+
- String classNames
+in newInstance() can now specify both
+factories and parsers
+
- removed method newInstance(String classNames) the same can be done with newInstance(classNames,
+null)
- modified tests use newInstance(*,null) instead of one argument version
+ -
+removed constructor with line numbers and Throwable from XmlPullParserException
-
+changed API to add default namespace declaration to be counted in
+getNamespaceCount() and available from getNamespace...(...) methods
-
+refactored tests for common problem: check if no XMLPULL implementation
+available and print just one error message (instead of dozen...)
+
+2002-04-03 (XMLPULL_1_0_5)
+
+-
+changed features URI to point to actual documentation on
+http://www.xmlpull.org
+
-
+automatic JUnit tests now covers whole API
-
+clarified isWhitespace() can only be checked on TEXT, IGNORABLE_WHITESPACES,
+CDSECT
-
+clarified what is attribute namespace for xmlns:ns='...' when
+FEATURE_REPORT_NAMESPACE_ATTRIBUTES is set
-
+changed defineCharacterEntity() to defineEntityReplacementText() and described
+semantics of this function and its motivation in J2ME environments
-
+clarified how nextToken() works: return un-normalized (no end-of-line
+normalization) parts of XML input
-
+if additional feature i set then XML text of START_TAG and END_TAG token is
+available allowing to do full XML document roundtrip: reproduce on output
+exactly what was in input. However this works on level of UNICODE characters
+(UTF16 char in Java) and output will need to be converted into required encoding
+(like UTF8 or UTF16).
-
+getNamespacesCount changed to getNamespaceCount for consistency
-
+getAttributesCount changed to getAttributeCount for consistency
+
+2002-03-30 (XMLPULL_1_0_4)
+
+-
+added FEATURE_ prefix to all feature constants
-
+changed function name getType() to getEventType()
-
+clarified that getNamespacesCount() does not include default namespaces
+declarations (xmlns='...')
-
+specified that attributes if has no namespace declared will have "" namespace
+(empty string)
-
+clarified that when getTextCharacters returns null then holder MUST
+contain start and length will be set to -1]
+
- added more comprehensive JUnit tests for API conformance
+
+
+2002-03-29 (XMLPULL_1_0_3)
+
+-
+changed getTextCharacters to use pass by reference two int parameters (char[]
+getTextCharacters (int [] holderForStartAndLength)
-
+nextToken() is required to return actual input data with getText() (no
+end-of-line normalization) - this will allow to reconstruct input XML
+
+2002-03-28 (XMLPULL_1_0_2a)
+
+-
+fixed typos in getAttribute(s)* and getNamespace(s)* functions
-
+numerous improvements to interface documentation
-
+clarified PROCESS_DOCDECL and removed REPORT_DOCDECL
+
-
+initial release of JUnit tests (very limited for now ...)
+
+2002-03-25 (XMLPULL_1_0_1)
+
+- first interim release of API and supporting files (incomplete)
+
+
+
+
+Aleksander Slominski
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/faq.html b/doc/faq.html
new file mode 100644
index 0000000..78f3bf4
--- /dev/null
+++ b/doc/faq.html
@@ -0,0 +1,304 @@
+
+
+XMLPULL FAQ
+
+
+
+
+
+
+XMLPULL API FAQ
+Version $Id: faq.html,v 1.9 2002/07/25 16:37:30 aslom Exp $
+
+
+Is the XMLPULL API V1 compatible with XML 1.0?
+
+
If PROCESS DOCDECL
+is set to true, the XMLPULL implementation is conforming to XML 1.0. However
+this feature is switched off by default and it must be turned on explicitly.
+For XML documents that do not have a DTD declaration, the parser behavior is
+independent of this feature.
+
+By default, all features are
+switched off. This avoids confusion with default settings of parsers
+with different capabilities, and allows parsers for the J2ME
+platform to integrate nicely into the XMLPULL framework.
+
+What is the relation between the SAX2 and the XMLPULL API?
+
+SAX2 defines how to do XML push parsing and is very well doing when one
+needs to process only parts of XML input (for example when filtering XML).
+The XMLPULL API is designed to allow fast and efficient XML pull parsing that
+is performing best in situation when the whole XML input must be processed and
+transformed (for example SOAP deserialization).
+
+It is important to notice that those two APIs are not overlapping but instead
+they supplement each other. In the matter of fact it is possible to switch
+easily from pull to push (a SAX2 driver built on top of
+XMLPULL is available), but opposite conversion is more difficult and requires
+either to buffer all SAX events, making streaming impossible, or an extra
+thread (this is explained in more details in a
+technical
+report, comparing push and pull parsing).
+
+By designing the XMLPULL API, we intended to provide an API for
+XML developers that is familiar to the SAX look and feel, but is designed
+for pull parsing. If you would like to propose improvements, please do not
+hesitate to post them to the XMLPULL
+discussion list.
+
+
Is an adapter implementing SAX2 on top of the XMLPULL
+API available?
+
+Yes - a SAX2 driver that uses the XMLPULL API to do XML parsing is available in
+the CVS repository.
+
+
+How complete is XMLPULL API?
+
+The current version of the XMLPULL V1 API is stable and we do not plan any
+backward-incompatible changes though some additions may be possible. However, we
+are open to discussing new
+features on the xmlpull-dev
+mailing list, and we are looking forward to prepare the next major release of
+the XMLPULL API when there is significant need for it (and backward compatibility can
+not be maintained).
+
+
+Why is there only one "large" interface,
+wouldn't it be cleaner to use event objects and polymorphism?
+
+On the first sight, it really seems cleaner to have event objects and
+polymorphism instead of placing all the access methods in one
+relatively large interface. However, while this would make the XMLPULL
+API "look" somewhat nicer, a separate event object would also
+introduce some issues.
+
+Actually, kXML1 and XPP2 had separate event objects, and the experiences
+gained there partially led to not using separate event objects in the
+Common XML PULL API. The problem is that the different object types do
+not have much in common. Polymorphism makes a lot of sense where an
+identical set of methods can be applied to a set of different
+objects. A good example may be AWT components, having common
+properties and methods such as the position, size, and a paint()
+method. XML start tags and an XML text events have only in common that
+they are observed when parsing an XML document, they do not share a
+single common property.
+
+When using separate event objects, there are several additional
+design options. For example, methods like getAttributeValue() make
+only sense for start tags, so it seems natural to place them only
+there. However, when it comes to actual access, one will require an
+instanceof check and a type cast:
+
+if (parser.getEvent() instanceOf StartTag ) {
+ StartTag st = (StartTag) parser.getEvent ();
+ // access tag via st
+}
+else ...
+
+
+While the overhead does not seem very large at the first sight,
+please keep in mind that in many cases there is not much done
+with the event, often access is as simple as a name check or
+similar.
+
+Alternatively to the previous approach, we could also use different
+access methods depending on the event type, avoiding the type
+cast. This would look like the next example:
+
+if ( parser.getEventType() == parser.START_TAG ) {
+ StartTag st = parser.getStartTag ();
+ // access tag via st
+}
+else ...
+
+
+Obviously, while in this case neither an instanceof check nor
+a type cast is required, this approach would add a lot of methods
+to the parser, and it would be no longer significantly smaller
+than the integrated interface that is now used in the XMLPULL API.
+
+Another option may be to add the access methods of
+all event types to the event base class. However, in that case
+the event object would be nearly as huge as the integrated
+interface of the XMLPULL API, and the API
+readability advantage would be lost.
+
+Finally, the event objects are not for free. Creating lots of
+objects that are used just for extracting some information to build an
+application dependent structure may create significant overhead. While
+this overhead may be reduced by reusing event objects, reusing event
+objects is extremely dangerous since an object given to the user will
+change in the background without further notice. In contrast, in the
+XMLPULL API it is obvious that the return values of query methods like
+getEventType, getText() and getName() will be different after a call
+to one of the next() method that advance the parser to the next
+event.
+
+
+What is the difference between
+nextToken(), next(), nextTag(), and nextText()?
+
+All those methods have in common that they advance the parser to
+a next event.
+
+
+
+- nextToken() provides fine grained access to all XML events,
+including "low level" events like comments and processing instructions.
+
+- next() works similar to nextToken(), but it skips low
+level events like comments and processing instructions. Text events that are
+interrupted by comments or processing instructions are aggregated to a single
+text event.
+
+
- nextTag() works like next(), but also skips
+text fragments that contain only whitespace. If the next
+event observed is not a start tag or end tag, an exception
+is thrown.
+
+
- nextText() has the precondition that the current event is a start
+tag. It reads text until the corresponding end tag is reached and stops on the
+end tag. The return value of nextText() is the text that was read. If
+nextText() observes an additional start tag while parsing text, an
+exception is thrown. The motivation behind this method is to provide an unified
+handling for the cases "<tag></tag>", "<tag/>", and
+</tag>some text</tag>".
+
+
+
+
+Why are there different next() methods, wouldn't it be cleaner to
+have a set method, allowing me to specify the type of events I am interested in
+in general?
+
+A significant advantage of pull parsers over push parsers
+is that they can easily be handed over to different methods as
+a parameter. Those methods can then handle their subtree.
+However, when the parser would have a lot of state options, at
+each of those hand over points it would be necessary to
+make sure that the state matches the requirements of the
+subroutine. The same checks would be necessary when the
+subroutine returns and the original processor regains
+control.
+
+
+Is it possible to perform an
+exact 1:1 XML roundtrip using the XMLPULL API? For instance,
+is it possible to build an XML editor on
+top of the XMLPULL API that does not change anything that
+is not "touched"?
+
+If the feature
+XML ROUNDTRIP is enabled, an exact XML 1.0 round-tripping is possible. The
+parser will make the exact content of XML start tags and end tags
+including white spaces and attribute formatting available to applications.
+However, this may not be possible for other than standard XML 1.0
+representations of the XML infoset such as WBXML. But even when
+XML ROUNDTRIP
+feature is not enabled, round-tripping at XML-Infoset level can be accomplished
+by using the
+
+nextToken() method instead of next().
+
+
+
How to write XML output with XMLPULL API?
+
+This is currently not supported though one can always write custom method for
+this purpose. For instance, one of internal JUnit tests shows an example how
+to round-trip XML - this is used to test XMLPULL API. Also, a prototype of an
+XmlSerializer interface can already be obtained from the CVS repository.
+For details, please refer to the ongoing discussion on
+the xmlpull-dev mailing list.
+
+
+Why is the XmlPullParserFactory class not abstract?
+
+The XmlPullParserFactory is not abstract to allow to use it "directly".
+Typical XMLPULL V1 API implementation should provide its own factory that
+extends XmlPullParserFactory. However if implementation factory class is
+not created, the default XmlPullParserFactory can be used to create
+parser instances. For that purpose, a comma separated list of parser class
+names, implementing the XmlPullParser interface,
+must be specified in the resource file
+/META-INF/services/org.xmlpull.v1.XmlPullParserFactory.
+This mechanism can also be used to specify factories extending the
+XmlPullParserFactory class. Making XmlPullParserFactory not abstract
+and allowing it to create parser instances directly allows to
+minimize size of XMLPULL implementations in J2ME environments - there
+is no need to write a factory class since the default XmlPullParserFactory
+can be used. Of course, for really tight memory environments, it may
+be more appropriate to use the constructor of a
+parser implementation directly, trading of the need of a
+factory class for some flexibility.
+
+To summarize, the XmlPullParserFactory has two distinct roles:
+
+ - it is a base class that can be used to create factory classes
+ for an API implementations (similarly to JAXP)
+ - it can be used in memory restricted environments to create parser
+ instances directly
+
+Please note that though XmlPullParserFactory is not abstract,
+it still can be used exactly the
+same way as if it were abstract. And in this respect it works exactly like
+factories in JAXP. Moreover, XMLPULL implementations should override
+XmlPullParserFactory to provide more customized and faster factories - the default
+factory uses Class.forName() and therefore may have a negative impact on
+performance.
+
+Why not use final method instead of TYPES array?
+
+The problem with modifiable entries in array is that user may by mistake modify
+entries (there is no way in java to declare a read-only array). However, this array
+is provided only to make conversion of parser event types to diagnostic text
+description easier; it has no influence on the parsing process itself. In the worst
+case, parser error messages using the TYPES array may be affected.
+
+It looks like a method would have been nicer - and would provide
+read-only conversion. But in that case it would not have been possible
+to put this functionality in the XmlPullParser interface without needing
+additional implementation effort in the parser.
+
+
+
How to access the latest source code?
+
+The latest packaged releases are available
+at http://www.xmlpull.org/,
+and the latest source (if you want to be on the cutting edge) can
+be obtained from anonymous CVS at:
+
+cvs -d :pserver:anonymous@cvs.xmlpull.org:/l/extreme/cvspub login
+CVS password: cvsanon
+
+cvs -d :pserver:anonymous@cvs.xmlpull.org:/l/extreme/cvspub co xmlpull-api-v1
+
+
+
+More questions?
+
+Please send additional questions and/or comments to the
+XMLPULL mailing list.
+
+
+Aleksander Slominski
+ and Stefan Haustein
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/features.html b/doc/features.html
new file mode 100644
index 0000000..83d4662
--- /dev/null
+++ b/doc/features.html
@@ -0,0 +1,317 @@
+
+
+XmlPull v1 API Features
+
+
+
+
+
+
+XmlPull v1 API Features
+
+
+
+The feature defines a discoverable and possibly changeable characteristic of
+XmlPull parser.
Please note: the key words "MUST", "MUST NOT", "REQUIRED",
+"SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED",
+"MAY", and "OPTIONAL" in this document are to be interpreted as
+described in RFC 2119.
+
+Standard features
+
+
+The semantics of of all standard features MUST be followed by every
+XmlPull v1 API
+implementation.
+
+All standard feature values MUST NOT change unless setFeature() is called
+(even when setInput() is called!)
+
+
+
+Standard feature: PROCESS NAMESPACES
+
+
+The feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#process-namespaces
+Processing of namespaces in XMLPULL V1 parser MUST be by default set to false.
+This feature MUST be recognized and allowed to be set both to true and
+false by every XMLPULL V1 API compliant parser implementation.
+If set to false XML namespaces MUST not be processed and instead
+namespace attributes (starting with xmlns) will be treated as normal
+attributes.
+If set to true than XML namespaces MUST be processed
+according to
+Namespaces in XML specification.
+The feature MUST be allowed to be changed only when parser is in
+START_DOCUMENT state i.e. this feature can not be changed during parsing.
+
+
+
+Standard feature: PROCESS DOCDECL
+
+Identified by
+http://xmlpull.org/v1/doc/features.html#process-docdecl
+The default value of the feature is undefined.
+If the VALIDATION feature is true then this feature MUST not be modified
+and MUST be reported as true
+If the feature is set to false and if
+XML document
+type declaration (in short DOCDECL) is encountered it MUST be reported by nextToken() and
+MUST be ignored by next(). Note that as the DOCDECL was ignored then
+during parsing may be fatal exception when
+undeclared entity is encountered!
+If the feature is true and VALIDATION feature is false then parser MUST be non validating as defined
+in XML 1.0 specification
+(DOCDECL MUST be parsed and processed by parser).
+If the feature is true and VALIDATION feature is true then parser MUST be validating
+as defined in XML 1.0
+specification.
+The feature MUST be allowed to be changed only when parser is in
+START_DOCUMENT state i.e. this feature can not be changed during parsing.
+
+Standard feature: VALIDATION
+
+Identified by
+http://xmlpull.org/v1/doc/features.html#validation
+The feature MUST be false by default.
+See description of PROCESS DOCDECL feature for
+required behavior.
+If the feature is set to true then PROCESS DOCDECL MUST be automatically
+set to true as well.
+The feature MUST be allowed to be changed only when parser is in
+START_DOCUMENT state i.e. this feature can not be changed during parsing.
+
+
+
+Optional features
+
+They MAY be supported but are not part of XmlPull API
+
+
+
+
+
+
+Optional feature: REPORT NAMESPACE ATTRIBUTES
+
+The feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#report-namespace-prefixes
+The feature MUST be false by default and only meaningful when PROCESS NAMESPACES feature
+is on.
+This feature MAY be recognized and allowed to be set to true (by default as other optional features it is false)
+
+
+When set to true then XMLPULL parser MUST report namespace attributes
+also - they can be distinguished looking for prefix == "xmlns" or prefix == ""
+and name == "xmlns
+The feature MUST be allowed to be changed only when parser is in
+START_DOCUMENT state i.e. this feature can not be changed during parsing.
+
+
+
+
+
+Optional feature: NAMES INTERNED
+
+This feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#names-interned
+If set to true then XMLPULL parser MUST intern all returned names
+using java.lang.String.intern that includes following functions: getName(),
+getPrefix(), getNamespace(), getNamespace(prefix), getNamespacePrefix(int),
+getNamespaceUri(int pos) , getAttributeName(), getAttributeNamespace(),
+getAttributePrefix(), getAttributeType(). However this feature provides no
+assurance about String values (like getText()) or attribute values
+(getAttributeValue()).
+
+NOTE: when enabled this feature allows for fast testing of equality against
+string constants (no need to use String.equals()).
+
+
+
+
+Optional feature: EXPAND ENTITY REF
+This feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#expand-entity-ref
+
+
+This optional feature changes behavior of nextToken() and when enabled parser
+MUST report expanded entity reference content as tokens and MUST
+report end of expanded entity ref as ENTITY_REF with name that is null
+(getText() returns null).
+
+
+For example if entity foo was defined to have replacement text bar then parser
+will report following tokens: ENTITY_REF with 'foo' as entity name, TEXT with
+value 'bar' and ENTITY_REF with no name to signal end of expansion) . If
+PROCESS_DOCDECL is true then reported tokens may include START_TAG/END_TAG if
+entity has embedded markup and ENTITY_REF for recursively expanded entity
+references (following calls to nextToken() will report entity content as
+possibly multiple TEXT, START_TAG, END_TAG, ENTITY_REF etc.).
+
+
+NOTE: it can only be supported when PROCESS_DOCDECL is true as
+defineEntityReplacementText() will always escape markup or entity references.
+
+
+NOTE: next() will always expand entity ref and report combined TEXT event and
+this feature does not affect next() behavior.
+
+
+Optional feature: XML ROUNDTRIP
+This feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#xml-roundtrip
+If ROUNDTRIP is on it is affecting getText/getTextCharacters() when
+nextToken() is used to make possible an exact roundtrip of XML 1.0 input -
+here are constraints on values returned by getText()/getTextCharacters:
+
+
+ - for all tokens exactly what was in input MUST be returned -
+ in particular returned content MUST NOT be end-of-line normalized (the
+ algorithm described in
+XML 1.0 End-of-Line
+Handling is not applied)
+ - for START_TAG and END_TAG event original XML value MUST be returned
+ for events for start/end tag (for example "tag" for <tag>)
+ - for PROCESSING INSTRUCTION event exact content of PI MUST be
+ returned: in <?target data?> white spaces between target and
+ data must be preserved
+ - content of XMLDecl must be reported as not null by
+ XMLDECL
+ CONTENT property
+ - DOCDECL MUST be reported exactly as in input
+
+
+ - additionally for nextToken(): ignorable whites spaces outside root element
+ MUST be reported as IGNORABLE_WHITESPACE
+
+By default this feature is off and it implies unchanged behavior of
+XmlPullParser:
+
+
+ - for all tokens call to getText()/getTextCharacters returns end-of-line
+ normalized content
+ (that includes beside TEXT, IGNORABLE_WHITESPACE also COMMENT,
+ PROCESSING_INSTRUCTION, ENTITY_REF etc.)
+ - getText() for START_TAG and END_TAG event MUST return null
+ - PROCESSING_INSTRUCTION MUST be reported as target + ' ' + data or exactly
+ as it was in input
+ - DOCDECL MUST be reported exactly if PROCESS DOCDECL is true otherwise MAY
+ be reported (but does not have to and may be even null)
+ - ignorable whites spaces (event IGNORABLE_WHITESPACE) outside root element
+ MAY be reported by nextToken()
+
+Note that content outside of root element is typically not reported by
+parsers to make it
+consistent with XML infoset
+Document
+Information Item properties in which white spaces in prolog and part root
+element are ignored. If reported IGNORABLE_WHITESPACE event may be used to
+preserved formatting of XML input when serializing it.
+
+However as IGNORABLE_WHITESPACE event MAY be reported make sure that
+application will be prepared to ignore IGNORABLE_WHITESPACE evens from
+nextToken() when processing content outside of root element (getDepth() == 0).
+
+
+
+
+Optional feature: DETECT ENCODING
+
+This feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#detect-encoding
+If this feature is true it means that XmlPull parser MUST detect
+encoding from input stream when inputEncoding is null
+in call setInput(InputStream inputStream, String inputEncoding).
+
+Parameter
+inputStream from setInput(InputStream inputStream, String inputEncoding)
+contains raw byte input stream of possibly
+unknown encoding (when inputEncoding is null) and in such case the parser
+must derive encoding from <?xml declaration or assume UTF8 or UTF16 as
+described in XML 1.0
+Appendix F.1 Detection Without External Encoding Information
+otherwise if inputEncoding is present then it must be used
+(this is consistent with
+XML 1.0
+Appendix F.2 Priorities in the Presence of External Encoding Information
+that allows for exception only for files and in such cases inputEncoding should
+be null to trigger auto detecting.
+
+
+
+
+
+
+Optional feature: SERIALIZER
+ATTVALUE USE APOSTROPHE
+
+This feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#serializer-attvalue-use-apostrophe
+If this feature is supported that means that XmlSerializer output for
+attribute value quotation can be controlled (when serializing XML 1.0 it allows
+to chose one of alternative
+representations for AttValue).
+
+If the feature is set to true it means than XmlSerializer parser MUST
+use apostrophe (') to quote attribute value.
+
+If the feature is set to false it means than XmlSerializer parser MUST
+use quotation mark (") to quote attribute value.
+
+
+
+
+
+Optional feature: RELAXED
+
+This feature is identified by
+
+http://xmlpull.org/v1/doc/features.html#relaxed
+If this feature is supported that means that XmlPull parser will be lenient
+when checking XML well formedness.
+
+NOTE: use it only if XML input is not well-formed and in general usage
+if this feature is discouraged
+
+NOTE: as there is no definition of what is relaxed XML parsing
+therefore what parser will do completely depends on implementation used
+
+
+
+
+
+
+
+
+Aleksander Slominski
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/javadoc_stylesheet.css b/doc/javadoc_stylesheet.css
new file mode 100644
index 0000000..e78c98e
--- /dev/null
+++ b/doc/javadoc_stylesheet.css
@@ -0,0 +1,41 @@
+/* Javadoc style sheet */
+
+a:link { color: #006600 }
+a:visited { color: #003300 }
+a:active { color: #00FF00 }
+
+/* Define colors, fonts and other style attributes here to override the defaults */
+
+/* Page background color */
+body { background-color: #FFFFFF }
+
+/*.TableHeadingColor { background: #CCCCFF } */
+/*.TableSubHeadingColor { background: #EEEEFF } */
+/*.NavBarCell1 { background-color:#EEEEFF;}*/
+/*.NavBarCell1Rev { background-color:#00008B;}*/
+
+
+/* Table colors */
+.TableHeadingColor { background: #AAFFAA } /* Dark mauve */
+.TableSubHeadingColor { background: #BBFFBB } /* Light mauve */
+.TableRowColor { background: #FFFFFF } /* White */
+
+/* Font used in left-hand frame lists */
+.FrameTitleFont { font-size: normal; font-family: normal }
+.FrameHeadingFont { font-size: normal; font-family: normal }
+.FrameItemFont { font-size: normal; font-family: normal }
+
+/* Example of smaller, sans-serif font in frames */
+/* .FrameItemFont { font-size: 10pt; font-family: Helvetica, Arial, sans-serif } */
+
+/* Navigation bar fonts and colors */
+.NavBarCell1 { background-color:#EEFFEE;}/* Light mauve */
+.NavBarCell1Rev { background-color:#008B00;}/* Dark Blue */
+.NavBarFont1 { font-family: Arial, Helvetica, sans-serif; color:#000000;}
+.NavBarFont1Rev { font-family: Arial, Helvetica, sans-serif; color:#FFFFFF;}
+
+.NavBarCell2 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;}
+.NavBarCell3 { font-family: Arial, Helvetica, sans-serif; background-color:#FFFFFF;}
+
+
+
diff --git a/doc/properties.html b/doc/properties.html
new file mode 100644
index 0000000..0086dc3
--- /dev/null
+++ b/doc/properties.html
@@ -0,0 +1,192 @@
+
+
+XmlPull v1 API Properties
+
+
+
+
+
+XmlPull v1 API Properties
+
+
+
+The property mechanism allows to pass information to
+XmlPull parser implementation that is not part of API.
Please note: the key words "MUST", "MUST NOT", "REQUIRED",
+"SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED",
+"MAY", and "OPTIONAL" in this document are to be interpreted as
+described in RFC 2119.
+
+
+
+
+Standard properties
+
+
+Currently there is no standard properties defined.
+
+
+
+Optional properties
+
+They MAY be supported but are not part of
+XmlPull API.
+Please report suggestions for other useful properties to
+XmlPull discussion group so they can be added here and
+made easier to discover.
+
+
+NOTE: to detect if optional property
+is supported try to call getProperty()
+and only if it returns non-null value
+it can be assumed that the property is supported.
+Implementations are required to return null
+for all unknown properties names as null
+is assumed to be default value for all properties.
+
+
+
+
+
+Optional property: LOCATION
+This property is identified by
+http://xmlpull.org/v1/doc/properties.html#location
+
+This property takes String as value. If supported this property can be set after setInput() to indicate
+location of input (for parser) or output (for serializer). The value of this
+property will be then used in getPositionDescription() and in exception messages
+to provide better diagnostic messages.
+
+
+
+
+
+
+Optional property: XMLDECL VERSION
+This property is identified by
+
+http://xmlpull.org/v1/doc/properties.html#xmldecl-version
+If PROCESS
+DOCDECL feature is enabled it is REQUIRED property with String otherwise it
+is optional.
+
+If supported and there was
+VersionInfo version in
+XMLDecl then it returns
+its content if standalone='no' otherwise if there was no standalone declaration
+or this property is not supported it returns null.
+
+For example if input XML stream contained <?xml version='1.0'
+standalone='true'?> then this property will contain "1.0".
+
+
+
+
+
+Optional property: XMLDECL STANDALONE
+This feature is identified by
+
+http://xmlpull.org/v1/doc/properties.html#xmldecl-standalone
+If PROCESS
+DOCDECL feature is enabled it is REQUIRED property with Boolean otherwise it
+is optional.
+
+If supported and there was
+SDDecl standalone in
+XMLDecl then it returns Boolean(true) if standalone='yes' or Boolean(false)
+if standalone='no' otherwise if there was no standalone declaration or this
+property is not supported it returns null.
+
+
+
+
+
+Optional property: XMLDECL CONTENT
+This feature is identified by
+
+http://xmlpull.org/v1/doc/properties.html#xmldecl-content
+If XML
+ROUNDTRIP feature is enabled it is REQUIRED property with String otherwise
+it is optional.
+
+If XML ROUNDTRIP feature is true then this property MUST contain everything
+after '<?xml' and before final '?>' if XML input contained XMLDecl (see section
+2.8 Prolog and Document Type
+Declaration in XML 1.0 ). For example if input XML stream contained <?xml
+version='1.0' standalone='true'?> then this property will contain "
+version='1.0' standalone='true'".
+
+
+
+
+Optional property: SERIALIZER INDENTATION
+This property is identified by
+
+http://xmlpull.org/v1/doc/properties.html#serializer-indentation
+OPTIONAL property with String value
+
+If passed string is not empty that it is used to indent output by one level.
+
+If passed string is empty only line separator (depending on
+LINE SEPARATOR property) will be
+written for indentation (if any).
+
+Otherwise if string is null no indentation
+is not done
+
+For example use TAB ("\t") or few spaces (" ")
+as string value.
+
+
+
+
+Optional property: SERIALIZER LINE
+SEPARATOR
+This property is identified by
+
+http://xmlpull.org/v1/doc/properties.html#serializer-line-separator
+OPTIONAL property with String value
+
+If indentation is enabled passed string will be used as line separator.
+
+If supported by default this property should be initialized just new line
+character ("\n").
+
+If value of property is null or it is String of length() == 0 no line separator
+will be written.
+
+
+
+
+
+
+
+
+
+
+
+
+Aleksander Slominski
+Last Modified: $Id: properties.html,v 1.9 2003/04/23 12:25:18 aslom Exp $
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/doc/quick_intro.html b/doc/quick_intro.html
new file mode 100644
index 0000000..eba77e1
--- /dev/null
+++ b/doc/quick_intro.html
@@ -0,0 +1,218 @@
+
+
+Quick Introduction to XmlPull v1 API
+
+
+
+
+
+
+Quick Introduction to XmlPull v1 API
+
+
XmlPull v1 API is a simple to use XML pull parsing API that was designed for
+simplicity and very good performance both in constrained environment such as
+defined by J2ME and on server side when used in J2EE application servers. XML
+pull parsing allows incremental (sometimes called streaming) parsing of XML where
+application is in control - the parsing can be interrupted at any given moment
+and resumed when application is ready to consume more input.
This document
+will show step by step how to create a simple application that is using
+XmlPull API to parse XML. If you need to write XML output check a companion
+document Quick Introduction to writing XML with
+XmlSerializer. For more comprehensive introduction to XmlPull v1 API and XML pull
+parsing in general read JavaWorld.com article "XML
+documents on the run, Part 3" by Dennis
+M. Sosnoski.
Main features of API
+
+
+Java version of XmlPull v1 API provides:
+- simple interface - parser consists of one interface, one exception
+and one factory to create parser
- implementation independent - factory
+class is modeled after JAXP and allows easily to switch to different XmlPull V1
+API implementation without even modifying source code
- ease of use -
+there is only one key method next() that is used to retrieve next
+event and there are only five events:
+
+- START DOCUMENT
- document start - parser has not yet read any input
+
- START_TAG
- parser is on start tag
+
- TEXT
- parser is on element content
+
- END_TAG
- parser is on end tag
+
- END_DOCUMENT
- document finished and no more parsing is allowed
+
+ - versatility - it is generic interface for XML parser and allows for
+multiple implementations and extensibility through features and properties
+
- performance - the interface is designed to allow implementing very fast XML parsers
+
- minimal requirements - designed to be compatible with J2ME (Java 2 Micro Edition)
+to work and on small devices and to allow create XmlPull compliant parsers of very small
+memory footprint.
+
+
+
+Requirements
+
+XmlPull is API and it requires implementation to run.
+
+See list of implementations
+on XmlPull website. After downloading one of implementations of XmlPull API v1 (version 1.1
+or newer)
+add jar file to your CLASSPATH. As XmlPull uses factory there is no need to
+explicitly state what is class with parser implementation: it will be picked up
+automatically from implementation jar file.
Code step-by-step
+
+First we need to create an instance of parser.
+To do this three steps are required:
+- get instance of XmlPull factory
+
- (optional step) by default factory will produce parsers that are not
+namespace aware; to change setNamespaceAware() function must be called
+
- create an instance of the parser
+
+
+Before doing anything make sure to import XmlPull v1 API classes:
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+
+
+
+and the code to do this may look similar to this:
+
+ XmlPullParserFactory factory = XmlPullParserFactory.newInstance(
+ System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null);
+ factory.setNamespaceAware(true);
+ XmlPullParser xpp = factory.newPullParser();
+
+
+Next step is to set parser input:
+
+ xpp.setInput ( new FileReader ( args [i] ) );
+
+
+and now we can start parsing!
+
+Typical XmlPull applicaition will repeatedly call
+next() function to retrieve next event, process event
+until the even is END_DOCUMENT:
+
+
public void processDocument(XmlPullParser xpp)
+ throws XmlPullParserException, IOException
+ {
+ int eventType = xpp.getEventType();
+ do {
+ if(eventType == xpp.START_DOCUMENT) {
+ System.out.println("Start document");
+ } else if(eventType == xpp.END_DOCUMENT) {
+ System.out.println("End document");
+ } else if(eventType == xpp.START_TAG) {
+ processStartElement(xpp);
+ } else if(eventType == xpp.END_TAG) {
+ processEndElement(xpp);
+ } else if(eventType == xpp.TEXT) {
+ processText(xpp);
+ }
+ eventType = xpp.next();
+ } while (eventType != xpp.END_DOCUMENT);
+ }
+
+
+
+Let see how to process start tag.
+Processing end tag is very similar - main difference is that the end tag has no attributes.
+
+
public void processStartElement (XmlPullParser xpp)
+ {
+ String name = xpp.getName();
+ String uri = xpp.getNamespace();
+ if ("".equals (uri)) {
+ System.out.println("Start element: " + name);
+ } else {
+ System.out.println("Start element: {" + uri + "}" + name);
+ }
+ }
+
+
+And now let see how element content is retrieved and printed:
+
+
int holderForStartAndLength[] = new int[2];
+ public void processText (XmlPullParser xpp) throws XmlPullParserException
+ {
+ char ch[] = xpp.getTextCharacters(holderForStartAndLength);
+ int start = holderForStartAndLength[0];
+ int length = holderForStartAndLength[1];
+ System.out.print("Characters: \"");
+ for (int i = start; i < start + length; i++) {
+ switch (ch[i]) {
+ case '\\':
+ System.out.print("\\\\");
+ break;
+ case '"':
+ System.out.print("\\\"");
+ break;
+ case '\n':
+ System.out.print("\\n");
+ break;
+ case '\r':
+ System.out.print("\\r");
+ break;
+ case '\t':
+ System.out.print("\\t");
+ break;
+ default:
+ System.out.print(ch[i]);
+ break;
+ }
+ }
+ System.out.print("\"\n");
+ }
+
+
+Complete sample
+
+
+
+
+
+The finished working sample created that was described is in
+MyXmlPullApp.java file in
+src/java/samples directory.
+
+For more information please visit
+http://www.xmlpull.org/.
+
+Output
+
+
+java MyXmlPullApp
+parser implementation class is class org.xmlpull.xpp3.PullParser
+Parsing simple sample XML
+Start document
+Start element: {http://www.megginson.com/ns/exp/poetry}poem
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}title
+Characters: "Roses are Red"
+End element: {http://www.megginson.com/ns/exp/poetry}title
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "Roses are red,"
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "Violets are blue;"
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "Sugar is sweet,"
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "And I love you."
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+End element: {http://www.megginson.com/ns/exp/poetry}poem
+
+
+
+Aleksander Slominski
+
+
+
+
\ No newline at end of file
diff --git a/doc/quick_write.html b/doc/quick_write.html
new file mode 100644
index 0000000..25c22f8
--- /dev/null
+++ b/doc/quick_write.html
@@ -0,0 +1,236 @@
+
+
+Quick Introduction to generting XML with XmlPull v1 API
+
+
+
+
+
+
+Quick Introduction to generating XML with XmlPull v1 API
+
+
This document describes how to use XmlSerializer that is part of XmlPull API
+to generate/write/serialize XML.
+
+
Main features of API
+
+
+XmlSerializer provides:
+
+- simple to use API that concentrates on hot generate correct XML
+quickly and in straightforward manner
- support for namespaces with automatic prefix declaration to make
+it as easy as possible to generate valid XML 1.0 documents with Namespaces
+
+
+
- control over namespace prefixes even though control over namespace
+prefixes is typically not needed
+but as prefixes are used in attribute values so it is important to allow
+control on how namespace prefixes are assigned if needed
- performance
+- the interface is designed to allow implementing very fast XML serializer
+
+
- minimal requirements - designed to be compatible with J2ME (Java 2 Micro Edition)
+to work on small devices and to allow creating XmlPull compliant serializer
+implementation with very small
+memory footprint.
+
+
+
+
+Requirements
+
+Before running sample code make sure to have parser that implements XmlPull
+API 1.1.x (read relevant part from Quick
+Introduction)
Writing XML: in few easy steps
+
+All XML generating can be done by using XmlSerializer interface.
+However before we can start writing we need to obtain instance of class that
+implements this interface.
+
+
XmlPull API allows multiple implementations to be used.
+To achieve this flexibility serializer class is not created directly but by
+using configurable factory that is responsible for locating and creating
+implementation. In general that involves following steps:
+
+
+- get instance of XmlPull factory - you can use system property as argument
+to configure factory with list of implementation to try and you can pass
+class to use as class loader context (important in servlet and application servers environments)
+
- create an instance of the serializer
+
+
+In your code as the first thing make sure to import XmlPull v1 API classes:
+
+import org.xmlpull.v1.XmlPullParserException;
+import org.xmlpull.v1.XmlPullParserFactory;
+import org.xmlpull.v1.XmlSerializer;
+
+
+
+and the code to create serializer may look like this:
+
+ XmlPullParserFactory factory = XmlPullParserFactory.newInstance(
+ System.getProperty(XmlPullParserFactory.PROPERTY_NAME), null);
+ XmlSerializer serializer = factory.newSerializer();
+
+
+Next step is to set serializer output - in this case it is set to write to
+standard output but can easily redirected to file or socket:
+
+ serializer.setOutput(new PrintWriter( System.out ));
+
+
+and now we can start using serializer to write XML!
+
+Typical applicaition will write XML declaration and then follow
+with writing few element start and end tags and their content.
+
+
Output must always have at least one start tag:
+
serializer.startTag(NAMESPACE, "poem");
+
+
+then we cna start writing more start tags, text cotnent, and end tags:
+
+ serializer.startTag(NAMESPACE, "title");
+ serializer.text("Roses are Red");
+ serializer.endTag(NAMESPACE, "title");
+
+
+where namespace is declared as string constant
+private final static String NAMESPACE = "http://www.megginson.com/ns/exp/poetry";
+
+it is possible to chain multiple calls:
+
+
serializer.startTag(NAMESPACE, "l")
+ .text("Roses are red,")
+ .endTag(NAMESPACE, "l");
+
+
+or put them even in one line:
+ serializer.startTag(NAMESPACE, "l").text("Violets are blue;").endTag(NAMESPACE, "l");
+
+
+but what make API really flexible and modular is to define functions that
+outputs well defined parts of XML, for example:
+ private static void writeLine(XmlSerializer serializer, String line, boolean addNewLine)
+ throws IOException {
+ serializer.startTag(NAMESPACE, "l");
+ serializer.text(line);
+ serializer.endTag(NAMESPACE, "l");
+ if(addNewLine) serializer.text("\n");
+ }
+
+
+and then to write chunkof XML output it is enough to simply call:
+ writeLine(serializer, "Sugar is sweet,", addNewLine);
+ writeLine(serializer, "And I love you.,", addNewLine);
+
+
+
+Serializer will check that end tag name and namespace is the same as
+of matching start tag (very good to validate that XML output is correct)
+so to finish writing XML we should close top level start tag:
+
+
serializer.endTag(NAMESPACE, "poem");
+
+It is important to inform serializer when XML output is finished
+so any remianing buffered XML output is send to putput stream and
+serializer will not allow any more input to do this call endDocument():
+
+
serializer.endDocument();
+
+
+
+
+Controlling namespace prefixes
+
+There is no need to manually set prefixes as XmlSerializer will automatically
+declare prefixes when needed. However sometimes it is necessary to indicate
+what prefix should be used:
+
+ serializer.setPrefix("ns", NAMESPACE);
+
+or what namespace should be bound as default namespace (to special empty string prefix):
+
+ serializer.setPrefix("", NAMESPACE);
+
+Prefix declaration must be done just before call to start tag and
+the prefix declaration scope starts on this star tag and finishes when corresponding
+end tag is reached.
+
+
Controlling output formatting
+
+XmlSerializer allows to create any infoset so it is possible to add manually
+new lines or indentation. for exmaple if would like to have new line after every end tag
+it is as easy as to call text() with new line:
+
+
if(addNewLine) serializer.text("\n");
+
+If serializer supports optional formatting properties and features then
+they can be used to have output indented automatically.
+Read more about them:
+
+
+
+
+
+
+Sample code
+
+
+The finished working sample created that was described is in
+MyXmlWriteApp.java file in
+src/java/samples directory.
+
+
For more information about XmlPull API
+please visit
+http://www.xmlpull.org/.
+
+
+
+
+
+
+Output from sample application
+
+When new lines are added manually:
+
+
java MyXmlWriteApp -n
+serializer implementation class is class org.kxml2.io.KXmlSerializer
+<?xml version="1.0"?>
+
+<poem xmlns="http://www.megginson.com/ns/exp/poetry">
+<title>Roses are Red</title>
+<l>Roses are red,</l>
+<Violets are blue;</l>
+<l>Sugar is sweet,</l>
+<l>And I love you.,</l>
+</poem>
+
+
+When using one of optional formatting properties to set indentation:
+
+
java MyXmlWriteApp -i 4
+serializer implementation class is class org.xmlpull.mxp1_serializer.MXSerializer
+<?xml version="1.0"?>
+
+<poem xmlns="http://www.megginson.com/ns/exp/poetry">
+ <title>Roses are Red</title>
+ <l>Roses are red,</l>
+ <l>Violets are blue;</l>
+ <l>Sugar is sweet,</l>
+ <l>And I love you.,</l>
+</poem>
+
+
+
+Aleksander Slominski
+
+
+
\ No newline at end of file
diff --git a/doc/run.txt b/doc/run.txt
new file mode 100644
index 0000000..6f90207
--- /dev/null
+++ b/doc/run.txt
@@ -0,0 +1,75 @@
+Running XMLPULL samples
+------------------------
+
+Make sure that API and (optionally) all automatic tests are build,
+see build.txt file in the same directory for details
+
+To run samples please use provided run script (on Windows run.bat and on UNIX run.sh).
+Samples can be run without run script but CLASSPATH needs to be
+
+Before running make sure that JAVA_HOME environment variable points
+to your installation of JDK version 1.3 or above.
+
+Before running samples ...
+--------------------------
+
+
+Before running samples automatic tests should be executed using run script
+to verify that you have properly installed and running XMLPULL implementation,
+
+NOTE: Make sure to have a jar file with XML PULL API V1 implementation
+in lib/impl_xmlpull_v1_api directory (and see build.txt instructions
+on how to build tests and then execute) then execute (on Windows run.bat
+on UNIX use ./run.sh):
+
+ run junit
+
+and you should see output similar to:
+
+ ..............
+ Time: 3.091
+
+ OK (14 tests)
+
+
+
+Running samples:
+-------------------------------------
+
+NOTE: Make sure to have a jar file with XML PULL API V1 implementation
+in lib/impl_xmlpull_v1_api directory and follow build.txt instructions
+on how to build samples.
+
+Then you can run every sample using provided run script (run.bat on Windows
+and ./run.sh on UNIX), for example (uses XPP3 jar file):
+
+C:\Forge\xmlpull-api-v1>run MyXmlPullApp
+JAVA_HOME=c:\jdk1.3
+c:\jdk1.3\bin\java -cp build\classes;build\samples;build\tests;lib\impl_xmlpull_v1_api\xpp3_1_0_5.
+jar;lib\junit\junit37.jar; MyXmlPullApp
+parser implementation class is class org.xmlpull.xpp3.PullParser
+Parsing simple sample XML
+Start document
+Start element: {http://www.megginson.com/ns/exp/poetry}poem
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}title
+Characters: "Roses are Red"
+End element: {http://www.megginson.com/ns/exp/poetry}title
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "Roses are red,"
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "Violets are blue;"
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "Sugar is sweet,"
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+Start element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "And I love you."
+End element: {http://www.megginson.com/ns/exp/poetry}l
+Characters: "\n"
+End element: {http://www.megginson.com/ns/exp/poetry}poem
diff --git a/lib/ant/LICENSE.txt b/lib/ant/LICENSE.txt
new file mode 100644
index 0000000..032be14
--- /dev/null
+++ b/lib/ant/LICENSE.txt
@@ -0,0 +1,48 @@
+/*
+ * ============================================================================
+ * The Apache Software License, Version 1.1
+ * ============================================================================
+ *
+ * Copyright (C) 1999 The Apache Software Foundation. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modifica-
+ * tion, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. The end-user documentation included with the redistribution, if any, must
+ * include the following acknowledgment: "This product includes software
+ * developed by the Apache Software Foundation (http://www.apache.org/)."
+ * Alternately, this acknowledgment may appear in the software itself, if
+ * and wherever such third-party acknowledgments normally appear.
+ *
+ * 4. The names "Ant" and "Apache Software Foundation" must not be used to
+ * endorse or promote products derived from this software without prior
+ * written permission. For written permission, please contact
+ * apache@apache.org.
+ *
+ * 5. Products derived from this software may not be called "Apache", nor may
+ * "Apache" appear in their name, without prior written permission of the
+ * Apache Software Foundation.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * APACHE SOFTWARE FOUNDATION OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLU-
+ * DING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * on behalf of the Apache Software Foundation. For more information on the
+ * Apache Software Foundation, please see .
+ *
+ */
diff --git a/lib/ant/README.txt b/lib/ant/README.txt
new file mode 100644
index 0000000..ef9e091
--- /dev/null
+++ b/lib/ant/README.txt
@@ -0,0 +1,2 @@
+Contains all that is required to build package with ANT
+For more details please see: http://jakarta.apache.org/ant/
diff --git a/lib/ant/ant-1.4.1.jar b/lib/ant/ant-1.4.1.jar
new file mode 100644
index 0000000000000000000000000000000000000000..8ad84e348091fa8e10ef2e58a236cc0e807a1c00
GIT binary patch
literal 417110
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 |