From: <lh...@us...> - 2009-11-04 16:58:52
|
Revision: 360 http://tinytim.svn.sourceforge.net/tinytim/?rev=360&view=rev Author: lheuer Date: 2009-11-04 16:58:30 +0000 (Wed, 04 Nov 2009) Log Message: ----------- Switch to Ontopia's Compact*Set, removed trove Modified Paths: -------------- tinytim/trunk/README.txt tinytim/trunk/build.xml tinytim/trunk/src/main/java/org/tinytim/internal/utils/CollectionFactory.java tinytim/trunk/src/main/java/org/tinytim/internal/utils/CopyUtils.java tinytim/trunk/src/test/java/org/tinytim/core/AllTests.java Added Paths: ----------- tinytim/trunk/lib/tmapi-2.0RC1-tests.jar tinytim/trunk/lib/tmapi-2.0RC1.jar tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactHashSet.java tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactIdentityHashSet.java tinytim/trunk/src/main/java/org/tinytim/internal/utils/OntopiaCollectionFactory.java tinytim/trunk/src/main/java/org/tinytim/mio/CXTMTopicMapWriter.java tinytim/trunk/src/main/java/org/tinytim/mio/XMLC14NWriter.java Removed Paths: ------------- tinytim/trunk/lib/LICENSE.trove.txt tinytim/trunk/lib/tmapi-2.0b1-tests.jar tinytim/trunk/lib/tmapi-2.0b1.jar tinytim/trunk/lib/trove-2.1.0.jar tinytim/trunk/src/main/java/org/tinytim/internal/utils/JavaCollectionFactory.java tinytim/trunk/src/main/java/org/tinytim/internal/utils/TroveCollectionFactory.java Modified: tinytim/trunk/README.txt =================================================================== --- tinytim/trunk/README.txt 2009-10-09 11:54:46 UTC (rev 359) +++ tinytim/trunk/README.txt 2009-11-04 16:58:30 UTC (rev 360) @@ -12,10 +12,9 @@ Installation ------------ No real installation needed, simply put the ``tinytim-2.0.0a6.jar`` and -``tmapi-2.0a2.jar`` into your classpath. That's all. :) -Optionally, you can put the ``trove-<VERSION>.jar`` into your classpath which -makes tinyTiM slightly more memory efficient and faster. +``tmapi-2*.jar`` into your classpath. That's all. :) + Mailing List ------------ If you have questions or suggestions, use our mailinglist Modified: tinytim/trunk/build.xml =================================================================== --- tinytim/trunk/build.xml 2009-10-09 11:54:46 UTC (rev 359) +++ tinytim/trunk/build.xml 2009-11-04 16:58:30 UTC (rev 360) @@ -11,10 +11,9 @@ <property name="dir.coverage" value="${basedir}/coverage"/> <property name="lib.junit" value="${dir.lib}/junit-4.5.jar"/> - <property name="lib.trove" value="${dir.lib}/trove-2.1.0.jar"/> <property name="lib.mio" value="${dir.lib}/semagia-mio-0.9.5.jar"/> - <property name="lib.tmapi" value="${dir.lib}/tmapi-2.0b1.jar"/> - <property name="lib.tmapi.tests" value="${dir.lib}/tmapi-2.0b1-tests.jar"/> + <property name="lib.tmapi" value="${dir.lib}/tmapi-2.0RC1.jar"/> + <property name="lib.tmapi.tests" value="${dir.lib}/tmapi-2.0RC1-tests.jar"/> <property name="lib.emma" value="${dir.lib}/emma.jar"/> <property name="lib.emma.task" value="${dir.lib}/emma_ant.jar"/> @@ -68,7 +67,6 @@ <pathelement location="${lib.mio}"/> <pathelement location="${lib.tmapi}"/> <pathelement location="${lib.tmapi.tests}"/> - <pathelement location="${lib.trove}"/> </path> </target> @@ -103,7 +101,6 @@ <pathelement location="${lib.mio}"/> <pathelement location="${lib.tmapi}"/> <pathelement location="${lib.tmapi.tests}"/> - <pathelement location="${lib.trove}"/> </classpath> <src path="${dir.test}"/> </javac> @@ -134,7 +131,6 @@ <pathelement location="${lib.mio}"/> <pathelement location="${lib.tmapi}"/> <pathelement location="${lib.tmapi.tests}"/> - <pathelement location="${lib.trove}"/> </classpath> <src path="${dir.test}"/> </javac> @@ -158,7 +154,6 @@ target="1.5"> <classpath> <pathelement location="${lib.tmapi}"/> - <pathelement location="${lib.trove}"/> <pathelement location="${lib.mio}"/> </classpath> <src path="${dir.src}"/> @@ -253,7 +248,6 @@ <include name="trove*"/> <include name="LICENSE.tmapi*"/> <include name="LICENSE.junit*"/> - <include name="LICENSE.trove*"/> </fileset> </copy> Deleted: tinytim/trunk/lib/LICENSE.trove.txt =================================================================== --- tinytim/trunk/lib/LICENSE.trove.txt 2009-10-09 11:54:46 UTC (rev 359) +++ tinytim/trunk/lib/LICENSE.trove.txt 2009-11-04 16:58:30 UTC (rev 360) @@ -1,528 +0,0 @@ -The Trove library is licensed under the Lesser GNU Public License, -which is included with the distribution in a file called LICENSE.txt. - -Other license arrangements are possible, for a fee: contact -e...@us... for terms/pricing. - -The PrimeFinder and HashFunctions classes in Trove are subject to the -following license restrictions: - -Copyright (c) 1999 CERN - European Organization for Nuclear Research. - -Permission to use, copy, modify, distribute and sell this software and -its documentation for any purpose is hereby granted without fee, -provided that the above copyright notice appear in all copies and that -both that copyright notice and this permission notice appear in -supporting documentation. CERN makes no representations about the -suitability of this software for any purpose. It is provided "as is" -without expressed or implied warranty. - - - -Content of Trove's LICENSE.txt: - - - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 - - Copyright (C) 1991, 1999 Free Software Foundation, Inc. - 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - -[This is the first released version of the Lesser GPL. It also counts - as the successor of the GNU Library Public License, version 2, hence - the version number 2.1.] - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -Licenses are intended to guarantee your freedom to share and change -free software--to make sure the software is free for all its users. - - This license, the Lesser General Public License, applies to some -specially designated software packages--typically libraries--of the -Free Software Foundation and other authors who decide to use it. You -can use it too, but we suggest you first think carefully about whether -this license or the ordinary General Public License is the better -strategy to use in any particular case, based on the explanations below. - - When we speak of free software, we are referring to freedom of use, -not price. Our General Public Licenses are designed to make sure that -you have the freedom to distribute copies of free software (and charge -for this service if you wish); that you receive source code or can get -it if you want it; that you can change the software and use pieces of -it in new free programs; and that you are informed that you can do -these things. - - To protect your rights, we need to make restrictions that forbid -distributors to deny you these rights or to ask you to surrender these -rights. These restrictions translate to certain responsibilities for -you if you distribute copies of the library or if you modify it. - - For example, if you distribute copies of the library, whether gratis -or for a fee, you must give the recipients all the rights that we gave -you. You must make sure that they, too, receive or can get the source -code. If you link other code with the library, you must provide -complete object files to the recipients, so that they can relink them -with the library after making changes to the library and recompiling -it. And you must show them these terms so they know their rights. - - We protect your rights with a two-step method: (1) we copyright the -library, and (2) we offer you this license, which gives you legal -permission to copy, distribute and/or modify the library. - - To protect each distributor, we want to make it very clear that -there is no warranty for the free library. Also, if the library is -modified by someone else and passed on, the recipients should know -that what they have is not the original version, so that the original -author's reputation will not be affected by problems that might be -introduced by others. - - Finally, software patents pose a constant threat to the existence of -any free program. We wish to make sure that a company cannot -effectively restrict the users of a free program by obtaining a -restrictive license from a patent holder. Therefore, we insist that -any patent license obtained for a version of the library must be -consistent with the full freedom of use specified in this license. - - Most GNU software, including some libraries, is covered by the -ordinary GNU General Public License. This license, the GNU Lesser -General Public License, applies to certain designated libraries, and -is quite different from the ordinary General Public License. We use -this license for certain libraries in order to permit linking those -libraries into non-free programs. - - When a program is linked with a library, whether statically or using -a shared library, the combination of the two is legally speaking a -combined work, a derivative of the original library. The ordinary -General Public License therefore permits such linking only if the -entire combination fits its criteria of freedom. The Lesser General -Public License permits more lax criteria for linking other code with -the library. - - We call this license the "Lesser" General Public License because it -does Less to protect the user's freedom than the ordinary General -Public License. It also provides other free software developers Less -of an advantage over competing non-free programs. These disadvantages -are the reason we use the ordinary General Public License for many -libraries. However, the Lesser license provides advantages in certain -special circumstances. - - For example, on rare occasions, there may be a special need to -encourage the widest possible use of a certain library, so that it becomes -a de-facto standard. To achieve this, non-free programs must be -allowed to use the library. A more frequent case is that a free -library does the same job as widely used non-free libraries. In this -case, there is little to gain by limiting the free library to free -software only, so we use the Lesser General Public License. - - In other cases, permission to use a particular library in non-free -programs enables a greater number of people to use a large body of -free software. For example, permission to use the GNU C Library in -non-free programs enables many more people to use the whole GNU -operating system, as well as its variant, the GNU/Linux operating -system. - - Although the Lesser General Public License is Less protective of the -users' freedom, it does ensure that the user of a program that is -linked with the Library has the freedom and the wherewithal to run -that program using a modified version of the Library. - - The precise terms and conditions for copying, distribution and -modification follow. Pay close attention to the difference between a -"work based on the library" and a "work that uses the library". The -former contains code derived from the library, whereas the latter must -be combined with the library in order to run. - - GNU LESSER GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License Agreement applies to any software library or other -program which contains a notice placed by the copyright holder or -other authorized party saying it may be distributed under the terms of -this Lesser General Public License (also called "this License"). -Each licensee is addressed as "you". - - A "library" means a collection of software functions and/or data -prepared so as to be conveniently linked with application programs -(which use some of those functions and data) to form executables. - - The "Library", below, refers to any such software library or work -which has been distributed under these terms. A "work based on the -Library" means either the Library or any derivative work under -copyright law: that is to say, a work containing the Library or a -portion of it, either verbatim or with modifications and/or translated -straightforwardly into another language. (Hereinafter, translation is -included without limitation in the term "modification".) - - "Source code" for a work means the preferred form of the work for -making modifications to it. For a library, complete source code means -all the source code for all modules it contains, plus any associated -interface definition files, plus the scripts used to control compilation -and installation of the library. - - Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running a program using the Library is not restricted, and output from -such a program is covered only if its contents constitute a work based -on the Library (independent of the use of the Library in a tool for -writing it). Whether that is true depends on what the Library does -and what the program that uses the Library does. - - 1. You may copy and distribute verbatim copies of the Library's -complete source code as you receive it, in any medium, provided that -you conspicuously and appropriately publish on each copy an -appropriate copyright notice and disclaimer of warranty; keep intact -all the notices that refer to this License and to the absence of any -warranty; and distribute a copy of this License along with the -Library. - - You may charge a fee for the physical act of transferring a copy, -and you may at your option offer warranty protection in exchange for a -fee. - - 2. You may modify your copy or copies of the Library or any portion -of it, thus forming a work based on the Library, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) The modified work must itself be a software library. - - b) You must cause the files modified to carry prominent notices - stating that you changed the files and the date of any change. - - c) You must cause the whole of the work to be licensed at no - charge to all third parties under the terms of this License. - - d) If a facility in the modified Library refers to a function or a - table of data to be supplied by an application program that uses - the facility, other than as an argument passed when the facility - is invoked, then you must make a good faith effort to ensure that, - in the event an application does not supply such function or - table, the facility still operates, and performs whatever part of - its purpose remains meaningful. - - (For example, a function in a library to compute square roots has - a purpose that is entirely well-defined independent of the - application. Therefore, Subsection 2d requires that any - application-supplied function or table used by this function must - be optional: if the application does not supply it, the square - root function must still compute square roots.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Library, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Library, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote -it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Library. - -In addition, mere aggregation of another work not based on the Library -with the Library (or with a work based on the Library) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may opt to apply the terms of the ordinary GNU General Public -License instead of this License to a given copy of the Library. To do -this, you must alter all the notices that refer to this License, so -that they refer to the ordinary GNU General Public License, version 2, -instead of to this License. (If a newer version than version 2 of the -ordinary GNU General Public License has appeared, then you can specify -that version instead if you wish.) Do not make any other change in -these notices. - - Once this change is made in a given copy, it is irreversible for -that copy, so the ordinary GNU General Public License applies to all -subsequent copies and derivative works made from that copy. - - This option is useful when you wish to copy part of the code of -the Library into a program that is not a library. - - 4. You may copy and distribute the Library (or a portion or -derivative of it, under Section 2) in object code or executable form -under the terms of Sections 1 and 2 above provided that you accompany -it with the complete corresponding machine-readable source code, which -must be distributed under the terms of Sections 1 and 2 above on a -medium customarily used for software interchange. - - If distribution of object code is made by offering access to copy -from a designated place, then offering equivalent access to copy the -source code from the same place satisfies the requirement to -distribute the source code, even though third parties are not -compelled to copy the source along with the object code. - - 5. A program that contains no derivative of any portion of the -Library, but is designed to work with the Library by being compiled or -linked with it, is called a "work that uses the Library". Such a -work, in isolation, is not a derivative work of the Library, and -therefore falls outside the scope of this License. - - However, linking a "work that uses the Library" with the Library -creates an executable that is a derivative of the Library (because it -contains portions of the Library), rather than a "work that uses the -library". The executable is therefore covered by this License. -Section 6 states terms for distribution of such executables. - - When a "work that uses the Library" uses material from a header file -that is part of the Library, the object code for the work may be a -derivative work of the Library even though the source code is not. -Whether this is true is especially significant if the work can be -linked without the Library, or if the work is itself a library. The -threshold for this to be true is not precisely defined by law. - - If such an object file uses only numerical parameters, data -structure layouts and accessors, and small macros and small inline -functions (ten lines or less in length), then the use of the object -file is unrestricted, regardless of whether it is legally a derivative -work. (Executables containing this object code plus portions of the -Library will still fall under Section 6.) - - Otherwise, if the work is a derivative of the Library, you may -distribute the object code for the work under the terms of Section 6. -Any executables containing that work also fall under Section 6, -whether or not they are linked directly with the Library itself. - - 6. As an exception to the Sections above, you may also combine or -link a "work that uses the Library" with the Library to produce a -work containing portions of the Library, and distribute that work -under terms of your choice, provided that the terms permit -modification of the work for the customer's own use and reverse -engineering for debugging such modifications. - - You must give prominent notice with each copy of the work that the -Library is used in it and that the Library and its use are covered by -this License. You must supply a copy of this License. If the work -during execution displays copyright notices, you must include the -copyright notice for the Library among them, as well as a reference -directing the user to the copy of this License. Also, you must do one -of these things: - - a) Accompany the work with the complete corresponding - machine-readable source code for the Library including whatever - changes were used in the work (which must be distributed under - Sections 1 and 2 above); and, if the work is an executable linked - with the Library, with the complete machine-readable "work that - uses the Library", as object code and/or source code, so that the - user can modify the Library and then relink to produce a modified - executable containing the modified Library. (It is understood - that the user who changes the contents of definitions files in the - Library will not necessarily be able to recompile the application - to use the modified definitions.) - - b) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (1) uses at run time a - copy of the library already present on the user's computer system, - rather than copying library functions into the executable, and (2) - will operate properly with a modified version of the library, if - the user installs one, as long as the modified version is - interface-compatible with the version that the work was made with. - - c) Accompany the work with a written offer, valid for at - least three years, to give the same user the materials - specified in Subsection 6a, above, for a charge no more - than the cost of performing this distribution. - - d) If distribution of the work is made by offering access to copy - from a designated place, offer equivalent access to copy the above - specified materials from the same place. - - e) Verify that the user has already received a copy of these - materials or that you have already sent this user a copy. - - For an executable, the required form of the "work that uses the -Library" must include any data and utility programs needed for -reproducing the executable from it. However, as a special exception, -the materials to be distributed need not include anything that is -normally distributed (in either source or binary form) with the major -components (compiler, kernel, and so on) of the operating system on -which the executable runs, unless that component itself accompanies -the executable. - - It may happen that this requirement contradicts the license -restrictions of other proprietary libraries that do not normally -accompany the operating system. Such a contradiction means you cannot -use both them and the Library together in an executable that you -distribute. - - 7. You may place library facilities that are a work based on the -Library side-by-side in a single library together with other library -facilities not covered by this License, and distribute such a combined -library, provided that the separate distribution of the work based on -the Library and of the other library facilities is otherwise -permitted, and provided that you do these two things: - - a) Accompany the combined library with a copy of the same work - based on the Library, uncombined with any other library - facilities. This must be distributed under the terms of the - Sections above. - - b) Give prominent notice with the combined library of the fact - that part of it is a work based on the Library, and explaining - where to find the accompanying uncombined form of the same work. - - 8. You may not copy, modify, sublicense, link with, or distribute -the Library except as expressly provided under this License. Any -attempt otherwise to copy, modify, sublicense, link with, or -distribute the Library is void, and will automatically terminate your -rights under this License. However, parties who have received copies, -or rights, from you under this License will not have their licenses -terminated so long as such parties remain in full compliance. - - 9. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Library or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Library (or any work based on the -Library), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Library or works based on it. - - 10. Each time you redistribute the Library (or any work based on the -Library), the recipient automatically receives a license from the -original licensor to copy, distribute, link with or modify the Library -subject to these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties with -this License. - - 11. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Library at all. For example, if a patent -license would not permit royalty-free redistribution of the Library by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Library. - -If any portion of this section is held invalid or unenforceable under any -particular circumstance, the balance of the section is intended to apply, -and the section as a whole is intended to apply in other circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 12. If the distribution and/or use of the Library is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Library under this License may add -an explicit geographical distribution limitation excluding those countries, -so that distribution is permitted only in or among countries not thus -excluded. In such case, this License incorporates the limitation as if -written in the body of this License. - - 13. The Free Software Foundation may publish revised and/or new -versions of the Lesser General Public License from time to time. -Such new versions will be similar in spirit to the present version, -but may differ in detail to address new problems or concerns. - -Each version is given a distinguishing version number. If the Library -specifies a version number of this License which applies to it and -"any later version", you have the option of following the terms and -conditions either of that version or of any later version published by -the Free Software Foundation. If the Library does not specify a -license version number, you may choose any version ever published by -the Free Software Foundation. - - 14. If you wish to incorporate parts of the Library into other free -programs whose distribution conditions are incompatible with these, -write to the author to ask for permission. For software which is -copyrighted by the Free Software Foundation, write to the Free -Software Foundation; we sometimes make exceptions for this. Our -decision will be guided by the two goals of preserving the free status -of all derivatives of our free software and of promoting the sharing -and reuse of software generally. - - NO WARRANTY - - 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO -WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. -EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR -OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY -KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE -LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME -THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN -WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY -AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU -FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR -CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE -LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING -RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A -FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF -SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Libraries - - If you develop a new library, and you want it to be of the greatest -possible use to the public, we recommend making it free software that -everyone can redistribute and change. You can do so by permitting -redistribution under these terms (or, alternatively, under the terms of the -ordinary General Public License). - - To apply these terms, attach the following notices to the library. It is -safest to attach them to the start of each source file to most effectively -convey 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 library's name and a brief idea of what it does.> - Copyright (C) <year> <name of author> - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - -Also add information on how to contact you by electronic and paper mail. - -You should also get your employer (if you work as a programmer) or your -school, if any, to sign a "copyright disclaimer" for the library, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the - library `Frob' (a library for tweaking knobs) written by James Random Hacker. - - <signature of Ty Coon>, 1 April 1990 - Ty Coon, President of Vice - -That's all there is to it! - - Added: tinytim/trunk/lib/tmapi-2.0RC1-tests.jar =================================================================== (Binary files differ) Property changes on: tinytim/trunk/lib/tmapi-2.0RC1-tests.jar ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Added: tinytim/trunk/lib/tmapi-2.0RC1.jar =================================================================== (Binary files differ) Property changes on: tinytim/trunk/lib/tmapi-2.0RC1.jar ___________________________________________________________________ Added: svn:mime-type + application/octet-stream Deleted: tinytim/trunk/lib/tmapi-2.0b1-tests.jar =================================================================== (Binary files differ) Deleted: tinytim/trunk/lib/tmapi-2.0b1.jar =================================================================== (Binary files differ) Deleted: tinytim/trunk/lib/trove-2.1.0.jar =================================================================== (Binary files differ) Modified: tinytim/trunk/src/main/java/org/tinytim/internal/utils/CollectionFactory.java =================================================================== --- tinytim/trunk/src/main/java/org/tinytim/internal/utils/CollectionFactory.java 2009-10-09 11:54:46 UTC (rev 359) +++ tinytim/trunk/src/main/java/org/tinytim/internal/utils/CollectionFactory.java 2009-11-04 16:58:30 UTC (rev 360) @@ -31,22 +31,8 @@ */ public final class CollectionFactory { - private static final String _COLL_FACTORY_TROVE = "org.tinytim.internal.utils.TroveCollectionFactory"; + private static final ICollectionFactory _COLL_FACTORY = new OntopiaCollectionFactory(); - private static final ICollectionFactory _COLL_FACTORY; - - static { - ICollectionFactory collFactory; - try { - Class.forName("gnu.trove.THashSet"); - collFactory = (ICollectionFactory) Class.forName(_COLL_FACTORY_TROVE).newInstance(); - } - catch (Exception ex) { - collFactory = new JavaCollectionFactory(); - } - _COLL_FACTORY = collFactory; - } - private CollectionFactory() { // noop. } Added: tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactHashSet.java =================================================================== --- tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactHashSet.java (rev 0) +++ tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactHashSet.java 2009-11-04 16:58:30 UTC (rev 360) @@ -0,0 +1,361 @@ + +// $Id$ + +package org.tinytim.internal.utils; + +// WARNING: If you do any changes to this class, make sure that you +// update CompactIdentityHashSet.java, UniqueSet.java and +// SoftHashMapIndex.java accordingly. + +import java.util.Collection; +import java.util.ConcurrentModificationException; +import java.util.Iterator; +import java.util.NoSuchElementException; + +/** + * INTERNAL: Implements the Set interface more compactly than + * java.util.HashSet by using a closed hashtable. + */ +class CompactHashSet<E> extends java.util.AbstractSet<E> { + + protected final static int INITIAL_SIZE = 3; + protected final static double LOAD_FACTOR = 0.75; + + /** + * This object is used to represent null, should clients add that to the set. + */ + protected final static Object nullObject = new Object(); + /** + * When an object is deleted this object is put into the hashtable + * in its place, so that other objects with the same key + * (collisions) further down the hashtable are not lost after we + * delete an object in the collision chain. + */ + protected final static Object deletedObject = new Object(); + protected int elements; + protected int freecells; + protected Object[] objects; + protected int modCount; + + /** + * Constructs a new, empty set. + */ + public CompactHashSet() { + objects = new Object[INITIAL_SIZE]; + elements = 0; + freecells = objects.length; + modCount = 0; + } + + /** + * Constructs a new, empty set. + */ + public CompactHashSet(int size) { + // NOTE: If array size is 0, we get a + // "java.lang.ArithmeticException: / by zero" in add(Object). + objects = new Object[(size==0 ? 1 : size)]; + elements = 0; + freecells = objects.length; + modCount = 0; + } + + /** + * Constructs a new set containing the elements in the specified + * collection. + * + * @param c the collection whose elements are to be placed into this set. + */ + public CompactHashSet(Collection c) { + this(c.size()); + addAll(c); + } + + // ===== SET IMPLEMENTATION ============================================= + + /** + * Returns an iterator over the elements in this set. The elements + * are returned in no particular order. + * + * @return an Iterator over the elements in this set. + * @see ConcurrentModificationException + */ + public Iterator iterator() { + return new CompactHashIterator(); + } + + /** + * Returns the number of elements in this set (its cardinality). + */ + public int size() { + return elements; + } + + /** + * Returns <tt>true</tt> if this set contains no elements. + */ + public boolean isEmpty() { + return elements == 0; + } + + /** + * Returns <tt>true</tt> if this set contains the specified element. + * + * @param o element whose presence in this set is to be tested. + * @return <tt>true</tt> if this set contains the specified element. + */ + public boolean contains(Object o) { + if (o == null) o = nullObject; + + int hash = o.hashCode(); + int index = (hash & 0x7FFFFFFF) % objects.length; + int offset = 1; + + // search for the object (continue while !null and !this object) + while(objects[index] != null && + !(objects[index].hashCode() == hash && + objects[index].equals(o))) { + index = ((index + offset) & 0x7FFFFFFF) % objects.length; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + return objects[index] != null; + } + + /** + * Adds the specified element to this set if it is not already + * present. + * + * @param o element to be added to this set. + * @return <tt>true</tt> if the set did not already contain the specified + * element. + */ + public boolean add(Object o) { + if (o == null) o = nullObject; + + int hash = o.hashCode(); + int index = (hash & 0x7FFFFFFF) % objects.length; + int offset = 1; + int deletedix = -1; + + // search for the object (continue while !null and !this object) + while(objects[index] != null && + !(objects[index].hashCode() == hash && + objects[index].equals(o))) { + + // if there's a deleted object here we can put this object here, + // provided it's not in here somewhere else already + if (objects[index] == deletedObject) + deletedix = index; + + index = ((index + offset) & 0x7FFFFFFF) % objects.length; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + if (objects[index] == null) { // wasn't present already + if (deletedix != -1) // reusing a deleted cell + index = deletedix; + else + freecells--; + + modCount++; + elements++; + objects[index] = o; + + // rehash with same capacity + if (1 - (freecells / (double) objects.length) > LOAD_FACTOR) { + rehash(objects.length); + // rehash with increased capacity + if (1 - (freecells / (double) objects.length) > LOAD_FACTOR) { + rehash(objects.length*2 + 1); + } + } + return true; + } else // was there already + return false; + } + + /** + * Removes the specified element from the set. + */ + public boolean remove(Object o) { + if (o == null) o = nullObject; + + int hash = o.hashCode(); + int index = (hash & 0x7FFFFFFF) % objects.length; + int offset = 1; + + // search for the object (continue while !null and !this object) + while(objects[index] != null && + !(objects[index].hashCode() == hash && + objects[index].equals(o))) { + index = ((index + offset) & 0x7FFFFFFF) % objects.length; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + // we found the right position, now do the removal + if (objects[index] != null) { + // we found the object + objects[index] = deletedObject; + modCount++; + elements--; + return true; + } else + // we did not find the object + return false; + } + + /** + * Removes all of the elements from this set. + */ + public void clear() { + elements = 0; + for (int ix = 0; ix < objects.length; ix++) + objects[ix] = null; + freecells = objects.length; + modCount++; + } + + public Object[] toArray() { + Object[] result = new Object[elements]; + Object[] objects = this.objects; + int pos = 0; + for (int i = 0; i < objects.length; i++) + if (objects[i] != null && objects[i] != deletedObject) { + if (objects[i] == nullObject) + result[pos++] = null; + else + result[pos++] = objects[i]; + } + return result; + } + + public Object[] toArray(Object a[]) { + int size = elements; + if (a.length < size) + a = (Object[])java.lang.reflect.Array.newInstance( + a.getClass().getComponentType(), size); + Object[] objects = this.objects; + int pos = 0; + for (int i = 0; i < objects.length; i++) + if (objects[i] != null && objects[i] != deletedObject) { + if (objects[i] == nullObject) + a[pos++] = null; + else + a[pos++] = objects[i]; + } + return a; + } + + // ===== INTERNAL METHODS =============================================== + + /** + * INTERNAL: Used for debugging only. + */ + public void dump() { + System.out.println("Size: " + objects.length); + System.out.println("Elements: " + elements); + System.out.println("Free cells: " + freecells); + System.out.println(); + for (int ix = 0; ix < objects.length; ix++) + System.out.println("[" + ix + "]: " + objects[ix]); + } + + /** + * INTERNAL: Rehashes the hashset to a bigger size. + */ + protected void rehash(int newCapacity) { + int oldCapacity = objects.length; + Object[] newObjects = new Object[newCapacity]; + + for (int ix = 0; ix < oldCapacity; ix++) { + Object o = objects[ix]; + if (o == null || o == deletedObject) + continue; + + int hash = o.hashCode(); + int index = (hash & 0x7FFFFFFF) % newCapacity; + int offset = 1; + + // search for the object + while(newObjects[index] != null) { // no need to test for duplicates + index = ((index + offset) & 0x7FFFFFFF) % newCapacity; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + newObjects[index] = o; + } + + objects = newObjects; + freecells = objects.length - elements; + } + + // ===== ITERATOR IMPLEMENTATON ========================================= + + private class CompactHashIterator implements Iterator { + private int index; + private int lastReturned = -1; + + /** + * The modCount value that the iterator believes that the backing + * CompactHashSet should have. If this expectation is violated, + * the iterator has detected concurrent modification. + */ + private int expectedModCount; + + public CompactHashIterator() { + for (index = 0; index < objects.length && + (objects[index] == null || + objects[index] == deletedObject); index++) + ; + expectedModCount = modCount; + } + + public boolean hasNext() { + return index < objects.length; + } + + public Object next() { + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + if (index >= objects.length) { + lastReturned = -2; + throw new NoSuchElementException(); + } + + lastReturned = index; + for (index += 1; index < objects.length && + (objects[index] == null || + objects[index] == deletedObject); index++) + ; + if (objects[lastReturned] == nullObject) + return null; + else + return objects[lastReturned]; + } + + public void remove() { + if (modCount != expectedModCount) + throw new ConcurrentModificationException(); + if (lastReturned == -1 || lastReturned == -2) + throw new IllegalStateException(); + // delete object + if (objects[lastReturned] != null && objects[lastReturned] != deletedObject) { + objects[lastReturned] = deletedObject; + elements--; + } + } + } + +} Property changes on: tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactHashSet.java ___________________________________________________________________ Added: svn:keywords + Rev Date Id Added: svn:eol-style + native Added: tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactIdentityHashSet.java =================================================================== --- tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactIdentityHashSet.java (rev 0) +++ tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactIdentityHashSet.java 2009-11-04 16:58:30 UTC (rev 360) @@ -0,0 +1,172 @@ + +// $Id$ + +package org.tinytim.internal.utils; + +// WARNING: This class is a direct copy of the CompactHashSet.java +// class, but with two changes. The while(...) calls has been changes +// to the new semantics and the use of hashCode() minimized. These +// changes should be repeated every time the CompactHashSet.java +// changes. + +import java.util.Collection; + +/** + * INTERNAL: This class is a specialization of the CompactHashSet + * class, and uses the == operator to compare objects. + */ +class CompactIdentityHashSet<E> extends CompactHashSet<E> { + + public CompactIdentityHashSet() { + } + + public CompactIdentityHashSet(int size) { + super(size); + } + + public CompactIdentityHashSet(Collection coll) { + super(coll); + } + + // ===== SET IMPLEMENTATION ================================================ + + /** + * Returns <tt>true</tt> if this set contains the specified element. + * + * @param o element whose presence in this set is to be tested. + * @return <tt>true</tt> if this set contains the specified element. + */ + public boolean contains(Object o) { + if (o == null) o = nullObject; + + int index = (System.identityHashCode(o) & 0x7FFFFFFF) % objects.length; + int offset = 1; + + // search for the object (continue while !null and !this object) + while(objects[index] != null && objects[index] != o) { + index = ((index + offset) & 0x7FFFFFFF) % objects.length; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + return objects[index] != null; + } + + /** + * Adds the specified element to this set if it is not already + * present. + * + * @param o element to be added to this set. + * @return <tt>true</tt> if the set did not already contain the specified + * element. + */ + public boolean add(Object o) { + if (o == null) o = nullObject; + + int index = (System.identityHashCode(o) & 0x7FFFFFFF) % objects.length; + int offset = 1; + int deletedix = -1; + + // search for the object (continue while !null and !this object) + while(objects[index] != null && objects[index] != o) { + + // if there's a deleted object here we can put this object here, + // provided it's not in here somewhere else already + if (objects[index] == deletedObject) + deletedix = index; + + index = ((index + offset) & 0x7FFFFFFF) % objects.length; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + if (objects[index] == null) { // wasn't present already + if (deletedix != -1) // reusing a deleted cell + index = deletedix; + else + freecells--; + + modCount++; + elements++; + objects[index] = o; + + // rehash with same capacity + if (1 - (freecells / (double) objects.length) > LOAD_FACTOR) { + rehash(objects.length); + // rehash with increased capacity + if (1 - (freecells / (double) objects.length) > LOAD_FACTOR) { + rehash(objects.length*2 + 1); + } + } + return true; + } else // was there already + return false; + } + + /** + * Removes the specified element from the set. + */ + public boolean remove(Object o) { + if (o == null) o = nullObject; + + int index = (System.identityHashCode(o) & 0x7FFFFFFF) % objects.length; + int offset = 1; + + // search for the object (continue while !null and !this object) + while(objects[index] != null && objects[index] != o) { + index = ((index + offset) & 0x7FFFFFFF) % objects.length; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + // we found the right position, now do the removal + if (objects[index] != null) { + // we found the object + objects[index] = deletedObject; + modCount++; + elements--; + return true; + } else + // we did not find the object + return false; + } + + // ===== INTERNAL METHODS ================================================== + + /** + * INTERNAL: Rehashes the hashset to a bigger size. + */ + protected void rehash(int newCapacity) { + int oldCapacity = objects.length; + Object[] newObjects = new Object[newCapacity]; + + for (int ix = 0; ix < oldCapacity; ix++) { + Object o = objects[ix]; + if (o == null || o == deletedObject) + continue; + + int index = (System.identityHashCode(o) & 0x7FFFFFFF) % newCapacity; + int offset = 1; + + // search for the object + while(newObjects[index] != null) { // no need to test for duplicates + index = ((index + offset) & 0x7FFFFFFF) % newCapacity; + offset = offset*2 + 1; + + if (offset == -1) + offset = 2; + } + + newObjects[index] = o; + } + + objects = newObjects; + freecells = objects.length - elements; + } +} Property changes on: tinytim/trunk/src/main/java/org/tinytim/internal/utils/CompactIdentityHashSet.java ___________________________________________________________________ Added: svn:keywords + Rev Date Id Added: svn:eol-style + native Modified: tinytim/trunk/src/main/java/org/tinytim/internal/utils/CopyUtils.java =================================================================== --- tinytim/trunk/src/main/java/org/tinytim/internal/utils/CopyUtils.java 2009-10-09 11:54:46 UTC (rev 359) +++ tinytim/trunk/src/main/java/org/tinytim/internal/utils/CopyUtils.java 2009-11-04 16:58:30 UTC (rev 360) @@ -57,14 +57,14 @@ * @param source The topic map to take the topics and associations from. * @param target The topic map which should receive the topics and associations. */ - public static void copy(TopicMap source, TopicMap target) { + public static void copy(final TopicMap source, final TopicMap target) { _copy(source, (ITopicMap) target); } /** * @see #copy(TopicMap, TopicMap) */ - private static void _copy(TopicMap source, ITopicMap target) { + private static void _copy(final TopicMap source, final ITopicMap target) { if (source == null || target == null) { throw new IllegalArgumentException("Neither the source topic map nor the target topic map must be null"); } @@ -127,8 +127,8 @@ * @param mergeMap The map which holds the merge mappings. * @return The newly created topic in the target topic map. */ - private static ITopic _copyTopic(Topic topic, ITopicMap target, - Map<Topic, Topic> mergeMap) { + private static ITopic _copyTopic(final Topic topic, final ITopicMap target, + final Map<Topic, Topic> mergeMap) { ITopic targetTopic = target.createEmptyTopic(); _copyIdentities(topic, targetTopic); _copyTypes(topic, targetTopic, mergeMap); @@ -143,7 +143,7 @@ * @param topic The topic to take the identities from. * @param targetTopic The topic which gets the identities. */ - private static void _copyIdentities(Topic topic, Topic targetTopic) { + private static void _copyIdentities(final Topic topic, final Topic targetTopic) { for(Locator sid: topic.getSubjectIdentifiers()) { targetTopic.addSubjectIdentifier(sid); } @@ -160,8 +160,8 @@ * @param targetTopic The topic which receives the types. * @param mergeMap The map which holds the merge mappings. */ - private static void _copyTypes(Topic topic, Topic targetTopic, - Map<Topic, Topic> mergeMap) { + private static void _copyTypes(final Topic topic, final Topic targetTopic, + final Map<Topic, Topic> mergeMap) { for (Topic type: topic.getTypes()) { Topic targetType = mergeMap.get(type); if (targetType == null) { @@ -179,8 +179,9 @@ * @param targetTopic The target topic which gets the charateristics. * @param mergeMap The map which holds the merge mappings. */ - private static void _copyCharacteristics(Topic topic, ITopic targetTopic, - Map<Topic, Topic> mergeMap) { + private static void _copyCharacteristics(final Topic topic, + final ITopic targetTopic, + final Map<Topic, Topic> mergeMap) { IIntObjectMap<Reifiable> sigs = CollectionFactory.createIntObjectMap(); for (Occurrence occ: targetTopic.getOccurrences()) { sigs.put(SignatureGenerator.generateSignature(occ), occ); @@ -229,9 +230,9 @@ * @param target The target name which receives the variants. * @param mergeMap The map which holds the merge mappings. */ - private static void _copyVariants(Name source, IName target, - Map<Topic, Topic> mergeMap) { - IIntObjectMap<Variant> sigs = CollectionFactory.createIntObjectMap(); + private static void _copyVariants(final Name source, final IName target, + final Map<Topic, Topic> mergeMap) { + final IIntObjectMap<Variant> sigs = CollectionFactory.createIntObjectMap(); for (Variant variant: target.getVariants()) { sigs.put(SignatureGenerator.generateSignature(variant), variant); } @@ -258,13 +259,14 @@ * @param target The target Topic Maps construct. * @param mergeMap The map which holds the merge mappings. */ - private static void _copyReifier(Reifiable source, Reifiable target, - Map<Topic, Topic> mergeMap) { - Topic sourceReifier = source.getReifier(); + private static void _copyReifier(final Reifiable source, + final Reifiable target, + final Map<Topic, Topic> mergeMap) { + final Topic sourceReifier = source.getReifier(); if (sourceReifier == null) { return; } - Topic reifier = mergeMap.containsKey(sourceReifier) ? mergeMap.get(sourceReifier) + final Topic reifier = mergeMap.containsKey(sourceReifier) ? mergeMap.get(sourceReifier) : _copyTopic(sourceReifier, (ITopicMap) target.getTopicMap(), mergeMap); target.setReifier(reifier); } @@ -276,10 +278,10 @@ * @param target The Topic Maps construct which receives the type. * @param mergeMap The map which holds the merge mappings. */ - private static ITopic _copyType(Typed source, TopicMap tm, - Map<Topic, Topic> mergeMap) { - Topic sourceType = source.getType(); - return mergeMap.containsKey(sourceType) ? (ITopic) mergeMap.get(sourceType) + private static ITopic _copyType(final Typed source, final TopicMap tm, + final Map<Topic, Topic> mergeMap) { + final Topic sourceType = source.getType(); + return mergeMap.containsKey(sourceType) ? (ITopic) mergeMap.get(sourceType) : _copyTopic(sourceType, (ITopicMap) tm, mergeMap); } @@ -291,9 +293,9 @@ * @param target The target which receives the scope. * @param mergeMap The map which holds the merge mappings. */ - private static IScope _copyScope(Scoped source, ITopicMap tm, - Map<Topic, Topic> mergeMap) { - Set<Topic> themes = CollectionFactory.createIdentitySet(source.getScope().size()); + private static IScope _copyScope(final Scoped source, final ITopicMap tm, + final Map<Topic, Topic> mergeMap) { + final Set<Topic> themes = CollectionFactory.createIdentitySet(source.getScope().size()); Topic theme = null; for (Topic sourceTheme: source.getScope()) { theme = mergeMap.containsKey(sourceTheme) ? mergeMap.get(sourceTheme) @@ -309,7 +311,8 @@ * @param source The source Topic Maps construct. * @param target The target Topic Maps construct. */ - private static void _copyItemIdentifiers(Construct source, Construct target) { + private static void _copyItemIdentifiers(final Construct source, + final Construct target) { for(Locator iid: source.getItemIdentifiers()) { target.addItemIdentifier(iid); } @@ -323,10 +326,10 @@ * @param target The topic map which receives the associations. * @param mergeMap The map which holds the merge mappings. */ - private static void _copyAssociations(TopicMap source, - ITopicMap target, Map<Topic, Topic> mergeMap) { - Set<Association> assocs = target.getAssociations(); - IIntObjectMap<Association> sigs = CollectionFactory.createIntObjectMap(assocs.size()); + private static void _copyAssociations(final TopicMap source, + final ITopicMap target, final Map<Topic, Topic> mergeMap) { + final Set<Association> assocs = target.getAssociations(); + final IIntObjectMap<Association> sigs = CollectionFactory.createIntObjectMap(assocs.size()); for (Association assoc: assocs) { sigs.put(SignatureGenerator.generateSignature(assoc), assoc); } @@ -364,8 +367,9 @@ * @param target The target topic. * @param mergeMap The map which holds the merge mappings. */ - private static void _addMerge(Topic source, Topic target, Map<Topic, Topic> mergeMap) { - Topic prevTarget = mergeMap.get(source); + private static void _addMerge(final Topic source, final Topic target, + final Map<Topic, Topic> mergeMap) { + final Topic prevTarget = mergeMap.get(source); if (prevTarget != null) { if (!prevTarget.equals(target)) { MergeUtils.merge(target, prevTarget); Deleted: tinytim/trunk/src/main/java/org/tinytim/internal/utils/JavaCollectionFactory.java =================================================================== --- tinytim/trunk/src/main/java/org/tinytim/internal/utils/JavaCollectionFactory.java 2009-10-09 11:54:46 UTC (rev 359) +++ tinytim/trunk/src/main/java/org/tinytim/internal/utils/JavaCollectionFactory.java 2009-11-04 16:58:30 UTC (rev 360) @@ -1,216 +0,0 @@ -/* - * Copyright 2008 Lars Heuer (heuer[at]semagia.com) - * - * 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 - * distrib... [truncated message content] |