Bumped version to 2.0.1a

gitignore added maven target/ and intellij project stuff
simplified a return statement in PluginPlayerListener
added TODO in LocationSerializer (creating a world should not be done
there)

.classpath

@@ -2,10 +2,6 @@
 <classpath>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
-	<classpathentry kind="lib" path="/Volumes/Data HD/Users/tobi/Code/bukkit-1.1-R5-20120224.051137-12.jar" sourcepath="/Users/tobi/Desktop/Bukkit">
-		<attributes>
-			<attribute name="javadoc_location" value="http://jd.bukkit.org/apidocs/"/>
-		</attributes>
-	</classpathentry>
+	<classpathentry kind="lib" path="/Users/tobi/Code/craftbukkit-1.4.5-R1.0.jar"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>

.gitignore

@@ -6,6 +6,13 @@
 # netbeans
 /nbproject
 
+# intelliJ
+.idea/
+*.iml
+
+# maven
+target/
+
 # vim
 .*.sw[a-p]
 

.project

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
-	<name>AncientGates</name>
+	<name>craftinc-gates</name>
 	<comment></comment>
 	<projects>
 	</projects>

LICENCE.txt

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, 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
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If 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 convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU 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
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is 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 General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

README.md

@@ -1,50 +1,51 @@
-#AncientGates - Easily create portals with custom design#
+# Craft Inc. Gates – Easily create portals with custom design
 
-Read the full userguide here: TODO
+(previously known as __AncientGates__)
 
-With this plugin the server operators (OPs) can create gates that will teleport anyone who enter to a location specific to that gate. The hightlights are: __It is so darn easy to use!__ :D and __The gates can look any way you like__ \o/
+With this plugin players can create gates that will teleport anyone who enter the gate to specific a location.
+The hightlights are: __It is so darn easy to use!__ and __The gates can look any way you like__
 
 Try the ingame command: __/gate__
+
+Also have a look at the full __[userguide](http://www.craftinc.de/blog/?p=255)__.
+
 Thought first you should take a look at the demonstration oloflarsson and karibu6 created:
 __[http://www.youtube.com/watch?v=L4hyqTpeEaA](http://www.youtube.com/watch?v=L4hyqTpeEaA)__
 
-##Commands##
 
-* __/gate help,h,? *[page]__ Display a help page
-* __/gate create,new [id]__ Create a gate
-* __/gate createsetfrom,newsetfrom,csf,nsf [id]__ Create a gate and set "from"
-* __/gate delete,del,remove,rm [id]__ Delete a gate
-* __/gate setfrom [id]__ Set "from" to your location.
-* __/gate setto [id]__ Set "to" to your location.
-* __/gate open [id]__ Open that gate
-* __/gate close [id]__ Close that gate
-* __/gate list,ls [page]__ Display a list of the gates
-* __/gate info,details [id]__ Display information about a gate
-
-##FAQ##
-
-__Why the name AncientGates?__
-
-Because the purpose of this plugin that I envision is that players should not be able to create gates to other worlds themselves. The server operators build gates with cool ruins around them and in order to get to another world the players need to find one of those ruins.
+## FAQ
 
 __Who can create a gate?__
 
-Only server operators! Not normal players. There is no suport for any permissions plugin.
+See the _Permissions_ section.
 
 __Who can destroy a gate?__
 
-Anyone if you do not use a third-party protection plugin like Factions.
+Anyone if you do not use a third-party protection plugin like Grief Prevention.
 
 __Are there IConnomy integration, Features for user to dial other gates etc?__
 
 Nope. This plugin is very minimalistic and plain. Server operators manage the portals players use them any time they are open.
 
-Installing
-----------
-1. Download the latest release: __[https://github.com/tomco/minecraft-ancient-gates/downloads](https://github.com/tomco/minecraft-ancient-gates/downloads)__
-1. Put AncientGates.jar in the plugins folder.
+## Permissions
 
-License
-----------
-This project has a LGPL license just like the Bukkit project.<br>
-This project uses [GSON](http://code.google.com/p/google-gson/) which has a [Apache 2.0 license](http://www.apache.org/licenses/LICENSE-2.0 ).
+ __craftincgates.info__
+
+ Gives access to info and list commands.
+
+  __craftincgates.use__
+
+ Allows you to travel via gates.
+
+  __craftincgates.manage__
+
+ Gives access to commands manipulating gates.
+
+## Installing
+
+1. Download the latest release: __[http://dev.bukkit.org/server-mods/craftinc-gates/files/](http://dev.bukkit.org/server-mods/craftinc-gates/files/)__
+2. Put CraftIncGates.jar in the plugins folder.
+
+## License
+
+This project has a LGPL license just like the Bukkit project.

build.xml

@@ -1,74 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!-- You may freely edit this file. See commented blocks below for -->
-<!-- some examples of how to customize the build. -->
-<!-- (If you delete it and reopen the project it will be recreated.) -->
-<!-- By default, only the Clean and Build commands use this build script. -->
-<!-- Commands such as Run, Debug, and Test only use this build script if -->
-<!-- the Compile on Save feature is turned off for the project. -->
-<!-- You can turn off the Compile on Save (or Deploy on Save) setting -->
-<!-- in the project's Project Properties dialog box.-->
-<project name="AncientGates" default="default" basedir=".">
-    <description>Builds, tests, and runs the project AncientGates.</description>
-    <import file="nbproject/build-impl.xml"/>
-    <!--
-
-    There exist several targets which are by default empty and which can be 
-    used for execution of your tasks. These targets are usually executed 
-    before and after some main targets. They are: 
-
-      -pre-init:                 called before initialization of project properties
-      -post-init:                called after initialization of project properties
-      -pre-compile:              called before javac compilation
-      -post-compile:             called after javac compilation
-      -pre-compile-single:       called before javac compilation of single file
-      -post-compile-single:      called after javac compilation of single file
-      -pre-compile-test:         called before javac compilation of JUnit tests
-      -post-compile-test:        called after javac compilation of JUnit tests
-      -pre-compile-test-single:  called before javac compilation of single JUnit test
-      -post-compile-test-single: called after javac compilation of single JUunit test
-      -pre-jar:                  called before JAR building
-      -post-jar:                 called after JAR building
-      -post-clean:               called after cleaning build products
-
-    (Targets beginning with '-' are not intended to be called on their own.)
-
-    Example of inserting an obfuscator after compilation could look like this:
-
-        <target name="-post-compile">
-            <obfuscate>
-                <fileset dir="${build.classes.dir}"/>
-            </obfuscate>
-        </target>
-
-    For list of available properties check the imported 
-    nbproject/build-impl.xml file. 
-
-
-    Another way to customize the build is by overriding existing main targets.
-    The targets of interest are: 
-
-      -init-macrodef-javac:     defines macro for javac compilation
-      -init-macrodef-junit:     defines macro for junit execution
-      -init-macrodef-debug:     defines macro for class debugging
-      -init-macrodef-java:      defines macro for class execution
-      -do-jar-with-manifest:    JAR building (if you are using a manifest)
-      -do-jar-without-manifest: JAR building (if you are not using a manifest)
-      run:                      execution of project 
-      -javadoc-build:           Javadoc generation
-      test-report:              JUnit report generation
-
-    An example of overriding the target for project execution could look like this:
-
-        <target name="run" depends="AncientGates-impl.jar">
-            <exec dir="bin" executable="launcher.exe">
-                <arg file="${dist.jar}"/>
-            </exec>
-        </target>
-
-    Notice that the overridden target depends on the jar target and not only on 
-    the compile target as the regular run target does. Again, for a list of available 
-    properties which you can use, check the target you are overriding in the
-    nbproject/build-impl.xml file. 
-
-    -->
-</project>

gson-license.txt

@@ -1,13 +0,0 @@
-Copyright (c) 2008-2009 Google Inc. 
-
-Licensed under the Apache License, Version 2.0 (the "License"); 
-you may not use this file except in compliance with the License. 
-You may obtain a copy of the License at 
-
-  http://www.apache.org/licenses/LICENSE-2.0 
-
-Unless required by applicable law or agreed to in writing, software 
-distributed under the License is distributed on an "AS IS" BASIS, 
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-See the License for the specific language governing permissions and 
-limitations under the License.

plugin.yml

@@ -1,7 +1,29 @@
-name: AncientGates
-version: 1.1
-main: org.mcteam.ancientgates.Plugin
+name: Craft Inc. Gates
+version: 2.0.1a
+description: A plugin to create gates for fast traveling.
+author: tomco,  s1m0ne
+authors: [oloflarsson, locutus, DrAgonmoray, s1m0ne, tomco]
+website: http://www.craftinc.de/craftinc-gates/
+
+main: de.craftinc.gates.Plugin
+database: false
+
 commands:
   gate:
-    description: All of the AncientGates commands
-    usage: See documentation.
+    description: All of the Craft Inc. Gates commands
+    usage: See documentation or type '/gate help' while playing.
+
+permissions:
+  craftincgates.*:
+    description: Gives access to all ancient gates commands and lets you use open gates.
+    children:
+      craftincgates.info: true
+      craftincgates.use: true
+      craftincgates.manage: true
+  craftincgates.info:
+    description: Gives access to info and list commands.
+  craftincgates.use:
+    default: true
+    description: Allows you to use open gates.
+  craftincgates.manage:
+    description: Gives access to commands manipulating gates.

pom.xml

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>de.craftinc</groupId>
+    <artifactId>CraftIncGates</artifactId>
+    <packaging>jar</packaging>
+    <version>1.1.1</version>
+
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.bukkit</groupId>
+            <artifactId>bukkit</artifactId>
+            <version>RELEASE</version>
+            <type>jar</type>
+            <scope>compile</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <directory>target</directory>
+        <outputDirectory>target/classes</outputDirectory>
+        <finalName>${project.artifactId}</finalName>
+        <sourceDirectory>src</sourceDirectory>
+        <resources>
+            <resource>
+                <directory>src/resources</directory>
+            </resource>
+        </resources>
+    </build>
+
+    <repositories>
+        <repository>
+            <id>bukkit-repo</id>
+            <url>http://repo.bukkit.org/content/groups/public</url>
+        </repository>
+    </repositories>
+</project>

src/de/craftinc/gates/BaseGate.java

@@ -0,0 +1,195 @@
+package de.craftinc.gates;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+
+import de.craftinc.gates.util.FloodUtil;
+
+
+public abstract class BaseGate
+{
+	/*
+	 * ATTRIBUTES
+	 */
+	protected Location location; /* saving both location and gateBlockLocations is redundant but makes it easy to allow players to reshape gates */
+	protected Set<Location> gateBlockLocations = new HashSet<Location>(); /* Locations of the blocks inside the gate */
+	
+	protected Location exit;
+	
+	protected boolean isHidden = false;
+	protected boolean isOpen = false;
+	
+	
+	/*
+	 * SETTER & GETTER
+	 */	
+	
+	public Location getLocation() 
+	{
+		return location;
+	}
+	
+	
+	public void setLocation(Location location)  throws Exception
+	{
+		this.location = location;
+		
+		if (isOpen) {
+			fillGate();
+			validate();
+		}
+	}
+	
+	
+	public Location getExit() 
+	{
+		return exit;
+	}
+	
+	
+	public void setExit(Location exit)  throws Exception
+	{
+		this.exit = exit;
+		validate();
+	}
+	
+	
+	public boolean isHidden() 
+	{
+		return isHidden;
+	}
+	
+	
+	public void setHidden(boolean isHidden) throws Exception
+	{
+		this.isHidden = isHidden;
+		
+		if (isHidden == true) {
+			emptyGate();
+		}
+		else if (isOpen()) {
+			fillGate();
+		}
+		
+		validate();
+	}
+	
+	
+	public boolean isOpen() 
+	{
+		return isOpen;
+	}
+	
+	
+	public void setOpen(boolean isOpen) throws Exception
+	{
+		if (isOpen == true && this.isOpen == false) {
+			findPortalBlocks();
+			
+			if (!isHidden) {
+				fillGate();
+			}
+		}
+		else if (isOpen == false && this.isOpen == true) {
+			emptyGate();
+		}
+		
+		this.isOpen = isOpen;
+		
+		validate();
+	}
+	
+	
+	public Set<Location> getGateBlockLocations() 
+	{
+		return gateBlockLocations;
+	}
+	
+	
+	/*
+	 * GATE BLOCK HANDLING
+	 */
+	
+	protected void fillGate()
+	{	
+		emptyGate();
+		findPortalBlocks();
+		
+		// This is not to do an effect
+		// It is to stop portal blocks from destroying themself as they cant rely on non created blocks :P
+		for (Location l : gateBlockLocations) {
+			l.getBlock().setType(Material.GLOWSTONE);
+		}
+		
+		for (Location l : gateBlockLocations) {
+			l.getBlock().setType(Material.PORTAL);
+		}
+	}
+	
+	
+	protected void emptyGate()
+	{
+		for (Location l : gateBlockLocations) {
+			if (l.getBlock().getType() == Material.PORTAL) {
+				l.getBlock().setType(Material.AIR);
+			}
+		}
+	}
+	
+	
+	protected void findPortalBlocks() 
+	{
+		gateBlockLocations = new HashSet<Location>();
+		Set<Block> gateBlocks = FloodUtil.getGateFrameBlocks(location.getBlock());
+		
+		if (gateBlocks != null) {
+			for (Block b : gateBlocks) {
+				gateBlockLocations.add(b.getLocation());
+			}
+		}
+	}
+	
+	
+	/*
+	 * VALIDATION
+	 */
+	
+	/**
+	 * Checks if valus attributes do add up; will close gate on wrong values.
+	 */
+	public void validate() throws Exception
+	{
+		if (!isOpen) {
+			return;
+		}
+		
+		if (location == null) {
+			setOpen(false);
+			throw new Exception("Gate got closed. It has no location.");
+		}
+		
+		if (exit == null) {
+			setOpen(false);
+			throw new Exception("Gate got closed. It has no exit.");
+		}
+		
+		if (gateBlockLocations.size() == 0) {
+			setOpen(false);
+			throw new Exception("Gate got closed. The frame is missing or broken.");
+		}
+		
+		
+		if (isHidden == false) {			
+			for (Location l : gateBlockLocations) {
+				if (l.getBlock().getType() == Material.AIR) {
+					setOpen(false);
+					throw new Exception("Gate got closed. The frame is missing or broken.");
+				}
+			}
+		}	
+	}
+}

src/de/craftinc/gates/Gate.java

@@ -0,0 +1,205 @@
+package de.craftinc.gates;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import org.bukkit.Location;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+
+import de.craftinc.gates.util.LocationSerializer;
+
+
+
+/**
+ * Adds persistence and serialization to the base gate class.
+ */
+public class Gate extends BaseGate implements ConfigurationSerializable
+{
+	/*
+	 * ATTRIBUTES
+	 */
+	
+	protected String id;
+	
+	protected static Map<String, Gate> instances = new HashMap<String, Gate>();	
+	
+	/*
+	 * CONSTRUCTORS
+	 */
+	
+	public Gate(String id) throws Exception
+	{
+		setId(id);
+	}
+	
+	
+	/*
+	 * SETTER & GETTER
+	 */
+	
+	public String getId() 
+	{
+		return id;
+	}
+
+
+
+	public void setId(String id) throws Exception
+	{
+		if (exists(id)) {
+			throw new Exception("A gate with '" + id + "' already exists");
+		}
+
+		this.id = id;
+	}
+
+
+	/*
+	 * INTERFACE: ConfigurationSerializable
+	 */
+	static protected String idKey = "id";
+	static protected String locationKey = "location";
+	static protected String gateBlocksKey = "gateBlocks";
+	static protected String exitKey = "exit";
+	static protected String isHiddenKey = "hidden";
+	static protected String isOpenKey = "open";
+	static protected String locationYawKey = "locationYaw";
+	static protected String locationPitchKey = "locationPitch";
+	static protected String exitYawKey = "exitYaw";
+	static protected String exitPitchKey = "exitPitch";
+	
+	
+	@SuppressWarnings("unchecked")
+	public Gate(Map<String, Object> map) 
+	{
+		try {
+			id = map.get(idKey).toString();
+			isHidden = (Boolean)map.get(isHiddenKey);
+			isOpen = (Boolean)map.get(isOpenKey);
+			
+			location = LocationSerializer.deserializeLocation((Map<String, Object>) map.get(locationKey));
+			exit = LocationSerializer.deserializeLocation((Map<String, Object>) map.get(exitKey));
+			
+			if (map.containsKey(exitPitchKey)) {
+				exit.setPitch(((Double)map.get(exitPitchKey)).floatValue());
+				exit.setYaw(((Double)map.get(exitYawKey)).floatValue());
+			}
+			
+			if (map.containsKey(locationPitchKey)) {
+				location.setPitch(((Double)map.get(locationPitchKey)).floatValue());
+				location.setYaw(((Double)map.get(locationYawKey)).floatValue());
+			}
+			
+			gateBlockLocations = new HashSet<Location>();
+			List<Map<String, Object>> serializedGateBlocks = (List<Map<String, Object>>)map.get(gateBlocksKey);
+			
+			for (Map<String, Object> sgb : serializedGateBlocks) {
+				gateBlockLocations.add(LocationSerializer.deserializeLocation(sgb));
+			}
+		}
+		catch (Exception e) {
+			Plugin.log("ERROR: Failed to load gate '" + id + "'! (" + e.getMessage() + ")");
+			Plugin.log("NOTE:  This gate will be removed from 'gates.yml' and added to 'invalid_gates.yml'!");
+			
+			Plugin.instance.storeInvalidGate(map);
+
+			return;
+		}
+		
+		instances.put(id, this);
+	}
+	
+	
+	public Map<String, Object> serialize() 
+	{
+		try {
+			validate(); // make sure to not write invalid stuff to disk
+		} 
+		catch (Exception e) {
+		}
+		
+		Map<String, Object> retVal = new HashMap<String, Object>();
+		
+		retVal.put(idKey, id);
+		retVal.put(locationKey, LocationSerializer.serializeLocation(location));
+		retVal.put(exitKey, LocationSerializer.serializeLocation(exit));
+		retVal.put(isHiddenKey, isHidden);
+		retVal.put(isOpenKey, isOpen);
+		
+		if (exit != null) {
+			retVal.put(exitPitchKey, exit.getPitch());
+			retVal.put(exitYawKey, exit.getYaw());
+		}
+		
+		retVal.put(locationPitchKey, location.getPitch());
+		retVal.put(locationYawKey, location.getYaw());
+		
+		List<Map<String, Object>> serializedGateBlocks = new ArrayList<Map<String, Object>>();
+		
+		for (Location l : gateBlockLocations) {
+			serializedGateBlocks.add(LocationSerializer.serializeLocation(l));
+		}
+		
+		retVal.put(gateBlocksKey, serializedGateBlocks);
+		
+		return retVal;
+	}
+
+
+	/*
+	 * ENTITY MANAGEMENT
+	 */
+	
+	public static Gate get(String id) 
+	{
+		return instances.get(id);
+	}
+	
+	
+	public static boolean exists(String id) 
+	{
+		return instances.containsKey(id);
+	}
+	
+	
+	public static Gate create(String id) throws Exception
+	{
+		Gate gate = new Gate(id);
+		
+		instances.put(gate.id, gate);
+		return gate;
+	}
+	
+	
+	public static void rename(String oldId, String newId) throws Exception
+	{
+		Gate gate = get(oldId);
+		
+		gate.setId(newId);
+		
+		delete(oldId);
+		instances.put(gate.id, gate);
+	}
+	
+	
+	public static void delete(String id) 
+	{
+		Gate g = get(id);
+		
+		if (g != null) {
+			g.emptyGate();
+		}
+		
+		instances.remove(id);
+	}
+	
+	
+	public static Collection<Gate> getAll() 
+	{
+		return instances.values();
+	}
+}

src/de/craftinc/gates/Plugin.java

@@ -0,0 +1,249 @@
+package de.craftinc.gates;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import de.craftinc.gates.commands.*;
+import de.craftinc.gates.listeners.PluginBlockListener;
+import de.craftinc.gates.listeners.PluginPlayerListener;
+import de.craftinc.gates.listeners.PluginPortalListener;
+
+
+public class Plugin extends JavaPlugin 
+{
+	public static Plugin instance;
+	
+	public static final String permissionInfo = "craftincgates.info";
+	public static final String permissionManage = "craftincgates.manage";
+	public static final String permissionAll = "craftincgates.*";
+	public static final String permissionUse = "craftincgates.use";
+	
+	public PluginPlayerListener playerListener = new PluginPlayerListener();
+	public PluginBlockListener blockListener = new PluginBlockListener();
+	public PluginPortalListener portalListener = new PluginPortalListener();
+	
+	private String baseCommand;
+	
+	private String gatesPath = "gates";
+	
+	
+	// Commands
+	public List<BaseCommand> commands = new ArrayList<BaseCommand>();
+	
+	
+	public Plugin()
+	{
+		instance = this;
+	}
+	
+	
+	@Override
+	public void onLoad() 
+	{
+		ConfigurationSerialization.registerClass(Gate.class);
+	}
+	
+
+	@Override
+	public void onDisable() 
+	{
+		// Save gates
+		saveGates();
+		
+		log("Disabled");
+	}
+
+	
+	@Override
+	public void onEnable() 
+	{
+		// Add the commands
+		commands.add(new CommandHelp());
+		commands.add(new CommandCreate());
+		commands.add(new CommandDelete());
+		commands.add(new CommandSetLocation());
+		commands.add(new CommandSetExit());
+		commands.add(new CommandOpen());
+		commands.add(new CommandRename());
+		commands.add(new CommandClose());
+		commands.add(new CommandList());
+		commands.add(new CommandInfo());
+		commands.add(new CommandSetHidden());
+		commands.add(new CommandSetVisible());
+
+		
+		// Register events
+		PluginManager pm = this.getServer().getPluginManager();
+		pm.registerEvents(this.playerListener, this);
+		pm.registerEvents(this.blockListener, this);
+		pm.registerEvents(this.portalListener, this);
+		
+		// Load gates
+		loadGates();
+		
+		log("Enabled");
+	}
+
+	
+	// -------------------------------------------- //
+	// Commands
+	// -------------------------------------------- //
+	
+	public String getBaseCommand()
+	{
+		if (this.baseCommand != null)
+			return this.baseCommand;
+		
+		Map<String, Map<String, Object>> Commands = this.getDescription().getCommands();
+		
+		this.baseCommand = Commands.keySet().iterator().next();
+		
+		return this.baseCommand;
+	}
+	
+	
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) 
+	{
+		List<String> parameters = new ArrayList<String>(Arrays.asList(args));
+		this.handleCommand(sender, parameters);
+		return true;
+	}
+	
+	
+	public void handleCommand(CommandSender sender, List<String> parameters) 
+	{
+		if (parameters.size() == 0) 
+		{
+			this.commands.get(0).execute(sender, parameters);
+			return;
+		}
+		
+		String commandName = parameters.get(0).toLowerCase();
+		parameters.remove(0);
+		
+		for (BaseCommand fcommand : this.commands) 
+		{
+			if (fcommand.getAliases().contains(commandName)) 
+			{
+				fcommand.execute(sender, parameters);
+				return;
+			}
+		}
+		
+		sender.sendMessage("Unknown gate-command \"" + commandName + "\". Try " + "/" + getBaseCommand() + " help");
+	}
+	
+	
+	/* 
+	 * Logging
+	 */
+	public static void log(String msg) 
+	{
+		log(Level.INFO, msg);
+	}
+	
+	
+	public static void log(Level level, String msg) {
+		Logger.getLogger("Minecraft").log(level, "["+instance.getDescription().getFullName()+"] "+msg);
+	}
+	
+	/*
+	 * Saving and Loading Gates
+	 */
+	public void loadGates() 
+	{
+		File gatesFile = new File(getDataFolder(), "gates.yml");
+		FileConfiguration gatesConfig = YamlConfiguration.loadConfiguration(gatesFile);
+		
+		gatesConfig.getList(gatesPath); // this will create all the gates
+	}
+	
+	
+	public void saveGates()
+	{
+		File gatesFile = new File(getDataFolder(), "gates.yml");
+		FileConfiguration gatesConfig = YamlConfiguration.loadConfiguration(gatesFile);
+		
+		gatesConfig.set(gatesPath, new ArrayList<Object>(Gate.getAll()));
+		
+		try {
+			gatesConfig.save(gatesFile);
+		} 
+		catch (IOException e) {
+			log("ERROR: Could not save gates to disk.");
+			e.printStackTrace();
+		}
+	}
+	
+	
+	public void storeInvalidGate(Map<String, Object> map)
+	{
+		File invalidGatesFile = new File(getDataFolder(), "invalid_gates.yml");
+		Boolean invalidGatesFileExists = invalidGatesFile.exists();
+		
+		try {
+			FileWriter fileWriter = new FileWriter(invalidGatesFile, true);
+			
+			if (!invalidGatesFileExists) {
+				fileWriter.write("gates:\n");
+			}
+			
+			fileWriter.write("- ==: ");
+			fileWriter.write(map.get("==").toString() + "\n");
+			map.remove("==");
+			
+			fileWriter.write("\topen: false\n");
+			map.remove("open");
+			
+			fileWriter.write("\tgateBlocks: []\n");
+			map.remove("gateBlocks");
+			
+			
+			for (String key : map.keySet()) {
+				Object value = map.get(key);
+				
+				fileWriter.write("\t" + key + ": ");
+				
+				if (value instanceof Map) {
+					fileWriter.write("\n");
+					
+					@SuppressWarnings("unchecked")
+					Map<String, Object> valueMap = (Map<String, Object>)value;
+					
+					for (String k : valueMap.keySet()) {
+						Object v = valueMap.get(k);
+					
+						fileWriter.write("\t\t" + k + ": " + v.toString() + "\n");
+					}
+
+				}
+				else {
+					fileWriter.write(value.toString() + "\n");
+				}
+				
+			}
+			
+			fileWriter.close();
+		}
+		catch (IOException e) {
+			log("ERROR: Could not save invalid gates to disk.");
+			e.printStackTrace();
+		}
+	}
+}

src/de/craftinc/gates/commands/BaseCommand.java

@@ -1,4 +1,4 @@
-package org.mcteam.ancientgates.commands;
+package de.craftinc.gates.commands;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -6,12 +6,11 @@ import java.util.List;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
-import org.mcteam.ancientgates.Gate;
-import org.mcteam.ancientgates.Plugin;
-import org.mcteam.ancientgates.Conf;
-import org.mcteam.ancientgates.util.TextUtil;
+import de.craftinc.gates.Gate;
+import de.craftinc.gates.Plugin;
+import de.craftinc.gates.util.TextUtil;
 
-public class BaseCommand 
+public abstract class BaseCommand 
 {
 	public List<String> aliases;
 	public List<String> requiredParameters;
@@ -27,9 +26,10 @@ public class BaseCommand
 	
 	public List<String> parameters;
 	
+	public String requiredPermission;
 	
-	public BaseCommand() 
-	{
+	
+	public BaseCommand() {
 		aliases = new ArrayList<String>();
 		requiredParameters = new ArrayList<String>();
 		optionalParameters = new ArrayList<String>();
@@ -64,7 +64,7 @@ public class BaseCommand
 	}
 	
 	public void sendMessage(String message) {
-		sender.sendMessage(Conf.colorSystem+message);
+		sender.sendMessage(message);
 	}
 	
 	public void sendMessage(List<String> messages) {
@@ -83,7 +83,7 @@ public class BaseCommand
 		}
 		
 		// validate permission
-		if( ! hasPermission(sender)) 
+		if( !hasPermission(sender)) 
 		{
 			sendMessage("You lack the permissions to "+this.helpDescription.toLowerCase()+".");
 			return false;
@@ -112,21 +112,30 @@ public class BaseCommand
 		return true;
 	}
 	
-	public boolean hasPermission(CommandSender sender) {
-		return Plugin.hasPermManage(sender);
+	public boolean hasPermission(CommandSender sender) 
+	{
+		if (sender.hasPermission(Plugin.permissionAll)) {
+			return true;
+		}
+		
+		if (sender.hasPermission(requiredPermission)) {
+			return true;
+		}
+		
+		return false; 
 	}
 	
 	// -------------------------------------------- //
 	// Help and usage description
 	// -------------------------------------------- //
-	public String getUseageTemplate(boolean withColor, boolean withDescription) {
+	public String getUsageTemplate(boolean withColor, boolean withDescription) {
 		String ret = "";
 		
-		if (withColor) {
-			ret += Conf.colorCommand;
-		}
+//		if (withColor) {
+//			ret += Conf.colorCommand;
+//		}
 		
-		ret += "/" + Plugin.instance.getBaseCommand()+ " " +TextUtil.implode(this.getAliases(), ",")+" ";
+		ret += "/" + Plugin.instance.getBaseCommand() + " " + TextUtil.implode(this.getAliases(), ",")+" ";
 		
 		List<String> parts = new ArrayList<String>();
 		
@@ -138,20 +147,20 @@ public class BaseCommand
 			parts.add("*["+optionalParameter+"]");
 		}
 		
-		if (withColor) {
-			ret += Conf.colorParameter;
-		}
+//		if (withColor) {
+//			ret += Conf.colorParameter;
+//		}
 		
 		ret += TextUtil.implode(parts, " ");
 		
-		if (withDescription) {
-			ret += "  "+Conf.colorSystem + this.helpDescription;
-		}
+//		if (withDescription) {
+//			ret += "  "+Conf.colorSystem + this.helpDescription;
+//		}
 		return ret;
 	}
 	
 	public String getUseageTemplate(boolean withColor) {
-		return getUseageTemplate(withColor, false);
+		return getUsageTemplate(withColor, false);
 	}
 	
 	public String getUseageTemplate() {

src/de/craftinc/gates/commands/BaseLocationCommand.java

@@ -0,0 +1,31 @@
+package de.craftinc.gates.commands;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+
+public abstract class BaseLocationCommand extends BaseCommand 
+{
+	protected Location getValidPlayerLocation()
+	{
+		// The player might stand in a halfblock or a sign or whatever
+		// Therefore we load som extra locations and blocks
+		Block playerBlock = player.getLocation().getBlock();
+		Block upBlock = playerBlock.getRelative(BlockFace.UP);
+                
+		if (playerBlock.getType() == Material.AIR) {
+			return player.getLocation();
+		} 
+		else if (upBlock.getType() == Material.AIR) {
+			return new Location(player.getLocation().getWorld(),
+					 			player.getLocation().getX(),
+					 			player.getLocation().getY() + 1,
+					 			player.getLocation().getZ(),
+					 			player.getLocation().getYaw(),
+					 			player.getLocation().getPitch());
+		} 
+		
+		return null;
+	}
+}

src/de/craftinc/gates/commands/CommandClose.java

@@ -0,0 +1,32 @@
+package de.craftinc.gates.commands;
+
+import de.craftinc.gates.Plugin;
+
+
+public class CommandClose extends BaseCommand 
+{
+	public CommandClose()
+	{
+		aliases.add("close");
+		
+		requiredParameters.add("id");	
+		
+		helpDescription = "Closes a gate to prevent players from using it.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	@Override
+	public void perform() 
+	{
+		try {
+			gate.setOpen(false);
+		}
+		catch(Exception e) {
+		}
+		
+		sendMessage("The gate was closed.");
+	}
+}
+

src/de/craftinc/gates/commands/CommandCreate.java

@@ -0,0 +1,58 @@
+package de.craftinc.gates.commands;
+
+import org.bukkit.Location;
+
+import de.craftinc.gates.Gate;
+import de.craftinc.gates.Plugin;
+
+
+public class CommandCreate extends BaseLocationCommand 
+{
+	public CommandCreate() 
+	{
+		aliases.add("create");
+		aliases.add("new");
+		
+		requiredParameters.add("id");		
+		
+		senderMustBePlayer = true;
+		hasGateParam = false;
+		
+		helpDescription = "Create a gate at your current location.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		String id = parameters.get(0);
+		
+		try {
+			gate = Gate.create(id);
+		} 
+		catch (Exception e) {
+			System.out.println(e.getMessage());
+		}
+		
+		Location playerLocation = getValidPlayerLocation();
+		
+		if (playerLocation != null) {
+			try {
+				gate.setLocation(playerLocation);
+			} 
+			catch (Exception e) {
+			}
+			
+			sendMessage("Gate with id \"" + id + "\" was created.");
+			sendMessage("The gates location has been set to your current location.");
+		}
+		else {
+			sendMessage("Gate with id \"" + id + "\" was created.");
+			sendMessage("Now you should build a frame and:");
+			sendMessage(new CommandSetLocation().getUsageTemplate(true, true));
+		}
+	}
+
+}
+

src/de/craftinc/gates/commands/CommandDelete.java

@@ -0,0 +1,31 @@
+package de.craftinc.gates.commands;
+
+import de.craftinc.gates.Gate;
+import de.craftinc.gates.Plugin;
+
+
+public class CommandDelete extends BaseCommand 
+{
+	public CommandDelete() 
+	{
+		aliases.add("delete");
+		aliases.add("del");
+		aliases.add("remove");
+		aliases.add("rm");
+		
+		requiredParameters.add("id");		
+		
+		senderMustBePlayer = false;
+		helpDescription = "Removes the gate from the game.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		Gate.delete(gate.getId());
+		sendMessage("Gate with id '" + gate.getId() + "' was deleted.");
+	}
+}
+

src/de/craftinc/gates/commands/CommandHelp.java

@@ -0,0 +1,94 @@
+package de.craftinc.gates.commands;
+
+import java.util.ArrayList;
+
+import org.bukkit.command.CommandSender;
+
+import de.craftinc.gates.util.TextUtil;
+
+public class CommandHelp extends BaseCommand 
+{
+	
+	public CommandHelp() 
+	{
+		aliases.add("help");
+		aliases.add("h");
+		aliases.add("?");
+		
+		optionalParameters.add("page");
+		hasGateParam = false;
+		
+		helpDescription = "Prints a list of all availible commands.";
+	}
+	
+	@Override
+	public boolean hasPermission(CommandSender sender) 
+	{
+		return true;
+	}
+	
+	
+	public void perform() 
+	{
+		int page = 1;
+		
+		if (parameters.size() > 0) 
+		{
+			try 
+			{
+				page = Integer.parseInt(parameters.get(0));
+			} 
+			catch (NumberFormatException e) 
+			{
+				// wasn't an integer
+			}
+		}
+		
+		sendMessage(TextUtil.titleize("Craft Inc. Gates Help ("+page+"/"+helpPages.size()+")"));
+		
+		page -= 1;
+		if (page < 0 || page >= helpPages.size()) 
+		{
+			sendMessage("This page does not exist");
+			return;
+		}
+		
+		sendMessage(helpPages.get(page));
+	}
+	
+	
+	//----------------------------------------------//
+	// Build the help pages
+	//----------------------------------------------//
+	
+	public static ArrayList<ArrayList<String>> helpPages;
+	
+	static 
+	{
+		helpPages = new ArrayList<ArrayList<String>>();
+		ArrayList<String> pageLines;
+
+		pageLines = new ArrayList<String>();
+		
+		pageLines.add( new CommandHelp().getUsageTemplate(true, true) );
+		pageLines.add( new CommandCreate().getUsageTemplate(true, true) );
+		pageLines.add( new CommandDelete().getUsageTemplate(true, true) );
+		pageLines.add( new CommandSetLocation().getUsageTemplate(true, true) );
+		pageLines.add( new CommandSetExit().getUsageTemplate(true, true) );
+		pageLines.add( new CommandOpen().getUsageTemplate(true, true) );
+		
+		helpPages.add(pageLines);
+		pageLines = new ArrayList<String>();
+		
+		pageLines.add( new CommandRename().getUsageTemplate(true, true) );
+		pageLines.add( new CommandClose().getUsageTemplate(true, true) );
+		pageLines.add( new CommandList().getUsageTemplate(true, true) );
+		pageLines.add( new CommandInfo().getUsageTemplate(true, true) );
+		pageLines.add( new CommandSetHidden().getUsageTemplate(true, true) );
+		pageLines.add( new CommandSetVisible().getUsageTemplate(true, true) );
+		
+		helpPages.add(pageLines);
+	}
+	
+}
+

src/de/craftinc/gates/commands/CommandInfo.java

@@ -0,0 +1,52 @@
+package de.craftinc.gates.commands;
+
+import org.bukkit.ChatColor;
+
+import de.craftinc.gates.Plugin;
+
+
+public class CommandInfo extends BaseCommand 
+{
+	public CommandInfo()
+	{
+		aliases.add("info");
+		aliases.add("details");
+		
+		requiredParameters.add("id");		
+		
+		helpDescription = "Prints detailed informations about a certain gate.";
+		
+		requiredPermission = Plugin.permissionInfo;
+	}
+	
+	
+	public void perform() 
+	{
+		sendMessage(ChatColor.LIGHT_PURPLE + "Information about " + ChatColor.WHITE + gate.getId() + ChatColor.LIGHT_PURPLE + ":");
+		
+		String openHiddenMessage = "This gate is";
+		
+		if (gate.isOpen())
+			openHiddenMessage += " open";
+		else
+			openHiddenMessage += " closed";
+		
+		if (gate.isHidden())
+			openHiddenMessage += " and hidden";
+		
+		openHiddenMessage += ".";
+		
+		sendMessage(openHiddenMessage);
+		
+		if (gate.getLocation() != null)
+			sendMessage(ChatColor.GREEN + "'from' location:       " + ChatColor.YELLOW + "( " + gate.getLocation().getBlockX() + " | " + gate.getLocation().getBlockY() + " | " + gate.getLocation().getBlockZ() + " ) in " + gate.getLocation().getWorld().getName());
+		else
+			sendMessage(ChatColor.GREEN + "this gate has no 'from' location");
+		
+		if (gate.getExit() != null)
+			sendMessage(ChatColor.GREEN + "'to' location:          " + ChatColor.YELLOW + "( " + gate.getExit().getBlockX() + " | " + gate.getExit().getBlockY() + " | " + gate.getExit().getBlockZ() + " ) in " + gate.getExit().getWorld().getName());
+		else
+			sendMessage(ChatColor.GREEN + "this gate has no 'to' location");
+	}
+
+}

src/de/craftinc/gates/commands/CommandList.java

@@ -1,15 +1,16 @@
-package org.mcteam.ancientgates.commands;
+package de.craftinc.gates.commands;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.List;
 
 import org.bukkit.ChatColor;
-import org.mcteam.ancientgates.Conf;
-import org.mcteam.ancientgates.Gate;
-import org.mcteam.ancientgates.util.TextUtil;
+
+import de.craftinc.gates.Gate;
+import de.craftinc.gates.Plugin;
+import de.craftinc.gates.util.TextUtil;
+
 
 public class CommandList extends BaseCommand
 {
@@ -21,18 +22,23 @@ public class CommandList extends BaseCommand
 		optionalParameters.add("page");
 		hasGateParam = false;
 		
-		helpDescription = "Display a list of the gates";
+		helpDescription = "Prints a list of all availible gates.";
+		
+		requiredPermission = Plugin.permissionInfo;
 	}
 	
 	
 	protected String intToTitleString(int i)
 	{
-		if ( i < 26 )
-			return Conf.colorMember + "" + (char)(i+65) + ":";
-		else if ( i == 26 )
-			return Conf.colorMember + "0 - 9:";
-		else
-			return Conf.colorMember + "!@#$:";
+		if ( i < 26 ) {
+			return ChatColor.GREEN + "" + (char)(i+65) + ":";
+		}
+		else if ( i == 26 ) {
+			return ChatColor.GREEN + "0 - 9:";
+		} 
+		else {
+			return ChatColor.GREEN + "!@#$:";
+		}
 	}
 	
 	
@@ -43,8 +49,9 @@ public class CommandList extends BaseCommand
 	{
 		Collection<Gate> gates = Gate.getAll();
 		
-		if (gates.size() == 0)
+		if (gates.size() == 0) {
 			return null;
+		}
 		
 		/* sort all gates by there first character
 		 * put gates in corresponding Lists
@@ -54,22 +61,26 @@ public class CommandList extends BaseCommand
 		 */
 		List<List<String>> ids = new ArrayList<List<String>>();
 		
-		for (int i=0; i<28; i++)
+		for (int i=0; i<28; i++) {
 			ids.add(new ArrayList<String>());
+		}
 		
-		for (Gate gate : gates)
-		{
+		for (Gate gate : gates) {
 			String id = gate.getId();
 			int first = id.charAt(0);
 			
-			if (first > 96 && first < 123) // convert lower case chars
+			if (first > 96 && first < 123) { // convert lower case chars
 				first -= 97;
-			else if (first > 64 && first < 91) // convert upper case chars
+			}
+			else if (first > 64 && first < 91)  { // convert upper case chars
 				first -= 65;
-			else if (first > 47 && first < 58) // convert numbers
+			}
+			else if (first > 47 && first < 58) { // convert numbers
 				first = 26;
-			else // everything else
+			}
+			else { // everything else
 				first = 27;
+			}
 			
 			ids.get(first).add(id);
 		}
@@ -80,102 +91,79 @@ public class CommandList extends BaseCommand
 		 * great. (tell me if there is a better way!)
 		 */
 		
-		// list<string>: a list from ids
-		// Integer: the number of lines neccessary for displaying the corresponding list
-		HashMap<List<String>, Integer> lines = new HashMap<List<String>, Integer>(27);
-		
-		for (List<String> currentIds : ids)
-		{
-			if (currentIds.size() == 0)
-				continue;
-			
-			int characters = TextUtil.implode(currentIds, ", ").length();
-			lines.put(currentIds, characters / 52 + 2);
-		}
-		
-		
 		int currentPage = 1;
 		int currentStartingCharList = 0;
 		boolean finishedCurrentIds = true;
 		
 		List<String> pageMessages = new ArrayList<String>();
 		
-		while (currentStartingCharList < ids.size())
-		{
+		while (currentStartingCharList < ids.size()) {
 			int linesLeftOnCurrentPage = 9;
 			
-			while (linesLeftOnCurrentPage > 1 && currentStartingCharList < ids.size())
-			{
+			while (linesLeftOnCurrentPage > 1 && currentStartingCharList < ids.size()) {
 				List<String> currentIds = ids.get(currentStartingCharList);
 				
-				if (currentIds.size() > 0)
-				{
+				if (currentIds.size() > 0) {
 					// add header line
-					if (currentPage == page)
+					if (currentPage == page) {
 						pageMessages.add(intToTitleString(currentStartingCharList));
+					}
 					
 					//sort
 					Collections.sort(currentIds);
 				
 					// add ids
-					if (lines.get(currentIds) <= linesLeftOnCurrentPage) // all ids fit on current page
-					{
-						linesLeftOnCurrentPage -= lines.get(currentIds);
+					int numLinesForCurrentChar = TextUtil.implode(currentIds, ", ").length() / 52 + 2;
+					
+					if (numLinesForCurrentChar <= linesLeftOnCurrentPage) { // all ids fit on current page
+						linesLeftOnCurrentPage -= numLinesForCurrentChar;
 						
-						
-						if (currentPage == page)
-						{
+						if (currentPage == page) {
 							pageMessages.add(TextUtil.implode(currentIds, ", "));
-							if (finishedCurrentIds == false)
+							if (finishedCurrentIds == false) {
 								pageMessages.set(pageMessages.size() -2, pageMessages.get(pageMessages.size() -2) + " (more on previous page)");
+							}
 						}
 						
 						finishedCurrentIds = true;
 					}
-					else // NOT all ids fit on current page
-					{
+					else { // NOT all ids fit on current page
 						int charsAvailible = (linesLeftOnCurrentPage - 1) * 52;
 						int idsPos = 0;
 						
-						while (true)
-						{
-							charsAvailible -= currentIds.get(idsPos).length() + 2;
-							
-							if (charsAvailible <= 0)
-								break;
-							
+						do {
+							charsAvailible -= currentIds.get(idsPos).length() + 2;				
 							idsPos++;
-						}
+						} while (charsAvailible > 0);
 						
 						List<String> idsToPutOnCurrentPage = currentIds.subList(0, idsPos);
 						currentIds.remove(idsToPutOnCurrentPage);
 						
 						String stringToPutOnCurrentPage = TextUtil.implode(idsToPutOnCurrentPage, ", ");
 						
-						if (currentPage == page)
-						{
+						if (currentPage == page) {
 							pageMessages.add(stringToPutOnCurrentPage);
 							pageMessages.set(pageMessages.size() -2, pageMessages.get(pageMessages.size() -2) + " (more on next page)");
 						}
 						
-						lines.put(currentIds, TextUtil.implode(currentIds, ", ").length() / 52 + 2);
 						linesLeftOnCurrentPage -= stringToPutOnCurrentPage.length() / 52 + 2;
 						
 						finishedCurrentIds = false;
 					}
 				}
 				
-				if (finishedCurrentIds)
+				if (finishedCurrentIds) {
 					currentStartingCharList++;
+				}
 			}
 			
 			currentPage++;
 		}
 		
-		if (pageMessages.isEmpty())
+		if (pageMessages.isEmpty()) {
 			return null;
-		else
-		{
+		} 
+		else {
 			ArrayList<String> retVal = new ArrayList<String>();
 			retVal.add(ChatColor.LIGHT_PURPLE + "This is page " + ChatColor.WHITE + page + ChatColor.LIGHT_PURPLE + "/" + ChatColor.WHITE + --currentPage + ChatColor.LIGHT_PURPLE + ". There are " + gates.size() + " gates on this server: ");
 			retVal.addAll(pageMessages);
@@ -189,26 +177,26 @@ public class CommandList extends BaseCommand
 	{
 		Collection<Gate> gates = Gate.getAll();
 		
-		if (gates.size() == 0)
+		if (gates.size() == 0) {
 			sendMessage("There are no gates yet.");
-		else
-		{
+		}
+		else {
 			int page = 1;
 			
-			try
-			{
+			try {
 				page = new Integer(parameters.get(0));
 			} 
-			catch (Exception e)
-			{
+			catch (Exception e) {
 			}
 			
 			List<String> messages = message(page);
 			
-			if (messages == null)
+			if (messages == null) {
 				sendMessage("The requested page is not availible");
-			else
+			}
+			else {
 				sendMessage(messages);
+			}
 		}
 	}
 }

src/de/craftinc/gates/commands/CommandOpen.java

@@ -0,0 +1,34 @@
+package de.craftinc.gates.commands;
+
+import de.craftinc.gates.Plugin;
+
+
+public class CommandOpen extends BaseCommand 
+{
+	
+	public CommandOpen()
+	{
+		aliases.add("open");
+		
+		requiredParameters.add("id");		
+		
+		helpDescription = "Open a gate so players can use it.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		try {
+			gate.setOpen(true);
+		} catch (Exception e) {
+			sendMessage(e.getMessage());
+			return;
+		}
+		
+		sendMessage("The gate was opened.");
+	}
+
+}
+

src/de/craftinc/gates/commands/CommandRename.java

@@ -0,0 +1,41 @@
+package de.craftinc.gates.commands;
+
+import de.craftinc.gates.Gate;
+import de.craftinc.gates.Plugin;
+
+
+public class CommandRename extends BaseCommand 
+{
+	public CommandRename() 
+	{
+		aliases.add("rename");
+		aliases.add("changename");
+		aliases.add("cn");
+		
+		hasGateParam = true;
+		senderMustBePlayer = false;
+		
+		requiredParameters.add("current name");
+		requiredParameters.add("new name");
+		
+		helpDescription = "Changes the id of a gate.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		String newId = parameters.get(1);
+		
+		try {
+			Gate.rename(gate.getId(), newId);
+		} 
+		catch (Exception e) {
+			sendMessage("Cannot rename " + gate.getId() + ". There is already a gate named " + newId + ".");
+		}
+		
+		sendMessage("Gate " + gate.getId() + " is now known as " + newId + ".");
+	}
+
+}

src/de/craftinc/gates/commands/CommandSetExit.java

@@ -0,0 +1,34 @@
+package de.craftinc.gates.commands;
+
+import de.craftinc.gates.Plugin;
+
+
+public class CommandSetExit extends BaseCommand 
+{
+	
+	public CommandSetExit() 
+	{
+		aliases.add("setto");
+		aliases.add("st");
+		
+		requiredParameters.add("id");		
+		
+		helpDescription = "Changes the location where the gate will teleport players to your current location.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		try {
+			gate.setExit(player.getLocation());
+		} 
+		catch (Exception e) {
+			sendMessage(e.getMessage());
+		}
+		
+		sendMessage("The exit of gate '" + gate.getId() + "' is now where you stand.");
+	}
+}
+

src/de/craftinc/gates/commands/CommandSetHidden.java

@@ -0,0 +1,32 @@
+package de.craftinc.gates.commands;
+
+import de.craftinc.gates.Plugin;
+
+
+public class CommandSetHidden extends BaseCommand 
+{
+	public CommandSetHidden() 
+	{
+		aliases.add("setHidden");
+		aliases.add("sh");
+		
+		requiredParameters.add("id");		
+		
+		helpDescription = "Makes a gate NOT consist of gate blocks while open.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		try {
+			gate.setHidden(true);
+		} 
+		catch (Exception e) {
+			sendMessage(e.getMessage());
+		}
+		
+		sendMessage("The gate '" + gate.getId() + "' is now hidden.");
+	}
+}

src/de/craftinc/gates/commands/CommandSetLocation.java

@@ -0,0 +1,45 @@
+package de.craftinc.gates.commands;
+
+
+import org.bukkit.Location;
+
+import de.craftinc.gates.Plugin;
+
+
+public class CommandSetLocation extends BaseLocationCommand 
+{
+	
+	public CommandSetLocation() 
+	{
+		aliases.add("setlocation");
+		aliases.add("sl");
+		
+		requiredParameters.add("id");		
+		
+		helpDescription = "Set the entrance of the gate to your current location.";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		Location playerLocation = getValidPlayerLocation();
+		
+		if (playerLocation == null) {
+			sendMessage("There is not enough room for a gate to open here");
+			return;
+		}
+		
+		try {
+			gate.setLocation(playerLocation);
+		} 
+		catch (Exception e) {
+			sendMessage(e.getMessage());
+		}
+		
+		sendMessage("The location of '" + gate.getId() + "' is now at your current location.");
+	}
+	
+}
+

src/de/craftinc/gates/commands/CommandSetVisible.java

@@ -0,0 +1,34 @@
+package de.craftinc.gates.commands;
+
+import de.craftinc.gates.Plugin;
+
+
+public class CommandSetVisible extends BaseCommand 
+{
+	
+	public CommandSetVisible() 
+	{
+		aliases.add("makevisible");
+		aliases.add("mv");
+		
+		requiredParameters.add("id");		
+		
+		helpDescription = "Make that gate visible";
+		
+		requiredPermission = Plugin.permissionManage;
+	}
+	
+	
+	public void perform() 
+	{
+		try {
+			gate.setHidden(false);
+		}
+		catch (Exception e) {
+			sendMessage(e.getMessage());
+		}
+		
+		sendMessage("The gate " + gate.getId() + " is now visible.");
+	}
+
+}

src/de/craftinc/gates/listeners/BaseLocationListener.java

@@ -0,0 +1,97 @@
+package de.craftinc.gates.listeners;
+
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+import de.craftinc.gates.Gate;
+
+
+public abstract class BaseLocationListener 
+{
+	protected Gate getValidGateAtPlayerLocation(PlayerMoveEvent e) {
+		Gate gate = null;
+		
+		Location playerLocation = e.getPlayer().getLocation();
+		World playerWorld = playerLocation.getWorld();
+		
+		Block blockTo = e.getFrom().getBlock();
+		Block blockToUp = blockTo.getRelative(BlockFace.UP);
+		
+		
+		for (Gate g : Gate.getAll()) {
+			// Check if the gate is open and useable
+			World gateWorld = g.getLocation().getWorld();
+			
+			if (g.isOpen() == false || !gateWorld.equals(playerWorld)) {
+				continue;
+			}
+			
+            
+			// Check if the location matches
+			for (Location l: g.getGateBlockLocations()) {
+				
+				if (locationsAreAtSamePositions(l, blockTo.getLocation()) || locationsAreAtSamePositions(l, blockToUp.getLocation())) {
+					// Check if the gate is still valid
+					try {
+						g.validate();
+						gate = g;
+	                    break;
+					} 
+					catch (Exception e2) {
+						// do nothing - gate is closed
+					}
+                }
+            }
+		}
+		
+		return gate;
+	}
+	
+	
+	protected Gate getGateAtPlayerLocation(PlayerMoveEvent e) {
+		Gate gate = null;
+		
+		Block blockTo = e.getFrom().getBlock();
+		Block blockToUp = blockTo.getRelative(BlockFace.UP);
+		
+		System.out.println(blockTo.getLocation().getWorld().getName());
+		
+		
+		for (Gate g : Gate.getAll()) {
+			// Check if the location matches
+			for (Location l: g.getGateBlockLocations()) {
+				
+				if (locationsAreAtSamePositions(l, blockTo.getLocation()) || locationsAreAtSamePositions(l, blockToUp.getLocation())) {
+					gate = g;
+                }
+            }
+		}
+		
+		return gate;
+	}
+	
+	
+	/**
+     * Does the same as the equal method of Location but ignores pitch and yaw.
+     */
+	protected boolean locationsAreAtSamePositions(final Location l1, final Location l2)
+    {
+		if (l1.getWorld() != l2.getWorld() && (l1.getWorld() == null || !l1.getWorld().equals(l2.getWorld()))) {
+			return false;
+        }
+		if (Double.doubleToLongBits(l1.getX()) != Double.doubleToLongBits(l2.getX())) {
+			return false;
+		}
+		if (Double.doubleToLongBits(l1.getY()) != Double.doubleToLongBits(l2.getY())) {
+			return false;
+		}
+		if (Double.doubleToLongBits(l1.getZ()) != Double.doubleToLongBits(l2.getZ())) {
+			return false;
+		}
+		
+		return true;
+    }
+}

src/de/craftinc/gates/listeners/PluginBlockListener.java

@@ -1,4 +1,4 @@
-package org.mcteam.ancientgates.listeners;
+package de.craftinc.gates.listeners;
 
 import org.bukkit.Material;
 import org.bukkit.block.Block;
@@ -30,17 +30,21 @@ public class PluginBlockListener implements Listener
 	
 	public boolean isBlockInPortal(Block block) 
 	{
-		if (block.getRelative(BlockFace.UP).getType() == Material.AIR)
+		if (block.getRelative(BlockFace.UP).getType() == Material.AIR) {
 			return false;
+		}
 		
-		if (block.getRelative(BlockFace.DOWN).getType() == Material.AIR)
+		if (block.getRelative(BlockFace.DOWN).getType() == Material.AIR) {
 			return false;
+		}
 		
-		if ( block.getRelative(BlockFace.NORTH).getType() != Material.AIR && block.getRelative(BlockFace.SOUTH).getType() != Material.AIR )
+		if ( block.getRelative(BlockFace.NORTH).getType() != Material.AIR && block.getRelative(BlockFace.SOUTH).getType() != Material.AIR ) {
 			return true;
+		}
 		
-		if ( block.getRelative(BlockFace.WEST).getType() != Material.AIR && block.getRelative(BlockFace.EAST).getType() != Material.AIR )
+		if ( block.getRelative(BlockFace.WEST).getType() != Material.AIR && block.getRelative(BlockFace.EAST).getType() != Material.AIR ) {
 			return true;
+		}
 		
 		return false;
 	}

src/de/craftinc/gates/listeners/PluginPlayerListener.java

@@ -0,0 +1,78 @@
+package de.craftinc.gates.listeners;
+
+import java.util.logging.Level;
+
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+import de.craftinc.gates.Gate;
+import de.craftinc.gates.Plugin;
+
+
+public class PluginPlayerListener extends BaseLocationListener implements Listener 
+{
+	@EventHandler(priority = EventPriority.NORMAL)
+	public void onPlayerMove(PlayerMoveEvent event) 
+	{
+		if (event.isCancelled()) {
+			return;
+		}
+		
+		// Check for permission
+		if (!hasPermission(event.getPlayer())) {
+			return;
+		}
+		
+		// Find the gate at the current location.
+		Gate gateAtLocation = getValidGateAtPlayerLocation(event);
+		
+		
+		if (gateAtLocation == null) {
+			return;
+		}
+		
+		// Teleport the player
+		checkChunkLoad(gateAtLocation.getLocation().getBlock());
+		
+		Location gateExit = gateAtLocation.getExit();
+		Location gateLocation = gateAtLocation.getLocation();
+		Location playerLocation = event.getPlayer().getLocation();
+		
+        Float newYaw = gateExit.getYaw() - gateLocation.getYaw() + playerLocation.getYaw();
+        
+        Location teleportToLocation = new Location( gateExit.getWorld(),
+        											gateExit.getX(),
+        											gateExit.getY(),
+        											gateExit.getZ(),
+					                                newYaw, 
+					                                playerLocation.getPitch() );
+                    
+		event.getPlayer().teleport(teleportToLocation);
+		event.setTo(teleportToLocation);
+	}
+	
+	
+	private void checkChunkLoad(Block b) 
+	{
+		World w = b.getWorld();
+		Chunk c = b.getChunk();
+		
+		if ( ! w.isChunkLoaded(c) )
+		{
+		    Plugin.log(Level.FINE, "Loading chunk: " + c.toString() + " on: " + w.toString());
+			w.loadChunk(c);
+		}
+	}
+	
+	
+	protected boolean hasPermission(Player player) {
+        return player.hasPermission(Plugin.permissionUse) || player.hasPermission(Plugin.permissionAll);
+    }
+}

src/de/craftinc/gates/listeners/PluginPortalListener.java

@@ -0,0 +1,27 @@
+package de.craftinc.gates.listeners;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerPortalEvent;
+
+import de.craftinc.gates.Gate;
+
+public class PluginPortalListener extends BaseLocationListener implements Listener
+{
+	@EventHandler(priority = EventPriority.NORMAL)
+	public void onPlayerPortal(PlayerPortalEvent event)
+	{		
+		if (event.isCancelled()) {
+			return;
+		}
+		
+		// Find the gate at the current location.
+		Gate gateAtLocation = getGateAtPlayerLocation(event);
+		
+		if (gateAtLocation != null) {
+			event.setCancelled(true);
+		}
+	}
+
+}

src/de/craftinc/gates/util/FloodUtil.java

@@ -1,4 +1,4 @@
-package org.mcteam.ancientgates.util;
+package de.craftinc.gates.util;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -7,14 +7,19 @@ import java.util.logging.Level;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
-import org.mcteam.ancientgates.Conf;
-import org.mcteam.ancientgates.Plugin;
 
-public class FloodUtil {
+import de.craftinc.gates.Plugin;
+
+
+public class FloodUtil 
+{
+	private final static int frameBlockSearchLimit = 20;
+	
 	private static final Set<BlockFace> exp1 = new HashSet<BlockFace>();
 	private static final Set<BlockFace> exp2 = new HashSet<BlockFace>();
 	
-	static {
+	static 
+	{
 		exp1.add(BlockFace.UP);
 		exp1.add(BlockFace.DOWN);
 		exp1.add(BlockFace.EAST);
@@ -28,9 +33,10 @@ public class FloodUtil {
 	
 	
 	// For the same frame and location this set of blocks is deterministic
-	public static Set<Block> getGateFrameBlocks(Block block) {
-		Set<Block> blocks1 = getAirFloodBlocks(block, new HashSet<Block>(), exp1, Conf.getGateMaxArea());
-		Set<Block> blocks2 = getAirFloodBlocks(block, new HashSet<Block>(), exp2, Conf.getGateMaxArea());
+	public static Set<Block> getGateFrameBlocks(Block block) 
+	{
+		Set<Block> blocks1 = getAirFloodBlocks(block, new HashSet<Block>(), exp1, frameBlockSearchLimit);
+		Set<Block> blocks2 = getAirFloodBlocks(block, new HashSet<Block>(), exp2, frameBlockSearchLimit);
 		
 		if (blocks1 == null && blocks2 == null) {
 			return null;
@@ -51,6 +57,7 @@ public class FloodUtil {
 		return blocks1;
 	}
 	
+	
 	public static Set<Block> getAirFloodBlocks(Block startBlock, Set<Block> foundBlocks, Set<BlockFace> expandFaces, int limit) 
 	{
 		if (foundBlocks == null)

src/de/craftinc/gates/util/GeometryUtil.java

@@ -1,4 +1,4 @@
-package org.mcteam.ancientgates.util;
+package de.craftinc.gates.util;
 
 import org.bukkit.Location;
 

src/de/craftinc/gates/util/LocationSerializer.java

@@ -0,0 +1,86 @@
+package de.craftinc.gates.util;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bukkit.Location;
+import org.bukkit.World;
+
+import de.craftinc.gates.Plugin;
+
+
+/**
+ * NOTE: We do not care about yaw and pitch for gate locations. So we won't serialize them.
+ */
+public class LocationSerializer 
+{
+	protected static String worldKey = "world";
+	protected static String xKey = "x";
+	protected static String yKey = "y";
+	protected static String zKey = "z";
+
+	
+	protected static World getWorld(String name) throws Exception 
+	{
+		World world = Plugin.instance.getServer().getWorld(name);
+
+		if (world == null) {
+			throw new Exception("World '" + name + "' does not exists anymore! Cannot get instance!");
+		}
+		
+		return world;
+	}
+	
+	
+	public static Map<String, Object> serializeLocation(Location l)
+	{
+		if (l == null) {
+			return null;
+		}
+		
+		Map<String, Object> serializedLocation = new HashMap<String, Object>();
+		
+		serializedLocation.put(worldKey, l.getWorld().getName());
+		serializedLocation.put(xKey, l.getX());
+		serializedLocation.put(yKey, l.getY());
+		serializedLocation.put(zKey, l.getZ());
+		
+		return serializedLocation;
+	}
+	
+
+	public static Location deserializeLocation(Map<String, Object> map) throws Exception
+	{
+		if (map == null) {
+			return null;
+		}
+		
+		World w = getWorld((String)map.get(worldKey));
+		
+		
+		// verbose loading of coordinates (they might be Double or Integer)
+		Object objX =  map.get(xKey);
+		Object objY =  map.get(yKey);
+		Object objZ =  map.get(zKey);
+		
+		double x,y,z;
+		
+		if (objX instanceof Integer)
+			x = (double)(Integer)objX;
+		else
+			x = (Double)objX;
+		
+		if (objY instanceof Integer)
+			y = (double)(Integer)objY;
+		else
+			y = (Double)objY;
+		
+		if (objZ instanceof Integer)
+			z = (double)(Integer)objZ;
+		else
+			z = (Double)objZ;
+		
+		
+		return new Location(w, x, y, z);
+	}
+}

src/de/craftinc/gates/util/TextUtil.java

@@ -0,0 +1,68 @@
+package de.craftinc.gates.util;
+
+import java.util.List;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+
+public class TextUtil 
+{
+	public static String titleize(String str) 
+	{
+		String line = ChatColor.GOLD + repeat("_", 60);
+		String center = ".[ " + ChatColor.YELLOW + str + ChatColor.GOLD + " ].";
+		int pivot = line.length() / 2;
+		int eatLeft = center.length() / 2;
+		int eatRight = center.length() - eatLeft;
+		
+		return line.substring(0, pivot - eatLeft) + center + line.substring(pivot + eatRight);
+	}
+	
+	
+	public static String repeat(String s, int times) 
+	{
+	    if (times <= 0) 
+	    	return "";
+	    
+	    return s + repeat(s, times-1);
+	}
+	
+	
+	/**
+	 * Joins all emements of list into a single string, sperating the original strings with glue.
+	 */
+	public static String implode(List<String> list, String glue)
+	{
+	    if (list.size() == 0) {
+	    	return "";
+	    }
+		
+		String ret = list.get(0);
+	    
+	    for (int i=1; i<list.size(); i++) {
+	        ret += glue + list.get(i);
+	    }
+	    
+	    return ret;
+	}
+	
+	/**
+	 * Joins all emements of list into a single string.
+	 */
+	public static String implode(List<String> list) {
+		return implode(list, "");
+	}
+	
+	
+	
+	public static String getMaterialName(Material material) 
+	{
+		String ret = material.toString();
+		ret = ret.replace('_', ' ');
+		ret = ret.toLowerCase();
+		
+		return ret.substring(0, 1).toUpperCase() + ret.substring(1);
+	}
+}
+
+

src/org/mcteam/ancientgates/Conf.java

@@ -1,75 +0,0 @@
-package org.mcteam.ancientgates;
-
-import java.io.File;
-import java.io.IOException;
-
-import org.bukkit.ChatColor;
-import org.mcteam.ancientgates.util.DiscUtil;
-
-
-public class Conf {
-	public static transient File file = new File(Plugin.instance.getDataFolder(), "conf.json");
-	
-	// Colors
-	public static ChatColor colorMember = ChatColor.GREEN;
-	public static ChatColor colorAlly = ChatColor.LIGHT_PURPLE;
-	public static ChatColor colorNeutral = ChatColor.WHITE;
-	public static ChatColor colorEnemy = ChatColor.RED;
-	
-	public static ChatColor colorSystem = ChatColor.YELLOW;
-	public static ChatColor colorChrome = ChatColor.GOLD;
-	public static ChatColor colorCommand = ChatColor.AQUA;
-	public static ChatColor colorParameter = ChatColor.DARK_AQUA;
-	
-	private static double gateSearchRadius = 10.0;
-	
-	static {
-		
-	}
-	
-	public static double getGateSearchRadius() {
-		return gateSearchRadius;
-	}
-	
-	public static int getGateMaxArea() {
-		return (int)gateSearchRadius * 7;
-	}
-	
-	// -------------------------------------------- //
-	// Persistance
-	// -------------------------------------------- //
-	
-	public static boolean save() {
-		//Factions.log("Saving config to disk.");
-		
-		try {
-			DiscUtil.write(file, Plugin.gson.toJson(new Conf()));
-		} catch (IOException e) {
-			e.printStackTrace();
-			Plugin.log("Failed to save the config to disk.");
-			return false;
-		}
-		return true;
-	}
-	
-	public static boolean load() {
-		Plugin.log("Loading conf from disk");
-		
-		if ( ! file.exists()) {
-			Plugin.log("No conf to load from disk. Creating new file.");
-			save();
-			return true;
-		}
-		
-		try {
-			Plugin.gson.fromJson(DiscUtil.read(file), Conf.class);
-		} catch (IOException e) {
-			e.printStackTrace();
-			Plugin.log("Failed to load the config from disk.");
-			return false;
-		}
-		
-		return true;
-	}
-}
-

src/org/mcteam/ancientgates/Gate.java

@@ -1,251 +0,0 @@
-package org.mcteam.ancientgates;
-
-import java.io.File;
-import java.io.IOException;
-
-import java.lang.reflect.Type;
-
-import java.util.Collection;
-import java.util.Map.Entry;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-
-import org.mcteam.ancientgates.gson.reflect.TypeToken;
-import org.mcteam.ancientgates.util.DiscUtil;
-import org.mcteam.ancientgates.util.FloodUtil;
-
-
-public class Gate 
-{
-	private static transient TreeMap<String, Gate> instances = new TreeMap<String, Gate>(String.CASE_INSENSITIVE_ORDER);
-	private static transient File file = new File(Plugin.instance.getDataFolder(), "gates.json");
-	
-	private transient String id;
-	private Location from;
-	private Location to;
-        
-    private Integer[][] gateBlocks;
-
-    
-	public Gate() 
-	{	
-	}
-	
-	
-	// -------------------------------------------- //
-	// Getters And Setters
-	// -------------------------------------------- //
-	
-	public void setId(String id) 
-	{
-		this.id = id;
-	}
-
-	
-	public String getId() 
-	{
-		return id;
-	}
-
-	
-	public void setFrom(Location from) 
-	{
-		this.from = from;
-	}
-
-	
-	public Location getFrom() 
-	{
-		return from;
-	}
-
-	public void setTo(Location to) 
-	{
-		this.to = to;
-	}
-
-	
-	public Location getTo() 
-	{
-		return to;
-	}
-     
-	
-    public Integer[][] getGateBlocks() 
-    {
-        return gateBlocks;
-    }
-
-    
-    public void setGateBlocks(Set<Block> gateBlocks) 
-    {
-        if (gateBlocks == null)
-            return;
-
-        this.gateBlocks = new Integer[gateBlocks.size()][3];
-
-        int blockcount = 0;
-        for (Block b : gateBlocks) 
-        {
-            if (b != null) 
-            {
-                this.gateBlocks[blockcount][0] = b.getX();
-                this.gateBlocks[blockcount][1] = b.getY();
-                this.gateBlocks[blockcount][2] = b.getZ();
-            }
-            blockcount++;
-        }
-    }
-	
-    
-	//----------------------------------------------//
-	// The Open And Close Methods
-	//----------------------------------------------//
-	
-	public boolean open() 
-	{
-		Set<Block> blocks = FloodUtil.getGateFrameBlocks(from.getBlock());
-		
-		if (blocks == null)
-			return false;
-		
-        // Uncomment lines below to have the old Portal open functionality back.
-                
-		// This is not to do an effect
-		// It is to stop portal blocks from destroying themself as they cant rely on non created blocks :P
-		for (Block block : blocks)
-			block.setType(Material.GLOWSTONE);
-		
-		for (Block block : blocks)
-			block.setType(Material.PORTAL);
-		
-		return true;
-	}
-	
-	
-	public void close() 
-	{
-		if (from != null)
-		{
-			Set<Block> blocks = FloodUtil.getGateFrameBlocks(from.getBlock());
-	                
-			if (blocks != null)
-			{
-				for (Block block : blocks)
-					block.setType(Material.AIR);
-			}
-		}
-	}
-	
-	
-	//----------------------------------------------//
-	// Persistance and entity management
-	//----------------------------------------------//
-	
-	public static Gate get(String id) 
-	{
-		return instances.get(id);
-	}
-	
-	
-	public static boolean exists(String id) 
-	{
-		return instances.containsKey(id);
-	}
-	
-	
-	public static Gate create(String id) 
-	{
-		Gate gate = new Gate();
-		gate.id = id;
-		instances.put(gate.id, gate);
-		Plugin.log("created new gate " + gate.id);
-		//faction.save();
-		return gate;
-	}
-	
-	
-	public static void rename(Gate gate, String newId)
-	{
-		delete(gate.id);
-		
-		gate.setId(newId);
-		instances.put(gate.id, gate);
-	}
-	
-	
-	public static void delete(String id) 
-	{
-		// Remove the faction
-		instances.remove(id);
-	}
-	
-	
-	public static boolean save() 
-	{
-		try 
-		{
-			DiscUtil.write(file, Plugin.gson.toJson(instances));
-		} 
-		catch (IOException e) 
-		{
-			Plugin.log("Failed to save the gates to disk due to I/O exception.");
-			e.printStackTrace();
-			return false;
-		} 
-		catch (NullPointerException e) 
-		{
-			Plugin.log("Failed to save the gates to disk due to NPE.");
-			e.printStackTrace();
-			return false;
-		}
-		
-		return true;
-	}
-	
-	
-	public static boolean load() 
-	{
-		Plugin.log("Loading gates from disk");
-		if ( ! file.exists()) {
-			Plugin.log("No gates to load from disk. Creating new file.");
-			save();
-			return true;
-		}
-		
-		try 
-		{
-			Type type = new TypeToken<Map<String, Gate>>(){}.getType();
-			Map<String, Gate> instancesFromFile = Plugin.gson.fromJson(DiscUtil.read(file), type);
-			instances.clear();
-			instances.putAll(instancesFromFile);
-		}
-		catch (IOException e) 
-		{
-			e.printStackTrace();
-			return false;
-		}
-		
-		fillIds();
-			
-		return true;
-	}
-	
-	
-	public static Collection<Gate> getAll() 
-	{
-		return instances.values();
-	}
-	
-	
-	public static void fillIds() 
-	{
-		for(Entry<String, Gate> entry : instances.entrySet()) 
-			entry.getValue().setId(entry.getKey());
-	}
-}

src/org/mcteam/ancientgates/MyLocationTypeAdapter.java

@@ -1,71 +0,0 @@
-package org.mcteam.ancientgates;
-
-import java.lang.reflect.Type;
-
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.World.Environment;
-import org.bukkit.WorldCreator;
-import org.mcteam.ancientgates.gson.JsonDeserializationContext;
-import org.mcteam.ancientgates.gson.JsonDeserializer;
-import org.mcteam.ancientgates.gson.JsonElement;
-import org.mcteam.ancientgates.gson.JsonObject;
-import org.mcteam.ancientgates.gson.JsonParseException;
-import org.mcteam.ancientgates.gson.JsonSerializationContext;
-import org.mcteam.ancientgates.gson.JsonSerializer;
-
-public class MyLocationTypeAdapter implements JsonDeserializer<Location>, JsonSerializer<Location> {
-	private static final String WORLD = "world";
-	private static final String X = "x";
-	private static final String Y = "y";
-	private static final String Z = "z";
-	private static final String YAW = "yaw";
-	private static final String PITCH = "pitch";
-	
-	@Override
-	public Location deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
-		JsonObject obj = json.getAsJsonObject();
-		
-		World world = this.getWorld(obj.get(WORLD).getAsString());
-		double x = obj.get(X).getAsDouble();
-		double y = obj.get(Y).getAsDouble();
-		double z = obj.get(Z).getAsDouble();
-		float yaw = obj.get(YAW).getAsFloat();
-		float pitch = obj.get(PITCH).getAsFloat();
-		
-		return new Location(world, x, y, z, yaw, pitch);
-	}
-
-	@Override
-	public JsonElement serialize(Location src, Type typeOfSrc, JsonSerializationContext context) {
-		JsonObject obj = new JsonObject();
-
-		if (src == null)
-		{
-			Plugin.log("Passed location is null in MyLocationTypeAdapter.");
-			return obj;
-		}
-		else if (src.getWorld() == null)
-		{
-			Plugin.log("Passed location's world is null in MyLocationTypeAdapter.");
-			return obj;
-		}
-
-		obj.addProperty(WORLD, src.getWorld().getName());
-		obj.addProperty(X, src.getX());
-		obj.addProperty(Y, src.getY());
-		obj.addProperty(Z, src.getZ());
-		obj.addProperty(YAW, src.getYaw());
-		obj.addProperty(PITCH, src.getPitch());
-		
-		return obj;
-	}
-	
-	private World getWorld(String name) {
-		World world = Plugin.instance.getServer().getWorld(name);
-		if (world == null) {
-                    world = Plugin.instance.getServer().createWorld(new WorldCreator(name).environment(Environment.NORMAL));
-		}
-		return world;
-	}
-}

src/org/mcteam/ancientgates/Plugin.java

@@ -1,140 +0,0 @@
-package org.mcteam.ancientgates;
-
-import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import org.bukkit.Location;
-
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.mcteam.ancientgates.commands.*;
-import org.mcteam.ancientgates.gson.Gson;
-import org.mcteam.ancientgates.gson.GsonBuilder;
-
-import org.mcteam.ancientgates.listeners.PluginBlockListener;
-import org.mcteam.ancientgates.listeners.PluginPlayerListener;
-
-
-public class Plugin extends JavaPlugin 
-{
-	public static Plugin instance;
-	
-	public PluginPlayerListener playerListener = new PluginPlayerListener();
-	public PluginBlockListener blockListener = new PluginBlockListener();
-	
-	private String baseCommand;
-	
-	public final static Gson gson = new GsonBuilder()
-	.setPrettyPrinting()
-	.excludeFieldsWithModifiers(Modifier.TRANSIENT, Modifier.VOLATILE)
-	.registerTypeAdapter(Location.class, new MyLocationTypeAdapter())
-	.create();
-	
-	// Commands
-	public List<BaseCommand> commands = new ArrayList<BaseCommand>();
-	
-	public Plugin()
-	{
-		instance = this;
-	}
-
-	@Override
-	public void onDisable() {
-		log("Disabled");
-	}
-
-	@Override
-	public void onEnable() 
-	{
-		// Add the commands
-		commands.add(new CommandHelp());
-		commands.add(new CommandCreate());
-		commands.add(new CommandCreateSetFrom());
-		commands.add(new CommandDelete());
-		commands.add(new CommandSetFrom());
-		commands.add(new CommandSetTo());
-		commands.add(new CommandOpen());
-		commands.add(new CommandRename());
-		commands.add(new CommandClose());
-		commands.add(new CommandList());
-		commands.add(new CommandInfo());
-		
-		// Ensure basefolder exists!
-		this.getDataFolder().mkdirs();
-		
-		// Load from disc
-		Conf.load();
-		Gate.load();
-		
-		// Register events
-		getServer().getPluginManager().registerEvents(this.playerListener, this);
-		getServer().getPluginManager().registerEvents(this.blockListener, this);
-		
-		log("Enabled");
-	}
-	
-	// -------------------------------------------- //
-	// Test rights
-	// -------------------------------------------- //
-	
-	public static boolean hasPermManage(CommandSender sender) {
-		return sender.isOp();
-	}
-	
-	// -------------------------------------------- //
-	// Commands
-	// -------------------------------------------- //
-	
-	@SuppressWarnings("unchecked")
-	public String getBaseCommand() {
-		if (this.baseCommand != null) {
-			return this.baseCommand;
-		}
-		Map<String, Map<String, Object>> Commands = (Map<String, Map<String, Object>>) this.getDescription().getCommands();
-		this.baseCommand = Commands.keySet().iterator().next();
-		return this.baseCommand;
-	}
-	
-	@Override
-	public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
-		List<String> parameters = new ArrayList<String>(Arrays.asList(args));
-		this.handleCommand(sender, parameters);
-		return true;
-	}
-	
-	public void handleCommand(CommandSender sender, List<String> parameters) {
-		if (parameters.size() == 0) {
-			this.commands.get(0).execute(sender, parameters);
-			return;
-		}
-		
-		String commandName = parameters.get(0).toLowerCase();
-		parameters.remove(0);
-		
-		for (BaseCommand fcommand : this.commands) {
-			if (fcommand.getAliases().contains(commandName)) {
-				fcommand.execute(sender, parameters);
-				return;
-			}
-		}
-		
-		sender.sendMessage(Conf.colorSystem+"Unknown gate-command \""+commandName+"\". Try "+Conf.colorCommand+"/"+getBaseCommand()+" help");
-	}
-	
-	// -------------------------------------------- //
-	// Logging
-	// -------------------------------------------- //
-	public static void log(String msg) {
-		log(Level.INFO, msg);
-	}
-	
-	public static void log(Level level, String msg) {
-		Logger.getLogger("Minecraft").log(level, "["+instance.getDescription().getFullName()+"] "+msg);
-	}
-
-}

src/org/mcteam/ancientgates/commands/CommandClose.java

@@ -1,18 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-public class CommandClose extends BaseCommand {
-	
-	public CommandClose() {
-		aliases.add("close");
-		
-		requiredParameters.add("id");		
-		
-		helpDescription = "Close that gate";
-	}
-	
-	public void perform() {
-		gate.close();
-		sendMessage("The gate was closed.");
-	}
-}
-

src/org/mcteam/ancientgates/commands/CommandCreate.java

@@ -1,32 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import org.mcteam.ancientgates.Gate;
-
-public class CommandCreate extends BaseCommand {
-	public CommandCreate() {
-		aliases.add("create");
-		aliases.add("new");
-		
-		requiredParameters.add("id");		
-		
-		senderMustBePlayer = false;
-		hasGateParam = false;
-		
-		helpDescription = "Create a gate";
-	}
-	
-	public void perform() {
-		String id = parameters.get(0);
-		if (Gate.exists(id)) {
-			sendMessage("There gate \"" + id + "\" already exists.");
-			return;
-		}
-		
-		Gate.create(id);
-		sendMessage("Gate with id \"" + id + "\" was created. Now you should:");
-		sendMessage(new CommandSetFrom().getUseageTemplate(true, true));
-		
-		Gate.save();
-	}
-}
-

src/org/mcteam/ancientgates/commands/CommandCreateSetFrom.java

@@ -1,82 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import java.util.Set;
-
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.mcteam.ancientgates.Conf;
-import org.mcteam.ancientgates.Gate;
-import org.mcteam.ancientgates.util.FloodUtil;
-
-public class CommandCreateSetFrom extends BaseCommand 
-{
-	public CommandCreateSetFrom() 
-	{
-		aliases.add("createsetfrom");
-		aliases.add("newsetfrom");
-		aliases.add("csf");
-		aliases.add("nsf");
-		
-		requiredParameters.add("id");		
-
-		hasGateParam = false;
-		
-		helpDescription = "Create a gate and set \"from\" to your location.";
-	}
-	
-	public void perform() 
-	{
-		String id = parameters.get(0);
-		
-		if (Gate.exists(id)) {
-			sendMessage("There gate \"" + id + "\" already exists.");
-			return;
-		}
-		
-		Gate.create(id);
-		Gate.save();
-		sendMessage("Gate with id \"" + id + "\" was created.");
-		
-		gate = Gate.get(id);
-		
-		// The player might stand in a halfblock or a sign or whatever
-		// Therefore we load som extra locations and blocks
-		Block playerBlock = player.getLocation().getBlock();
-		Block upBlock = playerBlock.getRelative(BlockFace.UP);
-		Location playerUpLocation = new Location(player.getLocation().getWorld(),
-                        						 player.getLocation().getX(),
-                        						 player.getLocation().getY() + 1,
-						                         player.getLocation().getZ(),
-						                         player.getLocation().getYaw(),
-						                         player.getLocation().getPitch());
-                
-	    Set<Block> gateBlocks = FloodUtil.getGateFrameBlocks(player.getLocation().getBlock());
-	    
-	    if (gateBlocks == null) 
-	    {
-            sendMessage("Could not set from! Your portal is too large.\nMax size is: " + Conf.getGateMaxArea() + " Blocks.");
-            return;
-	    }
-                
-		if (playerBlock.getType() == Material.AIR) 
-		{
-			gate.setFrom(player.getLocation());
-			gate.setGateBlocks(gateBlocks);
-		} 
-		else if (upBlock.getType() == Material.AIR) 
-		{
-			gate.setFrom(playerUpLocation);
-            gate.setGateBlocks(gateBlocks);
-		} 
-		else 
-		{
-			sendMessage("Could not set from! There is not enough room for a gate to open here");
-			return;
-		}
-		
-		sendMessage("From location for gate \""+gate.getId()+"\" is now where you stand.");
-		sendMessage("Your gate includes " + gateBlocks.size() + " Blocks.");
-	}
-}

src/org/mcteam/ancientgates/commands/CommandDelete.java

@@ -1,25 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import org.mcteam.ancientgates.Gate;
-
-public class CommandDelete extends BaseCommand {
-	public CommandDelete() {
-		aliases.add("delete");
-		aliases.add("del");
-		aliases.add("remove");
-		aliases.add("rm");
-		
-		requiredParameters.add("id");		
-		
-		senderMustBePlayer = false;
-		helpDescription = "Delete a gate";
-	}
-	
-	public void perform() {
-		gate.close();
-		sendMessage("Gate with id \"" + gate.getId() + "\" was deleted.");
-		Gate.delete(gate.getId());
-		Gate.save();
-	}
-}
-

src/org/mcteam/ancientgates/commands/CommandHelp.java

@@ -1,83 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import java.util.ArrayList;
-
-import org.bukkit.command.CommandSender;
-import org.mcteam.ancientgates.util.TextUtil;
-
-public class CommandHelp extends BaseCommand {
-	
-	public CommandHelp() {
-		aliases.add("help");
-		aliases.add("h");
-		aliases.add("?");
-		
-		optionalParameters.add("page");
-		hasGateParam = false;
-		
-		helpDescription = "Display a help page";
-	}
-	
-	@Override
-	public boolean hasPermission(CommandSender sender) {
-		return true;
-	}
-	
-	
-	public void perform() 
-	{
-		int page = 1;
-		
-		if (parameters.size() > 0) 
-		{
-			try 
-			{
-				page = Integer.parseInt(parameters.get(0));
-			} 
-			catch (NumberFormatException e) 
-			{
-				// wasn't an integer
-			}
-		}
-		
-		sendMessage(TextUtil.titleize("AncientGates Help ("+page+"/"+helpPages.size()+")"));
-		
-		page -= 1;
-		if (page < 0 || page >= helpPages.size()) 
-		{
-			sendMessage("This page does not exist");
-			return;
-		}
-		
-		sendMessage(helpPages.get(page));
-	}
-	
-	
-	//----------------------------------------------//
-	// Build the help pages
-	//----------------------------------------------//
-	
-	public static ArrayList<ArrayList<String>> helpPages;
-	
-	static 
-	{
-		helpPages = new ArrayList<ArrayList<String>>();
-		ArrayList<String> pageLines;
-
-		pageLines = new ArrayList<String>();
-		pageLines.add( new CommandHelp().getUseageTemplate(true, true) );
-		pageLines.add( new CommandCreate().getUseageTemplate(true, true) );
-		pageLines.add( new CommandCreateSetFrom().getUseageTemplate(true, true) );
-		pageLines.add( new CommandDelete().getUseageTemplate(true, true) );
-		pageLines.add( new CommandSetFrom().getUseageTemplate(true, true) );
-		pageLines.add( new CommandSetTo().getUseageTemplate(true, true) );
-		pageLines.add( new CommandOpen().getUseageTemplate(true, true) );
-		pageLines.add( new CommandRename().getUseageTemplate(true, true) );
-		pageLines.add( new CommandClose().getUseageTemplate(true, true) );
-		pageLines.add( new CommandList().getUseageTemplate(true, true) );
-		pageLines.add( new CommandInfo().getUseageTemplate(true, true) );
-		helpPages.add(pageLines);
-	}
-	
-}
-

src/org/mcteam/ancientgates/commands/CommandInfo.java

@@ -1,34 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import org.bukkit.ChatColor;
-
-
-public class CommandInfo extends BaseCommand 
-{
-	public CommandInfo()
-	{
-		aliases.add("info");
-		aliases.add("details");
-		
-		requiredParameters.add("id");		
-		
-		helpDescription = "Prints information about a gate";
-	}
-	
-	
-	public void perform() 
-	{
-		sendMessage(ChatColor.LIGHT_PURPLE + "Information about " + ChatColor.WHITE + gate.getId() + ChatColor.LIGHT_PURPLE + ":");
-		
-		if (gate.getFrom() != null)
-			sendMessage(ChatColor.GREEN + "'from' location:       " + ChatColor.YELLOW + "( " + gate.getFrom().getBlockX() + " | " + gate.getFrom().getBlockY() + " | " + gate.getFrom().getBlockZ() + " )");
-		else
-			sendMessage(ChatColor.GREEN + "this gate has no 'from' location");
-		
-		if (gate.getTo() != null)
-			sendMessage(ChatColor.GREEN + "'to' location:          " + ChatColor.YELLOW + "( " + gate.getTo().getBlockX() + " | " + gate.getTo().getBlockY() + " | " + gate.getTo().getBlockZ() + " )");
-		else
-			sendMessage(ChatColor.GREEN + "this gate has no 'to' location");
-		
-	}
-}

src/org/mcteam/ancientgates/commands/CommandOpen.java

@@ -1,40 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import org.bukkit.Material;
-
-public class CommandOpen extends BaseCommand {
-	
-	public CommandOpen() {
-		aliases.add("open");
-		
-		requiredParameters.add("id");		
-		
-		helpDescription = "Open that gate";
-	}
-	
-	public void perform() {
-		if (gate.getFrom() == null) {
-			sendMessage("You must set the from location first. To fix that:");
-			sendMessage(new CommandSetFrom().getUseageTemplate(true, true));
-			return;
-		}
-		
-		if (gate.getTo() == null) {
-			sendMessage("Sure, but note that this gate does not point anywhere :P");
-			sendMessage("To fix that: " + new CommandSetTo().getUseageTemplate(true, true));
-		}
-		
-		if (gate.getFrom().getBlock().getType() != Material.AIR) {
-			sendMessage("The gate could not open. The from location is not air.");
-			return;
-		}
-		
-		if (gate.open()) {
-			sendMessage("The gate was opened.");
-		} else {
-			sendMessage("Failed to open the gate. Have you built a frame?");
-			sendMessage("More info here: " + new CommandHelp().getUseageTemplate(true, true));
-		}
-	}
-}
-

src/org/mcteam/ancientgates/commands/CommandRename.java

@@ -1,40 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import org.mcteam.ancientgates.Gate;
-
-
-
-public class CommandRename extends BaseCommand 
-{
-	public CommandRename() 
-	{
-		aliases.add("rename");
-		aliases.add("changename");
-		aliases.add("cn");
-		
-		hasGateParam = true;
-		senderMustBePlayer = false;
-		
-		requiredParameters.add("current name");
-		requiredParameters.add("new name");
-		
-		helpDescription = "Change the name of a gate";
-	}
-	
-	
-	public void perform() 
-	{
-		String newId = parameters.get(1);
-		String oldId = gate.getId();
-		
-		if (Gate.exists(newId))
-		{
-			sendMessage("Cannot rename " + oldId + ". There is already a gate named " + newId + ".");
-			return;
-		}
-		
-		Gate.rename(gate, newId);
-		
-		sendMessage("Gate " + oldId + " is now known as " + newId + ".");
-	}
-}

src/org/mcteam/ancientgates/commands/CommandSetFrom.java

@@ -1,61 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import java.util.Set;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.mcteam.ancientgates.Conf;
-import org.mcteam.ancientgates.Gate;
-import org.mcteam.ancientgates.util.FloodUtil;
-
-public class CommandSetFrom extends BaseCommand {
-	
-	public CommandSetFrom() {
-		aliases.add("setfrom");
-		aliases.add("sf");
-		
-		requiredParameters.add("id");		
-		
-		helpDescription = "Set \"from\" to your location.";
-	}
-	
-	public void perform() {
-		// The player might stand in a halfblock or a sign or whatever
-		// Therefore we load som extra locations and blocks
-		Block playerBlock = player.getLocation().getBlock();
-		Block upBlock = playerBlock.getRelative(BlockFace.UP);
-		Location playerUpLocation = new Location(player.getLocation().getWorld(),
-                        player.getLocation().getX(),
-                        player.getLocation().getY() + 1,
-                        player.getLocation().getZ(),
-                        player.getLocation().getYaw(),
-                        player.getLocation().getPitch());
-		
-                Set<Block> gateBlocks = FloodUtil.getGateFrameBlocks(player.getLocation().getBlock());
-                if (gateBlocks == null) {
-                        sendMessage("There is no portal here, or your portal is too large.\nMax size is: " + Conf.getGateMaxArea() + " Blocks.");
-                        return;
-                }
-                
-		if (playerBlock.getType() == Material.AIR) {
-			gate.setFrom(player.getLocation());
-			gate.setGateBlocks(gateBlocks);
-		} else if (upBlock.getType() == Material.AIR) {
-			gate.setFrom(playerUpLocation);
-                        gate.setGateBlocks(gateBlocks);
-		} else {
-			sendMessage("There is not enough room for a gate to open here");
-			return;
-		}
-		
-
-		
-		sendMessage("From location for gate \""+gate.getId()+"\" is now where you stand.");
-		sendMessage("Your gate includes " + gateBlocks.size() + " Blocks.");
-		
-		Gate.save();
-	}
-	
-}
-

src/org/mcteam/ancientgates/commands/CommandSetTo.java

@@ -1,23 +0,0 @@
-package org.mcteam.ancientgates.commands;
-
-import org.mcteam.ancientgates.Gate;
-
-public class CommandSetTo extends BaseCommand {
-	
-	public CommandSetTo() {
-		aliases.add("setto");
-		
-		requiredParameters.add("id");		
-		
-		helpDescription = "Set \"to\" to your location.";
-	}
-	
-	public void perform() {
-		gate.setTo(player.getLocation());
-		sendMessage("To location for gate \""+gate.getId()+"\" is now where you stand.");
-		
-		Gate.save();
-	}
-	
-}
-

src/org/mcteam/ancientgates/gson/AnonymousAndLocalClassExclusionStrategy.java

@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-
-/**
- * Strategy for excluding anonymous and local classes.
- *
- * @author Joel Leitch
- */
-final class AnonymousAndLocalClassExclusionStrategy implements ExclusionStrategy {
-
-  public boolean shouldSkipField(FieldAttributes f) {
-    return isAnonymousOrLocal(f.getDeclaredClass());
-  }
-
-  public boolean shouldSkipClass(Class<?> clazz) {
-    return isAnonymousOrLocal(clazz);
-  }
-
-  private boolean isAnonymousOrLocal(Class<?> clazz) {
-    return !Enum.class.isAssignableFrom(clazz)
-        && (clazz.isAnonymousClass() || clazz.isLocalClass());
-  }
-}

src/org/mcteam/ancientgates/gson/Cache.java

@@ -1,61 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * Defines generic cache interface.
- * 
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-interface Cache<K, V> {
-
-  /**
-   * Adds the new value object into the cache for the given key.  If the key already
-   * exists, then this method will override the value for the key.
-   *
-   * @param key the key identifier for the {@code value} object
-   * @param value the value object to store in the cache
-   */
-  void addElement(K key, V value);
-
-  /**
-   * Retrieve the cached value for the given {@code key}.
-   *
-   * @param key the key identifying the value
-   * @return the cached value for the given {@code key}
-   */
-  V getElement(K key);
-  
-  /**
-   * Removes the value from the cache for the given key.
-   * 
-   * @param key the key identifying the value to remove
-   * @return the value for the given {@code key}
-   */
-  V removeElement(K key);
-
-  /**
-   * Removes everything from this cache.
-   */
-  void clear();
-  
-  /**
-   * @return the number of objects in this cache
-   */
-  int size();
-}

src/org/mcteam/ancientgates/gson/CamelCaseSeparatorNamingPolicy.java

@@ -1,73 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-import java.util.Collection;
-
-/**
- * Converts the field name that uses camel-case define word separation into separate words that
- * are separated by the provided {@code separatorString}.
- *
- * <p>The following is an example:</p>
- * <pre>
- * class IntWrapper {
- *   public int integerField = 0;
- * }
- *
- * CamelCaseSeparatorNamingPolicy policy = new CamelCaseSeparatorNamingPolicy("_");
- * String translatedFieldName =
- *     policy.translateName(IntWrapper.class.getField("integerField"));
- *
- * assert("integer_Field".equals(translatedFieldName));
- * </pre>
- *
- * @author Joel Leitch
- */
-final class CamelCaseSeparatorNamingPolicy extends RecursiveFieldNamingPolicy {
-  private final String separatorString;
-
-  /**
-   * Constructs a new CamelCaseSeparatorNamingPolicy object that will add the
-   * {@code separatorString} between each of the words separated by camel case.
-   *
-   * @param separatorString the string value to place between words
-   * @throws IllegalArgumentException thrown if the {@code separatorString} parameter
-   *         is null or empty.
-   */
-  public CamelCaseSeparatorNamingPolicy(String separatorString) {
-    Preconditions.checkNotNull(separatorString);
-    Preconditions.checkArgument(!"".equals(separatorString));
-    this.separatorString = separatorString;
-  }
-
-  @Override
-  protected String translateName(String target, Type fieldType,
-      Collection<Annotation> annnotations) {
-    StringBuilder translation = new StringBuilder();
-    for (int i = 0; i < target.length(); i++) {
-      char character = target.charAt(i);
-      if (Character.isUpperCase(character) && translation.length() != 0) {
-        translation.append(separatorString);
-      }
-      translation.append(character);
-    }
-
-    return translation.toString();
-  }
-}

src/org/mcteam/ancientgates/gson/CircularReferenceException.java

@@ -1,45 +0,0 @@
-/*
- * Copyright (C) 2009 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * Exception class to indicate a circular reference error.
- * This class is not part of the public API and hence is not public.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class CircularReferenceException extends RuntimeException {
-  private static final long serialVersionUID = 7444343294106513081L;
-  private final Object offendingNode;
-
-  CircularReferenceException(Object offendingNode) {
-    super("circular reference error");
-    this.offendingNode = offendingNode;
-  }
-  
-  public IllegalStateException createDetailedException(FieldAttributes offendingField) {
-    StringBuilder msg = new StringBuilder(getMessage());
-    if (offendingField != null) {
-      msg.append("\n  ").append("Offending field: ").append(offendingField.getName() + "\n");
-    }
-    if (offendingNode != null) {
-      msg.append("\n  ").append("Offending object: ").append(offendingNode);
-    }
-    return new IllegalStateException(msg.toString(), this);
-  }
-}

src/org/mcteam/ancientgates/gson/CompositionFieldNamingPolicy.java

@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-import java.util.Collection;
-
-/**
- * Performs numerous field naming translations wrapped up as one object.
- *
- * @author Joel Leitch
- */
-abstract class CompositionFieldNamingPolicy extends RecursiveFieldNamingPolicy {
-
-  private final RecursiveFieldNamingPolicy[] fieldPolicies;
-
-  public CompositionFieldNamingPolicy(RecursiveFieldNamingPolicy... fieldNamingPolicies) {
-    if (fieldNamingPolicies == null) {
-      throw new NullPointerException("naming policies can not be null.");
-    }
-    this.fieldPolicies = fieldNamingPolicies;
-  }
-
-  @Override
-  protected String translateName(String target, Type fieldType, Collection<Annotation> annotations) {
-    for (RecursiveFieldNamingPolicy policy : fieldPolicies) {
-      target = policy.translateName(target, fieldType, annotations);
-    }
-    return target;
-  }
-}

src/org/mcteam/ancientgates/gson/DefaultTypeAdapters.java

@@ -1,893 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.net.MalformedURLException;
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.net.URL;
-import java.sql.Time;
-import java.sql.Timestamp;
-import java.text.DateFormat;
-import java.text.ParseException;
-import java.text.SimpleDateFormat;
-import java.util.Calendar;
-import java.util.Collection;
-import java.util.Date;
-import java.util.GregorianCalendar;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.LinkedList;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Properties;
-import java.util.Set;
-import java.util.SortedSet;
-import java.util.StringTokenizer;
-import java.util.TreeSet;
-import java.util.UUID;
-
-/**
- * List of all the default type adapters ({@link JsonSerializer}s, {@link JsonDeserializer}s,
- * and {@link InstanceCreator}s.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class DefaultTypeAdapters {
-
-  private static final DefaultDateTypeAdapter DATE_TYPE_ADAPTER = new DefaultDateTypeAdapter();
-  private static final DefaultJavaSqlDateTypeAdapter JAVA_SQL_DATE_TYPE_ADAPTER =
-    new DefaultJavaSqlDateTypeAdapter();
-  private static final DefaultTimeTypeAdapter TIME_TYPE_ADAPTER =
-    new DefaultTimeTypeAdapter();
-  private static final DefaultTimestampDeserializer TIMESTAMP_DESERIALIZER =
-    new DefaultTimestampDeserializer();
-
-  @SuppressWarnings("rawtypes")
-  private static final EnumTypeAdapter ENUM_TYPE_ADAPTER = new EnumTypeAdapter();
-  private static final UrlTypeAdapter URL_TYPE_ADAPTER = new UrlTypeAdapter();
-  private static final UriTypeAdapter URI_TYPE_ADAPTER = new UriTypeAdapter();
-  private static final UuidTypeAdapter UUUID_TYPE_ADAPTER = new UuidTypeAdapter();
-  private static final LocaleTypeAdapter LOCALE_TYPE_ADAPTER = new LocaleTypeAdapter();
-  private static final CollectionTypeAdapter COLLECTION_TYPE_ADAPTER = new CollectionTypeAdapter();
-  private static final MapTypeAdapter MAP_TYPE_ADAPTER = new MapTypeAdapter();
-  private static final BigDecimalTypeAdapter BIG_DECIMAL_TYPE_ADAPTER = new BigDecimalTypeAdapter();
-  private static final BigIntegerTypeAdapter BIG_INTEGER_TYPE_ADAPTER = new BigIntegerTypeAdapter();
-
-  private static final BooleanTypeAdapter BOOLEAN_TYPE_ADAPTER = new BooleanTypeAdapter();
-  private static final ByteTypeAdapter BYTE_TYPE_ADAPTER = new ByteTypeAdapter();
-  private static final CharacterTypeAdapter CHARACTER_TYPE_ADAPTER = new CharacterTypeAdapter();
-  private static final DoubleDeserializer DOUBLE_TYPE_ADAPTER = new DoubleDeserializer();
-  private static final FloatDeserializer FLOAT_TYPE_ADAPTER = new FloatDeserializer();
-  private static final IntegerTypeAdapter INTEGER_TYPE_ADAPTER = new IntegerTypeAdapter();
-  private static final LongDeserializer LONG_DESERIALIZER = new LongDeserializer();
-  private static final NumberTypeAdapter NUMBER_TYPE_ADAPTER = new NumberTypeAdapter();
-  private static final ShortTypeAdapter SHORT_TYPE_ADAPTER = new ShortTypeAdapter();
-  private static final StringTypeAdapter STRING_TYPE_ADAPTER = new StringTypeAdapter();
-
-  private static final PropertiesCreator PROPERTIES_CREATOR = new PropertiesCreator();
-  private static final TreeSetCreator TREE_SET_CREATOR = new TreeSetCreator();
-  private static final HashSetCreator HASH_SET_CREATOR = new HashSetCreator();
-  private static final GregorianCalendarTypeAdapter GREGORIAN_CALENDAR_TYPE_ADAPTER =
-    new GregorianCalendarTypeAdapter();
-
-  // The constants DEFAULT_SERIALIZERS, DEFAULT_DESERIALIZERS, and DEFAULT_INSTANCE_CREATORS
-  // must be defined after the constants for the type adapters. Otherwise, the type adapter
-  // constants will appear as nulls.
-  private static final ParameterizedTypeHandlerMap<JsonSerializer<?>> DEFAULT_SERIALIZERS =
-      createDefaultSerializers();
-  private static final ParameterizedTypeHandlerMap<JsonDeserializer<?>> DEFAULT_DESERIALIZERS =
-      createDefaultDeserializers();
-  private static final ParameterizedTypeHandlerMap<InstanceCreator<?>> DEFAULT_INSTANCE_CREATORS =
-      createDefaultInstanceCreators();
-
-  private static ParameterizedTypeHandlerMap<JsonSerializer<?>> createDefaultSerializers() {
-    ParameterizedTypeHandlerMap<JsonSerializer<?>> map =
-        new ParameterizedTypeHandlerMap<JsonSerializer<?>>();
-
-    map.registerForTypeHierarchy(Enum.class, ENUM_TYPE_ADAPTER);
-    map.register(URL.class, URL_TYPE_ADAPTER);
-    map.register(URI.class, URI_TYPE_ADAPTER);
-    map.register(UUID.class, UUUID_TYPE_ADAPTER);
-    map.register(Locale.class, LOCALE_TYPE_ADAPTER);
-    map.registerForTypeHierarchy(Collection.class, COLLECTION_TYPE_ADAPTER);
-    map.registerForTypeHierarchy(Map.class, MAP_TYPE_ADAPTER);
-    map.register(Date.class, DATE_TYPE_ADAPTER);
-    map.register(java.sql.Date.class, JAVA_SQL_DATE_TYPE_ADAPTER);
-    map.register(Timestamp.class, DATE_TYPE_ADAPTER);
-    map.register(Time.class, TIME_TYPE_ADAPTER);
-    map.register(Calendar.class, GREGORIAN_CALENDAR_TYPE_ADAPTER);
-    map.register(GregorianCalendar.class, GREGORIAN_CALENDAR_TYPE_ADAPTER);
-    map.register(BigDecimal.class, BIG_DECIMAL_TYPE_ADAPTER);
-    map.register(BigInteger.class, BIG_INTEGER_TYPE_ADAPTER);
-
-    // Add primitive serializers
-    map.register(Boolean.class, BOOLEAN_TYPE_ADAPTER);
-    map.register(boolean.class, BOOLEAN_TYPE_ADAPTER);
-    map.register(Byte.class, BYTE_TYPE_ADAPTER);
-    map.register(byte.class, BYTE_TYPE_ADAPTER);
-    map.register(Character.class, CHARACTER_TYPE_ADAPTER);
-    map.register(char.class, CHARACTER_TYPE_ADAPTER);
-    map.register(Integer.class, INTEGER_TYPE_ADAPTER);
-    map.register(int.class, INTEGER_TYPE_ADAPTER);
-    map.register(Number.class, NUMBER_TYPE_ADAPTER);
-    map.register(Short.class, SHORT_TYPE_ADAPTER);
-    map.register(short.class, SHORT_TYPE_ADAPTER);
-    map.register(String.class, STRING_TYPE_ADAPTER);
-
-    map.makeUnmodifiable();
-    return map;
-  }
-
-  private static ParameterizedTypeHandlerMap<JsonDeserializer<?>> createDefaultDeserializers() {
-    ParameterizedTypeHandlerMap<JsonDeserializer<?>> map =
-        new ParameterizedTypeHandlerMap<JsonDeserializer<?>>();
-    map.registerForTypeHierarchy(Enum.class, wrapDeserializer(ENUM_TYPE_ADAPTER));
-    map.register(URL.class, wrapDeserializer(URL_TYPE_ADAPTER));
-    map.register(URI.class, wrapDeserializer(URI_TYPE_ADAPTER));
-    map.register(UUID.class, wrapDeserializer(UUUID_TYPE_ADAPTER));
-    map.register(Locale.class, wrapDeserializer(LOCALE_TYPE_ADAPTER));
-    map.registerForTypeHierarchy(Collection.class, wrapDeserializer(COLLECTION_TYPE_ADAPTER));
-    map.registerForTypeHierarchy(Map.class, wrapDeserializer(MAP_TYPE_ADAPTER));
-    map.register(Date.class, wrapDeserializer(DATE_TYPE_ADAPTER));
-    map.register(java.sql.Date.class, wrapDeserializer(JAVA_SQL_DATE_TYPE_ADAPTER));
-    map.register(Timestamp.class, wrapDeserializer(TIMESTAMP_DESERIALIZER));
-    map.register(Time.class, wrapDeserializer(TIME_TYPE_ADAPTER));
-    map.register(Calendar.class, GREGORIAN_CALENDAR_TYPE_ADAPTER);
-    map.register(GregorianCalendar.class, GREGORIAN_CALENDAR_TYPE_ADAPTER);
-    map.register(BigDecimal.class, wrapDeserializer(BIG_DECIMAL_TYPE_ADAPTER));
-    map.register(BigInteger.class, wrapDeserializer(BIG_INTEGER_TYPE_ADAPTER));
-
-    // Add primitive deserializers
-    map.register(Boolean.class, wrapDeserializer(BOOLEAN_TYPE_ADAPTER));
-    map.register(boolean.class, wrapDeserializer(BOOLEAN_TYPE_ADAPTER));
-    map.register(Byte.class, wrapDeserializer(BYTE_TYPE_ADAPTER));
-    map.register(byte.class, wrapDeserializer(BYTE_TYPE_ADAPTER));
-    map.register(Character.class, wrapDeserializer(CHARACTER_TYPE_ADAPTER));
-    map.register(char.class, wrapDeserializer(CHARACTER_TYPE_ADAPTER));
-    map.register(Double.class, wrapDeserializer(DOUBLE_TYPE_ADAPTER));
-    map.register(double.class, wrapDeserializer(DOUBLE_TYPE_ADAPTER));
-    map.register(Float.class, wrapDeserializer(FLOAT_TYPE_ADAPTER));
-    map.register(float.class, wrapDeserializer(FLOAT_TYPE_ADAPTER));
-    map.register(Integer.class, wrapDeserializer(INTEGER_TYPE_ADAPTER));
-    map.register(int.class, wrapDeserializer(INTEGER_TYPE_ADAPTER));
-    map.register(Long.class, wrapDeserializer(LONG_DESERIALIZER));
-    map.register(long.class, wrapDeserializer(LONG_DESERIALIZER));
-    map.register(Number.class, wrapDeserializer(NUMBER_TYPE_ADAPTER));
-    map.register(Short.class, wrapDeserializer(SHORT_TYPE_ADAPTER));
-    map.register(short.class, wrapDeserializer(SHORT_TYPE_ADAPTER));
-    map.register(String.class, wrapDeserializer(STRING_TYPE_ADAPTER));
-
-    map.makeUnmodifiable();
-    return map;
-  }
-
-  private static ParameterizedTypeHandlerMap<InstanceCreator<?>> createDefaultInstanceCreators() {
-    ParameterizedTypeHandlerMap<InstanceCreator<?>> map =
-        new ParameterizedTypeHandlerMap<InstanceCreator<?>>();
-    map.registerForTypeHierarchy(Map.class, MAP_TYPE_ADAPTER);
-
-    // Add Collection type instance creators
-    map.registerForTypeHierarchy(Collection.class, COLLECTION_TYPE_ADAPTER);
-
-    map.registerForTypeHierarchy(Set.class, HASH_SET_CREATOR);
-    map.registerForTypeHierarchy(SortedSet.class, TREE_SET_CREATOR);
-    map.register(Properties.class, PROPERTIES_CREATOR);
-    map.makeUnmodifiable();
-    return map;
-  }
-
-  @SuppressWarnings({"unchecked", "rawtypes"})
-  private static JsonDeserializer<?> wrapDeserializer(JsonDeserializer<?> deserializer) {
-    return new JsonDeserializerExceptionWrapper(deserializer);
-  }
-
-  static ParameterizedTypeHandlerMap<JsonSerializer<?>> getDefaultSerializers() {
-    return getDefaultSerializers(false, LongSerializationPolicy.DEFAULT);
-  }
-
-  static ParameterizedTypeHandlerMap<JsonSerializer<?>> getDefaultSerializers(
-      boolean serializeSpecialFloatingPointValues, LongSerializationPolicy longSerializationPolicy) {
-    ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers =
-        new ParameterizedTypeHandlerMap<JsonSerializer<?>>();
-
-    // Double primitive
-    DefaultTypeAdapters.DoubleSerializer doubleSerializer =
-        new DefaultTypeAdapters.DoubleSerializer(serializeSpecialFloatingPointValues);
-    serializers.registerIfAbsent(Double.class, doubleSerializer);
-    serializers.registerIfAbsent(double.class, doubleSerializer);
-
-    // Float primitive
-    DefaultTypeAdapters.FloatSerializer floatSerializer =
-        new DefaultTypeAdapters.FloatSerializer(serializeSpecialFloatingPointValues);
-    serializers.registerIfAbsent(Float.class, floatSerializer);
-    serializers.registerIfAbsent(float.class, floatSerializer);
-
-    // Long primitive
-    DefaultTypeAdapters.LongSerializer longSerializer =
-        new DefaultTypeAdapters.LongSerializer(longSerializationPolicy);
-    serializers.registerIfAbsent(Long.class, longSerializer);
-    serializers.registerIfAbsent(long.class, longSerializer);
-
-    serializers.registerIfAbsent(DEFAULT_SERIALIZERS);
-    return serializers;
-  }
-
-  static ParameterizedTypeHandlerMap<JsonDeserializer<?>> getDefaultDeserializers() {
-    return DEFAULT_DESERIALIZERS;
-  }
-
-  static ParameterizedTypeHandlerMap<InstanceCreator<?>> getDefaultInstanceCreators() {
-    return DEFAULT_INSTANCE_CREATORS;
-  }
-
-  static class DefaultDateTypeAdapter implements JsonSerializer<Date>, JsonDeserializer<Date> {
-    private final DateFormat format;
-
-    DefaultDateTypeAdapter() {
-      this.format = DateFormat.getDateTimeInstance();
-    }
-
-    DefaultDateTypeAdapter(final String datePattern) {
-      this.format = new SimpleDateFormat(datePattern);
-    }
-
-    DefaultDateTypeAdapter(final int style) {
-      this.format = DateFormat.getDateInstance(style);
-    }
-
-    public DefaultDateTypeAdapter(final int dateStyle, final int timeStyle) {
-      this.format = DateFormat.getDateTimeInstance(dateStyle, timeStyle);
-    }
-
-    // These methods need to be synchronized since JDK DateFormat classes are not thread-safe
-    // See issue 162
-    public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
-      synchronized (format) {
-        String dateFormatAsString = format.format(src);
-        return new JsonPrimitive(dateFormatAsString);
-      }
-    }
-
-    public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      if (!(json instanceof JsonPrimitive)) {
-        throw new JsonParseException("The date should be a string value");
-      }
-      try {
-        synchronized (format) {
-          return format.parse(json.getAsString());
-        }
-      } catch (ParseException e) {
-        throw new JsonSyntaxException(e);
-      }
-    }
-
-    @Override
-    public String toString() {
-      StringBuilder sb = new StringBuilder();
-      sb.append(DefaultDateTypeAdapter.class.getSimpleName());
-      sb.append('(').append(format.getClass().getSimpleName()).append(')');
-      return sb.toString();
-    }
-  }
-
-  static class DefaultJavaSqlDateTypeAdapter implements JsonSerializer<java.sql.Date>,
-      JsonDeserializer<java.sql.Date> {
-    private final DateFormat format;
-    DefaultJavaSqlDateTypeAdapter() {
-      this.format = new SimpleDateFormat("MMM d, yyyy");
-    }
-
-    public JsonElement serialize(java.sql.Date src, Type typeOfSrc,
-        JsonSerializationContext context) {
-      synchronized (format) {
-        String dateFormatAsString = format.format(src);
-        return new JsonPrimitive(dateFormatAsString);
-      }
-    }
-
-    public java.sql.Date deserialize(JsonElement json, Type typeOfT,
-        JsonDeserializationContext context) throws JsonParseException {
-      if (!(json instanceof JsonPrimitive)) {
-        throw new JsonParseException("The date should be a string value");
-      }
-      try {
-        synchronized (format) {
-          Date date = format.parse(json.getAsString());
-          return new java.sql.Date(date.getTime());
-        }
-      } catch (ParseException e) {
-        throw new JsonSyntaxException(e);
-      }
-    }
-  }
-
-  static class DefaultTimestampDeserializer implements JsonDeserializer<Timestamp> {
-    public Timestamp deserialize(JsonElement json, Type typeOfT,
-        JsonDeserializationContext context) throws JsonParseException {
-      Date date = context.deserialize(json, Date.class);
-      return new Timestamp(date.getTime());
-    }
-  }
-
-  static class DefaultTimeTypeAdapter implements JsonSerializer<Time>, JsonDeserializer<Time> {
-    private final DateFormat format;
-    DefaultTimeTypeAdapter() {
-      this.format = new SimpleDateFormat("hh:mm:ss a");
-    }
-    public JsonElement serialize(Time src, Type typeOfSrc, JsonSerializationContext context) {
-      synchronized (format) {
-        String dateFormatAsString = format.format(src);
-        return new JsonPrimitive(dateFormatAsString);
-      }
-    }
-    public Time deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      if (!(json instanceof JsonPrimitive)) {
-        throw new JsonParseException("The date should be a string value");
-      }
-      try {
-        synchronized (format) {
-          Date date = format.parse(json.getAsString());
-          return new Time(date.getTime());
-        }
-      } catch (ParseException e) {
-        throw new JsonSyntaxException(e);
-      }
-    }
-  }
-
-  private static class GregorianCalendarTypeAdapter
-      implements JsonSerializer<GregorianCalendar>, JsonDeserializer<GregorianCalendar> {
-
-    private static final String YEAR = "year";
-    private static final String MONTH = "month";
-    private static final String DAY_OF_MONTH = "dayOfMonth";
-    private static final String HOUR_OF_DAY = "hourOfDay";
-    private static final String MINUTE = "minute";
-    private static final String SECOND = "second";
-
-    public JsonElement serialize(GregorianCalendar src, Type typeOfSrc,
-        JsonSerializationContext context) {
-      JsonObject obj = new JsonObject();
-      obj.addProperty(YEAR, src.get(Calendar.YEAR));
-      obj.addProperty(MONTH, src.get(Calendar.MONTH));
-      obj.addProperty(DAY_OF_MONTH, src.get(Calendar.DAY_OF_MONTH));
-      obj.addProperty(HOUR_OF_DAY, src.get(Calendar.HOUR_OF_DAY));
-      obj.addProperty(MINUTE, src.get(Calendar.MINUTE));
-      obj.addProperty(SECOND, src.get(Calendar.SECOND));
-      return obj;
-    }
-
-    public GregorianCalendar deserialize(JsonElement json, Type typeOfT,
-        JsonDeserializationContext context) throws JsonParseException {
-      JsonObject obj = json.getAsJsonObject();
-      int year = obj.get(YEAR).getAsInt();
-      int month = obj.get(MONTH).getAsInt();
-      int dayOfMonth = obj.get(DAY_OF_MONTH).getAsInt();
-      int hourOfDay = obj.get(HOUR_OF_DAY).getAsInt();
-      int minute = obj.get(MINUTE).getAsInt();
-      int second = obj.get(SECOND).getAsInt();
-      return new GregorianCalendar(year, month, dayOfMonth, hourOfDay, minute, second);
-    }
-
-    @Override
-    public String toString() {
-      return GregorianCalendarTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  @SuppressWarnings("unchecked")
-  private static class EnumTypeAdapter<T extends Enum<T>>
-      implements JsonSerializer<T>, JsonDeserializer<T> {
-    public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src.name());
-    }
-
-    @SuppressWarnings("cast")
-    public T deserialize(JsonElement json, Type classOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return (T) Enum.valueOf((Class<T>) classOfT, json.getAsString());
-    }
-
-    @Override
-    public String toString() {
-      return EnumTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class UrlTypeAdapter implements JsonSerializer<URL>, JsonDeserializer<URL> {
-    public JsonElement serialize(URL src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src.toExternalForm());
-    }
-
-    public URL deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      try {
-        return new URL(json.getAsString());
-      } catch (MalformedURLException e) {
-        throw new JsonSyntaxException(e);
-      }
-    }
-
-    @Override
-    public String toString() {
-      return UrlTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class UriTypeAdapter implements JsonSerializer<URI>, JsonDeserializer<URI> {
-    public JsonElement serialize(URI src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src.toASCIIString());
-    }
-    public URI deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-    throws JsonParseException {
-      try {
-        return new URI(json.getAsString());
-      } catch (URISyntaxException e) {
-        throw new JsonSyntaxException(e);
-      }
-    }
-    @Override
-    public String toString() {
-      return UriTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class UuidTypeAdapter implements JsonSerializer<UUID>, JsonDeserializer<UUID> {
-    public JsonElement serialize(UUID src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src.toString());
-    }
-
-    public UUID deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return UUID.fromString(json.getAsString());
-    }
-
-    @Override
-    public String toString() {
-        return UuidTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class LocaleTypeAdapter
-      implements JsonSerializer<Locale>, JsonDeserializer<Locale> {
-    public JsonElement serialize(Locale src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src.toString());
-    }
-
-    public Locale deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      String locale = json.getAsString();
-      StringTokenizer tokenizer = new StringTokenizer(locale, "_");
-      String language = null;
-      String country = null;
-      String variant = null;
-      if (tokenizer.hasMoreElements()) {
-        language = tokenizer.nextToken();
-      }
-      if (tokenizer.hasMoreElements()) {
-        country = tokenizer.nextToken();
-      }
-      if (tokenizer.hasMoreElements()) {
-        variant = tokenizer.nextToken();
-      }
-      if (country == null && variant == null) {
-        return new Locale(language);
-      } else if (variant == null) {
-        return new Locale(language, country);
-      } else {
-        return new Locale(language, country, variant);
-      }
-    }
-
-    @Override
-    public String toString() {
-      return LocaleTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  @SuppressWarnings({"unchecked", "rawtypes"})
-  private static class CollectionTypeAdapter implements JsonSerializer<Collection>,
-      JsonDeserializer<Collection>, InstanceCreator<Collection> {
-    public JsonElement serialize(Collection src, Type typeOfSrc, JsonSerializationContext context) {
-      if (src == null) {
-        return JsonNull.createJsonNull();
-      }
-      JsonArray array = new JsonArray();
-      Type childGenericType = null;
-      if (typeOfSrc instanceof ParameterizedType) {
-        childGenericType = new TypeInfoCollection(typeOfSrc).getElementType();
-      }
-      for (Object child : src) {
-        if (child == null) {
-          array.add(JsonNull.createJsonNull());
-        } else {
-          Type childType = (childGenericType == null || childGenericType == Object.class)
-              ? child.getClass() : childGenericType;
-          JsonElement element = context.serialize(child, childType);
-          array.add(element);
-        }
-      }
-      return array;
-    }
-
-    public Collection deserialize(JsonElement json, Type typeOfT,
-        JsonDeserializationContext context) throws JsonParseException {
-      if (json.isJsonNull()) {
-        return null;
-      }
-      // Use ObjectConstructor to create instance instead of hard-coding a specific type.
-      // This handles cases where users are using their own subclass of Collection.
-      Collection collection = constructCollectionType(typeOfT, context);
-      Type childType = new TypeInfoCollection(typeOfT).getElementType();
-      for (JsonElement childElement : json.getAsJsonArray()) {
-        if (childElement == null || childElement.isJsonNull()) {
-          collection.add(null);
-        } else {
-          Object value = context.deserialize(childElement, childType);
-          collection.add(value);
-        }
-      }
-      return collection;
-    }
-
-    private Collection constructCollectionType(Type collectionType,
-        JsonDeserializationContext context) {
-      JsonDeserializationContextDefault contextImpl = (JsonDeserializationContextDefault) context;
-      ObjectConstructor objectConstructor = contextImpl.getObjectConstructor();
-      return (Collection) objectConstructor.construct(collectionType);
-    }
-
-    public Collection createInstance(Type type) {
-      return new LinkedList();
-    }
-  }
-
-  private static class PropertiesCreator implements InstanceCreator<Properties> {
-    public Properties createInstance(Type type) {
-      return new Properties();
-    }
-  }
-
-  @SuppressWarnings({"unchecked", "rawtypes"})
-  static class MapTypeAdapter implements JsonSerializer<Map>, JsonDeserializer<Map>,
-      InstanceCreator<Map> {
-
-    public JsonElement serialize(Map src, Type typeOfSrc, JsonSerializationContext context) {
-      JsonObject map = new JsonObject();
-      Type childGenericType = null;
-      if (typeOfSrc instanceof ParameterizedType) {
-        childGenericType = new TypeInfoMap(typeOfSrc).getValueType();
-      }
-
-      for (Map.Entry entry : (Set<Map.Entry>) src.entrySet()) {
-        Object value = entry.getValue();
-
-        JsonElement valueElement;
-        if (value == null) {
-          valueElement = JsonNull.createJsonNull();
-        } else {
-          Type childType = (childGenericType == null)
-              ? value.getClass() : childGenericType;
-          valueElement = context.serialize(value, childType);
-        }
-        map.add(String.valueOf(entry.getKey()), valueElement);
-      }
-      return map;
-    }
-
-    public Map deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      // Use ObjectConstructor to create instance instead of hard-coding a specific type.
-      // This handles cases where users are using their own subclass of Map.
-      Map<Object, Object> map = constructMapType(typeOfT, context);
-      TypeInfoMap mapTypeInfo = new TypeInfoMap(typeOfT);
-      for (Map.Entry<String, JsonElement> entry : json.getAsJsonObject().entrySet()) {
-        Object key = context.deserialize(new JsonPrimitive(entry.getKey()), mapTypeInfo.getKeyType());
-        Object value = context.deserialize(entry.getValue(), mapTypeInfo.getValueType());
-        map.put(key, value);
-      }
-      return map;
-    }
-
-    private Map constructMapType(Type mapType, JsonDeserializationContext context) {
-      JsonDeserializationContextDefault contextImpl = (JsonDeserializationContextDefault) context;
-      ObjectConstructor objectConstructor = contextImpl.getObjectConstructor();
-      return (Map) objectConstructor.construct(mapType);
-    }
-
-    public Map createInstance(Type type) {
-      return new LinkedHashMap();
-    }
-
-    @Override
-    public String toString() {
-      return MapTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class BigDecimalTypeAdapter
-      implements JsonSerializer<BigDecimal>, JsonDeserializer<BigDecimal> {
-    public JsonElement serialize(BigDecimal src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public BigDecimal deserialize(JsonElement json, Type typeOfT,
-        JsonDeserializationContext context) throws JsonParseException {
-      return json.getAsBigDecimal();
-    }
-
-    @Override
-    public String toString() {
-      return BigDecimalTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class BigIntegerTypeAdapter
-      implements JsonSerializer<BigInteger>, JsonDeserializer<BigInteger> {
-
-    public JsonElement serialize(BigInteger src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public BigInteger deserialize(JsonElement json, Type typeOfT,
-        JsonDeserializationContext context) throws JsonParseException {
-      return json.getAsBigInteger();
-    }
-
-    @Override
-    public String toString() {
-      return BigIntegerTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class NumberTypeAdapter
-      implements JsonSerializer<Number>, JsonDeserializer<Number> {
-    public JsonElement serialize(Number src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public Number deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsNumber();
-    }
-
-    @Override
-    public String toString() {
-      return NumberTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class LongSerializer implements JsonSerializer<Long> {
-    private final LongSerializationPolicy longSerializationPolicy;
-
-    private LongSerializer(LongSerializationPolicy longSerializationPolicy) {
-      this.longSerializationPolicy = longSerializationPolicy;
-    }
-
-    public JsonElement serialize(Long src, Type typeOfSrc, JsonSerializationContext context) {
-      return longSerializationPolicy.serialize(src);
-    }
-
-    @Override
-    public String toString() {
-      return LongSerializer.class.getSimpleName();
-    }
-  }
-
-  private static class LongDeserializer implements JsonDeserializer<Long> {
-    public Long deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsLong();
-    }
-
-    @Override
-    public String toString() {
-      return LongDeserializer.class.getSimpleName();
-    }
-  }
-
-  private static class IntegerTypeAdapter
-      implements JsonSerializer<Integer>, JsonDeserializer<Integer> {
-    public JsonElement serialize(Integer src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public Integer deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsInt();
-    }
-
-    @Override
-    public String toString() {
-      return IntegerTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class ShortTypeAdapter
-      implements JsonSerializer<Short>, JsonDeserializer<Short> {
-    public JsonElement serialize(Short src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public Short deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsShort();
-    }
-
-    @Override
-    public String toString() {
-      return ShortTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class ByteTypeAdapter implements JsonSerializer<Byte>, JsonDeserializer<Byte> {
-    public JsonElement serialize(Byte src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public Byte deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsByte();
-    }
-
-    @Override
-    public String toString() {
-      return ByteTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  static class FloatSerializer implements JsonSerializer<Float> {
-    private final boolean serializeSpecialFloatingPointValues;
-
-    FloatSerializer(boolean serializeSpecialDoubleValues) {
-      this.serializeSpecialFloatingPointValues = serializeSpecialDoubleValues;
-    }
-
-    public JsonElement serialize(Float src, Type typeOfSrc, JsonSerializationContext context) {
-      if (!serializeSpecialFloatingPointValues) {
-        if (Float.isNaN(src) || Float.isInfinite(src)) {
-          throw new IllegalArgumentException(src
-              + " is not a valid float value as per JSON specification. To override this"
-              + " behavior, use GsonBuilder.serializeSpecialFloatingPointValues() method.");
-        }
-      }
-      return new JsonPrimitive(src);
-    }
-  }
-
-  private static class FloatDeserializer implements JsonDeserializer<Float> {
-    public Float deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsFloat();
-    }
-
-    @Override
-    public String toString() {
-      return FloatDeserializer.class.getSimpleName();
-    }
-  }
-
-  static class DoubleSerializer implements JsonSerializer<Double> {
-    private final boolean serializeSpecialFloatingPointValues;
-
-    DoubleSerializer(boolean serializeSpecialDoubleValues) {
-      this.serializeSpecialFloatingPointValues = serializeSpecialDoubleValues;
-    }
-
-    public JsonElement serialize(Double src, Type typeOfSrc, JsonSerializationContext context) {
-      if (!serializeSpecialFloatingPointValues) {
-        if (Double.isNaN(src) || Double.isInfinite(src)) {
-          throw new IllegalArgumentException(src
-              + " is not a valid double value as per JSON specification. To override this"
-              + " behavior, use GsonBuilder.serializeSpecialDoubleValues() method.");
-        }
-      }
-      return new JsonPrimitive(src);
-    }
-  }
-
-  private static class DoubleDeserializer implements JsonDeserializer<Double> {
-    public Double deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsDouble();
-    }
-
-    @Override
-    public String toString() {
-      return DoubleDeserializer.class.getSimpleName();
-    }
-  }
-
-  private static class CharacterTypeAdapter
-      implements JsonSerializer<Character>, JsonDeserializer<Character> {
-    public JsonElement serialize(Character src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public Character deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsCharacter();
-    }
-
-    @Override
-    public String toString() {
-      return CharacterTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class StringTypeAdapter
-      implements JsonSerializer<String>, JsonDeserializer<String> {
-    public JsonElement serialize(String src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public String deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsString();
-    }
-
-    @Override
-    public String toString() {
-      return StringTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class BooleanTypeAdapter
-      implements JsonSerializer<Boolean>, JsonDeserializer<Boolean> {
-    public JsonElement serialize(Boolean src, Type typeOfSrc, JsonSerializationContext context) {
-      return new JsonPrimitive(src);
-    }
-
-    public Boolean deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-        throws JsonParseException {
-      return json.getAsBoolean();
-    }
-
-    @Override
-    public String toString() {
-      return BooleanTypeAdapter.class.getSimpleName();
-    }
-  }
-
-  private static class TreeSetCreator implements InstanceCreator<TreeSet<?>> {
-    public TreeSet<?> createInstance(Type type) {
-      return new TreeSet<Object>();
-    }
-    @Override
-    public String toString() {
-      return TreeSetCreator.class.getSimpleName();
-    }
-  }
-
-  private static class HashSetCreator implements InstanceCreator<HashSet<?>> {
-    public HashSet<?> createInstance(Type type) {
-      return new HashSet<Object>();
-    }
-    @Override
-    public String toString() {
-      return HashSetCreator.class.getSimpleName();
-    }
-  }
-}

src/org/mcteam/ancientgates/gson/DelegatingJsonElementVisitor.java

@@ -1,117 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-
-/**
- * A simple implementation of the {@link JsonElementVisitor} that simply delegates the method
- * invocation onto a {@code delegate} instance of the {@link JsonElementVisitor}.  This object
- * can be used to build a chain of visitors such that each Visitor instance can perform some
- * operation on the {@link JsonElement} and then pass on the input to the delegate.  This kind
- * of pattern is sometimes referred as a "Chain of Responsibility".
- *
- * <p>The following is an example use case:
- *
- * <pre>
- * class JsonEscapingVisitor extends DelegatingJsonElementVisitor {
- *   public JsonEscapingVisitor(JsonElementVisitor) {
- *     super(visitor);
- *   }
- *
- *   public void visitPrimitive(JsonPrimitive primitive) {
- *     JsonPrimitive escapedPrimitive = escapePrimitiveObject(primitive);
- *     super.visitPrimitive(escapedPrimitive);
- *   }
- * }
- *
- * JsonElementVisitor visitor = new JsonEscapingVisitor(new FormattingVisitor());
- * </pre></p>
- *
- * @author Joel Leitch
- */
-class DelegatingJsonElementVisitor implements JsonElementVisitor {
-  private final JsonElementVisitor delegate;
-
-  protected DelegatingJsonElementVisitor(JsonElementVisitor delegate) {
-    Preconditions.checkNotNull(delegate);
-    this.delegate = delegate;
-  }
-
-  public void endArray(JsonArray array) throws IOException {
-    delegate.endArray(array);
-  }
-
-  public void endObject(JsonObject object) throws IOException {
-    delegate.endObject(object);
-  }
-
-  public void startArray(JsonArray array) throws IOException {
-    delegate.startArray(array);
-  }
-
-  public void startObject(JsonObject object) throws IOException {
-    delegate.startObject(object);
-  }
-
-  public void visitArrayMember(JsonArray parent, JsonPrimitive member, 
-      boolean isFirst) throws IOException {
-    delegate.visitArrayMember(parent, member, isFirst);
-  }
-
-  public void visitArrayMember(JsonArray parent, JsonArray member, 
-      boolean isFirst) throws IOException {
-    delegate.visitArrayMember(parent, member, isFirst);
-  }
-
-  public void visitArrayMember(JsonArray parent, JsonObject member, 
-      boolean isFirst) throws IOException {
-    delegate.visitArrayMember(parent, member, isFirst);
-  }
-
-  public void visitObjectMember(JsonObject parent, String memberName, JsonPrimitive member, 
-      boolean isFirst) throws IOException {
-    delegate.visitObjectMember(parent, memberName, member, isFirst);
-  }
-
-  public void visitObjectMember(JsonObject parent, String memberName, JsonArray member, 
-      boolean isFirst) throws IOException {
-    delegate.visitObjectMember(parent, memberName, member, isFirst);
-  }
-
-  public void visitObjectMember(JsonObject parent, String memberName, JsonObject member, 
-      boolean isFirst) throws IOException {
-    delegate.visitObjectMember(parent, memberName, member, isFirst);
-  }
-
-  public void visitNullObjectMember(JsonObject parent, String memberName, 
-      boolean isFirst) throws IOException {
-    delegate.visitNullObjectMember(parent, memberName, isFirst);
-  }
-
-  public void visitPrimitive(JsonPrimitive primitive) throws IOException {
-    delegate.visitPrimitive(primitive);
-  }
-
-  public void visitNull() throws IOException {
-    delegate.visitNull();
-  }
-
-  public void visitNullArrayMember(JsonArray parent, boolean isFirst) throws IOException {
-    delegate.visitNullArrayMember(parent, isFirst);
-  }
-}

src/org/mcteam/ancientgates/gson/DisjunctionExclusionStrategy.java

@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.util.Collection;
-
-/**
- * A wrapper class used to collect numerous {@link ExclusionStrategy} objects
- * and perform a short-circuited OR operation.
- *
- * @author Joel Leitch
- */
-final class DisjunctionExclusionStrategy implements ExclusionStrategy {
-  private final Collection<ExclusionStrategy> strategies;
-
-  public DisjunctionExclusionStrategy(Collection<ExclusionStrategy> strategies) {
-    Preconditions.checkNotNull(strategies);
-    this.strategies = strategies;
-  }
-
-  public boolean shouldSkipField(FieldAttributes f) {
-    for (ExclusionStrategy strategy : strategies) {
-      if (strategy.shouldSkipField(f)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  public boolean shouldSkipClass(Class<?> clazz) {
-    for (ExclusionStrategy strategy : strategies) {
-      if (strategy.shouldSkipClass(clazz)) {
-        return true;
-      }
-    }
-    return false;
-  }
-}

src/org/mcteam/ancientgates/gson/Escaper.java

@@ -1,160 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
-/**
- * A utility class that is used to perform JSON escaping so that ", <, >, etc. characters are
- * properly encoded in the JSON string representation before returning to the client code.
- *
- * <p>This class contains a single method to escape a passed in string value:
- * <pre>
- *   String jsonStringValue = "beforeQuote\"afterQuote";
- *   String escapedValue = Escaper.escapeJsonString(jsonStringValue);
- * </pre></p>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class Escaper {
-
-  private static final char[] HEX_CHARS = {
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
-  };
-
-  private static final Set<Character> JS_ESCAPE_CHARS;
-  private static final Set<Character> HTML_ESCAPE_CHARS;
-
-  static {
-    Set<Character> mandatoryEscapeSet = new HashSet<Character>();
-    mandatoryEscapeSet.add('"');
-    mandatoryEscapeSet.add('\\');
-    JS_ESCAPE_CHARS = Collections.unmodifiableSet(mandatoryEscapeSet);
-
-    Set<Character> htmlEscapeSet = new HashSet<Character>();
-    htmlEscapeSet.add('<');
-    htmlEscapeSet.add('>');
-    htmlEscapeSet.add('&');
-    htmlEscapeSet.add('=');
-    htmlEscapeSet.add('\''); 
-//    htmlEscapeSet.add('/');  -- Removing slash for now since it causes some incompatibilities
-    HTML_ESCAPE_CHARS = Collections.unmodifiableSet(htmlEscapeSet);
-  }
-
-  private final boolean escapeHtmlCharacters;
-  
-  Escaper(boolean escapeHtmlCharacters) {
-    this.escapeHtmlCharacters = escapeHtmlCharacters;
-  }
-  
-  public String escapeJsonString(CharSequence plainText) {
-    StringBuffer escapedString = new StringBuffer(plainText.length() + 20);
-    try {
-      escapeJsonString(plainText, escapedString);
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-    return escapedString.toString();
-  }
-
-  private void escapeJsonString(CharSequence plainText, StringBuffer out) throws IOException {
-    int pos = 0;  // Index just past the last char in plainText written to out.
-    int len = plainText.length();
-    
-    for (int charCount, i = 0; i < len; i += charCount) {
-      int codePoint = Character.codePointAt(plainText, i);
-      charCount = Character.charCount(codePoint);
-      
-       if (!isControlCharacter(codePoint) && !mustEscapeCharInJsString(codePoint)) {
-          continue;
-       }
-
-       out.append(plainText, pos, i);
-       pos = i + charCount;
-       switch (codePoint) {
-         case '\b':
-           out.append("\\b");
-           break;
-         case '\t':
-           out.append("\\t");
-           break;
-         case '\n':
-           out.append("\\n");
-           break;
-         case '\f':
-           out.append("\\f");
-           break;
-         case '\r':
-           out.append("\\r");
-           break;
-         case '\\':
-           out.append("\\\\");
-           break;
-         case '/':
-           out.append("\\/");
-           break;
-         case '"':
-           out.append("\\\"");
-           break;
-         default:
-           appendHexJavaScriptRepresentation(codePoint, out);
-           break;
-       }
-     }
-     out.append(plainText, pos, len);
-  }
-  
-  private boolean mustEscapeCharInJsString(int codepoint) {
-    if (!Character.isSupplementaryCodePoint(codepoint)) {
-      char c = (char) codepoint;
-      return JS_ESCAPE_CHARS.contains(c)
-          || (escapeHtmlCharacters && HTML_ESCAPE_CHARS.contains(c));
-    }
-    return false;
-  }
-
-  private static boolean isControlCharacter(int codePoint) {
-    // JSON spec defines these code points as control characters, so they must be escaped
-    return codePoint < 0x20
-        || codePoint == 0x2028  // Line separator
-        || codePoint == 0x2029  // Paragraph separator
-        || (codePoint >= 0x7f && codePoint <= 0x9f);
-  }
-
-  private static void appendHexJavaScriptRepresentation(int codePoint, Appendable out)
-      throws IOException {
-    if (Character.isSupplementaryCodePoint(codePoint)) {
-      // Handle supplementary unicode values which are not representable in
-      // javascript.  We deal with these by escaping them as two 4B sequences
-      // so that they will round-trip properly when sent from java to javascript
-      // and back.
-      char[] surrogates = Character.toChars(codePoint);
-      appendHexJavaScriptRepresentation(surrogates[0], out);
-      appendHexJavaScriptRepresentation(surrogates[1], out);
-      return;
-    }
-    out.append("\\u")
-        .append(HEX_CHARS[(codePoint >>> 12) & 0xf])
-        .append(HEX_CHARS[(codePoint >>> 8) & 0xf])
-        .append(HEX_CHARS[(codePoint >>> 4) & 0xf])
-        .append(HEX_CHARS[codePoint & 0xf]);
-  }
-}

src/org/mcteam/ancientgates/gson/ExclusionStrategy.java

@@ -1,95 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * A strategy (or policy) definition that is used to decide whether or not a field or top-level
- * class should be serialized or deserialized as part of the JSON output/input. For serialization,
- * if the {@link #shouldSkipClass(Class)} method returns false then that class or field type
- * will not be part of the JSON output.  For deserialization, if {@link #shouldSkipClass(Class)}
- * returns false, then it will not be set as part of the Java object structure.
- *
- * <p>The following are a few examples that shows how you can use this exclusion mechanism.
- *
- * <p><strong>Exclude fields and objects based on a particular class type:</strong>
- * <pre class="code">
- * private static class SpecificClassExclusionStrategy implements ExclusionStrategy {
- *   private final Class&lt;?&gt; excludedThisClass;
- *
- *   public SpecificClassExclusionStrategy(Class&lt;?&gt; excludedThisClass) {
- *     this.excludedThisClass = excludedThisClass;
- *   }
- *
- *   public boolean shouldSkipClass(Class&lt;?&gt; clazz) {
- *     return excludedThisClass.equals(clazz);
- *   }
- *
- *   public boolean shouldSkipField(FieldAttributes f) {
- *     return excludedThisClass.equals(f.getDeclaredClass());
- *   }
- * }
- * </pre>
- *
- * <p><strong>Excludes fields and objects based on a particular annotation:</strong>
- * <pre class="code">
- * public &#64interface FooAnnotation {
- *   // some implementation here
- * }
- *
- * // Excludes any field (or class) that is tagged with an "&#64FooAnnotation"
- * private static class FooAnnotationExclusionStrategy implements ExclusionStrategy {
- *   public boolean shouldSkipClass(Class&lt;?&gt; clazz) {
- *     return clazz.getAnnotation(FooAnnotation.class) != null;
- *   }
- *
- *   public boolean shouldSkipField(FieldAttributes f) {
- *     return f.getAnnotation(FooAnnotation.class) != null;
- *   }
- * }
- * </pre>
- *
- * <p>Now if you want to configure {@code Gson} to use a user defined exclusion strategy, then
- * the {@code GsonBuilder} is required. The following is an example of how you can use the
- * {@code GsonBuilder} to configure Gson to use one of the above sample:
- * <pre class="code">
- * ExclusionStrategy excludeStrings = new UserDefinedExclusionStrategy(String.class);
- * Gson gson = new GsonBuilder()
- *     .setExclusionStrategies(excludeStrings)
- *     .create();
- * </pre>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- *
- * @see GsonBuilder#setExclusionStrategies(ExclusionStrategy...)
- *
- * @since 1.4
- */
-public interface ExclusionStrategy {
-
-  /**
-   * @param f the field object that is under test
-   * @return true if the field should be ignored; otherwise false
-   */
-  public boolean shouldSkipField(FieldAttributes f);
-
-  /**
-   * @param clazz the class object that is under test
-   * @return true if the class should be ignored; otherwise false
-   */
-  public boolean shouldSkipClass(Class<?> clazz);
-}

src/org/mcteam/ancientgates/gson/ExposeAnnotationDeserializationExclusionStrategy.java

@@ -1,39 +0,0 @@
-/*
- * Copyright (C) 2009 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.mcteam.ancientgates.gson;
-
-import org.mcteam.ancientgates.gson.annotations.Expose;
-
-/**
- * Excludes fields that do not have the {@link Expose} annotation
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class ExposeAnnotationDeserializationExclusionStrategy implements ExclusionStrategy {
-
-  public boolean shouldSkipClass(Class<?> clazz) {
-    return false;
-  }
-
-  public boolean shouldSkipField(FieldAttributes f) {
-    Expose annotation = f.getAnnotation(Expose.class);
-    if (annotation == null) {
-      return true;
-    }
-    return !annotation.deserialize();
-  }
-}

src/org/mcteam/ancientgates/gson/ExposeAnnotationSerializationExclusionStrategy.java

@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import org.mcteam.ancientgates.gson.annotations.Expose;
-
-/**
- * Excludes fields that do not have the {@link Expose} annotation
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class ExposeAnnotationSerializationExclusionStrategy implements ExclusionStrategy {
-
-  public boolean shouldSkipClass(Class<?> clazz) {
-    return false;
-  }
-
-  public boolean shouldSkipField(FieldAttributes f) {
-    Expose annotation = f.getAnnotation(Expose.class);
-    if (annotation == null) {
-      return true;
-    }
-    return !annotation.serialize();
-  }
-}

src/org/mcteam/ancientgates/gson/FieldAttributes.java

@@ -1,229 +0,0 @@
-/*
- * Copyright (C) 2009 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Field;
-import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-
-/**
- * A data object that stores attributes of a field.
- *
- * <p>This class is immutable; therefore, it can be safely shared across threads.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- *
- * @since 1.4
- */
-public final class FieldAttributes {
-  private static final String MAX_CACHE_PROPERTY_NAME =
-      "com.bukkit.mcteam.gson.annotation_cache_size_hint";
-
-  private static final Cache<Pair<Class<?>, String>, Collection<Annotation>> ANNOTATION_CACHE =
-      new LruCache<Pair<Class<?>,String>, Collection<Annotation>>(getMaxCacheSize());
-
-  private final Class<?> declaringClazz;
-  private final Field field;
-  private final Class<?> declaredType;
-  private final boolean isSynthetic;
-  private final int modifiers;
-  private final String name;
-
-  // Fields used for lazy initialization
-  private Type genericType;
-  private Collection<Annotation> annotations;
-
-  /**
-   * Constructs a Field Attributes object from the {@code f}.
-   *
-   * @param f the field to pull attributes from
-   */
-  FieldAttributes(final Class<?> declaringClazz, final Field f) {
-    Preconditions.checkNotNull(declaringClazz);
-    this.declaringClazz = declaringClazz;
-    name = f.getName();
-    declaredType = f.getType();
-    isSynthetic = f.isSynthetic();
-    modifiers = f.getModifiers();
-    field = f;
-  }
-
-  private static int getMaxCacheSize() {
-    final int defaultMaxCacheSize = 2000;
-    try {
-      String propertyValue = System.getProperty(
-          MAX_CACHE_PROPERTY_NAME, String.valueOf(defaultMaxCacheSize));
-      return Integer.parseInt(propertyValue);
-    } catch (NumberFormatException e) {
-      return defaultMaxCacheSize;
-    }
-  }
-
-  /**
-   * @return the declaring class that contains this field
-   */
-  public Class<?> getDeclaringClass() {
-    return declaringClazz;
-  }
-
-  /**
-   * @return the name of the field
-   */
-  public String getName() {
-    return name;
-  }
-
-  /**
-   * <p>For example, assume the following class definition:
-   * <pre class="code">
-   * public class Foo {
-   *   private String bar;
-   *   private List&lt;String&gt; red;
-   * }
-   *
-   * Type listParmeterizedType = new TypeToken<List<String>>() {}.getType();
-   * </pre>
-   *
-   * <p>This method would return {@code String.class} for the {@code bar} field and
-   * {@code listParameterizedType} for the {@code red} field.
-   *
-   * @return the specific type declared for this field
-   */
-  public Type getDeclaredType() {
-    if (genericType == null) {
-      genericType = field.getGenericType();
-    }
-    return genericType;
-  }
-
-  /**
-   * Returns the {@code Class<?>} object that was declared for this field.
-   *
-   * <p>For example, assume the following class definition:
-   * <pre class="code">
-   * public class Foo {
-   *   private String bar;
-   *   private List&lt;String&gt; red;
-   * }
-   * </pre>
-   *
-   * <p>This method would return {@code String.class} for the {@code bar} field and
-   * {@code List.class} for the {@code red} field.
-   *
-   * @return the specific class object that was declared for the field
-   */
-  public Class<?> getDeclaredClass() {
-    return declaredType;
-  }
-
-  /**
-   * Return the {@code T} annotation object from this field if it exist; otherwise returns
-   * {@code null}.
-   *
-   * @param annotation the class of the annotation that will be retrieved
-   * @return the annotation instance if it is bound to the field; otherwise {@code null}
-   */
-  public <T extends Annotation> T getAnnotation(Class<T> annotation) {
-    return getAnnotationFromArray(getAnnotations(), annotation);
-  }
-
-  /**
-   * Return the annotations that are present on this field.
-   *
-   * @return an array of all the annotations set on the field
-   * @since 1.4
-   */
-  public Collection<Annotation> getAnnotations() {
-    if (annotations == null) {
-      Pair<Class<?>, String> key = new Pair<Class<?>, String>(declaringClazz, name);
-      annotations = ANNOTATION_CACHE.getElement(key);
-      if (annotations == null) {
-        annotations = Collections.unmodifiableCollection(
-            Arrays.asList(field.getAnnotations()));
-        ANNOTATION_CACHE.addElement(key, annotations);
-      }
-    }
-    return annotations;
-  }
-
-  /**
-   * Returns {@code true} if the field is defined with the {@code modifier}.
-   *
-   * <p>This method is meant to be called as:
-   * <pre class="code">
-   * boolean hasPublicModifier = fieldAttribute.hasModifier(java.lang.reflect.Modifier.PUBLIC);
-   * </pre>
-   *
-   * @see java.lang.reflect.Modifier
-   */
-  public boolean hasModifier(int modifier) {
-    return (modifiers & modifier) != 0;
-  }
-
-  /**
-   * This is exposed internally only for the removing synthetic fields from the JSON output.
-   *
-   * @throws IllegalAccessException
-   * @throws IllegalArgumentException
-   */
-  void set(Object instance, Object value) throws IllegalAccessException {
-    field.set(instance, value);
-  }
-
-  /**
-   * This is exposed internally only for the removing synthetic fields from the JSON output.
-   *
-   * @return true if the field is synthetic; otherwise false
-   * @throws IllegalAccessException
-   * @throws IllegalArgumentException
-   */
-  Object get(Object instance) throws IllegalAccessException {
-    return field.get(instance);
-  }
-
-  /**
-   * This is exposed internally only for the removing synthetic fields from the JSON output.
-   *
-   * @return true if the field is synthetic; otherwise false
-   */
-  boolean isSynthetic() {
-    return isSynthetic;
-  }
-
-  /**
-   * @deprecated remove this when {@link FieldNamingStrategy} is deleted.
-   */
-  @Deprecated
-  Field getFieldObject() {
-    return field;
-  }
-
-  @SuppressWarnings("unchecked")
-  private static <T extends Annotation> T getAnnotationFromArray(
-      Collection<Annotation> annotations, Class<T> annotation) {
-    for (Annotation a : annotations) {
-      if (a.annotationType() == annotation) {
-        return (T) a;
-      }
-    }
-    return null;
-  }
-}

src/org/mcteam/ancientgates/gson/FieldNamingPolicy.java

@@ -1,99 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * An enumeration that defines a few standard naming conventions for JSON field names.
- * This enumeration should be used in conjunction with {@link org.mcteam.ancientgates.gson.GsonBuilder}
- * to configure a {@link org.mcteam.ancientgates.gson.Gson} instance to properly translate Java field
- * names into the desired JSON field names.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public enum FieldNamingPolicy {
-  /**
-   * Using this naming policy with Gson will ensure that the first "letter" of the Java
-   * field name is capitalized when serialized to its JSON form.
-   *
-   * <p>Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":</p>
-   * <ul>
-   *   <li>someFieldName ---> SomeFieldName</li>
-   *   <li>_someFieldName ---> _SomeFieldName</li>
-   * </ul>
-   */
-  UPPER_CAMEL_CASE(new ModifyFirstLetterNamingPolicy(
-      ModifyFirstLetterNamingPolicy.LetterModifier.UPPER)),
-
-  /**
-   * Using this naming policy with Gson will ensure that the first "letter" of the Java
-   * field name is capitalized when serialized to its JSON form and the words will be
-   * separated by a space.
-   *
-   * <p>Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":</p>
-   * <ul>
-   *   <li>someFieldName ---> Some Field Name</li>
-   *   <li>_someFieldName ---> _Some Field Name</li>
-   * </ul>
-   * 
-   * @since 1.4
-   */
-  UPPER_CAMEL_CASE_WITH_SPACES(new UpperCamelCaseSeparatorNamingPolicy(" ")),
-          
-  /**
-   * Using this naming policy with Gson will modify the Java Field name from its camel cased
-   * form to a lower case field name where each word is separated by an underscore (_).
-   *
-   * <p>Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":</p>
-   * <ul>
-   *   <li>someFieldName ---> some_field_name</li>
-   *   <li>_someFieldName ---> _some_field_name</li>
-   *   <li>aStringField ---> a_string_field</li>
-   *   <li>aURL ---> a_u_r_l</li>
-   * </ul>
-   */
-  LOWER_CASE_WITH_UNDERSCORES(new LowerCamelCaseSeparatorNamingPolicy("_")),
-  
-  /**
-   * Using this naming policy with Gson will modify the Java Field name from its camel cased
-   * form to a lower case field name where each word is separated by a dash (-).
-   *
-   * <p>Here's a few examples of the form "Java Field Name" ---> "JSON Field Name":</p>
-   * <ul>
-   *   <li>someFieldName ---> some-field-name</li>
-   *   <li>_someFieldName ---> _some-field-name</li>
-   *   <li>aStringField ---> a-string-field</li>
-   *   <li>aURL ---> a-u-r-l</li>
-   * </ul>
-   * Using dashes in JavaScript is not recommended since dash is also used for a minus sign in
-   * expressions. This requires that a field named with dashes is always accessed as a quoted
-   * property like {@code myobject['my-field']}. Accessing it as an object field
-   * {@code myobject.my-field} will result in an unintended javascript expression.
-   * @since 1.4
-   */
-  LOWER_CASE_WITH_DASHES(new LowerCamelCaseSeparatorNamingPolicy("-"));
-
-  private final FieldNamingStrategy2 namingPolicy;
-
-  private FieldNamingPolicy(FieldNamingStrategy2 namingPolicy) {
-    this.namingPolicy = namingPolicy;
-  }
-
-  FieldNamingStrategy2 getFieldNamingPolicy() {
-    return namingPolicy;
-  }
-}

src/org/mcteam/ancientgates/gson/FieldNamingStrategy.java

@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Field;
-
-/**
- * A mechanism for providing custom field naming in Gson.  This allows the client code to translate
- * field names into a particular convention that is not supported as a normal Java field
- * declaration rules.  For example, Java does not support "-" characters in a field name.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- * @since 1.3
- */
-public interface FieldNamingStrategy {
-
-  /**
-   * Translates the field name into its JSON field name representation.
-   *
-   * @param f the field object that we are translating
-   * @return the translated field name.
-   * @since 1.3
-   */
-  public String translateName(Field f);
-}

src/org/mcteam/ancientgates/gson/FieldNamingStrategy2.java

@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * The new mechanism for providing custom field naming in Gson.  This allows the client code
- * to translate field names into a particular convention that is not supported as a normal
- * Java field declaration rules.  For example, Java does not support "-" characters in a
- * field name.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-interface FieldNamingStrategy2 {
-
-  /**
-   * Translates the field name into its JSON field name representation.
-   *
-   * @param f the field that is being translated
-   * @return the translated field name.
-   * @since 1.3
-   */
-  public String translateName(FieldAttributes f);
-}

src/org/mcteam/ancientgates/gson/FieldNamingStrategy2Adapter.java

@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * Adapts the old "deprecated" {@link FieldNamingStrategy} to the new {@link FieldNamingStrategy2}
- * type. 
- * 
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class FieldNamingStrategy2Adapter implements FieldNamingStrategy2 {
-  private final FieldNamingStrategy adaptee;
-
-  public FieldNamingStrategy2Adapter(FieldNamingStrategy adaptee) {
-    Preconditions.checkNotNull(adaptee);
-    this.adaptee = adaptee;
-  }
-  
-  @SuppressWarnings("deprecation")
-  public String translateName(FieldAttributes f) {
-    return adaptee.translateName(f.getFieldObject());
-  }
-}

src/org/mcteam/ancientgates/gson/GenericArrayTypeImpl.java

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.GenericArrayType;
-import java.lang.reflect.Type;
-
-/**
- * An simple pojo-like immutable instance of the {@link GenericArrayType}.  This object provides
- * us the ability to create reflective types on demand.  This object is required for support
- * object similar to the one defined below:
- * <pre>
- * class Foo<T> {
- *   private final List<T>[] arrayOfListT;
- *
- *   Foo(List<T>[] arrayList) {
- *     this.arrayOfListT = arrayList;
- *   }
- * }
- * </pre>
- *
- * <p>During parsing or serialization, we know the real variable type parameter {@code T},
- * so we can build a new {@code GenericTypeArray} with the "real" type parameters and
- * pass that object along instead.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class GenericArrayTypeImpl implements GenericArrayType {
-
-  private final Type genericComponentType;
-
-  public GenericArrayTypeImpl(Type genericComponentType) {
-    this.genericComponentType = genericComponentType;
-  }
-
-  public Type getGenericComponentType() {
-    return genericComponentType;
-  }
-
-  @Override
-  public boolean equals(Object o) {
-    if (!(o instanceof  GenericArrayType)) {
-      return false;
-    }
-    GenericArrayType that = (GenericArrayType) o;
-    Type thatComponentType = that.getGenericComponentType();
-    return genericComponentType == null ?
-        thatComponentType == null : genericComponentType.equals(thatComponentType);
-  }
-
-  @Override
-  public int hashCode() {
-    return (genericComponentType == null) ? 0 : genericComponentType.hashCode();
-  }
-}

src/org/mcteam/ancientgates/gson/Gson.java

@@ -1,597 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.io.StringReader;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.lang.reflect.Modifier;
-import java.lang.reflect.Type;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-import org.mcteam.ancientgates.gson.JsonSerializationContextDefault;
-import org.mcteam.ancientgates.gson.stream.JsonReader;
-import org.mcteam.ancientgates.gson.stream.JsonToken;
-import org.mcteam.ancientgates.gson.stream.JsonWriter;
-import org.mcteam.ancientgates.gson.stream.MalformedJsonException;
-
-/**
- * This is the main class for using Gson. Gson is typically used by first constructing a
- * Gson instance and then invoking {@link #toJson(Object)} or {@link #fromJson(String, Class)}
- * methods on it.
- *
- * <p>You can create a Gson instance by invoking {@code new Gson()} if the default configuration
- * is all you need. You can also use {@link GsonBuilder} to build a Gson instance with various
- * configuration options such as versioning support, pretty printing, custom
- * {@link JsonSerializer}s, {@link JsonDeserializer}s, and {@link InstanceCreator}s.</p>
- *
- * <p>Here is an example of how Gson is used for a simple Class:
- *
- * <pre>
- * Gson gson = new Gson(); // Or use new GsonBuilder().create();
- * MyType target = new MyType();
- * String json = gson.toJson(target); // serializes target to Json
- * MyType target2 = gson.fromJson(json, MyType.class); // deserializes json into target2
- * </pre></p>
- *
- * <p>If the object that your are serializing/deserializing is a {@code ParameterizedType}
- * (i.e. contains at least one type parameter and may be an array) then you must use the
- * {@link #toJson(Object, Type)} or {@link #fromJson(String, Type)} method.  Here is an
- * example for serializing and deserialing a {@code ParameterizedType}:
- *
- * <pre>
- * Type listType = new TypeToken&lt;List&lt;String&gt;&gt;() {}.getType();
- * List&lt;String&gt; target = new LinkedList&lt;String&gt;();
- * target.add("blah");
- *
- * Gson gson = new Gson();
- * String json = gson.toJson(target, listType);
- * List&lt;String&gt; target2 = gson.fromJson(json, listType);
- * </pre></p>
- *
- * <p>See the <a href="https://sites.google.com/site/gson/gson-user-guide">Gson User Guide</a>
- * for a more complete set of examples.</p>
- *
- * @see org.mcteam.ancientgates.gson.reflect.TypeToken
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public final class Gson {
-
-  //TODO(inder): get rid of all the registerXXX methods and take all such parameters in the
-  // constructor instead. At the minimum, mark those methods private.
-
-  private static final String NULL_STRING = "null";
-
-  static final boolean DEFAULT_JSON_NON_EXECUTABLE = false;
-
-  // Default instances of plug-ins
-  static final AnonymousAndLocalClassExclusionStrategy DEFAULT_ANON_LOCAL_CLASS_EXCLUSION_STRATEGY =
-      new AnonymousAndLocalClassExclusionStrategy();
-  static final SyntheticFieldExclusionStrategy DEFAULT_SYNTHETIC_FIELD_EXCLUSION_STRATEGY =
-      new SyntheticFieldExclusionStrategy(true);
-  static final ModifierBasedExclusionStrategy DEFAULT_MODIFIER_BASED_EXCLUSION_STRATEGY =
-      new ModifierBasedExclusionStrategy(new int[] { Modifier.TRANSIENT, Modifier.STATIC });
-  static final FieldNamingStrategy2 DEFAULT_NAMING_POLICY =
-      new SerializedNameAnnotationInterceptingNamingPolicy(new JavaFieldNamingPolicy());
-
-  private static final ExclusionStrategy DEFAULT_EXCLUSION_STRATEGY =
-      createExclusionStrategy(VersionConstants.IGNORE_VERSIONS);
-
-  private static final String JSON_NON_EXECUTABLE_PREFIX = ")]}'\n";
-
-  private final ExclusionStrategy serializationStrategy;
-
-  private final ExclusionStrategy deserializationStrategy;
-
-  private final FieldNamingStrategy2 fieldNamingPolicy;
-  private final MappedObjectConstructor objectConstructor;
-
-  /** Map containing Type or Class objects as keys */
-  private final ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers;
-
-  /** Map containing Type or Class objects as keys */
-  private final ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers;
-
-  private final boolean serializeNulls;
-  private final boolean htmlSafe;
-  private final boolean generateNonExecutableJson;
-  private final boolean prettyPrinting;
-
-  /**
-   * Constructs a Gson object with default configuration. The default configuration has the
-   * following settings:
-   * <ul>
-   *   <li>The JSON generated by <code>toJson</code> methods is in compact representation. This
-   *   means that all the unneeded white-space is removed. You can change this behavior with
-   *   {@link GsonBuilder#setPrettyPrinting()}. </li>
-   *   <li>The generated JSON omits all the fields that are null. Note that nulls in arrays are
-   *   kept as is since an array is an ordered list. Moreover, if a field is not null, but its
-   *   generated JSON is empty, the field is kept. You can configure Gson to serialize null values
-   *   by setting {@link GsonBuilder#serializeNulls()}.</li>
-   *   <li>Gson provides default serialization and deserialization for Enums, {@link Map},
-   *   {@link java.net.URL}, {@link java.net.URI}, {@link java.util.Locale}, {@link java.util.Date},
-   *   {@link java.math.BigDecimal}, and {@link java.math.BigInteger} classes. If you would prefer
-   *   to change the default representation, you can do so by registering a type adapter through
-   *   {@link GsonBuilder#registerTypeAdapter(Type, Object)}. </li>
-   *   <li>The default Date format is same as {@link java.text.DateFormat#DEFAULT}. This format
-   *   ignores the millisecond portion of the date during serialization. You can change
-   *   this by invoking {@link GsonBuilder#setDateFormat(int)} or
-   *   {@link GsonBuilder#setDateFormat(String)}. </li>
-   *   <li>By default, Gson ignores the {@link org.mcteam.ancientgates.gson.annotations.Expose} annotation.
-   *   You can enable Gson to serialize/deserialize only those fields marked with this annotation
-   *   through {@link GsonBuilder#excludeFieldsWithoutExposeAnnotation()}. </li>
-   *   <li>By default, Gson ignores the {@link org.mcteam.ancientgates.gson.annotations.Since} annotation. You
-   *   can enable Gson to use this annotation through {@link GsonBuilder#setVersion(double)}.</li>
-   *   <li>The default field naming policy for the output Json is same as in Java. So, a Java class
-   *   field <code>versionNumber</code> will be output as <code>&quot;versionNumber@quot;</code> in
-   *   Json. The same rules are applied for mapping incoming Json to the Java classes. You can
-   *   change this policy through {@link GsonBuilder#setFieldNamingPolicy(FieldNamingPolicy)}.</li>
-   *   <li>By default, Gson excludes <code>transient</code> or <code>static</code> fields from
-   *   consideration for serialization and deserialization. You can change this behavior through
-   *   {@link GsonBuilder#excludeFieldsWithModifiers(int...)}.</li>
-   * </ul>
-   */
-  public Gson() {
-    this(DEFAULT_EXCLUSION_STRATEGY, DEFAULT_EXCLUSION_STRATEGY, DEFAULT_NAMING_POLICY,
-    new MappedObjectConstructor(DefaultTypeAdapters.getDefaultInstanceCreators()),
-    false, DefaultTypeAdapters.getDefaultSerializers(),
-    DefaultTypeAdapters.getDefaultDeserializers(), DEFAULT_JSON_NON_EXECUTABLE, true, false);
-  }
-
-  Gson(ExclusionStrategy serializationStrategy, ExclusionStrategy deserializationStrategy,
-       FieldNamingStrategy2 fieldNamingPolicy, MappedObjectConstructor objectConstructor,
-       boolean serializeNulls, ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers,
-       ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers,
-       boolean generateNonExecutableGson, boolean htmlSafe, boolean prettyPrinting) {
-    this.serializationStrategy = serializationStrategy;
-    this.deserializationStrategy = deserializationStrategy;
-    this.fieldNamingPolicy = fieldNamingPolicy;
-    this.objectConstructor = objectConstructor;
-    this.serializeNulls = serializeNulls;
-    this.serializers = serializers;
-    this.deserializers = deserializers;
-    this.generateNonExecutableJson = generateNonExecutableGson;
-    this.htmlSafe = htmlSafe;
-    this.prettyPrinting = prettyPrinting;
-  }
-
-  private ObjectNavigatorFactory createDefaultObjectNavigatorFactory(ExclusionStrategy strategy) {
-    return new ObjectNavigatorFactory(strategy, fieldNamingPolicy);
-  }
-
-  private static ExclusionStrategy createExclusionStrategy(double version) {
-    List<ExclusionStrategy> strategies = new LinkedList<ExclusionStrategy>();
-    strategies.add(DEFAULT_ANON_LOCAL_CLASS_EXCLUSION_STRATEGY);
-    strategies.add(DEFAULT_SYNTHETIC_FIELD_EXCLUSION_STRATEGY);
-    strategies.add(DEFAULT_MODIFIER_BASED_EXCLUSION_STRATEGY);
-    if (version != VersionConstants.IGNORE_VERSIONS) {
-      strategies.add(new VersionExclusionStrategy(version));
-    }
-    return new DisjunctionExclusionStrategy(strategies);
-  }
-
-  /**
-   * This method serializes the specified object into its equivalent representation as a tree of
-   * {@link JsonElement}s. This method should be used when the specified object is not a generic
-   * type. This method uses {@link Class#getClass()} to get the type for the specified object, but
-   * the {@code getClass()} loses the generic type information because of the Type Erasure feature
-   * of Java. Note that this method works fine if the any of the object fields are of generic type,
-   * just the object itself should not be of a generic type. If the object is of generic type, use
-   * {@link #toJsonTree(Object, Type)} instead.
-   *
-   * @param src the object for which Json representation is to be created setting for Gson
-   * @return Json representation of {@code src}.
-   * @since 1.4
-   */
-  public JsonElement toJsonTree(Object src) {
-    if (src == null) {
-      return JsonNull.createJsonNull();
-    }
-    return toJsonTree(src, src.getClass());
-  }
-
-  /**
-   * This method serializes the specified object, including those of generic types, into its
-   * equivalent representation as a tree of {@link JsonElement}s. This method must be used if the
-   * specified object is a generic type. For non-generic objects, use {@link #toJsonTree(Object)}
-   * instead.
-   *
-   * @param src the object for which JSON representation is to be created
-   * @param typeOfSrc The specific genericized type of src. You can obtain
-   * this type by using the {@link org.mcteam.ancientgates.gson.reflect.TypeToken} class. For example,
-   * to get the type for {@code Collection<Foo>}, you should use:
-   * <pre>
-   * Type typeOfSrc = new TypeToken&lt;Collection&lt;Foo&gt;&gt;(){}.getType();
-   * </pre>
-   * @return Json representation of {@code src}
-   * @since 1.4
-   */
-  public JsonElement toJsonTree(Object src, Type typeOfSrc) {
-    if (src == null) {
-      return JsonNull.createJsonNull();
-    }
-    JsonSerializationContextDefault context = new JsonSerializationContextDefault(
-        createDefaultObjectNavigatorFactory(serializationStrategy), serializeNulls, serializers);
-    return context.serialize(src, typeOfSrc, true);
-  }
-
-  /**
-   * This method serializes the specified object into its equivalent Json representation.
-   * This method should be used when the specified object is not a generic type. This method uses
-   * {@link Class#getClass()} to get the type for the specified object, but the
-   * {@code getClass()} loses the generic type information because of the Type Erasure feature
-   * of Java. Note that this method works fine if the any of the object fields are of generic type,
-   * just the object itself should not be of a generic type. If the object is of generic type, use
-   * {@link #toJson(Object, Type)} instead. If you want to write out the object to a
-   * {@link Writer}, use {@link #toJson(Object, Appendable)} instead.
-   *
-   * @param src the object for which Json representation is to be created setting for Gson
-   * @return Json representation of {@code src}.
-   */
-  public String toJson(Object src) {
-    if (src == null) {
-      return serializeNulls ? NULL_STRING : "";
-    }
-    return toJson(src, src.getClass());
-  }
-
-  /**
-   * This method serializes the specified object, including those of generic types, into its
-   * equivalent Json representation. This method must be used if the specified object is a generic
-   * type. For non-generic objects, use {@link #toJson(Object)} instead. If you want to write out
-   * the object to a {@link Appendable}, use {@link #toJson(Object, Type, Appendable)} instead.
-   *
-   * @param src the object for which JSON representation is to be created
-   * @param typeOfSrc The specific genericized type of src. You can obtain
-   * this type by using the {@link org.mcteam.ancientgates.gson.reflect.TypeToken} class. For example,
-   * to get the type for {@code Collection<Foo>}, you should use:
-   * <pre>
-   * Type typeOfSrc = new TypeToken&lt;Collection&lt;Foo&gt;&gt;(){}.getType();
-   * </pre>
-   * @return Json representation of {@code src}
-   */
-  public String toJson(Object src, Type typeOfSrc) {
-    StringWriter writer = new StringWriter();
-    toJson(toJsonTree(src, typeOfSrc), writer);
-    return writer.toString();
-  }
-
-  /**
-   * This method serializes the specified object into its equivalent Json representation.
-   * This method should be used when the specified object is not a generic type. This method uses
-   * {@link Class#getClass()} to get the type for the specified object, but the
-   * {@code getClass()} loses the generic type information because of the Type Erasure feature
-   * of Java. Note that this method works fine if the any of the object fields are of generic type,
-   * just the object itself should not be of a generic type. If the object is of generic type, use
-   * {@link #toJson(Object, Type, Appendable)} instead.
-   *
-   * @param src the object for which Json representation is to be created setting for Gson
-   * @param writer Writer to which the Json representation needs to be written
-   * @throws JsonIOException if there was a problem writing to the writer
-   * @since 1.2
-   */
-  public void toJson(Object src, Appendable writer) throws JsonIOException {
-    try {
-      if (src != null) {
-        toJson(src, src.getClass(), writer);
-      } else if (serializeNulls) {
-        writeOutNullString(writer);
-      }
-    } catch (IOException ioe) {
-      throw new RuntimeException(ioe);
-    }
-  }
-
-  /**
-   * This method serializes the specified object, including those of generic types, into its
-   * equivalent Json representation. This method must be used if the specified object is a generic
-   * type. For non-generic objects, use {@link #toJson(Object, Appendable)} instead.
-   *
-   * @param src the object for which JSON representation is to be created
-   * @param typeOfSrc The specific genericized type of src. You can obtain
-   * this type by using the {@link org.mcteam.ancientgates.gson.reflect.TypeToken} class. For example,
-   * to get the type for {@code Collection<Foo>}, you should use:
-   * <pre>
-   * Type typeOfSrc = new TypeToken&lt;Collection&lt;Foo&gt;&gt;(){}.getType();
-   * </pre>
-   * @param writer Writer to which the Json representation of src needs to be written.
-   * @throws JsonIOException if there was a problem writing to the writer
-   * @since 1.2
-   */
-  public void toJson(Object src, Type typeOfSrc, Appendable writer) throws JsonIOException {
-    JsonElement jsonElement = toJsonTree(src, typeOfSrc);
-    toJson(jsonElement, writer);
-  }
-
-  /**
-   * Writes the JSON representation of {@code src} of type {@code typeOfSrc} to
-   * {@code writer}.
-   * @throws JsonIOException if there was a problem writing to the writer
-   */
-  public void toJson(Object src, Type typeOfSrc, JsonWriter writer) throws JsonIOException {
-    toJson(toJsonTree(src, typeOfSrc), writer);
-  }
-
-  /**
-   * Converts a tree of {@link JsonElement}s into its equivalent JSON representation.
-   *
-   * @param jsonElement root of a tree of {@link JsonElement}s
-   * @return JSON String representation of the tree
-   * @since 1.4
-   */
-  public String toJson(JsonElement jsonElement) {
-    StringWriter writer = new StringWriter();
-    toJson(jsonElement, writer);
-    return writer.toString();
-  }
-
-  /**
-   * Writes out the equivalent JSON for a tree of {@link JsonElement}s.
-   *
-   * @param jsonElement root of a tree of {@link JsonElement}s
-   * @param writer Writer to which the Json representation needs to be written
-   * @throws JsonIOException if there was a problem writing to the writer
-   * @since 1.4
-   */
-  public void toJson(JsonElement jsonElement, Appendable writer) throws JsonIOException {
-    try {
-      if (generateNonExecutableJson) {
-        writer.append(JSON_NON_EXECUTABLE_PREFIX);
-      }
-      JsonWriter jsonWriter = new JsonWriter(Streams.writerForAppendable(writer));
-      if (prettyPrinting) {
-        jsonWriter.setIndent("  ");
-      }
-      toJson(jsonElement, jsonWriter);
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  /**
-   * Writes the JSON for {@code jsonElement} to {@code writer}.
-   * @throws JsonIOException if there was a problem writing to the writer
-   */
-  public void toJson(JsonElement jsonElement, JsonWriter writer) throws JsonIOException {
-    boolean oldLenient = writer.isLenient();
-    writer.setLenient(true);
-    boolean oldHtmlSafe = writer.isHtmlSafe();
-    writer.setHtmlSafe(htmlSafe);
-    try {
-      Streams.write(jsonElement, serializeNulls, writer);
-    } catch (IOException e) {
-      throw new JsonIOException(e);
-    } finally {
-      writer.setLenient(oldLenient);
-      writer.setHtmlSafe(oldHtmlSafe);
-    }
-  }
-
-  /**
-   * This method deserializes the specified Json into an object of the specified class. It is not
-   * suitable to use if the specified class is a generic type since it will not have the generic
-   * type information because of the Type Erasure feature of Java. Therefore, this method should not
-   * be used if the desired type is a generic type. Note that this method works fine if the any of
-   * the fields of the specified object are generics, just the object itself should not be a
-   * generic type. For the cases when the object is of generic type, invoke
-   * {@link #fromJson(String, Type)}. If you have the Json in a {@link Reader} instead of
-   * a String, use {@link #fromJson(Reader, Class)} instead.
-   *
-   * @param <T> the type of the desired object
-   * @param json the string from which the object is to be deserialized
-   * @param classOfT the class of T
-   * @return an object of type T from the string
-   * @throws JsonSyntaxException if json is not a valid representation for an object of type
-   * classOfT
-   */
-  public <T> T fromJson(String json, Class<T> classOfT) throws JsonSyntaxException {
-    Object object = fromJson(json, (Type) classOfT);
-    return Primitives.wrap(classOfT).cast(object);
-  }
-
-  /**
-   * This method deserializes the specified Json into an object of the specified type. This method
-   * is useful if the specified object is a generic type. For non-generic objects, use
-   * {@link #fromJson(String, Class)} instead. If you have the Json in a {@link Reader} instead of
-   * a String, use {@link #fromJson(Reader, Type)} instead.
-   *
-   * @param <T> the type of the desired object
-   * @param json the string from which the object is to be deserialized
-   * @param typeOfT The specific genericized type of src. You can obtain this type by using the
-   * {@link org.mcteam.ancientgates.gson.reflect.TypeToken} class. For example, to get the type for
-   * {@code Collection<Foo>}, you should use:
-   * <pre>
-   * Type typeOfT = new TypeToken&lt;Collection&lt;Foo&gt;&gt;(){}.getType();
-   * </pre>
-   * @return an object of type T from the string
-   * @throws JsonParseException if json is not a valid representation for an object of type typeOfT
-   * @throws JsonSyntaxException if json is not a valid representation for an object of type
-   */
-  @SuppressWarnings("unchecked")
-  public <T> T fromJson(String json, Type typeOfT) throws JsonSyntaxException {
-    if (json == null) {
-      return null;
-    }
-    StringReader reader = new StringReader(json);
-    T target = (T) fromJson(reader, typeOfT);
-    return target;
-  }
-
-  /**
-   * This method deserializes the Json read from the specified reader into an object of the
-   * specified class. It is not suitable to use if the specified class is a generic type since it
-   * will not have the generic type information because of the Type Erasure feature of Java.
-   * Therefore, this method should not be used if the desired type is a generic type. Note that
-   * this method works fine if the any of the fields of the specified object are generics, just the
-   * object itself should not be a generic type. For the cases when the object is of generic type,
-   * invoke {@link #fromJson(Reader, Type)}. If you have the Json in a String form instead of a
-   * {@link Reader}, use {@link #fromJson(String, Class)} instead.
-   *
-   * @param <T> the type of the desired object
-   * @param json the reader producing the Json from which the object is to be deserialized.
-   * @param classOfT the class of T
-   * @return an object of type T from the string
-   * @throws JsonIOException if there was a problem reading from the Reader
-   * @throws JsonSyntaxException if json is not a valid representation for an object of type
-   * @since 1.2
-   */
-  public <T> T fromJson(Reader json, Class<T> classOfT) throws JsonSyntaxException, JsonIOException {
-    JsonReader jsonReader = new JsonReader(json);
-    Object object = fromJson(jsonReader, classOfT);
-    assertFullConsumption(object, jsonReader);
-    return Primitives.wrap(classOfT).cast(object);
-  }
-
-  /**
-   * This method deserializes the Json read from the specified reader into an object of the
-   * specified type. This method is useful if the specified object is a generic type. For
-   * non-generic objects, use {@link #fromJson(Reader, Class)} instead. If you have the Json in a
-   * String form instead of a {@link Reader}, use {@link #fromJson(String, Type)} instead.
-   *
-   * @param <T> the type of the desired object
-   * @param json the reader producing Json from which the object is to be deserialized
-   * @param typeOfT The specific genericized type of src. You can obtain this type by using the
-   * {@link org.mcteam.ancientgates.gson.reflect.TypeToken} class. For example, to get the type for
-   * {@code Collection<Foo>}, you should use:
-   * <pre>
-   * Type typeOfT = new TypeToken&lt;Collection&lt;Foo&gt;&gt;(){}.getType();
-   * </pre>
-   * @return an object of type T from the json
-   * @throws JsonIOException if there was a problem reading from the Reader
-   * @throws JsonSyntaxException if json is not a valid representation for an object of type
-   * @since 1.2
-   */
-  public <T> T fromJson(Reader json, Type typeOfT) throws JsonIOException, JsonSyntaxException {
-    JsonReader jsonReader = new JsonReader(json);
-    T object = this.<T>fromJson(jsonReader, typeOfT);
-    assertFullConsumption(object, jsonReader);
-    return object;
-  }
-
-  private static void assertFullConsumption(Object obj, JsonReader reader) {
-    try {
-      if (obj != null && reader.peek() != JsonToken.END_DOCUMENT) {
-        throw new JsonIOException("JSON document was not fully consumed.");
-      }
-    } catch (MalformedJsonException e) {
-      throw new JsonSyntaxException(e);
-    } catch (IOException e) {
-      throw new JsonIOException(e);
-    }
-  }
-
-  /**
-   * Reads the next JSON value from {@code reader} and convert it to an object
-   * of type {@code typeOfT}.
-   * Since Type is not parameterized by T, this method is type unsafe and should be used carefully
-   *
-   * @throws JsonIOException if there was a problem writing to the Reader
-   * @throws JsonSyntaxException if json is not a valid representation for an object of type
-   */
-  @SuppressWarnings("unchecked")
-  public <T> T fromJson(JsonReader reader, Type typeOfT) throws JsonIOException, JsonSyntaxException {
-    boolean oldLenient = reader.isLenient();
-    reader.setLenient(true);
-    try {
-      JsonElement root = Streams.parse(reader);
-      return (T) fromJson(root, typeOfT);
-    } finally {
-      reader.setLenient(oldLenient);
-    }
-  }
-
-  /**
-   * This method deserializes the Json read from the specified parse tree into an object of the
-   * specified type. It is not suitable to use if the specified class is a generic type since it
-   * will not have the generic type information because of the Type Erasure feature of Java.
-   * Therefore, this method should not be used if the desired type is a generic type. Note that
-   * this method works fine if the any of the fields of the specified object are generics, just the
-   * object itself should not be a generic type. For the cases when the object is of generic type,
-   * invoke {@link #fromJson(JsonElement, Type)}.
-   * @param <T> the type of the desired object
-   * @param json the root of the parse tree of {@link JsonElement}s from which the object is to
-   * be deserialized
-   * @param classOfT The class of T
-   * @return an object of type T from the json
-   * @throws JsonSyntaxException if json is not a valid representation for an object of type typeOfT
-   * @since 1.3
-   */
-  public <T> T fromJson(JsonElement json, Class<T> classOfT) throws JsonSyntaxException {
-    Object object = fromJson(json, (Type) classOfT);
-    return Primitives.wrap(classOfT).cast(object);
-  }
-
-  /**
-   * This method deserializes the Json read from the specified parse tree into an object of the
-   * specified type. This method is useful if the specified object is a generic type. For
-   * non-generic objects, use {@link #fromJson(JsonElement, Class)} instead.
-   *
-   * @param <T> the type of the desired object
-   * @param json the root of the parse tree of {@link JsonElement}s from which the object is to
-   * be deserialized
-   * @param typeOfT The specific genericized type of src. You can obtain this type by using the
-   * {@link org.mcteam.ancientgates.gson.reflect.TypeToken} class. For example, to get the type for
-   * {@code Collection<Foo>}, you should use:
-   * <pre>
-   * Type typeOfT = new TypeToken&lt;Collection&lt;Foo&gt;&gt;(){}.getType();
-   * </pre>
-   * @return an object of type T from the json
-   * @throws JsonSyntaxException if json is not a valid representation for an object of type typeOfT
-   * @since 1.3
-   */
-  @SuppressWarnings("unchecked")
-  public <T> T fromJson(JsonElement json, Type typeOfT) throws JsonSyntaxException {
-    if (json == null) {
-      return null;
-    }
-    JsonDeserializationContext context = new JsonDeserializationContextDefault(
-        createDefaultObjectNavigatorFactory(deserializationStrategy), deserializers,
-        objectConstructor);
-    T target = (T) context.deserialize(json, typeOfT);
-    return target;
-  }
-
-  /**
-   * Appends the {@link #NULL_STRING} to the {@code writer} object.
-   *
-   * @param writer the object to append the null value to
-   */
-  private void writeOutNullString(Appendable writer) throws IOException {
-    writer.append(NULL_STRING);
-  }
-
-  @Override
-  public String toString() {
-  	StringBuilder sb = new StringBuilder("{")
-  	    .append("serializeNulls:").append(serializeNulls)
-  	    .append(",serializers:").append(serializers)
-  	    .append(",deserializers:").append(deserializers)
-
-      	// using the name instanceCreator instead of ObjectConstructor since the users of Gson are
-      	// more familiar with the concept of Instance Creators. Moreover, the objectConstructor is
-      	// just a utility class around instance creators, and its toString() only displays them.
-        .append(",instanceCreators:").append(objectConstructor)
-        .append("}");
-  	return sb.toString();
-  }
-}

src/org/mcteam/ancientgates/gson/GsonBuilder.java

@@ -1,571 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-import java.text.DateFormat;
-import java.util.Collection;
-import java.util.Date;
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.mcteam.ancientgates.gson.DefaultTypeAdapters.DefaultDateTypeAdapter;
-
-
-/**
- * <p>Use this builder to construct a {@link Gson} instance when you need to set configuration
- * options other than the default. For {@link Gson} with default configuration, it is simpler to
- * use {@code new Gson()}. {@code GsonBuilder} is best used by creating it, and then invoking its
- * various configuration methods, and finally calling create.</p>
- *
- * <p>The following is an example shows how to use the {@code GsonBuilder} to construct a Gson
- * instance:
- *
- * <pre>
- * Gson gson = new GsonBuilder()
- *     .registerTypeAdapter(Id.class, new IdTypeAdapter())
- *     .serializeNulls()
- *     .setDateFormat(DateFormat.LONG)
- *     .setFieldNamingPolicy(FieldNamingPolicy.UPPER_CAMEL_CASE)
- *     .setPrettyPrinting()
- *     .setVersion(1.0)
- *     .create();
- * </pre></p>
- *
- * <p>NOTE: the order of invocation of configuration methods does not matter.</p>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public final class GsonBuilder {
-  private static final InnerClassExclusionStrategy innerClassExclusionStrategy =
-      new InnerClassExclusionStrategy();
-  private static final ExposeAnnotationSerializationExclusionStrategy
-    exposeAnnotationSerializationExclusionStrategy =
-      new ExposeAnnotationSerializationExclusionStrategy();
-  private static final ExposeAnnotationDeserializationExclusionStrategy
-    exposeAnnotationDeserializationExclusionStrategy =
-      new ExposeAnnotationDeserializationExclusionStrategy();
-
-  private final Collection<ExclusionStrategy> exclusionStrategies =
-      new HashSet<ExclusionStrategy>();
-
-  private double ignoreVersionsAfter;
-  private ModifierBasedExclusionStrategy modifierBasedExclusionStrategy;
-  private boolean serializeInnerClasses;
-  private boolean excludeFieldsWithoutExposeAnnotation;
-  private LongSerializationPolicy longSerializationPolicy;
-  private FieldNamingStrategy2 fieldNamingPolicy;
-  private final ParameterizedTypeHandlerMap<InstanceCreator<?>> instanceCreators;
-  private final ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers;
-  private final ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers;
-  private boolean serializeNulls;
-  private String datePattern;
-  private int dateStyle;
-  private int timeStyle;
-  private boolean serializeSpecialFloatingPointValues;
-  private boolean escapeHtmlChars;
-  private boolean prettyPrinting;
-  private boolean generateNonExecutableJson;
-
-  /**
-   * Creates a GsonBuilder instance that can be used to build Gson with various configuration
-   * settings. GsonBuilder follows the builder pattern, and it is typically used by first
-   * invoking various configuration methods to set desired options, and finally calling
-   * {@link #create()}.
-   */
-  public GsonBuilder() {
-    // add default exclusion strategies
-    exclusionStrategies.add(Gson.DEFAULT_ANON_LOCAL_CLASS_EXCLUSION_STRATEGY);
-    exclusionStrategies.add(Gson.DEFAULT_SYNTHETIC_FIELD_EXCLUSION_STRATEGY);
-
-    // setup default values
-    ignoreVersionsAfter = VersionConstants.IGNORE_VERSIONS;
-    serializeInnerClasses = true;
-    prettyPrinting = false;
-    escapeHtmlChars = true;
-    modifierBasedExclusionStrategy = Gson.DEFAULT_MODIFIER_BASED_EXCLUSION_STRATEGY;
-    excludeFieldsWithoutExposeAnnotation = false;
-    longSerializationPolicy = LongSerializationPolicy.DEFAULT;
-    fieldNamingPolicy = Gson.DEFAULT_NAMING_POLICY;
-    instanceCreators = new ParameterizedTypeHandlerMap<InstanceCreator<?>>();
-    serializers = new ParameterizedTypeHandlerMap<JsonSerializer<?>>();
-    deserializers = new ParameterizedTypeHandlerMap<JsonDeserializer<?>>();
-    serializeNulls = false;
-    dateStyle = DateFormat.DEFAULT;
-    timeStyle = DateFormat.DEFAULT;
-    serializeSpecialFloatingPointValues = false;
-    generateNonExecutableJson = false;
-  }
-
-  /**
-   * Configures Gson to enable versioning support.
-   *
-   * @param ignoreVersionsAfter any field or type marked with a version higher than this value
-   * are ignored during serialization or deserialization.
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  public GsonBuilder setVersion(double ignoreVersionsAfter) {
-    this.ignoreVersionsAfter = ignoreVersionsAfter;
-    return this;
-  }
-
-  /**
-   * Configures Gson to excludes all class fields that have the specified modifiers. By default,
-   * Gson will exclude all fields marked transient or static. This method will override that
-   * behavior.
-   *
-   * @param modifiers the field modifiers. You must use the modifiers specified in the
-   * {@link java.lang.reflect.Modifier} class. For example,
-   * {@link java.lang.reflect.Modifier#TRANSIENT},
-   * {@link java.lang.reflect.Modifier#STATIC}.
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  public GsonBuilder excludeFieldsWithModifiers(int... modifiers) {
-    modifierBasedExclusionStrategy = new ModifierBasedExclusionStrategy(modifiers);
-    return this;
-  }
-
-  /**
-   * Makes the output JSON non-executable in Javascript by prefixing the generated JSON with some
-   * special text. This prevents attacks from third-party sites through script sourcing. See
-   * <a href="http://code.google.com/p/google-gson/issues/detail?id=42">Gson Issue 42</a>
-   * for details.
-   *
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.3
-   */
-  public GsonBuilder generateNonExecutableJson() {
-    this.generateNonExecutableJson = true;
-    return this;
-  }
-
-  /**
-   * Configures Gson to exclude all fields from consideration for serialization or deserialization
-   * that do not have the {@link org.mcteam.ancientgates.gson.annotations.Expose} annotation.
-   *
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  public GsonBuilder excludeFieldsWithoutExposeAnnotation() {
-    excludeFieldsWithoutExposeAnnotation = true;
-    return this;
-  }
-
-  /**
-   * Configure Gson to serialize null fields. By default, Gson omits all fields that are null
-   * during serialization.
-   *
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.2
-   */
-  public GsonBuilder serializeNulls() {
-    this.serializeNulls = true;
-    return this;
-  }
-
-  /**
-   * Configures Gson to exclude inner classes during serialization.
-   *
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.3
-   */
-  public GsonBuilder disableInnerClassSerialization() {
-    serializeInnerClasses = false;
-    return this;
-  }
-
-  /**
-   * Configures Gson to apply a specific serialization policy for {@code Long} and {@code long}
-   * objects.
-   *
-   * @param serializationPolicy the particular policy to use for serializing longs.
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.3
-   */
-  public GsonBuilder setLongSerializationPolicy(LongSerializationPolicy serializationPolicy) {
-    this.longSerializationPolicy = serializationPolicy;
-    return this;
-  }
-
-  /**
-   * Configures Gson to apply a specific naming policy to an object's field during serialization
-   * and deserialization.
-   *
-   * @param namingConvention the JSON field naming convention to use for serialization and
-   * deserialization.
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  public GsonBuilder setFieldNamingPolicy(FieldNamingPolicy namingConvention) {
-    return setFieldNamingStrategy(namingConvention.getFieldNamingPolicy());
-  }
-
-  /**
-   * Configures Gson to apply a specific naming policy strategy to an object's field during
-   * serialization and deserialization.
-   *
-   * @param fieldNamingStrategy the actual naming strategy to apply to the fields
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.3
-   */
-  public GsonBuilder setFieldNamingStrategy(FieldNamingStrategy fieldNamingStrategy) {
-    return setFieldNamingStrategy(new FieldNamingStrategy2Adapter(fieldNamingStrategy));
-  }
-
-  /**
-   * Configures Gson to apply a specific naming policy strategy to an object's field during
-   * serialization and deserialization.
-   *
-   * @param fieldNamingStrategy the actual naming strategy to apply to the fields
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  GsonBuilder setFieldNamingStrategy(FieldNamingStrategy2 fieldNamingStrategy) {
-    this.fieldNamingPolicy =
-        new SerializedNameAnnotationInterceptingNamingPolicy(fieldNamingStrategy);
-    return this;
-  }
-
-  /**
-   * Configures Gson to apply a set of exclusion strategies during both serialization and
-   * deserialization. Each of the {@code strategies} will be applied as a disjunction rule.
-   * This means that if one of the {@code strategies} suggests that a field (or class) should be
-   * skipped then that field (or object) is skipped during serializaiton/deserialization.
-   *
-   * @param strategies the set of strategy object to apply during object (de)serialization.
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.4
-   */
-  public GsonBuilder setExclusionStrategies(ExclusionStrategy... strategies) {
-    for (ExclusionStrategy strategy : strategies) {
-      exclusionStrategies.add(strategy);
-    }
-    return this;
-  }
-
-  /**
-   * Configures Gson to output Json that fits in a page for pretty printing. This option only
-   * affects Json serialization.
-   *
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  public GsonBuilder setPrettyPrinting() {
-    prettyPrinting = true;
-    return this;
-  }
-
-  /**
-   * By default, Gson escapes HTML characters such as &lt; &gt; etc. Use this option to configure
-   * Gson to pass-through HTML characters as is.
-   *
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.3
-   */
-  public GsonBuilder disableHtmlEscaping() {
-    this.escapeHtmlChars = false;
-    return this;
-  }
-
-  /**
-   * Configures Gson to serialize {@code Date} objects according to the pattern provided. You can
-   * call this method or {@link #setDateFormat(int)} multiple times, but only the last invocation
-   * will be used to decide the serialization format.
-   *
-   * <p>Note that this pattern must abide by the convention provided by {@code SimpleDateFormat}
-   * class. See the documentation in {@link java.text.SimpleDateFormat} for more information on
-   * valid date and time patterns.</p>
-   *
-   * @param pattern the pattern that dates will be serialized/deserialized to/from
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.2
-   */
-  public GsonBuilder setDateFormat(String pattern) {
-    // TODO(Joel): Make this fail fast if it is an invalid date format
-    this.datePattern = pattern;
-    return this;
-  }
-
-  /**
-   * Configures Gson to to serialize {@code Date} objects according to the style value provided.
-   * You can call this method or {@link #setDateFormat(String)} multiple times, but only the last
-   * invocation will be used to decide the serialization format.
-   *
-   * <p>Note that this style value should be one of the predefined constants in the
-   * {@code DateFormat} class. See the documentation in {@link java.text.DateFormat} for more
-   * information on the valid style constants.</p>
-   *
-   * @param style the predefined date style that date objects will be serialized/deserialized
-   * to/from
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.2
-   */
-  public GsonBuilder setDateFormat(int style) {
-    this.dateStyle = style;
-    this.datePattern = null;
-    return this;
-  }
-
-  /**
-   * Configures Gson to to serialize {@code Date} objects according to the style value provided.
-   * You can call this method or {@link #setDateFormat(String)} multiple times, but only the last
-   * invocation will be used to decide the serialization format.
-   *
-   * <p>Note that this style value should be one of the predefined constants in the
-   * {@code DateFormat} class. See the documentation in {@link java.text.DateFormat} for more
-   * information on the valid style constants.</p>
-   *
-   * @param dateStyle the predefined date style that date objects will be serialized/deserialized
-   * to/from
-   * @param timeStyle the predefined style for the time portion of the date objects
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.2
-   */
-  public GsonBuilder setDateFormat(int dateStyle, int timeStyle) {
-    this.dateStyle = dateStyle;
-    this.timeStyle = timeStyle;
-    this.datePattern = null;
-    return this;
-  }
-
-  /**
-   * Configures Gson for custom serialization or deserialization. This method combines the
-   * registration of an {@link InstanceCreator}, {@link JsonSerializer}, and a
-   * {@link JsonDeserializer}. It is best used when a single object {@code typeAdapter} implements
-   * all the required interfaces for custom serialization with Gson. If an instance creator,
-   * serializer or deserializer was previously registered for the specified {@code type}, it is
-   * overwritten.
-   *
-   * @param type the type definition for the type adapter being registered
-   * @param typeAdapter This object must implement at least one of the {@link InstanceCreator},
-   * {@link JsonSerializer}, and a {@link JsonDeserializer} interfaces.
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  public GsonBuilder registerTypeAdapter(Type type, Object typeAdapter) {
-    Preconditions.checkArgument(typeAdapter instanceof JsonSerializer<?>
-        || typeAdapter instanceof JsonDeserializer<?> || typeAdapter instanceof InstanceCreator<?>);
-    if (typeAdapter instanceof InstanceCreator<?>) {
-      registerInstanceCreator(type, (InstanceCreator<?>) typeAdapter);
-    }
-    if (typeAdapter instanceof JsonSerializer<?>) {
-      registerSerializer(type, (JsonSerializer<?>) typeAdapter);
-    }
-    if (typeAdapter instanceof JsonDeserializer<?>) {
-      registerDeserializer(type, (JsonDeserializer<?>) typeAdapter);
-    }
-    return this;
-  }
-
-  /**
-   * Configures Gson to use a custom {@link InstanceCreator} for the specified type. If an instance
-   * creator was previously registered for the specified class, it is overwritten. Since this method
-   * takes a type instead of a Class object, it can be used to register a specific handler for a
-   * generic type corresponding to a raw type.
-   *
-   * @param <T> the type for which instance creator is being registered
-   * @param typeOfT The Type definition for T
-   * @param instanceCreator the instance creator for T
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  private <T> GsonBuilder registerInstanceCreator(Type typeOfT,
-      InstanceCreator<? extends T> instanceCreator) {
-    instanceCreators.register(typeOfT, instanceCreator);
-    return this;
-  }
-
-  /**
-   * Configures Gson to use a custom JSON serializer for the specified type. You should use this
-   * method if you want to register different serializers for different generic types corresponding
-   * to a raw type.
-   *
-   * @param <T> the type for which the serializer is being registered
-   * @param typeOfT The type definition for T
-   * @param serializer the custom serializer
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  private <T> GsonBuilder registerSerializer(Type typeOfT, final JsonSerializer<T> serializer) {
-    serializers.register(typeOfT, serializer);
-    return this;
-  }
-
-  /**
-   * Configures Gson to use a custom JSON deserializer for the specified type. You should use this
-   * method if you want to register different deserializers for different generic types
-   * corresponding to a raw type.
-   *
-   * @param <T> the type for which the deserializer is being registered
-   * @param typeOfT The type definition for T
-   * @param deserializer the custom deserializer
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   */
-  private <T> GsonBuilder registerDeserializer(Type typeOfT, JsonDeserializer<T> deserializer) {
-    deserializers.register(typeOfT, new JsonDeserializerExceptionWrapper<T>(deserializer));
-    return this;
-  }
-
-  /**
-   * Configures Gson for custom serialization or deserialization for an inheritance type hierarchy.
-   * This method combines the registration of an {@link InstanceCreator}, {@link JsonSerializer},
-   * and a {@link JsonDeserializer}. It is best used when a single object {@code typeAdapter}
-   * implements all the required interfaces for custom serialization with Gson.
-   * If an instance creator, serializer or deserializer was previously registered for the specified
-   * type hierarchy, it is overwritten. If an instance creator, serializer or deserializer is
-   * registered for a specific type in the type hierarchy, it will be invoked instead of the one
-   * registered for the type hierarchy.
-   *
-   * @param baseType the class definition for the type adapter being registered for the base class
-   *        or interface
-   * @param typeAdapter This object must implement at least one of the {@link InstanceCreator},
-   * {@link JsonSerializer}, and a {@link JsonDeserializer} interfaces.
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.7
-   */
-  GsonBuilder registerTypeHierarchyAdapter(Class<?> baseType, Object typeAdapter) {
-    Preconditions.checkArgument(typeAdapter instanceof JsonSerializer<?>
-    || typeAdapter instanceof JsonDeserializer<?> || typeAdapter instanceof InstanceCreator<?>);
-    if (typeAdapter instanceof InstanceCreator<?>) {
-      registerInstanceCreatorForTypeHierarchy(baseType, (InstanceCreator<?>) typeAdapter);
-    }
-    if (typeAdapter instanceof JsonSerializer<?>) {
-      registerSerializerForTypeHierarchy(baseType, (JsonSerializer<?>) typeAdapter);
-    }
-    if (typeAdapter instanceof JsonDeserializer<?>) {
-      registerDeserializerForTypeHierarchy(baseType, (JsonDeserializer<?>) typeAdapter);
-    }
-    return this;
-  }
-
-  private <T> GsonBuilder registerInstanceCreatorForTypeHierarchy(Class<?> classOfT,
-      InstanceCreator<? extends T> instanceCreator) {
-    instanceCreators.registerForTypeHierarchy(classOfT, instanceCreator);
-    return this;
-  }
-
-  private <T> GsonBuilder registerSerializerForTypeHierarchy(Class<?> classOfT,
-      final JsonSerializer<T> serializer) {
-    serializers.registerForTypeHierarchy(classOfT, serializer);
-    return this;
-  }
-
-  private <T> GsonBuilder registerDeserializerForTypeHierarchy(Class<?> classOfT,
-      JsonDeserializer<T> deserializer) {
-    deserializers.registerForTypeHierarchy(classOfT,
-        new JsonDeserializerExceptionWrapper<T>(deserializer));
-    return this;
-  }
-
-  /**
-   * Section 2.4 of <a href="http://www.ietf.org/rfc/rfc4627.txt">JSON specification</a> disallows
-   * special double values (NaN, Infinity, -Infinity). However,
-   * <a href="http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf">Javascript
-   * specification</a> (see section 4.3.20, 4.3.22, 4.3.23) allows these values as valid Javascript
-   * values. Moreover, most JavaScript engines will accept these special values in JSON without
-   * problem. So, at a practical level, it makes sense to accept these values as valid JSON even
-   * though JSON specification disallows them.
-   *
-   * <p>Gson always accepts these special values during deserialization. However, it outputs
-   * strictly compliant JSON. Hence, if it encounters a float value {@link Float#NaN},
-   * {@link Float#POSITIVE_INFINITY}, {@link Float#NEGATIVE_INFINITY}, or a double value
-   * {@link Double#NaN}, {@link Double#POSITIVE_INFINITY}, {@link Double#NEGATIVE_INFINITY}, it
-   * will throw an {@link IllegalArgumentException}. This method provides a way to override the
-   * default behavior when you know that the JSON receiver will be able to handle these special
-   * values.
-   *
-   * @return a reference to this {@code GsonBuilder} object to fulfill the "Builder" pattern
-   * @since 1.3
-   */
-  public GsonBuilder serializeSpecialFloatingPointValues() {
-    this.serializeSpecialFloatingPointValues = true;
-    return this;
-  }
-
-  /**
-   * Creates a {@link Gson} instance based on the current configuration. This method is free of
-   * side-effects to this {@code GsonBuilder} instance and hence can be called multiple times.
-   *
-   * @return an instance of Gson configured with the options currently set in this builder
-   */
-  public Gson create() {
-    List<ExclusionStrategy> serializationStrategies =
-        new LinkedList<ExclusionStrategy>(exclusionStrategies);
-    List<ExclusionStrategy> deserializationStrategies =
-        new LinkedList<ExclusionStrategy>(exclusionStrategies);
-
-    serializationStrategies.add(modifierBasedExclusionStrategy);
-    deserializationStrategies.add(modifierBasedExclusionStrategy);
-
-    if (!serializeInnerClasses) {
-      serializationStrategies.add(innerClassExclusionStrategy);
-      deserializationStrategies.add(innerClassExclusionStrategy);
-    }
-    if (ignoreVersionsAfter != VersionConstants.IGNORE_VERSIONS) {
-      serializationStrategies.add(new VersionExclusionStrategy(ignoreVersionsAfter));
-      deserializationStrategies.add(new VersionExclusionStrategy(ignoreVersionsAfter));
-    }
-    if (excludeFieldsWithoutExposeAnnotation) {
-      serializationStrategies.add(exposeAnnotationSerializationExclusionStrategy);
-      deserializationStrategies.add(exposeAnnotationDeserializationExclusionStrategy);
-    }
-    ExclusionStrategy serializationExclusionStrategy =
-      new DisjunctionExclusionStrategy(serializationStrategies);
-    ExclusionStrategy deserializationExclusionStrategy =
-      new DisjunctionExclusionStrategy(deserializationStrategies);
-
-    ParameterizedTypeHandlerMap<JsonSerializer<?>> customSerializers = serializers.copyOf();
-    ParameterizedTypeHandlerMap<JsonDeserializer<?>> customDeserializers = deserializers.copyOf();
-    addTypeAdaptersForDate(datePattern, dateStyle, timeStyle, customSerializers,
-        customDeserializers);
-
-    customSerializers.registerIfAbsent(DefaultTypeAdapters.getDefaultSerializers(
-        serializeSpecialFloatingPointValues, longSerializationPolicy));
-
-    customDeserializers.registerIfAbsent(DefaultTypeAdapters.getDefaultDeserializers());
-
-    ParameterizedTypeHandlerMap<InstanceCreator<?>> customInstanceCreators =
-        instanceCreators.copyOf();
-    customInstanceCreators.registerIfAbsent(DefaultTypeAdapters.getDefaultInstanceCreators());
-
-    customSerializers.makeUnmodifiable();
-    customDeserializers.makeUnmodifiable();
-    instanceCreators.makeUnmodifiable();
-
-    MappedObjectConstructor objConstructor = new MappedObjectConstructor(customInstanceCreators);
-
-    Gson gson = new Gson(serializationExclusionStrategy, deserializationExclusionStrategy,
-        fieldNamingPolicy, objConstructor, serializeNulls, customSerializers,
-        customDeserializers, generateNonExecutableJson, escapeHtmlChars, prettyPrinting);
-    return gson;
-  }
-
-  private static void addTypeAdaptersForDate(String datePattern, int dateStyle, int timeStyle,
-      ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers,
-      ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers) {
-    DefaultDateTypeAdapter dateTypeAdapter = null;
-    if (datePattern != null && !"".equals(datePattern.trim())) {
-      dateTypeAdapter = new DefaultDateTypeAdapter(datePattern);
-    } else if (dateStyle != DateFormat.DEFAULT && timeStyle != DateFormat.DEFAULT) {
-      dateTypeAdapter = new DefaultDateTypeAdapter(dateStyle, timeStyle);
-    }
-
-    if (dateTypeAdapter != null) {
-      if (!serializers.hasSpecificHandlerFor(Date.class)) {
-        serializers.register(Date.class, dateTypeAdapter);
-      }
-      if (!deserializers.hasSpecificHandlerFor(Date.class)) {
-        deserializers.register(Date.class, dateTypeAdapter);
-      }
-    }
-  }
-}

src/org/mcteam/ancientgates/gson/InnerClassExclusionStrategy.java

@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Modifier;
-
-/**
- * Strategy for excluding inner classes.
- *
- * @author Joel Leitch
- */
-class InnerClassExclusionStrategy implements ExclusionStrategy {
-
-  public boolean shouldSkipField(FieldAttributes f) {
-    return isInnerClass(f.getDeclaredClass());
-  }
-
-  public boolean shouldSkipClass(Class<?> clazz) {
-    return isInnerClass(clazz);
-  }
-
-  private boolean isInnerClass(Class<?> clazz) {
-    return clazz.isMemberClass() && !isStatic(clazz);
-  }
-
-  private boolean isStatic(Class<?> clazz) {
-    return (clazz.getModifiers() & Modifier.STATIC) != 0;
-  }
-}

src/org/mcteam/ancientgates/gson/InstanceCreator.java

@@ -1,92 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * This interface is implemented to create instances of a class that does not define a no-args
- * constructor. If you can modify the class, you should instead add a private, or public
- * no-args constructor. However, that is not possible for library classes, such as JDK classes, or
- * a third-party library that you do not have source-code of. In such cases, you should define an
- * instance creator for the class. Implementations of this interface should be registered with
- * {@link GsonBuilder#registerTypeAdapter(Type, Object)} method before Gson will be able to use
- * them.
- * <p>Let us look at an example where defining an InstanceCreator might be useful. The
- * {@code Id} class defined below does not have a default no-args constructor.</p>
- *
- * <pre>
- * public class Id&lt;T&gt; {
- *   private final Class&lt;T&gt; clazz;
- *   private final long value;
- *   public Id(Class&lt;T&gt; clazz, long value) {
- *     this.clazz = clazz;
- *     this.value = value;
- *   }
- * }
- * </pre>
- *
- * <p>If Gson encounters an object of type {@code Id} during deserialization, it will throw an
- * exception. The easiest way to solve this problem will be to add a (public or private) no-args
- * constructor as follows:</p>
- *
- * <pre>
- * private Id() {
- *   this(Object.class, 0L);
- * }
- * </pre>
- *
- * <p>However, let us assume that the developer does not have access to the source-code of the
- * {@code Id} class, or does not want to define a no-args constructor for it. The developer
- * can solve this problem by defining an {@code InstanceCreator} for {@code Id}:</p>
- *
- * <pre>
- * class IdInstanceCreator implements InstanceCreator&lt;Id&gt; {
- *   public Id createInstance(Type type) {
- *     return new Id(Object.class, 0L);
- *   }
- * }
- * </pre>
- *
- * <p>Note that it does not matter what the fields of the created instance contain since Gson will
- * overwrite them with the deserialized values specified in Json. You should also ensure that a
- * <i>new</i> object is returned, not a common object since its fields will be overwritten.
- * The developer will need to register {@code IdInstanceCreator} with Gson as follows:</p>
- *
- * <pre>
- * Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdInstanceCreator()).create();
- * </pre>
- *
- * @param <T> the type of object that will be created by this implementation.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public interface InstanceCreator<T> {
-
-  /**
-   * Gson invokes this call-back method during deserialization to create an instance of the
-   * specified type. The fields of the returned instance are overwritten with the data present
-   * in the Json. Since the prior contents of the object are destroyed and overwritten, do not
-   * return an instance that is useful elsewhere. In particular, do not return a common instance,
-   * always use {@code new} to create a new instance.
-   *
-   * @param type the parameterized T represented as a {@link Type}.
-   * @return a default object instance of type T.
-   */
-  public T createInstance(Type type);
-}

src/org/mcteam/ancientgates/gson/JavaFieldNamingPolicy.java

@@ -1,51 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-import java.util.Collection;
-
-/**
- * A simple implementation of the {@link FieldNamingStrategy2} interface such that it does not
- * perform any string translation of the incoming field name.
- *
- * <p>The following is an example:</p>
- *
- * <pre>
- * class IntWrapper {
- *   public int integerField = 0;
- * }
- *
- * JavaFieldNamingPolicy policy = new JavaFieldNamingPolicy();
- * String translatedFieldName =
- *     policy.translateName(IntWrapper.class.getField("integerField"));
- *
- * assert("integerField".equals(translatedFieldName));
- * </pre>
- *
- * <p>This is the default {@link FieldNamingStrategy2} used by Gson.</p>
- *
- * @author Joel Leitch
- */
-final class JavaFieldNamingPolicy extends RecursiveFieldNamingPolicy {
-
-  @Override
-  protected String translateName(String target, Type fieldType, Collection<Annotation> annotations) {
-    return target;
-  }
-}

src/org/mcteam/ancientgates/gson/JsonArray.java

@@ -1,312 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Iterator;
-import java.util.List;
-
-/**
- * A class representing an array type in Json. An array is a list of {@link JsonElement}s each of
- * which can be of a different type. This is an ordered list, meaning that the order in which
- * elements are added is preserved.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public final class JsonArray extends JsonElement implements Iterable<JsonElement> {
-  private final List<JsonElement> elements;
-
-  /**
-   * Creates an empty JsonArray.
-   */
-  public JsonArray() {
-    elements = new ArrayList<JsonElement>();
-  }
-
-  /**
-   * Adds the specified element to self.
-   *
-   * @param element the element that needs to be added to the array.
-   */
-  public void add(JsonElement element) {
-    if (element == null) {
-      element = JsonNull.createJsonNull();
-    }
-    elements.add(element);
-  }
-
-  /**
-   * Adds all the elements of the specified array to self.
-   *
-   * @param array the array whose elements need to be added to the array.
-   */
-  public void addAll(JsonArray array) {
-    elements.addAll(array.elements);
-  }
-
-  /**
-   * Reverses the elements of the array.
-   */
-  void reverse() {
-    Collections.reverse(elements);
-  }
-
-  /**
-   * Returns the number of elements in the array.
-   *
-   * @return the number of elements in the array.
-   */
-  public int size() {
-    return elements.size();
-  }
-
-  /**
-   * Returns an iterator to navigate the elemetns of the array. Since the array is an ordered list,
-   * the iterator navigates the elements in the order they were inserted.
-   *
-   * @return an iterator to navigate the elements of the array.
-   */
-  public Iterator<JsonElement> iterator() {
-    return elements.iterator();
-  }
-
-  /**
-   * Returns the ith element of the array.
-   *
-   * @param i the index of the element that is being sought.
-   * @return the element present at the ith index.
-   * @throws IndexOutOfBoundsException if i is negative or greater than or equal to the
-   * {@link #size()} of the array.
-   */
-  public JsonElement get(int i) {
-    return elements.get(i);
-  }
-
-  /**
-   * convenience method to get this array as a {@link Number} if it contains a single element.
-   *
-   * @return get this element as a number if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid Number.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public Number getAsNumber() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsNumber();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a {@link String} if it contains a single element.
-   *
-   * @return get this element as a String if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid String.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public String getAsString() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsString();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a double if it contains a single element.
-   *
-   * @return get this element as a double if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid double.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public double getAsDouble() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsDouble();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a {@link BigDecimal} if it contains a single element.
-   *
-   * @return get this element as a {@link BigDecimal} if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive}.
-   * @throws NumberFormatException if the element at index 0 is not a valid {@link BigDecimal}.
-   * @throws IllegalStateException if the array has more than one element.
-   * @since 1.2
-   */
-  @Override
-  public BigDecimal getAsBigDecimal() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsBigDecimal();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a {@link BigInteger} if it contains a single element.
-   *
-   * @return get this element as a {@link BigInteger} if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive}.
-   * @throws NumberFormatException if the element at index 0 is not a valid {@link BigInteger}.
-   * @throws IllegalStateException if the array has more than one element.
-   * @since 1.2
-   */
-  @Override
-  public BigInteger getAsBigInteger() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsBigInteger();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a float if it contains a single element.
-   *
-   * @return get this element as a float if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid float.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public float getAsFloat() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsFloat();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a long if it contains a single element.
-   *
-   * @return get this element as a long if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid long.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public long getAsLong() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsLong();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as an integer if it contains a single element.
-   *
-   * @return get this element as an integer if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid integer.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public int getAsInt() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsInt();
-    }
-    throw new IllegalStateException();
-  }
-
-  @Override
-  public byte getAsByte() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsByte();
-    }
-    throw new IllegalStateException();
-  }
-
-  @Override
-  public char getAsCharacter() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsCharacter();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a primitive short if it contains a single element.
-   *
-   * @return get this element as a primitive short if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid short.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public short getAsShort() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsShort();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as a boolean if it contains a single element.
-   *
-   * @return get this element as a boolean if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid boolean.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  public boolean getAsBoolean() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsBoolean();
-    }
-    throw new IllegalStateException();
-  }
-
-  /**
-   * convenience method to get this array as an Object if it contains a single element.
-   *
-   * @return get this element as an Object if it is single element array.
-   * @throws ClassCastException if the element in the array is of not a {@link JsonPrimitive} and
-   * is not a valid Object.
-   * @throws IllegalStateException if the array has more than one element.
-   */
-  @Override
-  Object getAsObject() {
-    if (elements.size() == 1) {
-      return elements.get(0).getAsObject();
-    }
-    throw new IllegalStateException();
-  }
-
-  @Override
-  protected void toString(Appendable sb, Escaper escaper) throws IOException {
-    sb.append('[');
-    boolean first = true;
-    for (JsonElement element : elements) {
-      if (first) {
-        first = false;
-      } else {
-        sb.append(',');
-      }
-      element.toString(sb, escaper);
-    }
-    sb.append(']');
-  }
-}

src/org/mcteam/ancientgates/gson/JsonArrayDeserializationVisitor.java

@@ -1,112 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Array;
-import java.lang.reflect.Type;
-
-/**
- * A visitor that populates fields of an object with data from its equivalent
- * JSON representation
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class JsonArrayDeserializationVisitor<T> extends JsonDeserializationVisitor<T> {
-
-  JsonArrayDeserializationVisitor(JsonArray jsonArray, Type arrayType,
-      ObjectNavigatorFactory factory, ObjectConstructor objectConstructor,
-      ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers,
-      JsonDeserializationContext context) {
-    super(jsonArray, arrayType, factory, objectConstructor, deserializers, context);
-  }
-
-  @Override
-  @SuppressWarnings("unchecked")
-  protected T constructTarget() {
-
-    TypeInfo typeInfo = new TypeInfo(targetType);
-
-    if (!json.isJsonArray()) {
-      throw new JsonParseException("Expecting array found: " + json); 
-    }
-    JsonArray jsonArray = json.getAsJsonArray();
-    if (typeInfo.isArray()) {
-      TypeInfoArray arrayTypeInfo = TypeInfoFactory.getTypeInfoForArray(targetType);
-      // We know that we are getting back an array of the required type, so
-      // this typecasting is safe.
-      return (T) objectConstructor.constructArray(arrayTypeInfo.getSecondLevelType(),
-          jsonArray.size());
-    }
-    // is a collection
-    return (T) objectConstructor.construct(typeInfo.getRawClass());
-  }
-
-  public void visitArray(Object array, Type arrayType) {
-    if (!json.isJsonArray()) {
-      throw new JsonParseException("Expecting array found: " + json); 
-    }
-    JsonArray jsonArray = json.getAsJsonArray();
-    TypeInfoArray arrayTypeInfo = TypeInfoFactory.getTypeInfoForArray(arrayType);
-    for (int i = 0; i < jsonArray.size(); i++) {
-      JsonElement jsonChild = jsonArray.get(i);
-      Object child;
-
-      if (jsonChild == null || jsonChild.isJsonNull()) {
-        child = null;
-      } else if (jsonChild instanceof JsonObject) {
-        child = visitChildAsObject(arrayTypeInfo.getComponentRawType(), jsonChild);
-      } else if (jsonChild instanceof JsonArray) {
-        child = visitChildAsArray(arrayTypeInfo.getSecondLevelType(), jsonChild.getAsJsonArray());
-      } else if (jsonChild instanceof JsonPrimitive) {
-        child = visitChildAsObject(arrayTypeInfo.getComponentRawType(),
-            jsonChild.getAsJsonPrimitive());
-      } else {
-        throw new IllegalStateException();
-      }
-      Array.set(array, i, child);
-    }
-  }
-
-  // We should not implement any other method from Visitor interface since
-  // all other methods should be invoked on JsonObjectDeserializationVisitor
-  // instead.
-
-  public void startVisitingObject(Object node) {
-    throw new JsonParseException("Expecting array but found object: " + node);
-  }
-
-  public void visitArrayField(FieldAttributes f, Type typeOfF, Object obj) {
-    throw new JsonParseException("Expecting array but found array field " + f.getName() + ": "
-        + obj);
-  }
-
-  public void visitObjectField(FieldAttributes f, Type typeOfF, Object obj) {
-    throw new JsonParseException("Expecting array but found object field " + f.getName() + ": " 
-        + obj);
-  }
-
-  public boolean visitFieldUsingCustomHandler(FieldAttributes f, Type actualTypeOfField, Object parent) {
-    throw new JsonParseException("Expecting array but found field " + f.getName() + ": " 
-        + parent);
-  }
-
-  public void visitPrimitive(Object primitive) {
-    throw new JsonParseException(
-        "Type information is unavailable, and the target is not a primitive: " + json);
-  }
-}

src/org/mcteam/ancientgates/gson/JsonDeserializationContext.java

@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * Context for deserialization that is passed to a custom deserializer during invocation of its 
- * {@link JsonDeserializer#deserialize(JsonElement, Type, JsonDeserializationContext)}
- * method. 
- * 
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public interface JsonDeserializationContext {
-  
-  /**
-   * Invokes default deserialization on the specified object. It should never be invoked on 
-   * the element received as a parameter of the 
-   * {@link JsonDeserializer#deserialize(JsonElement, Type, JsonDeserializationContext)} method. Doing
-   * so will result in an infinite loop since Gson will in-turn call the custom deserializer again. 
-
-   * @param json the parse tree.
-   * @param typeOfT type of the expected return value.
-   * @param <T> The type of the deserialized object.
-   * @return An object of type typeOfT.
-   * @throws JsonParseException if the parse tree does not contain expected data.
-   */
-  public <T> T deserialize(JsonElement json, Type typeOfT) throws JsonParseException;
-}

src/org/mcteam/ancientgates/gson/JsonDeserializationContextDefault.java

@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * implementation of a deserialization context for Gson
- *
- * @author Inderjeet Singh
- */
-final class JsonDeserializationContextDefault implements JsonDeserializationContext {
-
-  private final ObjectNavigatorFactory navigatorFactory;
-  private final ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers;
-  private final MappedObjectConstructor objectConstructor;
-
-  JsonDeserializationContextDefault(ObjectNavigatorFactory navigatorFactory,
-      ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers,
-      MappedObjectConstructor objectConstructor) {
-    this.navigatorFactory = navigatorFactory;
-    this.deserializers = deserializers;
-    this.objectConstructor = objectConstructor;
-  }
-
-  ObjectConstructor getObjectConstructor() {
-    return objectConstructor;
-  }
-
-  @SuppressWarnings("unchecked")
-  public <T> T deserialize(JsonElement json, Type typeOfT) throws JsonParseException {
-    if (json == null || json.isJsonNull()) {
-      return null;
-    } else if (json.isJsonArray()) {
-      return (T) fromJsonArray(typeOfT, json.getAsJsonArray(), this);
-    } else if (json.isJsonObject()) {
-      return (T) fromJsonObject(typeOfT, json.getAsJsonObject(), this);
-    } else if (json.isJsonPrimitive()) {
-      return (T) fromJsonPrimitive(typeOfT, json.getAsJsonPrimitive(), this);
-    } else {
-      throw new JsonParseException("Failed parsing JSON source: " + json + " to Json");
-    }
-  }
-
-  private <T> T fromJsonArray(Type arrayType, JsonArray jsonArray,
-      JsonDeserializationContext context) throws JsonParseException {
-    JsonArrayDeserializationVisitor<T> visitor = new JsonArrayDeserializationVisitor<T>(
-        jsonArray, arrayType, navigatorFactory, objectConstructor, deserializers, context);
-    ObjectNavigator on = navigatorFactory.create(new ObjectTypePair(null, arrayType, true));
-    on.accept(visitor);
-    return visitor.getTarget();
-  }
-
-  private <T> T fromJsonObject(Type typeOfT, JsonObject jsonObject,
-      JsonDeserializationContext context) throws JsonParseException {
-    JsonObjectDeserializationVisitor<T> visitor = new JsonObjectDeserializationVisitor<T>(
-        jsonObject, typeOfT, navigatorFactory, objectConstructor, deserializers, context);
-    ObjectNavigator on = navigatorFactory.create(new ObjectTypePair(null, typeOfT, true));
-    on.accept(visitor);
-    return visitor.getTarget();
-  }
-
-  @SuppressWarnings("unchecked")
-  private <T> T fromJsonPrimitive(Type typeOfT, JsonPrimitive json,
-      JsonDeserializationContext context) throws JsonParseException {
-    JsonObjectDeserializationVisitor<T> visitor = new JsonObjectDeserializationVisitor<T>(
-        json, typeOfT, navigatorFactory, objectConstructor, deserializers, context);
-    ObjectNavigator on = 
-      navigatorFactory.create(new ObjectTypePair(json.getAsObject(), typeOfT, true));
-    on.accept(visitor);
-    Object target = visitor.getTarget();
-    return (T) target;
-  }
-}

src/org/mcteam/ancientgates/gson/JsonDeserializationVisitor.java

@@ -1,112 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * Abstract data value container for the {@link ObjectNavigator.Visitor}
- * implementations.  This class exposes the {@link #getTarget()} method
- * which returns the class that was visited by this object.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-abstract class JsonDeserializationVisitor<T> implements ObjectNavigator.Visitor {
-
-  protected final ObjectNavigatorFactory factory;
-  protected final ObjectConstructor objectConstructor;
-  protected final ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers;
-  protected T target;
-  protected final JsonElement json;
-  protected final Type targetType;
-  protected final JsonDeserializationContext context;
-  protected boolean constructed;
-
-  public JsonDeserializationVisitor(JsonElement json, Type targetType,
-      ObjectNavigatorFactory factory, ObjectConstructor objectConstructor,
-      ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers,
-      JsonDeserializationContext context) {
-    Preconditions.checkNotNull(json);
-    this.targetType = targetType;
-    this.factory = factory;
-    this.objectConstructor = objectConstructor;
-    this.deserializers = deserializers;
-    this.json = json;
-    this.context = context;
-    this.constructed = false;
-  }
-
-  public T getTarget() {
-    if (!constructed) {
-      target = constructTarget();
-      constructed = true;
-    }
-    return target;
-  }
-
-  protected abstract T constructTarget();
-
-  public void start(ObjectTypePair node) {
-  }
-
-  public void end(ObjectTypePair node) {
-  }
-
-  @SuppressWarnings("unchecked")
-  public final boolean visitUsingCustomHandler(ObjectTypePair objTypePair) {
-    Pair<JsonDeserializer<?>, ObjectTypePair> pair = objTypePair.getMatchingHandler(deserializers);
-    if (pair == null) {
-      return false;
-    }    
-    Object value = invokeCustomDeserializer(json, pair);
-    target = (T) value;
-    constructed = true;
-    return true;
-  }
-
-  protected Object invokeCustomDeserializer(JsonElement element, 
-      Pair<JsonDeserializer<?>, ObjectTypePair> pair) {
-    if (element == null || element.isJsonNull()) {
-      return null;
-    }
-    Type objType = pair.second.type;
-    return (pair.first).deserialize(element, objType, context);
-  }
-
-  final Object visitChildAsObject(Type childType, JsonElement jsonChild) {
-    JsonDeserializationVisitor<?> childVisitor =
-        new JsonObjectDeserializationVisitor<Object>(jsonChild, childType,
-            factory, objectConstructor, deserializers, context);
-    return visitChild(childType, childVisitor);
-  }
-
-  final Object visitChildAsArray(Type childType, JsonArray jsonChild) {
-    JsonDeserializationVisitor<?> childVisitor =
-        new JsonArrayDeserializationVisitor<Object>(jsonChild.getAsJsonArray(), childType,
-            factory, objectConstructor, deserializers, context);
-    return visitChild(childType, childVisitor);
-  }
-
-  private Object visitChild(Type type, JsonDeserializationVisitor<?> childVisitor) {
-    ObjectNavigator on = factory.create(new ObjectTypePair(null, type, false));
-    on.accept(childVisitor);
-    // the underlying object may have changed during the construction phase
-    // This happens primarily because of custom deserializers
-    return childVisitor.getTarget();
-  }
-}

src/org/mcteam/ancientgates/gson/JsonDeserializer.java

@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * <p>Interface representing a custom deserializer for Json. You should write a custom
- * deserializer, if you are not happy with the default deserialization done by Gson. You will
- * also need to register this deserializer through
- * {@link GsonBuilder#registerTypeAdapter(Type, Object)}.</p>
- *
- * <p>Let us look at example where defining a deserializer will be useful. The {@code Id} class
- * defined below has two fields: {@code clazz} and {@code value}.</p>
- *
- * <pre>
- * public class Id&lt;T&gt; {
- *   private final Class&lt;T&gt; clazz;
- *   private final long value;
- *   public Id(Class&lt;T&gt; clazz, long value) {
- *     this.clazz = clazz;
- *     this.value = value;
- *   }
- *   public long getValue() {
- *     return value;
- *   }
- * }
- * </pre>
- *
- * <p>The default deserialization of {@code Id(com.foo.MyObject.class, 20L)} will require the
- * Json string to be <code>{"clazz":com.foo.MyObject,"value":20}</code>. Suppose, you already know
- * the type of the field that the {@code Id} will be deserialized into, and hence just want to
- * deserialize it from a Json string {@code 20}. You can achieve that by writing a custom
- * deserializer:</p>
- *
- * <pre>
- * class IdDeserializer implements JsonDeserializer&lt;Id&gt;() {
- *   public Id fromJson(JsonElement json, Type typeOfT, JsonDeserializationContext context)
- *       throws JsonParseException {
- *     return (Id) new Id((Class)typeOfT, id.getValue());
- *   }
- * </pre>
- *
- * <p>You will also need to register {@code IdDeserializer} with Gson as follows:</p>
- *
- * <pre>
- * Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdDeserializer()).create();
- * </pre>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- *
- * @param <T> type for which the deserializer is being registered. It is possible that a
- * deserializer may be asked to deserialize a specific generic type of the T.
- */
-public interface JsonDeserializer<T> {
-
-  /**
-   * Gson invokes this call-back method during deserialization when it encounters a field of the
-   * specified type.
-   * <p>In the implementation of this call-back method, you should consider invoking
-   * {@link JsonDeserializationContext#deserialize(JsonElement, Type)} method to create objects
-   * for any non-trivial field of the returned object. However, you should never invoke it on the
-   * the same type passing {@code json} since that will cause an infinite loop (Gson will call your
-   * call-back method again).
-   *
-   * @param json The Json data being deserialized
-   * @param typeOfT The type of the Object to deserialize to
-   * @return a deserialized object of the specified type typeOfT which is a subclass of {@code T}
-   * @throws JsonParseException if json is not in the expected format of {@code typeofT}
-   */
-  public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-      throws JsonParseException;
-}

src/org/mcteam/ancientgates/gson/JsonDeserializerExceptionWrapper.java

@@ -1,71 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * Decorators a {@code JsonDeserializer} instance with exception handling.  This wrapper class
- * ensures that a {@code JsonDeserializer} will not propagate any exception other than a
- * {@link JsonParseException}.
- *
- * @param <T> type of the deserializer being wrapped.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-class JsonDeserializerExceptionWrapper<T> implements JsonDeserializer<T> {
-
-  private final JsonDeserializer<T> delegate;
-
-  /**
-   * Returns a wrapped {@link JsonDeserializer} object that has been decorated with
-   * {@link JsonParseException} handling.
-   *
-   * @param delegate the {@code JsonDeserializer} instance to be wrapped.
-   * @throws IllegalArgumentException if {@code delegate} is {@code null}.
-   */
-  JsonDeserializerExceptionWrapper(JsonDeserializer<T> delegate) {
-    Preconditions.checkNotNull(delegate);
-    this.delegate = delegate;
-  }
-
-  public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
-      throws JsonParseException {
-    try {
-      return delegate.deserialize(json, typeOfT, context);
-    } catch (JsonParseException e) {
-      // just rethrow the exception
-      throw e;
-    } catch (Exception e) {
-      // rethrow as a JsonParseException
-      StringBuilder errorMsg = new StringBuilder()
-          .append("The JsonDeserializer ")
-          .append(delegate)
-          .append(" failed to deserialized json object ")
-          .append(json)
-          .append(" given the type ")
-          .append(typeOfT);
-      throw new JsonParseException(errorMsg.toString(), e);
-    }
-  }
-  
-  @Override
-  public String toString() {
-    return delegate.toString();
-  }
-}

src/org/mcteam/ancientgates/gson/JsonElement.java

@@ -1,338 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-/**
- * A class representing an element of Json. It could either be a {@link JsonObject}, a
- * {@link JsonArray}, a {@link JsonPrimitive} or a {@link JsonNull}.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public abstract class JsonElement {
-  private static final Escaper BASIC_ESCAPER = new Escaper(false);
-
-  /**
-   * provides check for verifying if this element is an array or not.
-   *
-   * @return true if this element is of type {@link JsonArray}, false otherwise.
-   */
-  public boolean isJsonArray() {
-    return this instanceof JsonArray;
-  }
-
-  /**
-   * provides check for verifying if this element is a Json object or not.
-   *
-   * @return true if this element is of type {@link JsonObject}, false otherwise.
-   */
-  public boolean isJsonObject() {
-    return this instanceof JsonObject;
-  }
-
-  /**
-   * provides check for verifying if this element is a primitive or not.
-   *
-   * @return true if this element is of type {@link JsonPrimitive}, false otherwise.
-   */
-  public boolean isJsonPrimitive() {
-    return this instanceof JsonPrimitive;
-  }
-
-  /**
-   * provides check for verifying if this element represents a null value or not.
-   *
-   * @return true if this element is of type {@link JsonNull}, false otherwise.
-   * @since 1.2
-   */
-  public boolean isJsonNull() {
-    return this instanceof JsonNull;
-  }
-
-  /**
-   * convenience method to get this element as a {@link JsonObject}. If the element is of some
-   * other type, a {@link ClassCastException} will result. Hence it is best to use this method
-   * after ensuring that this element is of the desired type by calling {@link #isJsonObject()}
-   * first.
-   *
-   * @return get this element as a {@link JsonObject}.
-   * @throws IllegalStateException if the element is of another type.
-   */
-  public JsonObject getAsJsonObject() {
-    if (isJsonObject()) {
-      return (JsonObject) this;
-    }
-    throw new IllegalStateException("This is not a JSON Object.");
-  }
-
-  /**
-   * convenience method to get this element as a {@link JsonArray}. If the element is of some
-   * other type, a {@link ClassCastException} will result. Hence it is best to use this method
-   * after ensuring that this element is of the desired type by calling {@link #isJsonArray()}
-   * first.
-   *
-   * @return get this element as a {@link JsonArray}.
-   * @throws IllegalStateException if the element is of another type.
-   */
-  public JsonArray getAsJsonArray() {
-    if (isJsonArray()) {
-      return (JsonArray) this;
-    }
-    throw new IllegalStateException("This is not a JSON Array.");
-  }
-
-  /**
-   * convenience method to get this element as a {@link JsonPrimitive}. If the element is of some
-   * other type, a {@link ClassCastException} will result. Hence it is best to use this method
-   * after ensuring that this element is of the desired type by calling {@link #isJsonPrimitive()}
-   * first.
-   *
-   * @return get this element as a {@link JsonPrimitive}.
-   * @throws IllegalStateException if the element is of another type.
-   */
-  public JsonPrimitive getAsJsonPrimitive() {
-    if (isJsonPrimitive()) {
-      return (JsonPrimitive) this;
-    }
-    throw new IllegalStateException("This is not a JSON Primitive.");
-  }
-
-  /**
-   * convenience method to get this element as a {@link JsonNull}. If the element is of some
-   * other type, a {@link ClassCastException} will result. Hence it is best to use this method
-   * after ensuring that this element is of the desired type by calling {@link #isJsonNull()}
-   * first.
-   *
-   * @return get this element as a {@link JsonNull}.
-   * @throws IllegalStateException if the element is of another type.
-   * @since 1.2
-   */
-  public JsonNull getAsJsonNull() {
-    if (isJsonNull()) {
-      return (JsonNull) this;
-    }
-    throw new IllegalStateException("This is not a JSON Null.");
-  }
-
-  /**
-   * convenience method to get this element as a boolean value.
-   *
-   * @return get this element as a primitive boolean value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * boolean value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public boolean getAsBoolean() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a {@link Boolean} value.
-   *
-   * @return get this element as a {@link Boolean} value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * boolean value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  Boolean getAsBooleanWrapper() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a {@link Number}.
-   *
-   * @return get this element as a {@link Number}.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * number.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public Number getAsNumber() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a string value.
-   *
-   * @return get this element as a string value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * string value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public String getAsString() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a primitive double value.
-   *
-   * @return get this element as a primitive double value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * double value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public double getAsDouble() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a primitive float value.
-   *
-   * @return get this element as a primitive float value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * float value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public float getAsFloat() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a primitive long value.
-   *
-   * @return get this element as a primitive long value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * long value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public long getAsLong() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a primitive integer value.
-   *
-   * @return get this element as a primitive integer value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * integer value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public int getAsInt() {
-    throw new UnsupportedOperationException();
-  }
-  
-  /**
-   * convenience method to get this element as a primitive byte value.
-   *
-   * @return get this element as a primitive byte value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * byte value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   * @since 1.3
-   */
-  public byte getAsByte() {
-    throw new UnsupportedOperationException();
-  }
-  
-  /**
-   * convenience method to get this element as a primitive character value.
-   *
-   * @return get this element as a primitive char value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * char value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   * @since 1.3
-   */
-  public char getAsCharacter() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a {@link BigDecimal}.
-   *
-   * @return get this element as a {@link BigDecimal}.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive}.
-   * * @throws NumberFormatException if the element is not a valid {@link BigDecimal}.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   * @since 1.2
-   */
-  public BigDecimal getAsBigDecimal() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a {@link BigInteger}.
-   *
-   * @return get this element as a {@link BigInteger}.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive}.
-   * @throws NumberFormatException if the element is not a valid {@link BigInteger}.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   * @since 1.2
-   */
-  public BigInteger getAsBigInteger() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as a primitive short value.
-   *
-   * @return get this element as a primitive short value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * short value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  public short getAsShort() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * convenience method to get this element as an {@link Object} value.
-   *
-   * @return get this element as an Object value.
-   * @throws ClassCastException if the element is of not a {@link JsonPrimitive} and is not a valid
-   * Object value.
-   * @throws IllegalStateException if the element is of the type {@link JsonArray} but contains
-   * more than a single element.
-   */
-  Object getAsObject() {
-    throw new UnsupportedOperationException();
-  }
-
-  /**
-   * Returns a String representation of this element.
-   *
-   * @return String the string representation of this element.
-   */
-  @Override
-  public String toString() {
-    try {
-      StringBuilder sb = new StringBuilder();
-      toString(sb, BASIC_ESCAPER);
-      return sb.toString();
-    } catch (IOException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  protected abstract void toString(Appendable sb, Escaper escaper) throws IOException;
-}

src/org/mcteam/ancientgates/gson/JsonElementVisitor.java

@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-
-/**
- * Definition of a visitor for a JsonElement tree.
- * 
- * @author Inderjeet Singh
- */
-interface JsonElementVisitor {
-  void visitPrimitive(JsonPrimitive primitive) throws IOException;
-  void visitNull() throws IOException;
-
-  void startArray(JsonArray array) throws IOException;
-  void visitArrayMember(JsonArray parent, JsonPrimitive member, boolean isFirst) throws IOException;
-  void visitArrayMember(JsonArray parent, JsonArray member, boolean isFirst) throws IOException;
-  void visitArrayMember(JsonArray parent, JsonObject member, boolean isFirst) throws IOException;
-  void visitNullArrayMember(JsonArray parent, boolean isFirst) throws IOException;
-  void endArray(JsonArray array) throws IOException;
-  
-  void startObject(JsonObject object) throws IOException;
-  void visitObjectMember(JsonObject parent, String memberName, JsonPrimitive member, 
-      boolean isFirst) throws IOException;
-  void visitObjectMember(JsonObject parent, String memberName, JsonArray member, 
-      boolean isFirst) throws IOException;
-  void visitObjectMember(JsonObject parent, String memberName, JsonObject member, 
-      boolean isFirst) throws IOException;
-  void visitNullObjectMember(JsonObject parent, String memberName, 
-      boolean isFirst) throws IOException;
-  void endObject(JsonObject object) throws IOException;
-}

src/org/mcteam/ancientgates/gson/JsonFieldNameValidator.java

@@ -1,56 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-/**
- * This class can be used to check the validity of a JSON field name.
- *
- * <p>The primary use of this object is to ensure that any Java fields that use the
- * {@link org.mcteam.ancientgates.gson.annotations.SerializedName} annotation is providing valid JSON
- * field names.  This will make the code fail-fast rather than letting the invalid
- * field name propagate to the client and it fails to parse.</p>
- *
- * @author Joel Leitch
- */
-class JsonFieldNameValidator {
-  private static final String COMMON_PATTERN = "[a-zA-Z][a-zA-Z0-9\\ \\$_\\-]*$";
-  
-  private static final Pattern JSON_FIELD_NAME_PATTERN =
-      Pattern.compile("(^" + COMMON_PATTERN + ")|(^[\\$_]" + COMMON_PATTERN + ")");
-
-  
-  /**
-   * Performs validation on the JSON field name to ensure it is a valid field name.
-   *
-   * @param fieldName the name of the field to validate
-   * @return {@code fieldName} if it is a valid JSON field name
-   * @throws IllegalArgumentException if the field name is an invalid JSON field name
-   */
-  public String validate(String fieldName) {
-    Preconditions.checkNotNull(fieldName);
-    Preconditions.checkArgument(!"".equals(fieldName.trim()));
-
-    Matcher matcher = JSON_FIELD_NAME_PATTERN.matcher(fieldName);
-    if (!matcher.matches()) {
-      throw new IllegalArgumentException(fieldName + " is not a valid JSON field name.");
-    }
-    return fieldName;
-  }
-}

src/org/mcteam/ancientgates/gson/JsonIOException.java

@@ -1,46 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.mcteam.ancientgates.gson;
-
-/**
- * This exception is raised when Gson was unable to read an input stream
- * or write to one.
- * 
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public final class JsonIOException extends JsonParseException {
-
-  private static final long serialVersionUID = 1L;
-
-  public JsonIOException(String msg) {
-    super(msg);
-  }
-
-  public JsonIOException(String msg, Throwable cause) {
-    super(msg, cause);
-  }
-
-  /**
-   * Creates exception with the specified cause. Consider using
-   * {@link #JsonIOException(String, Throwable)} instead if you can describe what happened.
-   *
-   * @param cause root exception that caused this exception to be thrown.
-   */
-  public JsonIOException(Throwable cause) {
-    super(cause);
-  }
-}

src/org/mcteam/ancientgates/gson/JsonNull.java

@@ -1,72 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-
-/**
- * A class representing a Json {@code null} value.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- * @since 1.2
- */
-public final class JsonNull extends JsonElement {
-  private static final JsonNull INSTANCE = new JsonNull();
-
-  /**
-   * Creates a new JsonNull object.
-   */
-  public JsonNull() {
-    // Do nothing
-  }
-  
-  @Override
-  protected void toString(Appendable sb, Escaper escaper) throws IOException {
-    sb.append("null");
-  }
-  
-  /**
-   * All instances of JsonNull have the same hash code since they are indistinguishable
-   */
-  @Override
-  public int hashCode() {
-    return JsonNull.class.hashCode();
-  }
-  
-  /**
-   * All instances of JsonNull are the same
-   */
-  @Override
-  public boolean equals(Object other) {
-    return other instanceof JsonNull;
-  }
-  
-  /**
-   * Creation method used to return an instance of a {@link JsonNull}.  To reduce the memory
-   * footprint, a single object has been created for this class; therefore the same instance is
-   * being returned for each invocation of this method. This method is kept private since we 
-   * prefer the users to use {@link JsonNull#JsonNull()} which is similar to how other JsonElements
-   * are created. Note that all instances of JsonNull return true for {@link #equals(Object)} 
-   * when compared to each other.
-   *
-   * @return a instance of a {@link JsonNull}
-   */
-  static JsonNull createJsonNull() {
-    return INSTANCE;
-  }
-}

src/org/mcteam/ancientgates/gson/JsonObject.java

@@ -1,208 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.Set;
-
-/**
- * A class representing an object type in Json. An object consists of name-value pairs where names
- * are strings, and values are any other type of {@link JsonElement}. This allows for a creating a
- * tree of JsonElements. The member elements of this object are maintained in order they were added.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public final class JsonObject extends JsonElement {
-  // We are using a linked hash map because it is important to preserve
-  // the order in which elements are inserted. This is needed to ensure
-  // that the fields of an object are inserted in the order they were
-  // defined in the class.
-  private final Map<String, JsonElement> members;
-
-  /**
-   * Creates an empty JsonObject.
-   */
-  public JsonObject() {
-    members = new LinkedHashMap<String, JsonElement>();
-  }
-
-  /**
-   * Adds a member, which is a name-value pair, to self. The name must be a String, but the value
-   * can be an arbitrary JsonElement, thereby allowing you to build a full tree of JsonElements
-   * rooted at this node.
-   *
-   * @param property name of the member.
-   * @param value the member object.
-   */
-  public void add(String property, JsonElement value) {
-    Preconditions.checkNotNull(property);
-    if (value == null) {
-      value = JsonNull.createJsonNull();
-    }
-    members.put(property, value);
-  }
-
-  /**
-   * Removes the {@code property} from this {@link JsonObject}.
-   *
-   * @param property name of the member that should be removed.
-   * @return the {@link JsonElement} object that is being removed.
-   * @since 1.3
-   */
-  public JsonElement remove(String property) {
-    return members.remove(property);
-  }
-
-  /**
-   * Convenience method to add a primitive member. The specified value is converted to a
-   * JsonPrimitive of String.
-   *
-   * @param property name of the member.
-   * @param value the string value associated with the member.
-   */
-  public void addProperty(String property, String value) {
-    add(property, createJsonElement(value));
-  }
-
-  /**
-   * Convenience method to add a primitive member. The specified value is converted to a
-   * JsonPrimitive of Number.
-   *
-   * @param property name of the member.
-   * @param value the number value associated with the member.
-   */
-  public void addProperty(String property, Number value) {
-    add(property, createJsonElement(value));
-  }
-
-  /**
-   * Convenience method to add a boolean member. The specified value is converted to a
-   * JsonPrimitive of Boolean.
-   *
-   * @param property name of the member.
-   * @param value the number value associated with the member.
-   */
-  public void addProperty(String property, Boolean value) {
-    add(property, createJsonElement(value));
-  }
-
-  /**
-   * Convenience method to add a char member. The specified value is converted to a
-   * JsonPrimitive of Character.
-   *
-   * @param property name of the member.
-   * @param value the number value associated with the member.
-   */
-  public void addProperty(String property, Character value) {
-    add(property, createJsonElement(value));
-  }
-
-  /**
-   * Creates the proper {@link JsonElement} object from the given {@code value} object.
-   *
-   * @param value the object to generate the {@link JsonElement} for
-   * @return a {@link JsonPrimitive} if the {@code value} is not null, otherwise a {@link JsonNull}
-   */
-  private JsonElement createJsonElement(Object value) {
-    return value == null ? JsonNull.createJsonNull() : new JsonPrimitive(value);
-  }
-
-  /**
-   * Returns a set of members of this object. The set is ordered, and the order is in which the
-   * elements were added.
-   *
-   * @return a set of members of this object.
-   */
-  public Set<Map.Entry<String, JsonElement>> entrySet() {
-    return members.entrySet();
-  }
-
-  /**
-   * Convenience method to check if a member with the specified name is present in this object.
-   *
-   * @param memberName name of the member that is being checked for presence.
-   * @return true if there is a member with the specified name, false otherwise.
-   */
-  public boolean has(String memberName) {
-    return members.containsKey(memberName);
-  }
-
-  /**
-   * Returns the member with the specified name.
-   *
-   * @param memberName name of the member that is being requested.
-   * @return the member matching the name. Null if no such member exists.
-   */
-  public JsonElement get(String memberName) {
-    if (members.containsKey(memberName)) {
-      JsonElement member = members.get(memberName);
-      return member == null ? JsonNull.createJsonNull() : member;
-    }
-    return null;
-  }
-
-  /**
-   * Convenience method to get the specified member as a JsonPrimitive element.
-   *
-   * @param memberName name of the member being requested.
-   * @return the JsonPrimitive corresponding to the specified member.
-   */
-  public JsonPrimitive getAsJsonPrimitive(String memberName) {
-    return (JsonPrimitive) members.get(memberName);
-  }
-
-  /**
-   * Convenience method to get the specified member as a JsonArray.
-   *
-   * @param memberName name of the member being requested.
-   * @return the JsonArray corresponding to the specified member.
-   */
-  public JsonArray getAsJsonArray(String memberName) {
-    return (JsonArray) members.get(memberName);
-  }
-
-  /**
-   * Convenience method to get the specified member as a JsonObject.
-   *
-   * @param memberName name of the member being requested.
-   * @return the JsonObject corresponding to the specified member.
-   */
-  public JsonObject getAsJsonObject(String memberName) {
-    return (JsonObject) members.get(memberName);
-  }
-
-  @Override
-  protected void toString(Appendable sb, Escaper escaper) throws IOException {
-    sb.append('{');
-    boolean first = true;
-    for (Map.Entry<String, JsonElement> entry : members.entrySet()) {
-      if (first) {
-        first = false;
-      } else {
-        sb.append(',');
-      }
-      sb.append('\"');
-      sb.append(escaper.escapeJsonString(entry.getKey()));
-      sb.append("\":");
-      entry.getValue().toString(sb, escaper);
-    }
-    sb.append('}');
-  }
-}

src/org/mcteam/ancientgates/gson/JsonObjectDeserializationVisitor.java

@@ -1,135 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * A visitor that populates fields of an object with data from its equivalent
- * JSON representation
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class JsonObjectDeserializationVisitor<T> extends JsonDeserializationVisitor<T> {
-
-  JsonObjectDeserializationVisitor(JsonElement json, Type type,
-      ObjectNavigatorFactory factory, ObjectConstructor objectConstructor,
-      ParameterizedTypeHandlerMap<JsonDeserializer<?>> deserializers,
-      JsonDeserializationContext context) {
-    super(json, type, factory, objectConstructor, deserializers, context);
-  }
-
-  @Override
-  @SuppressWarnings("unchecked")
-  protected T constructTarget() {
-    return (T) objectConstructor.construct(targetType);
-  }
-
-  public void startVisitingObject(Object node) {
-    // do nothing
-  }
-
-  public void visitArray(Object array, Type componentType) {
-    // should not be called since this case should invoke JsonArrayDeserializationVisitor
-    throw new JsonParseException("Expecting object but found array: " + array);
-  }
-
-  public void visitObjectField(FieldAttributes f, Type typeOfF, Object obj) {
-    try {
-      if (!json.isJsonObject()) {
-        throw new JsonParseException("Expecting object found: " + json); 
-      }
-      JsonObject jsonObject = json.getAsJsonObject();
-      String fName = getFieldName(f);
-      JsonElement jsonChild = jsonObject.get(fName);
-      if (jsonChild != null) {
-        Object child = visitChildAsObject(typeOfF, jsonChild);
-        f.set(obj, child);
-      } else {
-        f.set(obj, null);
-      }
-    } catch (IllegalAccessException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  public void visitArrayField(FieldAttributes f, Type typeOfF, Object obj) {
-    try {
-      if (!json.isJsonObject()) {
-        throw new JsonParseException("Expecting object found: " + json); 
-      }
-      JsonObject jsonObject = json.getAsJsonObject();
-      String fName = getFieldName(f);
-      JsonArray jsonChild = (JsonArray) jsonObject.get(fName);
-      if (jsonChild != null) {
-        Object array = visitChildAsArray(typeOfF, jsonChild);
-        f.set(obj, array);
-      } else {
-        f.set(obj, null);
-      }
-    } catch (IllegalAccessException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  private String getFieldName(FieldAttributes f) {
-    FieldNamingStrategy2 namingPolicy = factory.getFieldNamingPolicy();
-    return namingPolicy.translateName(f);
-  }
-
-  public boolean visitFieldUsingCustomHandler(FieldAttributes f, Type declaredTypeOfField, Object parent) {
-    try {
-      String fName = getFieldName(f);
-      if (!json.isJsonObject()) {
-        throw new JsonParseException("Expecting object found: " + json); 
-      }
-      JsonElement child = json.getAsJsonObject().get(fName);
-      TypeInfo typeInfo = new TypeInfo(declaredTypeOfField);
-      if (child == null) { // Child will be null if the field wasn't present in Json
-        return true;
-      } else if (child.isJsonNull()) {
-        if (!typeInfo.isPrimitive()) {
-          f.set(parent, null);
-        }
-        return true;
-      }
-      ObjectTypePair objTypePair = new ObjectTypePair(null, declaredTypeOfField, false);
-      Pair<JsonDeserializer<?>, ObjectTypePair> pair = objTypePair.getMatchingHandler(deserializers);
-      if (pair == null) {
-        return false;
-      }      
-      Object value = invokeCustomDeserializer(child, pair);
-      if (value != null || !typeInfo.isPrimitive()) {
-        f.set(parent, value);
-      }
-      return true;
-    } catch (IllegalAccessException e) {
-      throw new RuntimeException();
-    }
-  }
-
-  @SuppressWarnings("unchecked")
-  public void visitPrimitive(Object primitive) {
-    if (!json.isJsonPrimitive()) {
-      throw new JsonParseException(
-          "Type information is unavailable, and the target object is not a primitive: " + json);
-    }
-    JsonPrimitive prim = json.getAsJsonPrimitive();
-    target = (T) prim.getAsObject();
-  }
-}

src/org/mcteam/ancientgates/gson/JsonParseException.java

@@ -1,64 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * This exception is raised if there is a serious issue that occurs during parsing of a Json
- * string.  One of the main usages for this class is for the Gson infrastructure.  If the incoming
- * Json is bad/malicious, an instance of this exception is raised.
- *
- * <p>This exception is a {@link RuntimeException} because it is exposed to the client.  Using a
- * {@link RuntimeException} avoids bad coding practices on the client side where they catch the
- * exception and do nothing.  It is often the case that you want to blow up if there is a parsing
- * error (i.e. often clients do not know how to recover from a {@link JsonParseException}.</p>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public class JsonParseException extends RuntimeException {
-  static final long serialVersionUID = -4086729973971783390L;
-
-  /**
-   * Creates exception with the specified message. If you are wrapping another exception, consider
-   * using {@link #JsonParseException(String, Throwable)} instead.
-   *
-   * @param msg error message describing a possible cause of this exception.
-   */
-  public JsonParseException(String msg) {
-    super(msg);
-  }
-
-  /**
-   * Creates exception with the specified message and cause.
-   *
-   * @param msg error message describing what happened.
-   * @param cause root exception that caused this exception to be thrown.
-   */
-  public JsonParseException(String msg, Throwable cause) {
-    super(msg, cause);
-  }
-
-  /**
-   * Creates exception with the specified cause. Consider using
-   * {@link #JsonParseException(String, Throwable)} instead if you can describe what happened.
-   *
-   * @param cause root exception that caused this exception to be thrown.
-   */
-  public JsonParseException(Throwable cause) {
-    super(cause);
-  }
-}

src/org/mcteam/ancientgates/gson/JsonParser.java

@@ -1,98 +0,0 @@
-/*
- * Copyright (C) 2009 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.mcteam.ancientgates.gson;
-
-import java.io.EOFException;
-import java.io.IOException;
-import java.io.Reader;
-import java.io.StringReader;
-
-import org.mcteam.ancientgates.gson.stream.JsonReader;
-import org.mcteam.ancientgates.gson.stream.JsonToken;
-import org.mcteam.ancientgates.gson.stream.MalformedJsonException;
-
-/**
- * A parser to parse Json into a parse tree of {@link JsonElement}s
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- * @since 1.3
- */
-public final class JsonParser {
-
-  /**
-   * Parses the specified JSON string into a parse tree
-   *
-   * @param json JSON text
-   * @return a parse tree of {@link JsonElement}s corresponding to the specified JSON
-   * @throws JsonParseException if the specified text is not valid JSON
-   * @since 1.3
-   */
-  public JsonElement parse(String json) throws JsonSyntaxException {
-    return parse(new StringReader(json));
-  }
-
-  /**
-   * Parses the specified JSON string into a parse tree
-   *
-   * @param json JSON text
-   * @return a parse tree of {@link JsonElement}s corresponding to the specified JSON
-   * @throws JsonParseException if the specified text is not valid JSON
-   * @since 1.3
-   */
-  public JsonElement parse(Reader json) throws JsonIOException, JsonSyntaxException {
-    try {
-      JsonReader jsonReader = new JsonReader(json);
-      JsonElement element = parse(jsonReader);
-      if (!element.isJsonNull() && jsonReader.peek() != JsonToken.END_DOCUMENT) {
-        throw new JsonSyntaxException("Did not consume the entire document.");
-      }
-      return element;
-    } catch (MalformedJsonException e) {
-      throw new JsonSyntaxException(e);
-    } catch (IOException e) {
-      throw new JsonIOException(e);
-    } catch (NumberFormatException e) {
-      throw new JsonSyntaxException(e);
-    }
-  }
-
-  /**
-   * Returns the next value from the JSON stream as a parse tree.
-   *
-   * @throws JsonParseException if there is an IOException or if the specified
-   *     text is not valid JSON
-   * @since 1.6
-   */
-  public JsonElement parse(JsonReader json) throws JsonIOException, JsonSyntaxException {
-    boolean lenient = json.isLenient();
-    json.setLenient(true);
-    try {
-      return Streams.parse(json);
-    } catch (StackOverflowError e) {
-      throw new JsonParseException("Failed parsing JSON source: " + json + " to Json", e);
-    } catch (OutOfMemoryError e) {
-      throw new JsonParseException("Failed parsing JSON source: " + json + " to Json", e);
-    } catch (JsonParseException e) {
-      if (e.getCause() instanceof EOFException) {
-        return JsonNull.createJsonNull();
-      }
-      throw e;
-    } finally {
-      json.setLenient(lenient);
-    }
-  }
-}

src/org/mcteam/ancientgates/gson/JsonPrimitive.java

@@ -1,387 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-/**
- * A class representing a Json primitive value. A primitive value
- * is either a String, a Java primitive, or a Java primitive
- * wrapper type.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public final class JsonPrimitive extends JsonElement {
-  private static final Class<?>[] PRIMITIVE_TYPES = { int.class, long.class, short.class,
-      float.class, double.class, byte.class, boolean.class, char.class, Integer.class, Long.class,
-      Short.class, Float.class, Double.class, Byte.class, Boolean.class, Character.class };
-
-  private static final BigInteger INTEGER_MAX = BigInteger.valueOf(Integer.MAX_VALUE);
-  private static final BigInteger LONG_MAX = BigInteger.valueOf(Long.MAX_VALUE);
-
-  private Object value;
-
-  /**
-   * Create a primitive containing a boolean value.
-   *
-   * @param bool the value to create the primitive with.
-   */
-  public JsonPrimitive(Boolean bool) {
-    setValue(bool);
-  }
-
-  /**
-   * Create a primitive containing a {@link Number}.
-   *
-   * @param number the value to create the primitive with.
-   */
-  public JsonPrimitive(Number number) {
-    setValue(number);
-  }
-
-  /**
-   * Create a primitive containing a String value.
-   *
-   * @param string the value to create the primitive with.
-   */
-  public JsonPrimitive(String string) {
-    setValue(string);
-  }
-
-  /**
-   * Create a primitive containing a character. The character is turned into a one character String
-   * since Json only supports String.
-   *
-   * @param c the value to create the primitive with.
-   */
-  public JsonPrimitive(Character c) {
-    setValue(c);
-  }
-
-  /**
-   * Create a primitive using the specified Object. It must be an instance of {@link Number}, a
-   * Java primitive type, or a String.
-   *
-   * @param primitive the value to create the primitive with.
-   */
-  JsonPrimitive(Object primitive) {
-    setValue(primitive);
-  }
-
-  void setValue(Object primitive) {
-    if (primitive instanceof Character) {
-      // convert characters to strings since in JSON, characters are represented as a single
-      // character string
-      char c = ((Character) primitive).charValue();
-      this.value = String.valueOf(c);
-    } else {
-      Preconditions.checkArgument(primitive instanceof Number
-          || isPrimitiveOrString(primitive));
-      this.value = primitive;
-    }
-  }
-
-  /**
-   * Check whether this primitive contains a boolean value.
-   *
-   * @return true if this primitive contains a boolean value, false otherwise.
-   */
-  public boolean isBoolean() {
-    return value instanceof Boolean;
-  }
-
-  /**
-   * convenience method to get this element as a {@link Boolean}.
-   *
-   * @return get this element as a {@link Boolean}.
-   * @throws ClassCastException if the value contained is not a valid boolean value.
-   */
-  @Override
-  Boolean getAsBooleanWrapper() {
-    return (Boolean) value;
-  }
-
-  /**
-   * convenience method to get this element as a boolean value.
-   *
-   * @return get this element as a primitive boolean value.
-   * @throws ClassCastException if the value contained is not a valid boolean value.
-   */
-  @Override
-  public boolean getAsBoolean() {
-    return isBoolean() ? getAsBooleanWrapper().booleanValue() : Boolean.parseBoolean(getAsString());
-  }
-
-  /**
-   * Check whether this primitive contains a Number.
-   *
-   * @return true if this primitive contains a Number, false otherwise.
-   */
-  public boolean isNumber() {
-    return value instanceof Number;
-  }
-
-  /**
-   * convenience method to get this element as a Number.
-   *
-   * @return get this element as a Number.
-   * @throws ClassCastException if the value contained is not a valid Number.
-   */
-  @Override
-  public Number getAsNumber() {
-    return value instanceof String ? stringToNumber((String) value) : (Number) value;
-  }
-
-  static Number stringToNumber(String value) {
-    try {
-      long longValue = Long.parseLong(value);
-      if (longValue >= Integer.MIN_VALUE && longValue <= Integer.MAX_VALUE) {
-        return (int) longValue;
-      }
-      return longValue;
-    } catch (NumberFormatException ignored) {
-    }
-
-    try {
-      return new BigDecimal(value);
-    } catch (NumberFormatException ignored) {
-      return Double.parseDouble(value); // probably NaN, -Infinity or Infinity
-    }
-  }
-
-  /**
-   * Check whether this primitive contains a String value.
-   *
-   * @return true if this primitive contains a String value, false otherwise.
-   */
-  public boolean isString() {
-    return value instanceof String;
-  }
-
-  /**
-   * convenience method to get this element as a String.
-   *
-   * @return get this element as a String.
-   * @throws ClassCastException if the value contained is not a valid String.
-   */
-  @Override
-  public String getAsString() {
-    if (isNumber()) {
-      return getAsNumber().toString();
-    } else if (isBoolean()) {
-      return getAsBooleanWrapper().toString();
-    } else {
-      return (String) value;
-    }
-  }
-
-  /**
-   * convenience method to get this element as a primitive double.
-   *
-   * @return get this element as a primitive double.
-   * @throws ClassCastException if the value contained is not a valid double.
-   */
-  @Override
-  public double getAsDouble() {
-    return isNumber() ? getAsNumber().doubleValue() : Double.parseDouble(getAsString());
-  }
-
-  /**
-   * convenience method to get this element as a {@link BigDecimal}.
-   *
-   * @return get this element as a {@link BigDecimal}.
-   * @throws NumberFormatException if the value contained is not a valid {@link BigDecimal}.
-   */
-  @Override
-  public BigDecimal getAsBigDecimal() {
-    return value instanceof BigDecimal ? (BigDecimal) value : new BigDecimal(value.toString());
-  }
-
-  /**
-   * convenience method to get this element as a {@link BigInteger}.
-   *
-   * @return get this element as a {@link BigInteger}.
-   * @throws NumberFormatException if the value contained is not a valid {@link BigInteger}.
-   */
-  @Override
-  public BigInteger getAsBigInteger() {
-    return value instanceof BigInteger ? (BigInteger) value : new BigInteger(value.toString());
-  }
-
-  /**
-   * convenience method to get this element as a float.
-   *
-   * @return get this element as a float.
-   * @throws ClassCastException if the value contained is not a valid float.
-   */
-  @Override
-  public float getAsFloat() {
-    return isNumber() ? getAsNumber().floatValue() : Float.parseFloat(getAsString());
-  }
-
-  /**
-   * convenience method to get this element as a primitive long.
-   *
-   * @return get this element as a primitive long.
-   * @throws ClassCastException if the value contained is not a valid long.
-   */
-  @Override
-  public long getAsLong() {
-    return isNumber() ? getAsNumber().longValue() : Long.parseLong(getAsString());
-  }
-
-  /**
-   * convenience method to get this element as a primitive short.
-   *
-   * @return get this element as a primitive short.
-   * @throws ClassCastException if the value contained is not a valid short value.
-   */
-  @Override
-  public short getAsShort() {
-    return isNumber() ? getAsNumber().shortValue() : Short.parseShort(getAsString());
-  }
-
- /**
-  * convenience method to get this element as a primitive integer.
-  *
-  * @return get this element as a primitive integer.
-  * @throws ClassCastException if the value contained is not a valid integer.
-  */
-  @Override
-  public int getAsInt() {
-    return isNumber() ? getAsNumber().intValue() : Integer.parseInt(getAsString());
-  }
-
-  @Override
-  public byte getAsByte() {
-    return isNumber() ? getAsNumber().byteValue() : Byte.parseByte(getAsString());
-  }
-
-  @Override
-  public char getAsCharacter() {
-    return getAsString().charAt(0);
-  }
-
-  /**
-   * convenience method to get this element as an Object.
-   *
-   * @return get this element as an Object that can be converted to a suitable value.
-   */
-  @Override
-  Object getAsObject() {
-    if (value instanceof BigInteger) {
-      BigInteger big = (BigInteger) value;
-      if (big.compareTo(INTEGER_MAX) < 0) {
-        return big.intValue();
-      } else if (big.compareTo(LONG_MAX) < 0) {
-        return big.longValue();
-      }
-    }
-    // No need to convert to float or double since those lose precision
-    return value;
-  }
-
-  @Override
-  protected void toString(Appendable sb, Escaper escaper) throws IOException {
-    if (isString()) {
-      sb.append('"');
-      sb.append(escaper.escapeJsonString(value.toString()));
-      sb.append('"');
-    } else {
-      sb.append(value.toString());
-    }
-  }
-
-  private static boolean isPrimitiveOrString(Object target) {
-    if (target instanceof String) {
-      return true;
-    }
-
-    Class<?> classOfPrimitive = target.getClass();
-    for (Class<?> standardPrimitive : PRIMITIVE_TYPES) {
-      if (standardPrimitive.isAssignableFrom(classOfPrimitive)) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  @Override
-  public int hashCode() {
-    if (value == null) {
-      return 31;
-    }
-    // Using recommended hashing algorithm from Effective Java for longs and doubles
-    if (isIntegral(this)) {
-      long value = getAsNumber().longValue();
-      return (int) (value ^ (value >>> 32));
-    }
-    if (isFloatingPoint(this)) {
-      long value = Double.doubleToLongBits(getAsNumber().doubleValue());
-      return (int) (value ^ (value >>> 32));
-    }
-    return value.hashCode();
-  }
-
-  @Override
-  public boolean equals(Object obj) {
-    if (this == obj) {
-      return true;
-    }
-    if (obj == null || getClass() != obj.getClass()) {
-      return false;
-    }
-    JsonPrimitive other = (JsonPrimitive)obj;
-    if (value == null) {
-      return other.value == null;
-    }
-    if (isIntegral(this) && isIntegral(other)) {
-      return getAsNumber().longValue() == other.getAsNumber().longValue();
-    }
-    if (isFloatingPoint(this) && isFloatingPoint(other)) {
-      return getAsNumber().doubleValue() == other.getAsNumber().doubleValue();
-    }
-    return value.equals(other.value);
-  }
-
-  /**
-   * Returns true if the specified number is an integral type
-   * (Long, Integer, Short, Byte, BigInteger)
-   */
-  private static boolean isIntegral(JsonPrimitive primitive) {
-    if (primitive.value instanceof Number) {
-      Number number = (Number) primitive.value;
-      return number instanceof BigInteger || number instanceof Long || number instanceof Integer
-      || number instanceof Short || number instanceof Byte;
-    }
-    return false;
-  }
-
-  /**
-   * Returns true if the specified number is a floating point type (BigDecimal, double, float)
-   */
-  private static boolean isFloatingPoint(JsonPrimitive primitive) {
-    if (primitive.value instanceof Number) {
-      Number number = (Number) primitive.value;
-      return number instanceof BigDecimal || number instanceof Double || number instanceof Float;
-    }
-    return false;
-  }
-}

src/org/mcteam/ancientgates/gson/JsonSerializationContext.java

@@ -1,49 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * Context for serialization that is passed to a custom serializer during invocation of its
- * {@link JsonSerializer#serialize(Object, Type, JsonSerializationContext)} method.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public interface JsonSerializationContext {
-
-  /**
-   * Invokes default serialization on the specified object.
-   *
-   * @param src the object that needs to be serialized.
-   * @return a tree of {@link JsonElement}s corresponding to the serialized form of {@code src}.
-   */
-  public JsonElement serialize(Object src);
-
-  /**
-   * Invokes default serialization on the specified object passing the specific type information.
-   * It should never be invoked on the element received as a parameter of the
-   * {@link JsonSerializer#serialize(Object, Type, JsonSerializationContext)} method. Doing
-   * so will result in an infinite loop since Gson will in-turn call the custom serializer again.
-   *
-   * @param src the object that needs to be serialized.
-   * @param typeOfSrc the actual genericized type of src object.
-   * @return a tree of {@link JsonElement}s corresponding to the serialized form of {@code src}.
-   */
-  public JsonElement serialize(Object src, Type typeOfSrc);
-}

src/org/mcteam/ancientgates/gson/JsonSerializationContextDefault.java

@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * An implementation of serialization context for Gson.
- *
- * @author Inderjeet Singh
- */
-final class JsonSerializationContextDefault implements JsonSerializationContext {
-
-  private final ObjectNavigatorFactory factory;
-  private final ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers;
-  private final boolean serializeNulls;
-  private final MemoryRefStack ancestors;
-
-  JsonSerializationContextDefault(ObjectNavigatorFactory factory, boolean serializeNulls,
-      ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers) {
-    this.factory = factory;
-    this.serializeNulls = serializeNulls;
-    this.serializers = serializers;
-    this.ancestors = new MemoryRefStack();
-  }
-
-  public JsonElement serialize(Object src) {
-    if (src == null) {
-      return JsonNull.createJsonNull();
-    }
-    return serialize(src, src.getClass(), true);
-  }
-
-  public JsonElement serialize(Object src, Type typeOfSrc) {
-    return serialize(src, typeOfSrc, true);
-  }
-
-  public JsonElement serialize(Object src, Type typeOfSrc, boolean preserveType) {
-    ObjectNavigator on = factory.create(new ObjectTypePair(src, typeOfSrc, preserveType));
-    JsonSerializationVisitor visitor =
-        new JsonSerializationVisitor(factory, serializeNulls, serializers, this, ancestors);
-    on.accept(visitor);
-    return visitor.getJsonElement();
-  }
-}

src/org/mcteam/ancientgates/gson/JsonSerializationVisitor.java

@@ -1,236 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Array;
-import java.lang.reflect.Type;
-
-/**
- * A visitor that adds JSON elements corresponding to each field of an object
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class JsonSerializationVisitor implements ObjectNavigator.Visitor {
-
-  private final ObjectNavigatorFactory factory;
-  private final ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers;
-  private final boolean serializeNulls;
-  private final JsonSerializationContext context;
-  private final MemoryRefStack ancestors;
-  private JsonElement root;
-
-  JsonSerializationVisitor(ObjectNavigatorFactory factory, boolean serializeNulls,
-      ParameterizedTypeHandlerMap<JsonSerializer<?>> serializers, JsonSerializationContext context,
-      MemoryRefStack ancestors) {
-    this.factory = factory;
-    this.serializeNulls = serializeNulls;
-    this.serializers = serializers;
-    this.context = context;
-    this.ancestors = ancestors;
-  }
-
-  public Object getTarget() {
-    return null;
-  }
-
-  public void start(ObjectTypePair node) {
-    if (node == null) {
-      return;
-    }
-    if (ancestors.contains(node)) {
-      throw new CircularReferenceException(node);
-    }
-    ancestors.push(node);
-  }
-
-  public void end(ObjectTypePair node) {
-    if (node != null) {
-      ancestors.pop();
-    }
-  }
-
-  public void startVisitingObject(Object node) {
-    assignToRoot(new JsonObject());
-  }
-
-  public void visitArray(Object array, Type arrayType) {
-    assignToRoot(new JsonArray());
-    int length = Array.getLength(array);
-    TypeInfoArray fieldTypeInfo = TypeInfoFactory.getTypeInfoForArray(arrayType);
-    Type componentType = fieldTypeInfo.getSecondLevelType();
-    for (int i = 0; i < length; ++i) {
-      Object child = Array.get(array, i);
-      Type childType = componentType;
-      // we should not get more specific component type yet since it is possible
-      // that a custom
-      // serializer is registered for the componentType
-      addAsArrayElement(new ObjectTypePair(child, childType, false));
-    }
-  }
-
-  public void visitArrayField(FieldAttributes f, Type typeOfF, Object obj) {
-    try {
-      if (isFieldNull(f, obj)) {
-        if (serializeNulls) {
-          addChildAsElement(f, JsonNull.createJsonNull());
-        }
-      } else {
-        Object array = getFieldValue(f, obj);
-        addAsChildOfObject(f, new ObjectTypePair(array, typeOfF, false));
-      }
-    } catch (CircularReferenceException e) {
-      throw e.createDetailedException(f);
-    }
-  }
-
-  public void visitObjectField(FieldAttributes f, Type typeOfF, Object obj) {
-    try {
-      if (isFieldNull(f, obj)) {
-        if (serializeNulls) {
-          addChildAsElement(f, JsonNull.createJsonNull());
-        }
-      } else {
-        Object fieldValue = getFieldValue(f, obj);
-        // we should not get more specific component type yet since it is
-        // possible that a custom
-        // serializer is registered for the componentType
-        addAsChildOfObject(f, new ObjectTypePair(fieldValue, typeOfF, false));
-      }
-    } catch (CircularReferenceException e) {
-      throw e.createDetailedException(f);
-    }
-  }
-
-  public void visitPrimitive(Object obj) {
-    JsonElement json = obj == null ? JsonNull.createJsonNull() : new JsonPrimitive(obj);
-    assignToRoot(json);
-  }
-
-  private void addAsChildOfObject(FieldAttributes f, ObjectTypePair fieldValuePair) {
-    JsonElement childElement = getJsonElementForChild(fieldValuePair);
-    addChildAsElement(f, childElement);
-  }
-
-  private void addChildAsElement(FieldAttributes f, JsonElement childElement) {
-    FieldNamingStrategy2 namingPolicy = factory.getFieldNamingPolicy();
-    root.getAsJsonObject().add(namingPolicy.translateName(f), childElement);
-  }
-
-  private void addAsArrayElement(ObjectTypePair elementTypePair) {
-    if (elementTypePair.getObject() == null) {
-      root.getAsJsonArray().add(JsonNull.createJsonNull());
-    } else {
-      JsonElement childElement = getJsonElementForChild(elementTypePair);
-      root.getAsJsonArray().add(childElement);
-    }
-  }
-
-  private JsonElement getJsonElementForChild(ObjectTypePair fieldValueTypePair) {
-    ObjectNavigator on = factory.create(fieldValueTypePair);
-    JsonSerializationVisitor childVisitor =
-        new JsonSerializationVisitor(factory, serializeNulls, serializers, context, ancestors);
-    on.accept(childVisitor);
-    return childVisitor.getJsonElement();
-  }
-
-  public boolean visitUsingCustomHandler(ObjectTypePair objTypePair) {
-    try {
-      Object obj = objTypePair.getObject();
-      if (obj == null) {
-        if (serializeNulls) {
-          assignToRoot(JsonNull.createJsonNull());
-        }
-        return true;
-      }
-      JsonElement element = findAndInvokeCustomSerializer(objTypePair);
-      if (element != null) {
-        assignToRoot(element);
-        return true;
-      }
-      return false;
-    } catch (CircularReferenceException e) {
-      throw e.createDetailedException(null);
-    }
-  }
-
-  /**
-   * objTypePair.getObject() must not be null
-   */
-  @SuppressWarnings({"unchecked", "rawtypes"})
-  private JsonElement findAndInvokeCustomSerializer(ObjectTypePair objTypePair) {
-    Pair<JsonSerializer<?>,ObjectTypePair> pair = objTypePair.getMatchingHandler(serializers);
-    if (pair == null) {
-      return null;
-    }
-    JsonSerializer serializer = pair.first;
-    objTypePair = pair.second;
-    start(objTypePair);
-    try {
-      JsonElement element =
-          serializer.serialize(objTypePair.getObject(), objTypePair.getType(), context);
-      return element == null ? JsonNull.createJsonNull() : element;
-    } finally {
-      end(objTypePair);
-    }
-  }
-
-  public boolean visitFieldUsingCustomHandler(FieldAttributes f, Type declaredTypeOfField, Object parent) {
-    try {
-      Preconditions.checkState(root.isJsonObject());
-      Object obj = f.get(parent);
-      if (obj == null) {
-        if (serializeNulls) {
-          addChildAsElement(f, JsonNull.createJsonNull());
-        }
-        return true;
-      }
-      ObjectTypePair objTypePair = new ObjectTypePair(obj, declaredTypeOfField, false);
-      JsonElement child = findAndInvokeCustomSerializer(objTypePair);
-      if (child != null) {
-        addChildAsElement(f, child);
-        return true;
-      }
-      return false;
-    } catch (IllegalAccessException e) {
-      throw new RuntimeException();
-    } catch (CircularReferenceException e) {
-      throw e.createDetailedException(f);
-    }
-  }
-
-  private void assignToRoot(JsonElement newRoot) {
-    Preconditions.checkNotNull(newRoot);
-    root = newRoot;
-  }
-
-  private boolean isFieldNull(FieldAttributes f, Object obj) {
-    return getFieldValue(f, obj) == null;
-  }
-
-  private Object getFieldValue(FieldAttributes f, Object obj) {
-    try {
-      return f.get(obj);
-    } catch (IllegalAccessException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
-  public JsonElement getJsonElement() {
-    return root;
-  }
-}

src/org/mcteam/ancientgates/gson/JsonSerializer.java

@@ -1,86 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.Type;
-
-/**
- * Interface representing a custom serializer for Json. You should write a custom serializer, if
- * you are not happy with the default serialization done by Gson. You will also need to register
- * this serializer through {@link org.mcteam.ancientgates.gson.GsonBuilder#registerTypeAdapter(Type, Object)}.
- *
- * <p>Let us look at example where defining a serializer will be useful. The {@code Id} class
- * defined below has two fields: {@code clazz} and {@code value}.</p>
- *
- * <p><pre>
- * public class Id&lt;T&gt; {
- *   private final Class&lt;T&gt; clazz;
- *   private final long value;
- *
- *   public Id(Class&lt;T&gt; clazz, long value) {
- *     this.clazz = clazz;
- *     this.value = value;
- *   }
- *
- *   public long getValue() {
- *     return value;
- *   }
- * }
- * </pre></p>
- *
- * <p>The default serialization of {@code Id(com.foo.MyObject.class, 20L)} will be
- * <code>{"clazz":com.foo.MyObject,"value":20}</code>. Suppose, you just want the output to be
- * the value instead, which is {@code 20} in this case. You can achieve that by writing a custom
- * serializer:</p>
- *
- * <p><pre>
- * class IdSerializer implements JsonSerializer&lt;Id&gt;() {
- *   public JsonElement toJson(Id id, Type typeOfId, JsonSerializationContext context) {
- *     return new JsonPrimitive(id.getValue());
- *   }
- * }
- * </pre></p>
- *
- * <p>You will also need to register {@code IdSerializer} with Gson as follows:</p>
- * <pre>
- * Gson gson = new GsonBuilder().registerTypeAdapter(Id.class, new IdSerializer()).create();
- * </pre>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- *
- * @param <T> type for which the serializer is being registered. It is possible that a serializer
- *        may be asked to serialize a specific generic type of the T.
- */
-public interface JsonSerializer<T> {
-
-  /**
-   * Gson invokes this call-back method during serialization when it encounters a field of the
-   * specified type.
-   *
-   * <p>In the implementation of this call-back method, you should consider invoking
-   * {@link JsonSerializationContext#serialize(Object, Type)} method to create JsonElements for any
-   * non-trivial field of the {@code src} object. However, you should never invoke it on the
-   * {@code src} object itself since that will cause an infinite loop (Gson will call your
-   * call-back method again).</p>
-   *
-   * @param src the object that needs to be converted to Json.
-   * @param typeOfSrc the actual type (fully genericized version) of the source object.
-   * @return a JsonElement corresponding to the specified object.
-   */
-  public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context);
-}

src/org/mcteam/ancientgates/gson/JsonStreamParser.java

@@ -1,123 +0,0 @@
-/*
- * Copyright (C) 2009 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.mcteam.ancientgates.gson;
-
-import java.io.EOFException;
-import java.io.IOException;
-import java.io.Reader;
-import java.io.StringReader;
-import java.util.Iterator;
-import java.util.NoSuchElementException;
-
-import org.mcteam.ancientgates.gson.stream.JsonReader;
-import org.mcteam.ancientgates.gson.stream.JsonToken;
-import org.mcteam.ancientgates.gson.stream.MalformedJsonException;
-
-
-/**
- * A streaming parser that allows reading of multiple {@link JsonElement}s from the specified reader
- * asynchronously.
- * 
- * <p>This class is conditionally thread-safe (see Item 70, Effective Java second edition). To
- * properly use this class across multiple threads, you will need to add some external
- * synchronization.  For example:
- * 
- * <pre>
- * JsonStreamParser parser = new JsonStreamParser("['first'] {'second':10} 'third'");
- * JsonElement element;
- * synchronized (parser) {  // synchronize on an object shared by threads
- *   if (parser.hasNext()) {
- *     element = parser.next();
- *   }
- * }
- * </pre>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- * @since 1.4
- */
-public final class JsonStreamParser implements Iterator<JsonElement> {
-
-  private final JsonReader parser;
-  private final Object lock;
-
-  /**
-   * @param json The string containing JSON elements concatenated to each other.
-   * @since 1.4
-   */
-  public JsonStreamParser(String json) {
-    this(new StringReader(json));      
-  }
-  
-  /**
-   * @param reader The data stream containing JSON elements concatenated to each other.
-   * @since 1.4
-   */
-  public JsonStreamParser(Reader reader) {
-    parser = new JsonReader(reader);
-    parser.setLenient(true);
-    lock = new Object();
-  }
-  
-  /**
-   * Returns the next available {@link JsonElement} on the reader. Null if none available.
-   * 
-   * @return the next available {@link JsonElement} on the reader. Null if none available.
-   * @throws JsonParseException if the incoming stream is malformed JSON.
-   * @since 1.4
-   */
-  public JsonElement next() throws JsonParseException {
-    if (!hasNext()) {
-      throw new NoSuchElementException();
-    }
-    
-    try {
-      return Streams.parse(parser);
-    } catch (StackOverflowError e) {
-      throw new JsonParseException("Failed parsing JSON source to Json", e);
-    } catch (OutOfMemoryError e) {
-      throw new JsonParseException("Failed parsing JSON source to Json", e);
-    } catch (JsonParseException e) {
-      throw e.getCause() instanceof EOFException ? new NoSuchElementException() : e;
-    }
-  }
-
-  /**
-   * Returns true if a {@link JsonElement} is available on the input for consumption
-   * @return true if a {@link JsonElement} is available on the input, false otherwise
-   * @since 1.4
-   */
-  public boolean hasNext() {
-    synchronized (lock) {
-      try {
-        return parser.peek() != JsonToken.END_DOCUMENT;
-      } catch (MalformedJsonException e) {
-        throw new JsonSyntaxException(e);
-      } catch (IOException e) {
-        throw new JsonIOException(e);
-      }
-    }
-  }
-
-  /**
-   * This optional {@link Iterator} method is not relevant for stream parsing and hence is not
-   * implemented.
-   * @since 1.4
-   */
-  public void remove() {
-    throw new UnsupportedOperationException();
-  }
-}

src/org/mcteam/ancientgates/gson/JsonSyntaxException.java

@@ -1,47 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.mcteam.ancientgates.gson;
-
-/**
- * This exception is raised when Gson attempts to read (or write) a malformed
- * JSON element.
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public final class JsonSyntaxException extends JsonParseException {
-
-  private static final long serialVersionUID = 1L;
-
-  public JsonSyntaxException(String msg) {
-    super(msg);
-  }
-
-  public JsonSyntaxException(String msg, Throwable cause) {
-    super(msg, cause);
-  }
-
-  /**
-   * Creates exception with the specified cause. Consider using
-   * {@link #JsonSyntaxException(String, Throwable)} instead if you can
-   * describe what actually happened.
-   *
-   * @param cause root exception that caused this exception to be thrown.
-   */
-  public JsonSyntaxException(Throwable cause) {
-    super(cause);
-  }
-}

src/org/mcteam/ancientgates/gson/JsonTreeNavigator.java

@@ -1,111 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.io.IOException;
-import java.util.Map;
-
-/**
- * A navigator to navigate a tree of JsonElement nodes in Depth-first order
- * 
- * @author Inderjeet Singh
- */
-final class JsonTreeNavigator {
-  private final JsonElementVisitor visitor;
-  private final boolean visitNulls;
-
-  JsonTreeNavigator(JsonElementVisitor visitor, boolean visitNulls) {
-    this.visitor = visitor;
-    this.visitNulls = visitNulls;
-  }
-  
-  public void navigate(JsonElement element) throws IOException {
-    if (element.isJsonNull()) {
-      visitor.visitNull();
-    } else if (element.isJsonArray()) {
-      JsonArray array = element.getAsJsonArray();
-      visitor.startArray(array);
-      boolean isFirst = true;
-      for (JsonElement child : array) {
-        visitChild(array, child, isFirst);
-        if (isFirst) {
-          isFirst = false;
-        }
-      }
-      visitor.endArray(array);
-    } else if (element.isJsonObject()) {
-      JsonObject object = element.getAsJsonObject();
-      visitor.startObject(object);
-      boolean isFirst = true;
-      for (Map.Entry<String, JsonElement> member : object.entrySet()) {
-        boolean visited = visitChild(object, member.getKey(), member.getValue(), isFirst);
-        if (visited && isFirst) {
-          isFirst = false;
-        }
-      }
-      visitor.endObject(object);
-    } else { // must be JsonPrimitive
-      visitor.visitPrimitive(element.getAsJsonPrimitive());
-    }    
-  }
-
-  /**
-   * Returns true if the child was visited, false if it was skipped.
-   */
-  private boolean visitChild(JsonObject parent, String childName, JsonElement child, 
-      boolean isFirst) throws IOException {
-    if (child.isJsonNull()) {
-      if (visitNulls) {
-        visitor.visitNullObjectMember(parent, childName, isFirst);
-        navigate(child.getAsJsonNull());
-      } else { // Null value is being skipped.
-        return false;
-      }
-    } else if (child.isJsonArray()) {
-      JsonArray childAsArray = child.getAsJsonArray();
-      visitor.visitObjectMember(parent, childName, childAsArray, isFirst);
-      navigate(childAsArray);
-    } else if (child.isJsonObject()) {
-      JsonObject childAsObject = child.getAsJsonObject();
-      visitor.visitObjectMember(parent, childName, childAsObject, isFirst);
-      navigate(childAsObject);
-    } else { // is a JsonPrimitive
-      visitor.visitObjectMember(parent, childName, child.getAsJsonPrimitive(), isFirst);          
-    }
-    return true;
-  }
-
-  /**
-   * Returns true if the child was visited, false if it was skipped.
-   */
-  private void visitChild(JsonArray parent, JsonElement child, boolean isFirst) throws IOException {
-    if (child.isJsonNull()) {
-      visitor.visitNullArrayMember(parent, isFirst);
-      navigate(child);
-	  } else if (child.isJsonArray()) {
-      JsonArray childAsArray = child.getAsJsonArray();
-      visitor.visitArrayMember(parent, childAsArray, isFirst);
-      navigate(childAsArray);
-    } else if (child.isJsonObject()) {
-      JsonObject childAsObject = child.getAsJsonObject();
-      visitor.visitArrayMember(parent, childAsObject, isFirst);
-      navigate(childAsObject);
-    } else { // is a JsonPrimitive
-      visitor.visitArrayMember(parent, child.getAsJsonPrimitive(), isFirst);          
-    }
-  }
-}

src/org/mcteam/ancientgates/gson/LongSerializationPolicy.java

@@ -1,74 +0,0 @@
-/*
- * Copyright (C) 2009 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * Defines the expected format for a {@code long} or {@code Long} type when its serialized.
- *
- * @since 1.3
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-public enum LongSerializationPolicy {
-  /**
-   * This is the "default" serialization policy that will output a {@code long} object as a JSON
-   * number.  For example, assume an object has a long field named "f" then the serialized output
-   * would be:
-   * {@code {"f":123}}.
-   */
-  DEFAULT(new DefaultStrategy()),
-  
-  /**
-   * Serializes a long value as a quoted string.  For example, assume an object has a long field 
-   * named "f" then the serialized output would be:
-   * {@code {"f":"123"}}.
-   */
-  STRING(new StringStrategy());
-  
-  private final Strategy strategy;
-  
-  private LongSerializationPolicy(Strategy strategy) {
-    this.strategy = strategy;
-  }
-
-  /**
-   * Serialize this {@code value} using this serialization policy.
-   *
-   * @param value the long value to be serialized into a {@link JsonElement}
-   * @return the serialized version of {@code value}
-   */
-  public JsonElement serialize(Long value) {
-    return strategy.serialize(value);
-  }
-  
-  private interface Strategy {
-    JsonElement serialize(Long value);
-  }
-  
-  private static class DefaultStrategy implements Strategy {
-    public JsonElement serialize(Long value) {
-      return new JsonPrimitive(value);
-    }
-  }
-  
-  private static class StringStrategy implements Strategy {
-    public JsonElement serialize(Long value) {
-      return new JsonPrimitive(String.valueOf(value));
-    }
-  }
-}

src/org/mcteam/ancientgates/gson/LowerCamelCaseSeparatorNamingPolicy.java

@@ -1,43 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-/**
- * A {@link FieldNamingStrategy2} that ensures the JSON field names consist of only
- * lower case letters and are separated by a particular {@code separatorString}.
- *
- *<p>The following is an example:</p>
- * <pre>
- * class StringWrapper {
- *   public String AStringField = "abcd";
- * }
- *
- * LowerCamelCaseSeparatorNamingPolicy policy = new LowerCamelCaseSeparatorNamingPolicy("_");
- * String translatedFieldName =
- *     policy.translateName(StringWrapper.class.getField("AStringField"));
- *
- * assert("a_string_field".equals(translatedFieldName));
- * </pre>
- *
- * @author Joel Leitch
- */
-final class LowerCamelCaseSeparatorNamingPolicy extends CompositionFieldNamingPolicy {
-
-  public LowerCamelCaseSeparatorNamingPolicy(String separatorString) {
-    super(new CamelCaseSeparatorNamingPolicy(separatorString), new LowerCaseNamingPolicy());
-  }
-}

src/org/mcteam/ancientgates/gson/LowerCaseNamingPolicy.java

@@ -1,50 +0,0 @@
-/*
- * Copyright (C) 2008 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Type;
-import java.util.Collection;
-
-/**
- * A {@link FieldNamingStrategy2} that ensures the JSON field names consist of only
- * lower case letters.
- *
- * <p>The following is an example:</p>
- * <pre>
- * class IntWrapper {
- *   public int integerField = 0;
- * }
- *
- * LowerCaseNamingPolicy policy = new LowerCaseNamingPolicy();
- * String translatedFieldName =
- *     policy.translateName(IntWrapper.class.getField("integerField"));
- *
- * assert("integerfield".equals(translatedFieldName));
- * </pre>
- *
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class LowerCaseNamingPolicy extends RecursiveFieldNamingPolicy {
-
-  @Override
-  protected String translateName(String target, Type fieldType,
-      Collection<Annotation> annotations) {
-    return target.toLowerCase();
-  }
-}

src/org/mcteam/ancientgates/gson/LruCache.java

@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/**
- * An implementation of the {@link Cache} interface that evict objects from the cache using an
- * LRU (least recently used) algorithm.  Object start getting evicted from the cache once the
- * {@code maxCapacity} is reached.
- * 
- * @author Inderjeet Singh
- * @author Joel Leitch
- */
-final class LruCache<K, V> extends LinkedHashMap<K, V> implements Cache<K, V> {
-  private static final long serialVersionUID = 1L;
-
-  private final int maxCapacity;
-
-  LruCache(int maxCapacity) {
-    super(maxCapacity, 0.7F, true);
-    this.maxCapacity = maxCapacity;
-  }
-
-  public void addElement(K key, V value) {
-    put(key, value);
-  }
-
-  @Override
-  public void clear() {
-    super.clear();
-  }
-
-  public V getElement(K key) {
-    return get(key);
-  }
-
-  public V removeElement(K key) {
-    return remove(key);
-  }
-
-  @Override
-  public int size() {
-    return super.size();
-  }
-  
-  @Override
-  protected boolean removeEldestEntry(Map.Entry<K, V> entry) {
-    return size() > maxCapacity;
-  }
-}

src/org/mcteam/ancientgates/gson/MapAsArrayTypeAdapter.java

@@ -1,168 +0,0 @@
-/*
- * Copyright (C) 2010 Google Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.mcteam.ancientgates.gson;
-
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-
-/**
- * Adapts maps containing complex keys as arrays of map entries.
- *
- * <h3>Maps as JSON objects</h3>
- * The standard GSON map type adapter converts Java {@link Map Maps} to JSON
- * Objects. This requires that map keys can be serialized as strings; this is
- * insufficient for some key types. For example, consider a map whose keys are
- * points on a grid. The default JSON form encodes reasonably: <pre>   {@code
- *   Map<Point, String> original = new LinkedHashMap<Point, String>();
- *   original.put(new Point(5, 6), "a");
- *   original.put(new Point(8, 8), "b");
- *   System.out.println(gson.toJson(original, type));
- * }</pre>
- * The above code prints this JSON object:<pre>   {@code
- *   {
- *     "(5,6)": "a",
- *     "(8,8)": "b"
- *   }
- * }</pre>
- * But GSON is unable to deserialize this value because the JSON string name is
- * just the {@link Object#toString() toString()} of the map key. Attempting to
- * convert the above JSON to an object fails with a parse exception:
- * <pre>com.bukkit.mcteam.gson.JsonParseException: Expecting object found: "(5,6)"
- *   at com.bukkit.mcteam.gson.JsonObjectDeserializationVisitor.visitFieldUsingCustomHandler
- *   at com.bukkit.mcteam.gson.ObjectNavigator.navigateClassFields
- *   ...</pre>
- *
- * <h3>Maps as JSON arrays</h3>
- * An alternative approach taken by this type adapter is to encode maps as
- * arrays of map entries. Each map entry is a two element array containing a key
- * and a value. This approach is more flexible because any type can be used as
- * the map's key; not just strings. But it's also less portable because the
- * receiver of such JSON must be aware of the map entry convention.
- *
- * <p>Register this adapter when you are creating your GSON instance.
- * <pre>   {@code
- *   Gson gson = new GsonBuilder()
- *     .registerTypeAdapter(Map.class, new MapAsArrayTypeAdapter())
- *     .create();
- * }</pre>
- * This will change the structure of the JSON emitted by the code above. Now we
- * get an array. In this case the arrays elements are map entries:
- * <pre>   {@code
- *   [
- *     [
- *       {
- *         "x": 5,
- *         "y": 6
- *       },
- *       "a",
- *     ],
- *     [
- *       {
- *         "x": 8,
- *         "y": 8
- *       },
- *       "b"
- *     ]
- *   ]
- * }</pre>
- * This format will serialize and deserialize just fine as long as this adapter
- * is registered.
- *
- * <p>This adapter returns regular JSON objects for maps whose keys are not
- * complex. A key is complex if its JSON-serialized form is an array or an
- * object.
- */
-public final class MapAsArrayTypeAdapter
-    implements JsonSerializer<Map<?, ?>>, JsonDeserializer<Map<?, ?>> {
-
-  public Map<?, ?> deserialize(JsonElement json, Type typeOfT,
-      JsonDeserializationContext context) throws JsonParseException {
-    Map<Object, Object> result = new LinkedHashMap<Object, Object>();
-    Type[] keyAndValueType = typeToTypeArguments(typeOfT);
-    if (json.isJsonArray()) {
-      JsonArray array = json.getAsJsonArray();
-      for (int i = 0; i < array.size(); i++) {
-        JsonArray entryArray = array.get(i).getAsJsonArray();
-        Object k = context.deserialize(entryArray.get(0), keyAndValueType[0]);
-        Object v = context.deserialize(entryArray.get(1), keyAndValueType[1]);
-        result.put(k, v);
-      }
-      checkSize(array, array.size(), result, result.size());
-    } else {
-      JsonObject object = json.getAsJsonObject();
-      for (Map.Entry<String, JsonElement> entry : object.entrySet()) {
-        Object k = context.deserialize(new JsonPrimitive(entry.getKey()), keyAndValueType[0]);
-        Object v = context.deserialize(entry.getValue(), keyAndValueType[1]);
-        result.put(k, v);
-      }
-      checkSize(object, object.entrySet().size(), result, result.size());
-    }
-    return result;
-  }
-
-  public JsonElement serialize(Map<?, ?> src, Type typeOfSrc, JsonSerializationContext context) {
-    Type[] keyAndValueType = typeToTypeArguments(typeOfSrc);
-    boolean serializeAsArray = false;
-    List<JsonElement> keysAndValues = new ArrayList<JsonElement>();
-    for (Map.Entry<?, ?> entry : src.entrySet()) {
-      JsonElement key = context.serialize(entry.getKey(), keyAndValueType[0]);
-      serializeAsArray |= key.isJsonObject() || key.isJsonArray();
-      keysAndValues.add(key);
-      keysAndValues.add(context.serialize(entry.getValue(), keyAndValueType[1]));
-    }
-
-    if (serializeAsArray) {
-      JsonArray result = new JsonArray();
-      for (int i = 0; i < keysAndValues.size(); i+=2) {
-        JsonArray entryArray = new JsonArray();
-        entryArray.add(keysAndValues.get(i));
-        entryArray.add(keysAndValues.get(i + 1));
-        result.add(entryArray);
-      }
-      return result;
-    } else {
-      JsonObject result = new JsonObject();
-      for (int i = 0; i < keysAndValues.size(); i+=2) {
-        result.add(keysAndValues.get(i).getAsString(), keysAndValues.get(i + 1));
-      }
-      checkSize(src, src.size(), result, result.entrySet().size());
-      return result;
-    }
-  }
-
-  private Type[] typeToTypeArguments(Type typeOfT) {
-    if (typeOfT instanceof ParameterizedType) {
-      Type[] typeArguments = ((ParameterizedType) typeOfT).getActualTypeArguments();
-      if (typeArguments.length != 2) {
-        throw new IllegalArgumentException("MapAsArrayTypeAdapter cannot handle " + typeOfT);
-      }
-      return typeArguments;
-    }
-    return new Type[] { Object.class, Object.class };
-  }
-
-  private void checkSize(Object input, int inputSize, Object output, int outputSize) {
-    if (inputSize != outputSize) {
-      throw new JsonSyntaxException("Input size " + inputSize + " != output size " + outputSize
-          + " for input " + input + " and output " + output);
-    }
-  }
-}