aboutsummaryrefslogtreecommitdiffstats
path: root/infrastructure/net.appjet.common
diff options
context:
space:
mode:
Diffstat (limited to 'infrastructure/net.appjet.common')
-rw-r--r--infrastructure/net.appjet.common/rhino/rhinospect.scala58
-rw-r--r--infrastructure/net.appjet.common/util/BCrypt.java752
-rw-r--r--infrastructure/net.appjet.common/util/BetterFile.java280
-rw-r--r--infrastructure/net.appjet.common/util/ClassReload.java263
-rw-r--r--infrastructure/net.appjet.common/util/ExpiringMapping.java163
-rw-r--r--infrastructure/net.appjet.common/util/HttpServletRequestFactory.java306
-rw-r--r--infrastructure/net.appjet.common/util/LenientFormatter.java2809
-rw-r--r--infrastructure/net.appjet.common/util/LimitedSizeMapping.java28
8 files changed, 4659 insertions, 0 deletions
diff --git a/infrastructure/net.appjet.common/rhino/rhinospect.scala b/infrastructure/net.appjet.common/rhino/rhinospect.scala
new file mode 100644
index 0000000..65f278c
--- /dev/null
+++ b/infrastructure/net.appjet.common/rhino/rhinospect.scala
@@ -0,0 +1,58 @@
+/**
+ * Copyright 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 net.appjet.common.rhino;
+
+import java.lang.reflect.Modifier;
+
+object rhinospect {
+
+ def visitFields(obj: Object, func: (String,Any)=>Unit) {
+ var cls: Class[_] = obj.getClass;
+
+ if (cls.isArray) {
+ import java.lang.reflect.Array;
+ for(i <- 0 until Array.getLength(obj)) {
+ func(String.valueOf(i), Array.get(obj, i));
+ }
+ }
+ else {
+ while (cls ne null) {
+ for (f <- cls.getDeclaredFields) {
+ if (! Modifier.isStatic(f.getModifiers)) {
+ f.setAccessible(true);
+ val nm = f.getName;
+ val vl = f.get(obj);
+ func(nm, vl);
+ }
+ }
+ cls = cls.getSuperclass;
+ }
+ }
+ }
+
+ def dumpFields(obj: Object, depth: Int, prefix: String): String = {
+ val s = new java.io.StringWriter();
+ val out = new java.io.PrintWriter(s);
+ visitFields(obj, (name: String, value: Any) => {
+ out.printf("%30s: %s\n", name+prefix, String.valueOf(value));
+ if (depth > 0 && value.isInstanceOf[Object]) {
+ out.print(dumpFields(value.asInstanceOf[Object], depth-1, prefix+" --"));
+ }
+ });
+ s.toString();
+ }
+}
diff --git a/infrastructure/net.appjet.common/util/BCrypt.java b/infrastructure/net.appjet.common/util/BCrypt.java
new file mode 100644
index 0000000..818c261
--- /dev/null
+++ b/infrastructure/net.appjet.common/util/BCrypt.java
@@ -0,0 +1,752 @@
+package net.appjet.common.util;
+
+// Copyright (c) 2006 Damien Miller <djm@mindrot.org>
+//
+// Permission to use, copy, modify, and distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+import java.io.UnsupportedEncodingException;
+
+import java.security.SecureRandom;
+
+/**
+ * BCrypt implements OpenBSD-style Blowfish password hashing using
+ * the scheme described in "A Future-Adaptable Password Scheme" by
+ * Niels Provos and David Mazieres.
+ * <p>
+ * This password hashing system tries to thwart off-line password
+ * cracking using a computationally-intensive hashing algorithm,
+ * based on Bruce Schneier's Blowfish cipher. The work factor of
+ * the algorithm is parameterised, so it can be increased as
+ * computers get faster.
+ * <p>
+ * Usage is really simple. To hash a password for the first time,
+ * call the hashpw method with a random salt, like this:
+ * <p>
+ * <code>
+ * String pw_hash = BCrypt.hashpw(plain_password, BCrypt.gensalt()); <br />
+ * </code>
+ * <p>
+ * To check whether a plaintext password matches one that has been
+ * hashed previously, use the checkpw method:
+ * <p>
+ * <code>
+ * if (BCrypt.checkpw(candidate_password, stored_hash))<br />
+ * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It matches");<br />
+ * else<br />
+ * &nbsp;&nbsp;&nbsp;&nbsp;System.out.println("It does not match");<br />
+ * </code>
+ * <p>
+ * The gensalt() method takes an optional parameter (log_rounds)
+ * that determines the computational complexity of the hashing:
+ * <p>
+ * <code>
+ * String strong_salt = BCrypt.gensalt(10)<br />
+ * String stronger_salt = BCrypt.gensalt(12)<br />
+ * </code>
+ * <p>
+ * The amount of work increases exponentially (2**log_rounds), so
+ * each increment is twice as much work. The default log_rounds is
+ * 10, and the valid range is 4 to 31.
+ *
+ * @author Damien Miller
+ * @version 0.2
+ */
+public class BCrypt {
+ // BCrypt parameters
+ private static int GENSALT_DEFAULT_LOG2_ROUNDS = 10;
+ private static final int BCRYPT_SALT_LEN = 16;
+
+ // Blowfish parameters
+ private static final int BLOWFISH_NUM_ROUNDS = 16;
+
+ // Initial contents of key schedule
+ private static final int P_orig[] = {
+ 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+ 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+ 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+ 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+ 0x9216d5d9, 0x8979fb1b
+ };
+ private static final int S_orig[] = {
+ 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+ 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+ 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+ 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+ 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+ 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+ 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+ 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+ 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+ 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+ 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+ 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+ 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+ 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+ 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+ 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+ 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+ 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+ 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+ 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+ 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+ 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+ 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+ 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+ 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+ 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+ 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+ 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+ 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+ 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+ 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+ 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+ 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+ 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+ 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+ 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+ 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+ 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+ 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+ 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+ 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+ 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+ 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+ 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+ 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+ 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+ 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+ 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+ 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+ 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+ 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+ 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+ 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+ 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+ 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+ 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+ 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+ 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+ 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+ 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+ 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+ 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+ 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+ 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a,
+ 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+ 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+ 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+ 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+ 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+ 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+ 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+ 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+ 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+ 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+ 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+ 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+ 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+ 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+ 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+ 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+ 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+ 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+ 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+ 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+ 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+ 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+ 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+ 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+ 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+ 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+ 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+ 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+ 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+ 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+ 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+ 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+ 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+ 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+ 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+ 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+ 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+ 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+ 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+ 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+ 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+ 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+ 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+ 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+ 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+ 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+ 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+ 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+ 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+ 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+ 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+ 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+ 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+ 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+ 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+ 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+ 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+ 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+ 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+ 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+ 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+ 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+ 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+ 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7,
+ 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+ 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+ 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+ 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+ 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+ 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+ 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+ 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+ 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+ 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+ 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+ 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+ 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+ 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+ 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+ 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+ 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+ 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+ 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+ 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+ 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+ 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+ 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+ 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+ 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+ 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+ 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+ 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+ 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+ 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+ 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+ 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+ 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+ 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+ 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+ 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+ 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+ 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+ 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+ 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+ 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+ 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+ 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+ 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+ 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+ 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+ 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+ 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+ 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+ 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+ 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+ 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+ 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+ 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+ 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+ 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+ 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+ 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+ 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+ 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+ 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+ 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+ 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+ 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0,
+ 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+ 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+ 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+ 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+ 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+ 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+ 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+ 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+ 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+ 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+ 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+ 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+ 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+ 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+ 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+ 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+ 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+ 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+ 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+ 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+ 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+ 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+ 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+ 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+ 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+ 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+ 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+ 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+ 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+ 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+ 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+ 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+ 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+ 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+ 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+ 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+ 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+ 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+ 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+ 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+ 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+ 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+ 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+ 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+ 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+ 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+ 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+ 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+ 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+ 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+ 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+ 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+ 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+ 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+ 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+ 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+ 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+ 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+ 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+ 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+ 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+ 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+ 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+ 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
+ };
+
+ // bcrypt IV: "OrpheanBeholderScryDoubt"
+ static private final int bf_crypt_ciphertext[] = {
+ 0x4f727068, 0x65616e42, 0x65686f6c,
+ 0x64657253, 0x63727944, 0x6f756274
+ };
+
+ // Table for Base64 encoding
+ static private final char base64_code[] = {
+ '.', '/', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
+ 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
+ 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
+ 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
+ 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
+ '6', '7', '8', '9'
+ };
+
+ // Table for Base64 decoding
+ static private final byte index_64[] = {
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 0, 1, 54, 55,
+ 56, 57, 58, 59, 60, 61, 62, 63, -1, -1,
+ -1, -1, -1, -1, -1, 2, 3, 4, 5, 6,
+ 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+ 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
+ -1, -1, -1, -1, -1, -1, 28, 29, 30,
+ 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+ 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
+ 51, 52, 53, -1, -1, -1, -1, -1
+ };
+
+ // Expanded Blowfish key
+ private int P[];
+ private int S[];
+
+ /**
+ * Encode a byte array using bcrypt's slightly-modified base64
+ * encoding scheme. Note that this is *not* compatible with
+ * the standard MIME-base64 encoding.
+ *
+ * @param d the byte array to encode
+ * @param len the number of bytes to encode
+ * @return base64-encoded string
+ * @exception IllegalArgumentException if the length is invalid
+ */
+ private static String encode_base64(byte d[], int len)
+ throws IllegalArgumentException {
+ int off = 0;
+ StringBuffer rs = new StringBuffer();
+ int c1, c2;
+
+ if (len <= 0 || len > d.length)
+ throw new IllegalArgumentException ("Invalid len");
+
+ while (off < len) {
+ c1 = d[off++] & 0xff;
+ rs.append(base64_code[(c1 >> 2) & 0x3f]);
+ c1 = (c1 & 0x03) << 4;
+ if (off >= len) {
+ rs.append(base64_code[c1 & 0x3f]);
+ break;
+ }
+ c2 = d[off++] & 0xff;
+ c1 |= (c2 >> 4) & 0x0f;
+ rs.append(base64_code[c1 & 0x3f]);
+ c1 = (c2 & 0x0f) << 2;
+ if (off >= len) {
+ rs.append(base64_code[c1 & 0x3f]);
+ break;
+ }
+ c2 = d[off++] & 0xff;
+ c1 |= (c2 >> 6) & 0x03;
+ rs.append(base64_code[c1 & 0x3f]);
+ rs.append(base64_code[c2 & 0x3f]);
+ }
+ return rs.toString();
+ }
+
+ /**
+ * Look up the 3 bits base64-encoded by the specified character,
+ * range-checking againt conversion table
+ * @param x the base64-encoded value
+ * @return the decoded value of x
+ */
+ private static byte char64(char x) {
+ if ((int)x < 0 || (int)x > index_64.length)
+ return -1;
+ return index_64[(int)x];
+ }
+
+ /**
+ * Decode a string encoded using bcrypt's base64 scheme to a
+ * byte array. Note that this is *not* compatible with
+ * the standard MIME-base64 encoding.
+ * @param s the string to decode
+ * @param maxolen the maximum number of bytes to decode
+ * @return an array containing the decoded bytes
+ * @throws IllegalArgumentException if maxolen is invalid
+ */
+ private static byte[] decode_base64(String s, int maxolen)
+ throws IllegalArgumentException {
+ StringBuffer rs = new StringBuffer();
+ int off = 0, slen = s.length(), olen = 0;
+ byte ret[];
+ byte c1, c2, c3, c4, o;
+
+ if (maxolen <= 0)
+ throw new IllegalArgumentException ("Invalid maxolen");
+
+ while (off < slen - 1 && olen < maxolen) {
+ c1 = char64(s.charAt(off++));
+ c2 = char64(s.charAt(off++));
+ if (c1 == -1 || c2 == -1)
+ break;
+ o = (byte)(c1 << 2);
+ o |= (c2 & 0x30) >> 4;
+ rs.append((char)o);
+ if (++olen >= maxolen || off >= slen)
+ break;
+ c3 = char64(s.charAt(off++));
+ if (c3 == -1)
+ break;
+ o = (byte)((c2 & 0x0f) << 4);
+ o |= (c3 & 0x3c) >> 2;
+ rs.append((char)o);
+ if (++olen >= maxolen || off >= slen)
+ break;
+ c4 = char64(s.charAt(off++));
+ o = (byte)((c3 & 0x03) << 6);
+ o |= c4;
+ rs.append((char)o);
+ ++olen;
+ }
+
+ ret = new byte[olen];
+ for (off = 0; off < olen; off++)
+ ret[off] = (byte)rs.charAt(off);
+ return ret;
+ }
+
+ /**
+ * Blowfish encipher a single 64-bit block encoded as
+ * two 32-bit halves
+ * @param lr an array containing the two 32-bit half blocks
+ * @param off the position in the array of the blocks
+ */
+ private final void encipher(int lr[], int off) {
+ int i, n, l = lr[off], r = lr[off + 1];
+
+ l ^= P[0];
+ for (i = 0; i <= BLOWFISH_NUM_ROUNDS - 2;) {
+ // Feistel substitution on left word
+ n = S[(l >> 24) & 0xff];
+ n += S[0x100 | ((l >> 16) & 0xff)];
+ n ^= S[0x200 | ((l >> 8) & 0xff)];
+ n += S[0x300 | (l & 0xff)];
+ r ^= n ^ P[++i];
+
+ // Feistel substitution on right word
+ n = S[(r >> 24) & 0xff];
+ n += S[0x100 | ((r >> 16) & 0xff)];
+ n ^= S[0x200 | ((r >> 8) & 0xff)];
+ n += S[0x300 | (r & 0xff)];
+ l ^= n ^ P[++i];
+ }
+ lr[off] = r ^ P[BLOWFISH_NUM_ROUNDS + 1];
+ lr[off + 1] = l;
+ }
+
+ /**
+ * Cycically extract a word of key material
+ * @param data the string to extract the data from
+ * @param offp a "pointer" (as a one-entry array) to the
+ * current offset into data
+ * @return the next word of material from data
+ */
+ private static int streamtoword(byte data[], int offp[]) {
+ int i;
+ int word = 0;
+ int off = offp[0];
+
+ for (i = 0; i < 4; i++) {
+ word = (word << 8) | (data[off] & 0xff);
+ off = (off + 1) % data.length;
+ }
+
+ offp[0] = off;
+ return word;
+ }
+
+ /**
+ * Initialise the Blowfish key schedule
+ */
+ private void init_key() {
+ P = (int[])P_orig.clone();
+ S = (int[])S_orig.clone();
+ }
+
+ /**
+ * Key the Blowfish cipher
+ * @param key an array containing the key
+ */
+ private void key(byte key[]) {
+ int i;
+ int koffp[] = { 0 };
+ int lr[] = { 0, 0 };
+ int plen = P.length, slen = S.length;
+
+ for (i = 0; i < plen; i++)
+ P[i] = P[i] ^ streamtoword(key, koffp);
+
+ for (i = 0; i < plen; i += 2) {
+ encipher(lr, 0);
+ P[i] = lr[0];
+ P[i + 1] = lr[1];
+ }
+
+ for (i = 0; i < slen; i += 2) {
+ encipher(lr, 0);
+ S[i] = lr[0];
+ S[i + 1] = lr[1];
+ }
+ }
+
+ /**
+ * Perform the "enhanced key schedule" step described by
+ * Provos and Mazieres in "A Future-Adaptable Password Scheme"
+ * http://www.openbsd.org/papers/bcrypt-paper.ps
+ * @param data salt information
+ * @param key password information
+ */
+ private void ekskey(byte data[], byte key[]) {
+ int i;
+ int koffp[] = { 0 }, doffp[] = { 0 };
+ int lr[] = { 0, 0 };
+ int plen = P.length, slen = S.length;
+
+ for (i = 0; i < plen; i++)
+ P[i] = P[i] ^ streamtoword(key, koffp);
+
+ for (i = 0; i < plen; i += 2) {
+ lr[0] ^= streamtoword(data, doffp);
+ lr[1] ^= streamtoword(data, doffp);
+ encipher(lr, 0);
+ P[i] = lr[0];
+ P[i + 1] = lr[1];
+ }
+
+ for (i = 0; i < slen; i += 2) {
+ lr[0] ^= streamtoword(data, doffp);
+ lr[1] ^= streamtoword(data, doffp);
+ encipher(lr, 0);
+ S[i] = lr[0];
+ S[i + 1] = lr[1];
+ }
+ }
+
+ /**
+ * Perform the central password hashing step in the
+ * bcrypt scheme
+ * @param password the password to hash
+ * @param salt the binary salt to hash with the password
+ * @param log_rounds the binary logarithm of the number
+ * of rounds of hashing to apply
+ * @return an array containing the binary hashed password
+ */
+ private byte[] crypt_raw(byte password[], byte salt[], int log_rounds) {
+ int rounds, i, j;
+ int cdata[] = (int[])bf_crypt_ciphertext.clone();
+ int clen = cdata.length;
+ byte ret[];
+
+ if (log_rounds < 4 || log_rounds > 31)
+ throw new IllegalArgumentException ("Bad number of rounds");
+ rounds = 1 << log_rounds;
+ if (salt.length != BCRYPT_SALT_LEN)
+ throw new IllegalArgumentException ("Bad salt length");
+
+ init_key();
+ ekskey(salt, password);
+ for (i = 0; i < rounds; i++) {
+ key(password);
+ key(salt);
+ }
+
+ for (i = 0; i < 64; i++) {
+ for (j = 0; j < (clen >> 1); j++)
+ encipher(cdata, j << 1);
+ }
+
+ ret = new byte[clen * 4];
+ for (i = 0, j = 0; i < clen; i++) {
+ ret[j++] = (byte)((cdata[i] >> 24) & 0xff);
+ ret[j++] = (byte)((cdata[i] >> 16) & 0xff);
+ ret[j++] = (byte)((cdata[i] >> 8) & 0xff);
+ ret[j++] = (byte)(cdata[i] & 0xff);
+ }
+ return ret;
+ }
+
+ /**
+ * Hash a password using the OpenBSD bcrypt scheme
+ * @param password the password to hash
+ * @param salt the salt to hash with (perhaps generated
+ * using BCrypt.gensalt)
+ * @return the hashed password
+ */
+ public static String hashpw(String password, String salt) {
+ BCrypt B;
+ String real_salt;
+ byte passwordb[], saltb[], hashed[];
+ char minor = (char)0;
+ int rounds, off = 0;
+ StringBuffer rs = new StringBuffer();
+
+ if (salt.charAt(0) != '$' || salt.charAt(1) != '2')
+ throw new IllegalArgumentException ("Invalid salt version");
+ if (salt.charAt(1) != '$') {
+ minor = salt.charAt(2);
+ if (minor != 'a' || salt.charAt(3) != '$')
+ throw new IllegalArgumentException ("Invalid salt revision");
+ off = 4;
+ } else
+ off = 3;
+
+ // Extract number of rounds
+ if (salt.charAt(off + 2) > '$')
+ throw new IllegalArgumentException ("Missing salt rounds");
+ rounds = Integer.parseInt(salt.substring(off, off + 2));
+
+ real_salt = salt.substring(off + 3, off + 25);
+ try {
+ passwordb = (password + (minor >= 'a' ? "\000" : "")).getBytes("US-ASCII");
+ } catch (UnsupportedEncodingException uee) {
+ // The JDK guarantees that US-ASCII is supported.
+ throw new AssertionError("US-ASCII is not supported");
+ }
+
+ saltb = decode_base64(real_salt, BCRYPT_SALT_LEN);
+
+ B = new BCrypt();
+ hashed = B.crypt_raw(passwordb, saltb, rounds);
+
+ rs.append("$2");
+ if (minor >= 'a')
+ rs.append(minor);
+ rs.append("$");
+ if (rounds < 10)
+ rs.append("0");
+ rs.append(Integer.toString(rounds));
+ rs.append("$");
+ rs.append(encode_base64(saltb, saltb.length));
+ rs.append(encode_base64(hashed,
+ bf_crypt_ciphertext.length * 4 - 1));
+ return rs.toString();
+ }
+
+ /**
+ * Generate a salt for use with the BCrypt.hashpw() method
+ * @param log_rounds the log2 of the number of rounds of
+ * hashing to apply - the work factor therefore increases as
+ * 2**log_rounds.
+ * @param random an instance of SecureRandom to use
+ * @return an encoded salt value
+ */
+ public static String gensalt(int log_rounds, SecureRandom random) {
+ StringBuffer rs = new StringBuffer();
+ byte rnd[] = new byte[BCRYPT_SALT_LEN];
+
+ random.nextBytes(rnd);
+
+ rs.append("$2a$");
+ if (log_rounds < 10)
+ rs.append("0");
+ rs.append(Integer.toString(log_rounds));
+ rs.append("$");
+ rs.append(encode_base64(rnd, rnd.length));
+ return rs.toString();
+ }
+
+ /**
+ * Generate a salt for use with the BCrypt.hashpw() method
+ * @param log_rounds the log2 of the number of rounds of
+ * hashing to apply - the work factor therefore increases as
+ * 2**log_rounds.
+ * @return an encoded salt value
+ */
+ public static String gensalt(int log_rounds) {
+ return gensalt(log_rounds, new SecureRandom());
+ }
+
+ /**
+ * Generate a salt for use with the BCrypt.hashpw() method,
+ * selecting a reasonable default for the number of hashing
+ * rounds to apply
+ * @return an encoded salt value
+ */
+ public static String gensalt() {
+ return gensalt(GENSALT_DEFAULT_LOG2_ROUNDS);
+ }
+
+ /**
+ * Check that a plaintext password matches a previously hashed
+ * one
+ * @param plaintext the plaintext password to verify
+ * @param hashed the previously-hashed password
+ * @return true if the passwords match, false otherwise
+ */
+ public static boolean checkpw(String plaintext, String hashed) {
+ return (hashed.compareTo(hashpw(plaintext, hashed)) == 0);
+ }
+}
diff --git a/infrastructure/net.appjet.common/util/BetterFile.java b/infrastructure/net.appjet.common/util/BetterFile.java
new file mode 100644
index 0000000..c674810
--- /dev/null
+++ b/infrastructure/net.appjet.common/util/BetterFile.java
@@ -0,0 +1,280 @@
+/**
+ * Copyright 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 net.appjet.common.util;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.*;
+
+
+/**
+ * A bunch of stuff that should've been in the Java Standard Libraries.
+ */
+public class BetterFile {
+ public static String getFileContents(File f, boolean t) throws FileNotFoundException {
+ FileInputStream in;
+ try {
+ in = new FileInputStream(f);
+ } catch (FileNotFoundException e) {
+ if (t) throw e;
+ return null;
+ }
+ return getStreamContents(in);
+ }
+
+ public static String getFileContents(File f) {
+ try {
+ return getFileContents(f, false);
+ } catch (FileNotFoundException e) {
+ // won't ever get here.
+ }
+ return null;
+ }
+
+ public static String getBinaryFileContents(File f) {
+ FileInputStream in;
+ try {
+ in = new FileInputStream(f);
+ } catch (FileNotFoundException e) {
+ e.printStackTrace();
+ return null;
+ }
+
+ return getBinaryStreamContents(in);
+ }
+
+ // Using the non-converting String contructor here. Yum.
+ @SuppressWarnings({"deprecation"})
+ public static String getBinaryStreamContents(InputStream in) {
+ StringBuilder out = new StringBuilder();
+ byte[] b = new byte[4096];
+ try {
+ for (int n; (n = in.read(b)) != -1 ;) {
+ out.append(new String(b, 0, 0, n));
+ }
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ }
+ return out.toString();
+ }
+
+ public static String getStreamContents(InputStream instream) {
+ InputStreamReader in = new InputStreamReader(instream, java.nio.charset.Charset.forName("UTF-8"));
+ StringBuilder out = new StringBuilder();
+
+ char[] b = new char[4096];
+ try {
+ for (int n; (n = in.read(b)) != -1; ){
+ out.append(b, 0, n);
+ }
+ in.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ }
+ return out.toString();
+ }
+
+ public static String getBinaryFileContents(String filename) {
+ return getBinaryFileContents(new File(filename));
+ }
+
+ public static String getFileContents(String filename) {
+ return getFileContents(new File(filename));
+ }
+
+ public static String getFileContents(String filename, boolean t) throws FileNotFoundException {
+ return getFileContents(new File(filename), t);
+ }
+
+ public static byte[] getStreamBytes(InputStream instream) {
+ byte[] b = new byte[8192];
+ ByteArrayOutputStream baos = new ByteArrayOutputStream(16384);
+ try {
+ for (int n; (n = instream.read(b)) != -1;) {
+ baos.write(b, 0, n);
+ }
+ instream.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ }
+ return baos.toByteArray();
+ }
+
+ public static String getReaderString(BufferedReader reader) {
+ StringBuffer out = new StringBuffer();
+ char[] c = new char[8192];
+ try {
+ for (int n; (n = reader.read(c, 0, c.length)) != -1;) {
+ out.append(c, 0, n);
+ }
+ reader.close();
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ }
+ return out.toString();
+ }
+
+ public static byte[] getFileBytes(File f) {
+ try {
+ return getStreamBytes(new FileInputStream(f));
+ } catch (IOException e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ public static byte[] getFileBytes(String filename) {
+ return getFileBytes(new File(filename));
+ }
+
+ public static String getUnicodeFile(File f) throws FileNotFoundException {
+ return getReaderString(new BufferedReader(new UnicodeReader(new FileInputStream(f), null)));
+ }
+
+ public static String getUnicodeFile(String filename) throws FileNotFoundException {
+ return getUnicodeFile(new File(filename));
+ }
+
+ public static String stringFromUnicode(byte[] bytes) {
+ return getReaderString(new BufferedReader(new UnicodeReader(new ByteArrayInputStream(bytes), null)));
+ }
+
+ // Ripped from: http://koti.mbnet.fi/akini/java/unicodereader/
+ /**
+ version: 1.1 / 2007-01-25
+ - changed BOM recognition ordering (longer boms first)
+
+ Original pseudocode : Thomas Weidenfeller
+ Implementation tweaked: Aki Nieminen
+
+ http://www.unicode.org/unicode/faq/utf_bom.html
+ BOMs:
+ 00 00 FE FF = UTF-32, big-endian
+ FF FE 00 00 = UTF-32, little-endian
+ EF BB BF = UTF-8,
+ FE FF = UTF-16, big-endian
+ FF FE = UTF-16, little-endian
+
+ Win2k Notepad:
+ Unicode format = UTF-16LE
+ ***/
+
+ /**
+ * Generic unicode textreader, which will use BOM mark
+ * to identify the encoding to be used. If BOM is not found
+ * then use a given default or system encoding.
+ */
+ public static class UnicodeReader extends Reader {
+ PushbackInputStream internalIn;
+ InputStreamReader internalIn2 = null;
+ String defaultEnc;
+
+ private static final int BOM_SIZE = 4;
+
+ /**
+ *
+ * @param in inputstream to be read
+ * @param defaultEnc default encoding if stream does not have
+ * BOM marker. Give NULL to use system-level default.
+ */
+ UnicodeReader(InputStream in, String defaultEnc) {
+ internalIn = new PushbackInputStream(in, BOM_SIZE);
+ this.defaultEnc = defaultEnc;
+ }
+
+ public String getDefaultEncoding() {
+ return defaultEnc;
+ }
+
+ /**
+ * Get stream encoding or NULL if stream is uninitialized.
+ * Call init() or read() method to initialize it.
+ */
+ public String getEncoding() {
+ if (internalIn2 == null) return null;
+ return internalIn2.getEncoding();
+ }
+
+ /**
+ * Read-ahead four bytes and check for BOM marks. Extra bytes are
+ * unread back to the stream, only BOM bytes are skipped.
+ */
+ protected void init() throws IOException {
+ if (internalIn2 != null) return;
+
+ String encoding;
+ byte bom[] = new byte[BOM_SIZE];
+ int n, unread;
+ n = internalIn.read(bom, 0, bom.length);
+
+ if ( (bom[0] == (byte)0x00) && (bom[1] == (byte)0x00) &&
+ (bom[2] == (byte)0xFE) && (bom[3] == (byte)0xFF) ) {
+ encoding = "UTF-32BE";
+ unread = n - 4;
+ } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) &&
+ (bom[2] == (byte)0x00) && (bom[3] == (byte)0x00) ) {
+ encoding = "UTF-32LE";
+ unread = n - 4;
+ } else if ( (bom[0] == (byte)0xEF) && (bom[1] == (byte)0xBB) &&
+ (bom[2] == (byte)0xBF) ) {
+ encoding = "UTF-8";
+ unread = n - 3;
+ } else if ( (bom[0] == (byte)0xFE) && (bom[1] == (byte)0xFF) ) {
+ encoding = "UTF-16BE";
+ unread = n - 2;
+ } else if ( (bom[0] == (byte)0xFF) && (bom[1] == (byte)0xFE) ) {
+ encoding = "UTF-16LE";
+ unread = n - 2;
+ } else {
+ // Unicode BOM mark not found, unread all bytes
+ encoding = defaultEnc;
+ unread = n;
+ }
+ //System.out.println("read=" + n + ", unread=" + unread);
+
+ if (unread > 0) internalIn.unread(bom, (n - unread), unread);
+
+ // Use given encoding
+ if (encoding == null) {
+ internalIn2 = new InputStreamReader(internalIn);
+ } else {
+ internalIn2 = new InputStreamReader(internalIn, encoding);
+ }
+ }
+
+ public void close() throws IOException {
+ init();
+ internalIn2.close();
+ }
+
+ public int read(char[] cbuf, int off, int len) throws IOException {
+ init();
+ return internalIn2.read(cbuf, off, len);
+ }
+
+ }
+}
diff --git a/infrastructure/net.appjet.common/util/ClassReload.java b/infrastructure/net.appjet.common/util/ClassReload.java
new file mode 100644
index 0000000..3fbc480
--- /dev/null
+++ b/infrastructure/net.appjet.common/util/ClassReload.java
@@ -0,0 +1,263 @@
+/**
+ * Copyright 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 net.appjet.common.util;
+
+import java.io.*;
+import java.util.*;
+import java.lang.reflect.*;
+
+public class ClassReload {
+
+ /**
+ * To use: Optionally call initCompilerArgs, just like command-line
+ * starting after "scalac" or "fsc", do not use "-d", you may
+ * want to use "-classpath"/"-cp", no source files. Then call
+ * compile(...). Then load classes. isUpToDate() will tell you
+ * if source files have changed since compilation. If you want
+ * to compile again, use recompile() to create a new class-loader so that
+ * you can have new versions of existing classes. The class-loader
+ * behavior is to load classes that were generated during compilation
+ * using the output of compilation, and delegate all other classes to
+ * the parent loader.
+ */
+ public static class ScalaSourceClassLoader extends ClassLoader {
+ public ScalaSourceClassLoader(ClassLoader parent) {
+ super(parent);
+ }
+ public ScalaSourceClassLoader() {
+ this(ScalaSourceClassLoader.class.getClassLoader());
+ }
+
+ private List<String> compilerArgs = Collections.emptyList();
+ private List<String> sourceFileList = Collections.emptyList();
+
+ private Map<File,Long> sourceFileMap = new HashMap<File,Long>();
+ private Map<String,byte[]> outputFileMap = new HashMap<String,byte[]>();
+
+ private boolean successfulCompile = false;
+
+ public void initCompilerArgs(String... args) {
+ compilerArgs = new ArrayList<String>();
+ for(String a : args) compilerArgs.add(a);
+ }
+
+ public boolean compile(String... sourceFiles) {
+ sourceFileList = new ArrayList<String>();
+ for(String a : sourceFiles) sourceFileList.add(a);
+
+ sourceFileMap.clear();
+ outputFileMap.clear();
+
+ File tempDir = makeTemporaryDir();
+ try {
+ List<String> argsToPass = new ArrayList<String>();
+ argsToPass.add("-d");
+ argsToPass.add(tempDir.getAbsolutePath());
+ argsToPass.addAll(compilerArgs);
+ for(String sf : sourceFileList) {
+ File f = new File(sf).getAbsoluteFile();
+ sourceFileMap.put(f, f.lastModified());
+ argsToPass.add(f.getPath());
+ }
+ String[] argsToPassArray = argsToPass.toArray(new String[0]);
+
+ int compileResult = invokeFSC(argsToPassArray);
+
+ if (compileResult != 0) {
+ successfulCompile = false;
+ return false;
+ }
+
+ for(String outputFile : listRecursive(tempDir)) {
+ outputFileMap.put(outputFile,
+ getFileBytes(new File(tempDir, outputFile)));
+ }
+
+ successfulCompile = true;
+ return true;
+ }
+ finally {
+ deleteRecursive(tempDir);
+ }
+ }
+
+ public ScalaSourceClassLoader recompile() {
+ ScalaSourceClassLoader sscl = new ScalaSourceClassLoader(getParent());
+ sscl.initCompilerArgs(compilerArgs.toArray(new String[0]));
+ sscl.compile(sourceFileList.toArray(new String[0]));
+ return sscl;
+ }
+
+ public boolean isSuccessfulCompile() {
+ return successfulCompile;
+ }
+
+ public boolean isUpToDate() {
+ for(Map.Entry<File,Long> entry : sourceFileMap.entrySet()) {
+ long mod = entry.getKey().lastModified();
+ if (mod == 0 || mod > entry.getValue()) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ @Override protected synchronized Class<?> loadClass(String name,
+ boolean resolve)
+ throws ClassNotFoundException {
+
+ // Based on java.lang.ClassLoader.loadClass(String,boolean)
+
+ // First, check if the class has already been loaded
+ Class<?> c = findLoadedClass(name);
+ if (c == null) {
+ String fileName = name.replace('.','/')+".class";
+ if (outputFileMap.containsKey(fileName)) {
+ // define it ourselves
+ byte b[] = outputFileMap.get(fileName);
+ c = defineClass(name, b, 0, b.length);
+ }
+ }
+ if (c != null) {
+ if (resolve) {
+ resolveClass(c);
+ }
+ return c;
+ }
+ else {
+ // use super behavior
+ return super.loadClass(name, resolve);
+ }
+ }
+ }
+
+ private static byte[] readStreamFully(InputStream in) throws IOException {
+ InputStream from = new BufferedInputStream(in);
+ ByteArrayOutputStream to = new ByteArrayOutputStream(in.available());
+ ferry(from, to);
+ return to.toByteArray();
+ }
+
+ private static void ferry(InputStream from, OutputStream to)
+ throws IOException {
+
+ byte[] buf = new byte[1024];
+ boolean done = false;
+ while (! done) {
+ int numRead = from.read(buf);
+ if (numRead < 0) {
+ done = true;
+ }
+ else {
+ to.write(buf, 0, numRead);
+ }
+ }
+ from.close();
+ to.close();
+ }
+
+ private static Class<?> classForName(String name) {
+ try {
+ return Class.forName(name);
+ }
+ catch (ClassNotFoundException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ static boolean deleteRecursive(File f) {
+ if(f.exists()) {
+ File[] files = f.listFiles();
+ for(File g : files) {
+ if(g.isDirectory()) {
+ deleteRecursive(g);
+ }
+ else {
+ g.delete();
+ }
+ }
+ }
+ return f.delete();
+ }
+
+ static byte[] getFileBytes(File f) {
+ try {
+ return readStreamFully(new FileInputStream(f));
+ }
+ catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ static List<String> listRecursive(File dir) {
+ List<String> L = new ArrayList<String>();
+ listRecursive(dir, "", L);
+ return L;
+ }
+
+ static void listRecursive(File dir, String prefix, Collection<String> drop) {
+ for(File f : dir.listFiles()) {
+ if (f.isDirectory()) {
+ listRecursive(f, prefix + f.getName() + "/", drop);
+ }
+ else {
+ drop.add(prefix + f.getName());
+ }
+ }
+ }
+
+ static File makeTemporaryDir() {
+ try {
+ File f = File.createTempFile("ajclsreload", "").getAbsoluteFile();
+ if (! f.delete())
+ throw new RuntimeException("error creating temp dir");
+ if (! f.mkdir())
+ throw new RuntimeException("error creating temp dir");
+ return f;
+ }
+ catch (IOException e) {
+ throw new RuntimeException("error creating temp dir");
+ }
+ }
+
+ private static int invokeFSC(String[] args) {
+ try {
+ Class<?> fsc =
+ Class.forName("scala.tools.nsc.StandardCompileClient");
+ Object compiler = fsc.newInstance();
+ Method main0Method = fsc.getMethod("main0", String[].class);
+ return (Integer)main0Method.invoke(compiler, (Object)args);
+ }
+ catch (ClassNotFoundException e) { throw new RuntimeException(e); }
+ catch (InstantiationException e) { throw new RuntimeException(e); }
+ catch (NoSuchMethodException e) { throw new RuntimeException(e); }
+ catch (IllegalAccessException e) { throw new RuntimeException(e); }
+ catch (InvocationTargetException e) {
+ Throwable origThrowable = e.getCause();
+ if (origThrowable == null) throw new RuntimeException(e);
+ else if (origThrowable instanceof Error) {
+ throw (Error)origThrowable;
+ }
+ else if (origThrowable instanceof RuntimeException) {
+ throw (RuntimeException)origThrowable;
+ }
+ else {
+ throw new RuntimeException(origThrowable);
+ }
+ }
+ }
+} \ No newline at end of file
diff --git a/infrastructure/net.appjet.common/util/ExpiringMapping.java b/infrastructure/net.appjet.common/util/ExpiringMapping.java
new file mode 100644
index 0000000..d4b9d5a
--- /dev/null
+++ b/infrastructure/net.appjet.common/util/ExpiringMapping.java
@@ -0,0 +1,163 @@
+/**
+ * Copyright 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 net.appjet.common.util;
+
+import java.util.*;
+
+// this class is synchronized
+
+public class ExpiringMapping<K,V> {
+
+ private Map<K,TimeStampedValue> keyToValue =
+ new HashMap<K,TimeStampedValue>();
+ private SortedMap<Long,K> timeToKey= new TreeMap<Long,K>();
+
+ private long lastTimeStamp = 0;
+
+ private ExpiryPolicy policy;
+
+ public ExpiringMapping(final long maxAgeMillis) {
+ this(new ExpiryPolicy() {
+ public boolean hasExpired(long timeStamp, long now, int rank) {
+ return now - timeStamp > maxAgeMillis;
+ }
+ });
+ }
+
+ protected ExpiringMapping(ExpiryPolicy policy) {
+ this.policy = policy;
+ }
+
+ public synchronized void clear() {
+ keyToValue.clear();
+ timeToKey.clear();
+ }
+
+ public synchronized void put(K key, V value) {
+ TimeStampedValue old = keyToValue.get(key);
+ if (old != null) {
+ timeToKey.remove(old.getTimeStamp());
+ }
+ TimeStampedValue newVal = new TimeStampedValue(value);
+ keyToValue.put(key, newVal);
+ timeToKey.put(newVal.getTimeStamp(), key);
+ checkExpiry();
+ }
+
+ public synchronized void touch(K key) {
+ TimeStampedValue old = keyToValue.get(key);
+ if (old != null) {
+ put(key, old.getValue());
+ }
+ }
+
+ public synchronized void remove(Object key) {
+ TimeStampedValue old = keyToValue.get(key);
+ if (old != null) {
+ keyToValue.remove(key);
+ timeToKey.remove(old.getTimeStamp());
+ }
+ }
+
+ // doesn't "touch" key or trigger expiry of expired items
+ public synchronized V get(Object key) {
+ if (keyToValue.containsKey(key)) {
+ return keyToValue.get(key).getValue();
+ } else {
+ return null;
+ }
+ }
+
+ public synchronized boolean containsKey(Object key) {
+ return keyToValue.containsKey(key);
+ }
+
+ public synchronized void checkExpiry() {
+ while (timeToKey.size() > 0) {
+ long oldestTime = timeToKey.firstKey();
+ if (hasExpired(oldestTime, timeToKey.size())) {
+ remove(timeToKey.get(oldestTime));
+ }
+ else {
+ break;
+ }
+ }
+ }
+
+ // lists keys in time order, oldest to newest
+ public synchronized List<K> listAllKeys() {
+ List<K> keyList = new java.util.ArrayList<K>(timeToKey.size());
+ for(Map.Entry<Long,K> entry : timeToKey.entrySet()) {
+ keyList.add(entry.getValue());
+ }
+ return Collections.unmodifiableList(keyList);
+ }
+
+ // result must be monotonic
+ private boolean hasExpired(long time, int rank) {
+ return policy.hasExpired(time, System.currentTimeMillis(), rank);
+ }
+
+ private long nowTimeStamp() {
+ // return "now", but unique
+ long now = System.currentTimeMillis();
+ if (now <= lastTimeStamp) {
+ now = lastTimeStamp+1;
+ }
+ lastTimeStamp = now;
+ return now;
+ }
+
+ private class TimeStampedValue {
+ private final V value;
+ private long timeStamp;
+ private TimeStampedValue(V value) {
+ this(value, nowTimeStamp());
+ }
+ private TimeStampedValue(V value, long timeStamp) {
+ this.value = value; this.timeStamp = timeStamp;
+ }
+ public void setTimeStamp(long ts) {
+ timeStamp = ts;
+ }
+ public long getTimeStamp() {
+ return timeStamp;
+ }
+ public V getValue() {
+ return value;
+ }
+ public String toString() {
+ return "("+value+", "+new Date(timeStamp)+")";
+ }
+ }
+
+ public synchronized String toString() {
+ return keyToValue.toString();
+ }
+
+ protected interface ExpiryPolicy {
+ // result must be monotonic wrt timeStamp given now
+ boolean hasExpired(long timeStamp, long now, int rank);
+ }
+
+}
+
+ /*private static int compareLongs(long a, long b) {
+ if (a < b) return -1;
+ if (a > b) return 1;
+ return 0;
+ }*/
diff --git a/infrastructure/net.appjet.common/util/HttpServletRequestFactory.java b/infrastructure/net.appjet.common/util/HttpServletRequestFactory.java
new file mode 100644
index 0000000..4d7826a
--- /dev/null
+++ b/infrastructure/net.appjet.common/util/HttpServletRequestFactory.java
@@ -0,0 +1,306 @@
+/**
+ * Copyright 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 net.appjet.common.util;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+import java.net.URL;
+import java.net.URI;
+import java.net.URLDecoder;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Enumeration;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class HttpServletRequestFactory {
+ public static class RequestResponse {
+ public final HttpServletRequest request;
+ public final HttpServletResponse response;
+
+ private RequestResponse(HttpServletRequest req, HttpServletResponse res) {
+ request = req;
+ response = res;
+ }
+ }
+
+ public static HttpServletRequest createRequest(String uri, Map<String, String> headers,
+ String method, String body)
+ throws java.net.URISyntaxException {
+ return new InnerHttpServletRequest(new URI(uri), headers, method, body);
+ }
+
+ public static HttpServletRequest createRequest(HttpServletRequest req)
+ throws java.net.URISyntaxException {
+ Map<String, String> headers = new java.util.HashMap<String, String>();
+ Enumeration<String> headerNames = (Enumeration<String>) req.getHeaderNames();
+ while (headerNames.hasMoreElements()) {
+ String e = headerNames.nextElement();
+ headers.put(e, req.getHeader(e));
+ }
+ return createRequest(
+ req.getRequestURL() +
+ (req.getQueryString() != null ? "?"+req.getQueryString() : ""),
+ headers, req.getMethod(), null);
+ }
+
+ public static HttpServletResponse createResponse() {
+ return new InnerHttpServletResponse();
+ }
+
+ public static RequestResponse createPair(String uri, Map<String, String> headers,
+ String method, String body)
+ throws java.net.URISyntaxException {
+ return new RequestResponse(createRequest(uri, headers, method, body), createResponse());
+ }
+
+ public static interface ServletAccessor {
+ int getStatusCode();
+ String getOutput();
+ }
+
+ private static class InnerHttpServletRequest implements HttpServletRequest {
+ private String method;
+ private String host;
+ private String scheme;
+ private int port;
+ private String path;
+ private String queryString;
+ private Map<String, String[]> parameters;
+ private Map<String, String> headers;
+ private final String body;
+
+ public InnerHttpServletRequest(URI uri, Map<String, String> headers, String method,
+ String body)
+ throws java.net.URISyntaxException {
+ this.method = method;
+ this.host = uri.getHost();
+ this.scheme = uri.getScheme();
+ this.port = uri.getPort();
+ this.path = uri.getRawPath();
+ this.queryString = uri.getRawQuery();
+ extractParameters();
+ extractHeaders(headers);
+ this.headers.put("host", host);
+ if (body != null)
+ this.headers.put("content-length", Integer.toString(body.length()));
+ this.body = body;
+ }
+
+ private void extractHeaders(Map<String, String> headers) {
+ this.headers = new HashMap<String, String>();
+ for (Map.Entry<String, String> kv : headers.entrySet()) {
+ this.headers.put(kv.getKey().toLowerCase(), kv.getValue());
+ }
+ }
+
+ private String decodeUTF8(String s) {
+ try {
+ return URLDecoder.decode(s, "UTF-8");
+ } catch (java.io.UnsupportedEncodingException e) {
+ System.err.println("Unsupported character encoding! UTF-8");
+ return s;
+ }
+ }
+
+ private void extractParameters() {
+ parameters = new HashMap<String, String[]>();
+ if (queryString == null)
+ return;
+
+ Map<String, List<String> > params = new HashMap<String, List<String> >();
+ String[] pairs = queryString.split("&");
+ for (String s : pairs) {
+ String[] kv = s.split("=", 2);
+ if (! params.containsKey(kv[0])) {
+ params.put(decodeUTF8(kv[0]), new ArrayList<String>());
+ }
+ params.get(decodeUTF8(kv[0])).add(decodeUTF8(kv[1]));
+ }
+ String[] stringArray = new String[0];
+
+ for (Map.Entry<String, List<String> > e : params.entrySet()) {
+ parameters.put(e.getKey(), e.getValue().toArray(stringArray));
+ }
+ }
+
+ // HttpServletRequest methods
+ public String getAuthType() { return null; }
+ public String getContextPath() { return ""; }
+ public javax.servlet.http.Cookie[] getCookies() { return new javax.servlet.http.Cookie[0]; }
+ @SuppressWarnings({"deprecation"})
+ public long getDateHeader(String name) { return java.util.Date.parse(getHeader(name)); }
+ public String getHeader(String name) { return headers.get(name.toLowerCase()); }
+ public Enumeration<String> getHeaders(String name) {
+ Vector<String> v = new Vector<String>();
+ v.add(getHeader(name));
+ return v.elements();
+ }
+ public Enumeration<String> getHeaderNames() {
+ return Collections.enumeration(headers.keySet());
+ }
+ public int getIntHeader(String name) { return Integer.parseInt(getHeader(name)); }
+ public String getMethod() { return method.toUpperCase(); }
+ public String getPathInfo() { return null; }
+ public String getPathTranslated() { return null; }
+ public String getQueryString() { return queryString; }
+ public String getRemoteUser() { return null; }
+ public boolean isUserInRole(String role) { return false; }
+ public java.security.Principal getUserPrincipal() { return null; }
+ public String getRequestedSessionId() { return null; }
+ public String getRequestURI() { return path; }
+ public StringBuffer getRequestURL() {
+ return new StringBuffer(scheme+"://"+host+(port==-1?"":":"+port)+path);
+ }
+ public String getServletPath() { return ""; }
+ public javax.servlet.http.HttpSession getSession(boolean create) { return null; }
+ public javax.servlet.http.HttpSession getSession() { return null; }
+ public boolean isRequestedSessionIdValid() { return false; }
+ public boolean isRequestedSessionIdFromCookie() { return false; }
+ public boolean isRequestedSessionIdFromURL() { return false; }
+ public boolean isRequestedSessionIdFromUrl() { return isRequestedSessionIdFromURL(); }
+
+ // ServletRequest methods
+ public Object getAttribute(String name) { return null; }
+ public Enumeration<String> getAttributeNames() {
+ return Collections.enumeration(new ArrayList<String>());
+ }
+ public String getCharacterEncoding() { return null; }
+ public void setCharacterEncoding(String env) { }
+ public int getContentLength() {
+ return ((getHeader("Content-Length") == null)
+ ? (body == null ? 0 : body.length())
+ : getIntHeader("Content-Length"));
+ }
+ public String getContentType() { return getHeader("Content-Type"); }
+ public javax.servlet.ServletInputStream getInputStream() throws java.io.IOException{
+ return new javax.servlet.ServletInputStream() {
+ private java.io.InputStream istream =
+ new java.io.ByteArrayInputStream(body.getBytes());
+ public int read() throws java.io.IOException {
+ return istream.read();
+ }
+ };
+ }
+ public String getParameter(String name) {
+ String[] vals = getParameterValues(name);
+ if (vals == null) return null;
+ if (vals.length < 1) return null;
+ return vals[0];
+ }
+ public Enumeration<String> getParameterNames() {
+ return Collections.enumeration(parameters.keySet());
+ }
+ public String[] getParameterValues(String name) { return parameters.get(name); }
+ public Map getParameterMap() { return Collections.unmodifiableMap(parameters); }
+ public String getProtocol() { return "HTTP/1.1"; }
+ public String getScheme() { return scheme; }
+ public String getServerName() { return host; }
+ public int getServerPort() { return port; }
+ public java.io.BufferedReader getReader() {
+ return new java.io.BufferedReader(new java.io.StringReader(body));
+ }
+ public String getRemoteAddr() { return "127.0.0.1"; }
+ public String getRemoteHost() { return "localhost"; }
+ public void setAttribute(String name, Object o) { }
+ public void removeAttribute(String name) { }
+ public java.util.Locale getLocale() { return java.util.Locale.US; }
+ public Enumeration<java.util.Locale> getLocales() {
+ Vector<java.util.Locale> v = new Vector<java.util.Locale>();
+ v.add(java.util.Locale.US);
+ return v.elements();
+ }
+ public boolean isSecure() { return false; }
+ public javax.servlet.RequestDispatcher getRequestDispatcher(String path) { return null; }
+ public String getRealPath(String path) { return null; }
+ public int getRemotePort() { return -1; }
+ public String getLocalName() { return "localhost"; }
+ public String getLocalAddr() { return "127.0.0.1"; }
+ public int getLocalPort() { return 80; }
+ }
+
+ private static class InnerHttpServletResponse implements HttpServletResponse, ServletAccessor {
+ private InnerHttpServletResponse() { }
+
+ // ServletAccessor methods
+ public int getStatusCode() { return e_code; }
+ public String getOutput() {
+ try {
+ writer.flush();
+ ostream.flush();
+ } catch (java.io.IOException e) {
+ return "(An IOException occurred while getting output: "+e.getMessage()+")";
+ }
+ return ostream.toString();
+ }
+
+ // HttpServletResponse methods
+ private int e_code = 200;
+ private String e_msg = "";
+
+ public void addCookie(javax.servlet.http.Cookie cookie) { }
+ public void addDateHeader(String name, long date) { }
+ public void addHeader(String name, String value) { }
+ public void addIntHeader(String name, int value) { }
+ public boolean containsHeader(String name) { return true; }
+ public String encodeRedirectUrl(String url) { return encodeRedirectURL(url); }
+ public String encodeRedirectURL(String url) { return url; }
+ public String encodeUrl(String url) { return encodeURL(url); }
+ public String encodeURL(String url) { return url; }
+ public void sendError(int sc) { e_code = sc; }
+ public void sendError(int sc, String msg) { e_code = sc; e_msg = msg;}
+ public void sendRedirect(String location) { }
+ public void setDateHeader(String name, long date) { }
+ public void setHeader(String name, String value) { }
+ public void setIntHeader(String name, int value) { }
+ public void setStatus(int sc) { e_code = sc; }
+ public void setStatus(int sc, String sm) { e_code = sc; e_msg = sm; }
+
+ // ServletResponse methods
+ private String c_enc = "";
+ private String c_type = "";
+ private java.util.Locale locale = java.util.Locale.US;
+ private final java.io.OutputStream ostream = new java.io.ByteArrayOutputStream();
+ private final javax.servlet.ServletOutputStream sostream =
+ new javax.servlet.ServletOutputStream() {
+ public void write(int b) throws java.io.IOException {
+ ostream.write(b);
+ }
+ };
+ private final java.io.PrintWriter writer = new java.io.PrintWriter(ostream);
+
+ public void flushBuffer() { }
+ public int getBufferSize() { return 0; }
+ public String getCharacterEncoding() { return c_enc; }
+ public String getContentType() { return c_type; }
+ public java.util.Locale getLocale() { return locale; }
+ public javax.servlet.ServletOutputStream getOutputStream() { return sostream; }
+ public java.io.PrintWriter getWriter() { return writer; }
+ public boolean isCommitted() { return false; }
+ public void reset() { }
+ public void resetBuffer() { }
+ public void setBufferSize(int size) { }
+ public void setCharacterEncoding(String charset) { c_enc = charset; }
+ public void setContentLength(int len) { }
+ public void setContentType(String type) { c_type = type; }
+ public void setLocale(java.util.Locale loc) { locale = loc; }
+ }
+} \ No newline at end of file
diff --git a/infrastructure/net.appjet.common/util/LenientFormatter.java b/infrastructure/net.appjet.common/util/LenientFormatter.java
new file mode 100644
index 0000000..293dcdf
--- /dev/null
+++ b/infrastructure/net.appjet.common/util/LenientFormatter.java
@@ -0,0 +1,2809 @@
+/* Portions Copyright 2009 Google Inc.
+ * The rest licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF and Google license this file to You 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 net.appjet.common.util;
+
+import java.util.*;
+import java.io.BufferedWriter;
+import java.io.Closeable;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.Flushable;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.math.MathContext;
+import java.nio.CharBuffer;
+import java.nio.charset.Charset;
+import java.security.AccessController;
+import java.security.PrivilegedAction;
+import java.text.DateFormatSymbols;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.text.NumberFormat;
+
+/**
+ * <p>The {@code LenientFormatter} class is a copy of {@code java.util.Formatter}
+ * that is lenient in the exact type of {@code java.lang.Number} passed into
+ * certain flags (integer, floating point, date, and character formats).</p>
+ *
+ * <p>The {@code Formatter} class is a String-formatting utility that is designed
+ * to work like the {@code printf} function of the C programming language.
+ * Its key methods are the {@code format} methods which create a formatted
+ * {@code String} by replacing a set of placeholders (format tokens) with formatted
+ * values. The style used to format each value is determined by the format
+ * token used. For example, the call<br/>
+ * {@code format("My decimal value is %d and my String is %s.", 3, "Hello");}<br/>
+ * returns the {@code String}<br/>
+ * {@code My decimal value is 3 and my String is Hello.}
+ *
+ * <p>The format token consists of a percent sign, optionally followed
+ * by flags and precision arguments, and then a single character that
+ * indicates the type of value
+ * being formatted. If the type is a time/date, then the type character
+ * {@code t} is followed by an additional character that indicates how the
+ * date is to be formatted. The two characters {@code <$} immediately
+ * following the % sign indicate that the previous value should be used again
+ * instead of moving on to the next value argument. A number {@code n}
+ * and a dollar sign immediately following the % sign make n the next argument
+ * to be used.
+ *
+ * <p>The available choices are the following:
+ *
+ * <table BORDER="1" WIDTH="100%" CELLPADDING="3" CELLSPACING="0" SUMMARY="">
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Text value types</B></TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code s}</td>
+ * <td width="10%">String</td>
+ * <td width="30%">{@code format("%s, %s", "hello", "Hello");}</td>
+ * <td width="30%">{@code hello, Hello}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code S}, {@code s}</td>
+ * <td width="10%">String to capitals</td>
+ * <td width="30%">{@code format("%S, %S", "hello", "Hello");}</td>
+ * <td width="30%">{@code HELLO, HELLO}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code c}</td>
+ * <td width="10%">Character</td>
+ * <td width="30%">{@code format("%c, %c", 'd', 0x65);}</td>
+ * <td width="30%">{@code d, e}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code C}</td>
+ * <td width="10%">Character to capitals</td>
+ * <td width="30%">{@code format("%C, %C", 'd', 0x65);}</td>
+ * <td width="30%">{@code D, E}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Text option flags</B><br/>The value between the
+ * option and the type character indicates the minimum width in
+ * characters of the formatted value </TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code -}</td>
+ * <td width="10%">Left justify (width value is required)</td>
+ * <td width="30%">{@code format("%-3C, %3C", 'd', 0x65);}</td>
+ * <td width="30%">{@code D , E}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Integer types</B></TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code d}</td>
+ * <td width="10%">int, formatted as decimal</td>
+ * <td width="30%">{@code format("%d, %d"1$, 35, 0x10);}</td>
+ * <td width="30%">{@code 35, 16}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code o}</td>
+ * <td width="10%">int, formatted as octal</td>
+ * <td width="30%">{@code format("%o, %o", 8, 010);}</td>
+ * <td width="30%">{@code 10, 10}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code X}, {@code x}</td>
+ * <td width="10%">int, formatted as hexidecimal</td>
+ * <td width="30%">{@code format("%x, %X", 10, 10);}</td>
+ * <td width="30%">{@code a, A}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Integer option flags</B><br/>The value between the
+ * option and the type character indicates the minimum width in
+ * characters of the formatted value </TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code +}</td>
+ * <td width="10%">lead with the number's sign</td>
+ * <td width="30%">{@code format("%+d, %+4d", 5, 5);}</td>
+ * <td width="30%">{@code +5, +5}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code -}</td>
+ * <td width="10%">Left justify (width value is required)</td>
+ * <td width="30%">{@code format("%-6dx", 5);}</td>
+ * <td width="30%">{@code 5 x}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code #}</td>
+ * <td width="10%">Print the leading characters that indicate
+ * hexidecimal or octal (for use only with hex and octal types) </td>
+ * <td width="30%">{@code format("%#o", 010);}</td>
+ * <td width="30%">{@code 010}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code }</td>
+ * <td width="10%">A space indicates that non-negative numbers
+ * should have a leading space. </td>
+ * <td width="30%">{@code format("x% d% 5d", 4, 4);}</td>
+ * <td width="30%">{@code x 4 4}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code 0}</td>
+ * <td width="10%">Pad the number with leading zeros (width value is required)</td>
+ * <td width="30%">{@code format("%07d, %03d", 4, 5555);}</td>
+ * <td width="30%">{@code 0000004, 5555}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code (}</td>
+ * <td width="10%">Put parentheses around negative numbers (decimal only)</td>
+ * <td width="30%">{@code format("%(d, %(d, %(6d", 12, -12, -12);}</td>
+ * <td width="30%">{@code 12, (12), (12)}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Float types</B><br/>A value immediately following the % symbol
+ * gives the minimum width in characters of the formatted value; if it
+ * is followed by a period and another integer, then the second value
+ * gives the precision (6 by default).</TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code f}</td>
+ * <td width="10%">float (or double) formatted as a decimal, where
+ * the precision indicates the number of digits after the decimal.</td>
+ * <td width="30%">{@code format("%f %<.1f %<1.5f %<10f %<6.0f", 123.456f);}</td>
+ * <td width="30%">{@code 123.456001 123.5 123.45600 123.456001 123}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code E}, {@code e}</td>
+ * <td width="10%">float (or double) formatted in decimal exponential
+ * notation, where the precision indicates the number of significant digits.</td>
+ * <td width="30%">{@code format("%E %<.1e %<1.5E %<10E %<6.0E", 123.456f);}</td>
+ * <td width="30%">{@code 1.234560E+02 1.2e+02 1.23456E+02 1.234560E+02 1E+02}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code G}, {@code g}</td>
+ * <td width="10%">float (or double) formatted in decimal exponential
+ * notation , where the precision indicates the maximum number of significant digits.</td>
+ * <td width="30%">{@code format("%G %<.1g %<1.5G %<10G %<6.0G", 123.456f);}</td>
+ * <td width="30%">{@code 123.456 1e+02 123.46 123.456 1E+02}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code A}, {@code a}</td>
+ * <td width="10%">float (or double) formatted as a hexidecimal in exponential
+ * notation, where the precision indicates the number of significant digits.</td>
+ * <td width="30%">{@code format("%A %<.1a %<1.5A %<10A %<6.0A", 123.456f);}</td>
+ * <td width="30%">{@code 0X1.EDD2F2P6 0x1.fp6 0X1.EDD2FP6 0X1.EDD2F2P6 0X1.FP6}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Float-type option flags</B><br/>See the Integer-type options.
+ * The options for float-types are the
+ * same as for integer types with one addition: </TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code ,}</td>
+ * <td width="10%">Use a comma in place of a decimal if the locale
+ * requires it. </td>
+ * <td width="30%">{@code format(new Locale("fr"), "%,7.2f", 6.03f);}</td>
+ * <td width="30%">{@code 6,03}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Date types</B></TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code t}, {@code T}</td>
+ * <td width="10%">Date</td>
+ * <td width="30%">{@code format(new Locale("fr"), "%tB %TB", Calendar.getInstance(), Calendar.getInstance());}</td>
+ * <td width="30%">{@code avril AVRIL}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Date format precisions</B><br/>The format precision character
+ * follows the {@code t}. </TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code A}, {@code a}</td>
+ * <td width="10%">The day of the week</td>
+ * <td width="30%">{@code format("%ta %tA", cal, cal);}</td>
+ * <td width="30%">{@code Tue Tuesday}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code b}, {@code B}, {@code h}</td>
+ * <td width="10%">The name of the month</td>
+ * <td width="30%">{@code format("%tb %<tB %<th", cal, cal, cal);}</td>
+ * <td width="30%">{@code Apr April Apr}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code C}</td>
+ * <td width="10%">The century</td>
+ * <td width="30%">{@code format("%tC\n", cal);}</td>
+ * <td width="30%">{@code 20}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code d}, {@code e}</td>
+ * <td width="10%">The day of the month (with or without leading zeros)</td>
+ * <td width="30%">{@code format("%td %te", cal, cal);}</td>
+ * <td width="30%">{@code 01 1}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code F}</td>
+ * <td width="10%">The complete date formatted as YYYY-MM-DD</td>
+ * <td width="30%">{@code format("%tF", cal);}</td>
+ * <td width="30%">{@code 2008-04-01}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code D}</td>
+ * <td width="10%">The complete date formatted as MM/DD/YY
+ * (not corrected for locale) </td>
+ * <td width="30%">{@code format(new Locale("en_US"), "%tD", cal);<br/>format(new Locale("en_UK"), " %tD", cal);}</td>
+ * <td width="30%">{@code 04/01/08 04/01/08}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code j}</td>
+ * <td width="10%">The number of the day (from the beginning of the year).</td>
+ * <td width="30%">{@code format("%tj\n", cal);}</td>
+ * <td width="30%">{@code 092}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code m}</td>
+ * <td width="10%">The number of the month</td>
+ * <td width="30%">{@code format("%tm\n", cal);}</td>
+ * <td width="30%">{@code 04}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code y}, {@code Y}</td>
+ * <td width="10%">The year</td>
+ * <td width="30%">{@code format("%ty %tY", cal, cal);}</td>
+ * <td width="30%">{@code 08 2008}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code H}, {@code I}, {@code k}, {@code l}</td>
+ * <td width="10%">The hour of the day, in 12 or 24 hour format, with or
+ * without a leading zero</td>
+ * <td width="30%">{@code format("%tH %tI %tk %tl", cal, cal, cal, cal);}</td>
+ * <td width="30%">{@code 16 04 16 4}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code p}</td>
+ * <td width="10%">a.m. or p.m.</td>
+ * <td width="30%">{@code format("%tp %Tp", cal, cal);}</td>
+ * <td width="30%">{@code pm PM}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code M}, {@code S}, {@code L}, {@code N}</td>
+ * <td width="10%">The minutes, seconds, milliseconds, and nanoseconds</td>
+ * <td width="30%">{@code format("%tM %tS %tL %tN", cal, cal, cal, cal);}</td>
+ * <td width="30%">{@code 08 17 359 359000000}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code Z}, {@code z}</td>
+ * <td width="10%">The time zone: its abbreviation or offset from GMT</td>
+ * <td width="30%">{@code format("%tZ %tz", cal, cal);}</td>
+ * <td width="30%">{@code CEST +0100}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code R}, {@code r}, {@code T}</td>
+ * <td width="10%">The complete time</td>
+ * <td width="30%">{@code format("%tR %tr %tT", cal, cal, cal);}</td>
+ * <td width="30%">{@code 16:15 04:15:32 PM 16:15:32}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code s}, {@code Q}</td>
+ * <td width="10%">The number of seconds or milliseconds from "the epoch"
+ * (1 January 1970 00:00:00 UTC) </td>
+ * <td width="30%">{@code format("%ts %tQ", cal, cal);}</td>
+ * <td width="30%">{@code 1207059412 1207059412656}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code c}</td>
+ * <td width="10%">The complete time and date</td>
+ * <td width="30%">{@code format("%tc", cal);}</td>
+ * <td width="30%">{@code Tue Apr 01 16:19:17 CEST 2008}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Other data types</B></TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code B}, {@code b}</td>
+ * <td width="10%">Boolean</td>
+ * <td width="30%">{@code format("%b, %B", true, false);}</td>
+ * <td width="30%">{@code true, FALSE}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code H}, {@code h}</td>
+ * <td width="10%">Hashcode</td>
+ * <td width="30%">{@code format("%h, %H", obj, obj);}</td>
+ * <td width="30%">{@code 190d11, 190D11}</td>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code n}</td>
+ * <td width="10%">line separator</td>
+ * <td width="30%">{@code format("first%nsecond", "???");}</td>
+ * <td width="30%">{@code first<br/>second}</td>
+ * </tr>
+ * <tr BGCOLOR="#CCCCFF" CLASS="TableHeadingColor">
+ * <TD COLSPAN=4>
+ * <B>Escape sequences</B></TD>
+ * </tr>
+ * <tr>
+ * <td width="5%">{@code %}</td>
+ * <td width="10%">Escape the % character</td>
+ * <td width="30%">{@code format("%d%%, %d", 50, 60);}</td>
+ * <td width="30%">{@code 50%, 60}</td>
+ * </tr>
+ * </table>
+ *
+ * <p>An instance of Formatter can be created to write the formatted
+ * output to standard types of output streams. Its functionality can
+ * also be accessed through the format methods of an output stream
+ * or of {@code String}:<br/>
+ * {@code System.out.println(String.format("%ty\n", cal));}<br/>
+ * {@code System.out.format("%ty\n", cal);}
+ *
+ * <p>The class is not multi-threaded safe. The user is responsible for
+ * maintaining a thread-safe design if a {@code Formatter} is
+ * accessed by multiple threads.
+ *
+ * @since 1.5
+ */
+public final class LenientFormatter implements Closeable, Flushable {
+
+ /**
+ * The enumeration giving the available styles for formatting very large
+ * decimal numbers.
+ */
+ public enum BigDecimalLayoutForm {
+ /**
+ * Use scientific style for BigDecimals.
+ */
+ SCIENTIFIC,
+ /**
+ * Use normal decimal/float style for BigDecimals.
+ */
+ DECIMAL_FLOAT
+ }
+
+ private Appendable out;
+
+ private Locale locale;
+
+ private boolean closed = false;
+
+ private IOException lastIOException;
+
+ /**
+ * Constructs a {@code Formatter}.
+ *
+ * The output is written to a {@code StringBuilder} which can be acquired by invoking
+ * {@link #out()} and whose content can be obtained by calling
+ * {@code toString()}.
+ *
+ * The {@code Locale} for the {@code LenientFormatter} is the default {@code Locale}.
+ */
+ public LenientFormatter() {
+ this(new StringBuilder(), Locale.getDefault());
+ }
+
+ /**
+ * Constructs a {@code Formatter} whose output will be written to the
+ * specified {@code Appendable}.
+ *
+ * The locale for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param a
+ * the output destination of the {@code Formatter}. If {@code a} is {@code null},
+ * then a {@code StringBuilder} will be used.
+ */
+ public LenientFormatter(Appendable a) {
+ this(a, Locale.getDefault());
+ }
+
+ /**
+ * Constructs a {@code Formatter} with the specified {@code Locale}.
+ *
+ * The output is written to a {@code StringBuilder} which can be acquired by invoking
+ * {@link #out()} and whose content can be obtained by calling
+ * {@code toString()}.
+ *
+ * @param l
+ * the {@code Locale} of the {@code Formatter}. If {@code l} is {@code null},
+ * then no localization will be used.
+ */
+ public LenientFormatter(Locale l) {
+ this(new StringBuilder(), l);
+ }
+
+ /**
+ * Constructs a {@code Formatter} with the specified {@code Locale}
+ * and whose output will be written to the
+ * specified {@code Appendable}.
+ *
+ * @param a
+ * the output destination of the {@code Formatter}. If {@code a} is {@code null},
+ * then a {@code StringBuilder} will be used.
+ * @param l
+ * the {@code Locale} of the {@code Formatter}. If {@code l} is {@code null},
+ * then no localization will be used.
+ */
+ public LenientFormatter(Appendable a, Locale l) {
+ if (null == a) {
+ out = new StringBuilder();
+ } else {
+ out = a;
+ }
+ locale = l;
+ }
+
+ /**
+ * Constructs a {@code Formatter} whose output is written to the specified file.
+ *
+ * The charset of the {@code Formatter} is the default charset.
+ *
+ * The {@code Locale} for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param fileName
+ * the filename of the file that is used as the output
+ * destination for the {@code Formatter}. The file will be truncated to
+ * zero size if the file exists, or else a new file will be
+ * created. The output of the {@code Formatter} is buffered.
+ * @throws FileNotFoundException
+ * if the filename does not denote a normal and writable file,
+ * or if a new file cannot be created, or if any error arises when
+ * opening or creating the file.
+ * @throws SecurityException
+ * if there is a {@code SecurityManager} in place which denies permission
+ * to write to the file in {@code checkWrite(file.getPath())}.
+ */
+ public LenientFormatter(String fileName) throws FileNotFoundException {
+ this(new File(fileName));
+
+ }
+
+ /**
+ * Constructs a {@code Formatter} whose output is written to the specified file.
+ *
+ * The {@code Locale} for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param fileName
+ * the filename of the file that is used as the output
+ * destination for the {@code Formatter}. The file will be truncated to
+ * zero size if the file exists, or else a new file will be
+ * created. The output of the {@code Formatter} is buffered.
+ * @param csn
+ * the name of the charset for the {@code Formatter}.
+ * @throws FileNotFoundException
+ * if the filename does not denote a normal and writable file,
+ * or if a new file cannot be created, or if any error arises when
+ * opening or creating the file.
+ * @throws SecurityException
+ * if there is a {@code SecurityManager} in place which denies permission
+ * to write to the file in {@code checkWrite(file.getPath())}.
+ * @throws UnsupportedEncodingException
+ * if the charset with the specified name is not supported.
+ */
+ public LenientFormatter(String fileName, String csn) throws FileNotFoundException,
+ UnsupportedEncodingException {
+ this(new File(fileName), csn);
+ }
+
+ /**
+ * Constructs a {@code Formatter} with the given {@code Locale} and charset,
+ * and whose output is written to the specified file.
+ *
+ * @param fileName
+ * the filename of the file that is used as the output
+ * destination for the {@code Formatter}. The file will be truncated to
+ * zero size if the file exists, or else a new file will be
+ * created. The output of the {@code Formatter} is buffered.
+ * @param csn
+ * the name of the charset for the {@code Formatter}.
+ * @param l
+ * the {@code Locale} of the {@code Formatter}. If {@code l} is {@code null},
+ * then no localization will be used.
+ * @throws FileNotFoundException
+ * if the filename does not denote a normal and writable file,
+ * or if a new file cannot be created, or if any error arises when
+ * opening or creating the file.
+ * @throws SecurityException
+ * if there is a {@code SecurityManager} in place which denies permission
+ * to write to the file in {@code checkWrite(file.getPath())}.
+ * @throws UnsupportedEncodingException
+ * if the charset with the specified name is not supported.
+ */
+ public LenientFormatter(String fileName, String csn, Locale l)
+ throws FileNotFoundException, UnsupportedEncodingException {
+
+ this(new File(fileName), csn, l);
+ }
+
+ /**
+ * Constructs a {@code Formatter} whose output is written to the specified {@code File}.
+ *
+ * The charset of the {@code Formatter} is the default charset.
+ *
+ * The {@code Locale} for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param file
+ * the {@code File} that is used as the output destination for the
+ * {@code Formatter}. The {@code File} will be truncated to zero size if the {@code File}
+ * exists, or else a new {@code File} will be created. The output of the
+ * {@code Formatter} is buffered.
+ * @throws FileNotFoundException
+ * if the {@code File} is not a normal and writable {@code File}, or if a
+ * new {@code File} cannot be created, or if any error rises when opening or
+ * creating the {@code File}.
+ * @throws SecurityException
+ * if there is a {@code SecurityManager} in place which denies permission
+ * to write to the {@code File} in {@code checkWrite(file.getPath())}.
+ */
+ public LenientFormatter(File file) throws FileNotFoundException {
+ this(new FileOutputStream(file));
+ }
+
+ /**
+ * Constructs a {@code Formatter} with the given charset,
+ * and whose output is written to the specified {@code File}.
+ *
+ * The {@code Locale} for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param file
+ * the {@code File} that is used as the output destination for the
+ * {@code Formatter}. The {@code File} will be truncated to zero size if the {@code File}
+ * exists, or else a new {@code File} will be created. The output of the
+ * {@code Formatter} is buffered.
+ * @param csn
+ * the name of the charset for the {@code Formatter}.
+ * @throws FileNotFoundException
+ * if the {@code File} is not a normal and writable {@code File}, or if a
+ * new {@code File} cannot be created, or if any error rises when opening or
+ * creating the {@code File}.
+ * @throws SecurityException
+ * if there is a {@code SecurityManager} in place which denies permission
+ * to write to the {@code File} in {@code checkWrite(file.getPath())}.
+ * @throws UnsupportedEncodingException
+ * if the charset with the specified name is not supported.
+ */
+ public LenientFormatter(File file, String csn) throws FileNotFoundException,
+ UnsupportedEncodingException {
+ this(file, csn, Locale.getDefault());
+ }
+
+ /**
+ * Constructs a {@code Formatter} with the given {@code Locale} and charset,
+ * and whose output is written to the specified {@code File}.
+ *
+ * @param file
+ * the {@code File} that is used as the output destination for the
+ * {@code Formatter}. The {@code File} will be truncated to zero size if the {@code File}
+ * exists, or else a new {@code File} will be created. The output of the
+ * {@code Formatter} is buffered.
+ * @param csn
+ * the name of the charset for the {@code Formatter}.
+ * @param l
+ * the {@code Locale} of the {@code Formatter}. If {@code l} is {@code null},
+ * then no localization will be used.
+ * @throws FileNotFoundException
+ * if the {@code File} is not a normal and writable {@code File}, or if a
+ * new {@code File} cannot be created, or if any error rises when opening or
+ * creating the {@code File}.
+ * @throws SecurityException
+ * if there is a {@code SecurityManager} in place which denies permission
+ * to write to the {@code File} in {@code checkWrite(file.getPath())}.
+ * @throws UnsupportedEncodingException
+ * if the charset with the specified name is not supported.
+ */
+ public LenientFormatter(File file, String csn, Locale l)
+ throws FileNotFoundException, UnsupportedEncodingException {
+ FileOutputStream fout = null;
+ try {
+ fout = new FileOutputStream(file);
+ OutputStreamWriter writer = new OutputStreamWriter(fout, csn);
+ out = new BufferedWriter(writer);
+ } catch (RuntimeException e) {
+ closeOutputStream(fout);
+ throw e;
+ } catch (UnsupportedEncodingException e) {
+ closeOutputStream(fout);
+ throw e;
+ }
+
+ locale = l;
+ }
+
+ /**
+ * Constructs a {@code Formatter} whose output is written to the specified {@code OutputStream}.
+ *
+ * The charset of the {@code Formatter} is the default charset.
+ *
+ * The {@code Locale} for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param os
+ * the stream to be used as the destination of the {@code Formatter}.
+ */
+ public LenientFormatter(OutputStream os) {
+ OutputStreamWriter writer = new OutputStreamWriter(os, Charset
+ .defaultCharset());
+ out = new BufferedWriter(writer);
+ locale = Locale.getDefault();
+ }
+
+ /**
+ * Constructs a {@code Formatter} with the given charset,
+ * and whose output is written to the specified {@code OutputStream}.
+ *
+ * The {@code Locale} for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param os
+ * the stream to be used as the destination of the {@code Formatter}.
+ * @param csn
+ * the name of the charset for the {@code Formatter}.
+ * @throws UnsupportedEncodingException
+ * if the charset with the specified name is not supported.
+ */
+ public LenientFormatter(OutputStream os, String csn)
+ throws UnsupportedEncodingException {
+
+ this(os, csn, Locale.getDefault());
+ }
+
+ /**
+ * Constructs a {@code Formatter} with the given {@code Locale} and charset,
+ * and whose output is written to the specified {@code OutputStream}.
+ *
+ * @param os
+ * the stream to be used as the destination of the {@code Formatter}.
+ * @param csn
+ * the name of the charset for the {@code Formatter}.
+ * @param l
+ * the {@code Locale} of the {@code Formatter}. If {@code l} is {@code null},
+ * then no localization will be used.
+ * @throws UnsupportedEncodingException
+ * if the charset with the specified name is not supported.
+ */
+ public LenientFormatter(OutputStream os, String csn, Locale l)
+ throws UnsupportedEncodingException {
+
+ OutputStreamWriter writer = new OutputStreamWriter(os, csn);
+ out = new BufferedWriter(writer);
+
+ locale = l;
+ }
+
+ /**
+ * Constructs a {@code Formatter} whose output is written to the specified {@code PrintStream}.
+ *
+ * The charset of the {@code Formatter} is the default charset.
+ *
+ * The {@code Locale} for the {@code Formatter} is the default {@code Locale}.
+ *
+ * @param ps
+ * the {@code PrintStream} used as destination of the {@code Formatter}. If
+ * {@code ps} is {@code null}, then a {@code NullPointerException} will
+ * be raised.
+ */
+ public LenientFormatter(PrintStream ps) {
+ if (null == ps) {
+ throw new NullPointerException();
+ }
+ out = ps;
+ locale = Locale.getDefault();
+ }
+
+ private void checkClosed() {
+ if (closed) {
+ throw new FormatterClosedException();
+ }
+ }
+
+ /**
+ * Returns the {@code Locale} of the {@code Formatter}.
+ *
+ * @return the {@code Locale} for the {@code Formatter} or {@code null} for no {@code Locale}.
+ * @throws FormatterClosedException
+ * if the {@code Formatter} has been closed.
+ */
+ public Locale locale() {
+ checkClosed();
+ return locale;
+ }
+
+ /**
+ * Returns the output destination of the {@code Formatter}.
+ *
+ * @return the output destination of the {@code Formatter}.
+ * @throws FormatterClosedException
+ * if the {@code Formatter} has been closed.
+ */
+ public Appendable out() {
+ checkClosed();
+ return out;
+ }
+
+ /**
+ * Returns the content by calling the {@code toString()} method of the output
+ * destination.
+ *
+ * @return the content by calling the {@code toString()} method of the output
+ * destination.
+ * @throws FormatterClosedException
+ * if the {@code Formatter} has been closed.
+ */
+ @Override
+ public String toString() {
+ checkClosed();
+ return out.toString();
+ }
+
+ /**
+ * Flushes the {@code Formatter}. If the output destination is {@link Flushable},
+ * then the method {@code flush()} will be called on that destination.
+ *
+ * @throws FormatterClosedException
+ * if the {@code Formatter} has been closed.
+ */
+ public void flush() {
+ checkClosed();
+ if (out instanceof Flushable) {
+ try {
+ ((Flushable) out).flush();
+ } catch (IOException e) {
+ lastIOException = e;
+ }
+ }
+ }
+
+ /**
+ * Closes the {@code Formatter}. If the output destination is {@link Closeable},
+ * then the method {@code close()} will be called on that destination.
+ *
+ * If the {@code Formatter} has been closed, then calling the this method will have no
+ * effect.
+ *
+ * Any method but the {@link #ioException()} that is called after the
+ * {@code Formatter} has been closed will raise a {@code FormatterClosedException}.
+ */
+ public void close() {
+ closed = true;
+ try {
+ if (out instanceof Closeable) {
+ ((Closeable) out).close();
+ }
+ } catch (IOException e) {
+
+ lastIOException = e;
+ }
+ }
+
+ /**
+ * Returns the last {@code IOException} thrown by the {@code Formatter}'s output
+ * destination. If the {@code append()} method of the destination does not throw
+ * {@code IOException}s, the {@code ioException()} method will always return {@code null}.
+ *
+ * @return the last {@code IOException} thrown by the {@code Formatter}'s output
+ * destination.
+ */
+ public IOException ioException() {
+ return lastIOException;
+ }
+
+ /**
+ * Writes a formatted string to the output destination of the {@code Formatter}.
+ *
+ * @param format
+ * a format string.
+ * @param args
+ * the arguments list used in the {@code format()} method. If there are
+ * more arguments than those specified by the format string, then
+ * the additional arguments are ignored.
+ * @return this {@code Formatter}.
+ * @throws IllegalFormatException
+ * if the format string is illegal or incompatible with the
+ * arguments, or if fewer arguments are sent than those required by
+ * the format string, or any other illegal situation.
+ * @throws FormatterClosedException
+ * if the {@code Formatter} has been closed.
+ */
+ public LenientFormatter format(String format, Object... args) {
+ return format(locale, format, args);
+ }
+
+ /**
+ * Writes a formatted string to the output destination of the {@code Formatter}.
+ *
+ * @param l
+ * the {@code Locale} used in the method. If {@code locale} is
+ * {@code null}, then no localization will be applied. This
+ * parameter does not influence the {@code Locale} specified during
+ * construction.
+ * @param format
+ * a format string.
+ * @param args
+ * the arguments list used in the {@code format()} method. If there are
+ * more arguments than those specified by the format string, then
+ * the additional arguments are ignored.
+ * @return this {@code Formatter}.
+ * @throws IllegalFormatException
+ * if the format string is illegal or incompatible with the
+ * arguments, or if fewer arguments are sent than those required by
+ * the format string, or any other illegal situation.
+ * @throws FormatterClosedException
+ * if the {@code Formatter} has been closed.
+ */
+ public LenientFormatter format(Locale l, String format, Object... args) {
+ checkClosed();
+ CharBuffer formatBuffer = CharBuffer.wrap(format);
+ ParserStateMachine parser = new ParserStateMachine(formatBuffer);
+ Transformer transformer = new Transformer(this, l);
+
+ int currentObjectIndex = 0;
+ Object lastArgument = null;
+ boolean hasLastArgumentSet = false;
+ while (formatBuffer.hasRemaining()) {
+ parser.reset();
+ FormatToken token = parser.getNextFormatToken();
+ String result;
+ String plainText = token.getPlainText();
+ if (token.getConversionType() == (char) FormatToken.UNSET) {
+ result = plainText;
+ } else {
+ plainText = plainText.substring(0, plainText.indexOf('%'));
+ Object argument = null;
+ if (token.requireArgument()) {
+ int index = token.getArgIndex() == FormatToken.UNSET ? currentObjectIndex++
+ : token.getArgIndex();
+ argument = getArgument(args, index, token, lastArgument,
+ hasLastArgumentSet);
+ lastArgument = argument;
+ hasLastArgumentSet = true;
+ }
+ result = transformer.transform(token, argument);
+ result = (null == result ? plainText : plainText + result);
+ }
+ // if output is made by formattable callback
+ if (null != result) {
+ try {
+ out.append(result);
+ } catch (IOException e) {
+ lastIOException = e;
+ }
+ }
+ }
+ return this;
+ }
+
+ private Object getArgument(Object[] args, int index, FormatToken token,
+ Object lastArgument, boolean hasLastArgumentSet) {
+ if (index == FormatToken.LAST_ARGUMENT_INDEX && !hasLastArgumentSet) {
+ throw new MissingFormatArgumentException("<"); //$NON-NLS-1$
+ }
+
+ if (null == args) {
+ return null;
+ }
+
+ if (index >= args.length) {
+ throw new MissingFormatArgumentException(token.getPlainText());
+ }
+
+ if (index == FormatToken.LAST_ARGUMENT_INDEX) {
+ return lastArgument;
+ }
+
+ return args[index];
+ }
+
+ private static void closeOutputStream(OutputStream os) {
+ if (null == os) {
+ return;
+ }
+ try {
+ os.close();
+
+ } catch (IOException e) {
+ // silently
+ }
+ }
+
+ /*
+ * Information about the format string of a specified argument, which
+ * includes the conversion type, flags, width, precision and the argument
+ * index as well as the plainText that contains the whole format string used
+ * as the result for output if necessary. Besides, the string for flags is
+ * recorded to construct corresponding FormatExceptions if necessary.
+ */
+ private static class FormatToken {
+
+ static final int LAST_ARGUMENT_INDEX = -2;
+
+ static final int UNSET = -1;
+
+ static final int FLAGS_UNSET = 0;
+
+ static final int DEFAULT_PRECISION = 6;
+
+ static final int FLAG_MINUS = 1;
+
+ static final int FLAG_SHARP = 1 << 1;
+
+ static final int FLAG_ADD = 1 << 2;
+
+ static final int FLAG_SPACE = 1 << 3;
+
+ static final int FLAG_ZERO = 1 << 4;
+
+ static final int FLAG_COMMA = 1 << 5;
+
+ static final int FLAG_PARENTHESIS = 1 << 6;
+
+ private static final int FLAGT_TYPE_COUNT = 6;
+
+ private int formatStringStartIndex;
+
+ private String plainText;
+
+ private int argIndex = UNSET;
+
+ private int flags = 0;
+
+ private int width = UNSET;
+
+ private int precision = UNSET;
+
+ private StringBuilder strFlags = new StringBuilder(FLAGT_TYPE_COUNT);
+
+ private char dateSuffix;// will be used in new feature.
+
+ private char conversionType = (char) UNSET;
+
+ boolean isPrecisionSet() {
+ return precision != UNSET;
+ }
+
+ boolean isWidthSet() {
+ return width != UNSET;
+ }
+
+ boolean isFlagSet(int flag) {
+ return 0 != (flags & flag);
+ }
+
+ int getArgIndex() {
+ return argIndex;
+ }
+
+ void setArgIndex(int index) {
+ argIndex = index;
+ }
+
+ String getPlainText() {
+ return plainText;
+ }
+
+ void setPlainText(String plainText) {
+ this.plainText = plainText;
+ }
+
+ int getWidth() {
+ return width;
+ }
+
+ void setWidth(int width) {
+ this.width = width;
+ }
+
+ int getPrecision() {
+ return precision;
+ }
+
+ void setPrecision(int precise) {
+ this.precision = precise;
+ }
+
+ String getStrFlags() {
+ return strFlags.toString();
+ }
+
+ int getFlags() {
+ return flags;
+ }
+
+ void setFlags(int flags) {
+ this.flags = flags;
+ }
+
+ /*
+ * Sets qualified char as one of the flags. If the char is qualified,
+ * sets it as a flag and returns true. Or else returns false.
+ */
+ boolean setFlag(char c) {
+ int newFlag;
+ switch (c) {
+ case '-': {
+ newFlag = FLAG_MINUS;
+ break;
+ }
+ case '#': {
+ newFlag = FLAG_SHARP;
+ break;
+ }
+ case '+': {
+ newFlag = FLAG_ADD;
+ break;
+ }
+ case ' ': {
+ newFlag = FLAG_SPACE;
+ break;
+ }
+ case '0': {
+ newFlag = FLAG_ZERO;
+ break;
+ }
+ case ',': {
+ newFlag = FLAG_COMMA;
+ break;
+ }
+ case '(': {
+ newFlag = FLAG_PARENTHESIS;
+ break;
+ }
+ default:
+ return false;
+ }
+ if (0 != (flags & newFlag)) {
+ throw new DuplicateFormatFlagsException(String.valueOf(c));
+ }
+ flags = (flags | newFlag);
+ strFlags.append(c);
+ return true;
+
+ }
+
+ int getFormatStringStartIndex() {
+ return formatStringStartIndex;
+ }
+
+ void setFormatStringStartIndex(int index) {
+ formatStringStartIndex = index;
+ }
+
+ char getConversionType() {
+ return conversionType;
+ }
+
+ void setConversionType(char c) {
+ conversionType = c;
+ }
+
+ char getDateSuffix() {
+ return dateSuffix;
+ }
+
+ void setDateSuffix(char c) {
+ dateSuffix = c;
+ }
+
+ boolean requireArgument() {
+ return conversionType != '%' && conversionType != 'n';
+ }
+ }
+
+ /*
+ * Transforms the argument to the formatted string according to the format
+ * information contained in the format token.
+ */
+ private static class Transformer {
+
+ private LenientFormatter formatter;
+
+ private FormatToken formatToken;
+
+ private Object arg;
+
+ private Locale locale;
+
+ private static String lineSeparator;
+
+ private NumberFormat numberFormat;
+
+ private DecimalFormatSymbols decimalFormatSymbols;
+
+ private DateTimeUtil dateTimeUtil;
+
+ Transformer(LenientFormatter formatter, Locale locale) {
+ this.formatter = formatter;
+ this.locale = (null == locale ? Locale.US : locale);
+ }
+
+ private NumberFormat getNumberFormat() {
+ if (null == numberFormat) {
+ numberFormat = NumberFormat.getInstance(locale);
+ }
+ return numberFormat;
+ }
+
+ private DecimalFormatSymbols getDecimalFormatSymbols() {
+ if (null == decimalFormatSymbols) {
+ decimalFormatSymbols = new DecimalFormatSymbols(locale);
+ }
+ return decimalFormatSymbols;
+ }
+
+ /*
+ * Gets the formatted string according to the format token and the
+ * argument.
+ */
+ String transform(FormatToken token, Object argument) {
+
+ /* init data member to print */
+ this.formatToken = token;
+ this.arg = argument;
+
+ String result;
+ switch (token.getConversionType()) {
+ case 'B':
+ case 'b': {
+ result = transformFromBoolean();
+ break;
+ }
+ case 'H':
+ case 'h': {
+ result = transformFromHashCode();
+ break;
+ }
+ case 'S':
+ case 's': {
+ result = transformFromString();
+ break;
+ }
+ case 'C':
+ case 'c': {
+ result = transformFromCharacter();
+ break;
+ }
+ case 'd':
+ case 'o':
+ case 'x':
+ case 'X': {
+ if (null == arg || arg instanceof BigInteger) {
+ result = transformFromBigInteger();
+ } else {
+ result = transformFromInteger();
+ }
+ break;
+ }
+ case 'e':
+ case 'E':
+ case 'g':
+ case 'G':
+ case 'f':
+ case 'a':
+ case 'A': {
+ result = transformFromFloat();
+ break;
+ }
+ case '%': {
+ result = transformFromPercent();
+ break;
+ }
+ case 'n': {
+ result = transformFromLineSeparator();
+ break;
+ }
+ case 't':
+ case 'T': {
+ result = transformFromDateTime();
+ break;
+ }
+ default: {
+ throw new UnknownFormatConversionException(String
+ .valueOf(token.getConversionType()));
+ }
+ }
+
+ if (Character.isUpperCase(token.getConversionType())) {
+ if (null != result) {
+ result = result.toUpperCase(Locale.US);
+ }
+ }
+ return result;
+ }
+
+ /*
+ * Transforms the Boolean argument to a formatted string.
+ */
+ private String transformFromBoolean() {
+ StringBuilder result = new StringBuilder();
+ int startIndex = 0;
+ int flags = formatToken.getFlags();
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && !formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException("-" //$NON-NLS-1$
+ + formatToken.getConversionType());
+ }
+
+ // only '-' is valid for flags
+ if (FormatToken.FLAGS_UNSET != flags
+ && FormatToken.FLAG_MINUS != flags) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), formatToken.getConversionType());
+ }
+
+ if (null == arg) {
+ result.append("false"); //$NON-NLS-1$
+ } else if (arg instanceof Boolean) {
+ result.append(arg);
+ } else {
+ result.append("true"); //$NON-NLS-1$
+ }
+ return padding(result, startIndex);
+ }
+
+ /*
+ * Transforms the hashcode of the argument to a formatted string.
+ */
+ private String transformFromHashCode() {
+ StringBuilder result = new StringBuilder();
+
+ int startIndex = 0;
+ int flags = formatToken.getFlags();
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && !formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException("-" //$NON-NLS-1$
+ + formatToken.getConversionType());
+ }
+
+ // only '-' is valid for flags
+ if (FormatToken.FLAGS_UNSET != flags
+ && FormatToken.FLAG_MINUS != flags) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), formatToken.getConversionType());
+ }
+
+ if (null == arg) {
+ result.append("null"); //$NON-NLS-1$
+ } else {
+ result.append(Integer.toHexString(arg.hashCode()));
+ }
+ return padding(result, startIndex);
+ }
+
+ /*
+ * Transforms the String to a formatted string.
+ */
+ private String transformFromString() {
+ StringBuilder result = new StringBuilder();
+ int startIndex = 0;
+ int flags = formatToken.getFlags();
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && !formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException("-" //$NON-NLS-1$
+ + formatToken.getConversionType());
+ }
+
+ // only '-' is valid for flags if the argument is not an
+ // instance of Formattable
+ if (FormatToken.FLAGS_UNSET != flags
+ && FormatToken.FLAG_MINUS != flags) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), formatToken.getConversionType());
+ }
+
+ result.append(arg);
+ return padding(result, startIndex);
+ }
+
+ /*
+ * Transforms the Character to a formatted string.
+ */
+ private String transformFromCharacter() {
+ StringBuilder result = new StringBuilder();
+
+ int startIndex = 0;
+ int flags = formatToken.getFlags();
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && !formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException("-" //$NON-NLS-1$
+ + formatToken.getConversionType());
+ }
+
+ // only '-' is valid for flags
+ if (FormatToken.FLAGS_UNSET != flags
+ && FormatToken.FLAG_MINUS != flags) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), formatToken.getConversionType());
+ }
+
+ if (formatToken.isPrecisionSet()) {
+ throw new IllegalFormatPrecisionException(formatToken
+ .getPrecision());
+ }
+
+ if (null == arg) {
+ result.append("null"); //$NON-NLS-1$
+ } else {
+ if (arg instanceof Character) {
+ result.append(arg);
+ } else if (arg instanceof Byte) {
+ byte b = ((Byte) arg).byteValue();
+ if (!Character.isValidCodePoint(b)) {
+ throw new IllegalFormatCodePointException(b);
+ }
+ result.append((char) b);
+ } else if (arg instanceof Short) {
+ short s = ((Short) arg).shortValue();
+ if (!Character.isValidCodePoint(s)) {
+ throw new IllegalFormatCodePointException(s);
+ }
+ result.append((char) s);
+ } else if (arg instanceof Number) {
+ int codePoint = ((Number) arg).intValue();
+ if (!Character.isValidCodePoint(codePoint)) {
+ throw new IllegalFormatCodePointException(codePoint);
+ }
+ result.append(String.valueOf(Character.toChars(codePoint)));
+ } else {
+ // argument of other class is not acceptable.
+ throw new IllegalFormatConversionException(formatToken
+ .getConversionType(), arg.getClass());
+ }
+ }
+ return padding(result, startIndex);
+ }
+
+ /*
+ * Transforms percent to a formatted string. Only '-' is legal flag.
+ * Precision is illegal.
+ */
+ private String transformFromPercent() {
+ StringBuilder result = new StringBuilder("%"); //$NON-NLS-1$
+
+ int startIndex = 0;
+ int flags = formatToken.getFlags();
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && !formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException("-" //$NON-NLS-1$
+ + formatToken.getConversionType());
+ }
+
+ if (FormatToken.FLAGS_UNSET != flags
+ && FormatToken.FLAG_MINUS != flags) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), formatToken.getConversionType());
+ }
+ if (formatToken.isPrecisionSet()) {
+ throw new IllegalFormatPrecisionException(formatToken
+ .getPrecision());
+ }
+ return padding(result, startIndex);
+ }
+
+ /*
+ * Transforms line separator to a formatted string. Any flag, the width
+ * or the precision is illegal.
+ */
+ private String transformFromLineSeparator() {
+ if (formatToken.isPrecisionSet()) {
+ throw new IllegalFormatPrecisionException(formatToken
+ .getPrecision());
+ }
+
+ if (formatToken.isWidthSet()) {
+ throw new IllegalFormatWidthException(formatToken.getWidth());
+ }
+
+ int flags = formatToken.getFlags();
+ if (FormatToken.FLAGS_UNSET != flags) {
+ throw new IllegalFormatFlagsException(formatToken.getStrFlags());
+ }
+
+ if (null == lineSeparator) {
+ lineSeparator = AccessController
+ .doPrivileged(new PrivilegedAction<String>() {
+
+ public String run() {
+ return System.getProperty("line.separator"); //$NON-NLS-1$
+ }
+ });
+ }
+ return lineSeparator;
+ }
+
+ /*
+ * Pads characters to the formatted string.
+ */
+ private String padding(StringBuilder source, int startIndex) {
+ int start = startIndex;
+ boolean paddingRight = formatToken
+ .isFlagSet(FormatToken.FLAG_MINUS);
+ char paddingChar = '\u0020';// space as padding char.
+ if (formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ if ('d' == formatToken.getConversionType()) {
+ paddingChar = getDecimalFormatSymbols().getZeroDigit();
+ } else {
+ paddingChar = '0';
+ }
+ } else {
+ // if padding char is space, always padding from the head
+ // location.
+ start = 0;
+ }
+ int width = formatToken.getWidth();
+ int precision = formatToken.getPrecision();
+
+ int length = source.length();
+ if (precision >= 0) {
+ length = Math.min(length, precision);
+ source.delete(length, source.length());
+ }
+ if (width > 0) {
+ width = Math.max(source.length(), width);
+ }
+ if (length >= width) {
+ return source.toString();
+ }
+
+ char[] paddings = new char[width - length];
+ Arrays.fill(paddings, paddingChar);
+ String insertString = new String(paddings);
+
+ if (paddingRight) {
+ source.append(insertString);
+ } else {
+ source.insert(start, insertString);
+ }
+ return source.toString();
+ }
+
+ /*
+ * Transforms the Integer to a formatted string.
+ */
+ private String transformFromInteger() {
+ int startIndex = 0;
+ boolean isNegative = false;
+ StringBuilder result = new StringBuilder();
+ char currentConversionType = formatToken.getConversionType();
+ long value;
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ || formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ if (!formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException(formatToken
+ .getStrFlags());
+ }
+ }
+ // Combination of '+' & ' ' is illegal.
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)
+ && formatToken.isFlagSet(FormatToken.FLAG_SPACE)) {
+ throw new IllegalFormatFlagsException(formatToken.getStrFlags());
+ }
+ if (formatToken.isPrecisionSet()) {
+ throw new IllegalFormatPrecisionException(formatToken
+ .getPrecision());
+ }
+ if (arg instanceof Long) {
+ value = ((Long) arg).longValue();
+ } else if (arg instanceof Integer) {
+ value = ((Integer) arg).longValue();
+ } else if (arg instanceof Short) {
+ value = ((Short) arg).longValue();
+ } else if (arg instanceof Byte) {
+ value = ((Byte) arg).longValue();
+ }
+ else if (arg instanceof Number) {
+ value = ((Number) arg).longValue();
+ } else {
+ throw new IllegalFormatConversionException(formatToken
+ .getConversionType(), arg.getClass());
+ }
+ if ('d' != currentConversionType) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)
+ || formatToken.isFlagSet(FormatToken.FLAG_SPACE)
+ || formatToken.isFlagSet(FormatToken.FLAG_COMMA)
+ || formatToken.isFlagSet(FormatToken.FLAG_PARENTHESIS)) {
+ throw new FormatFlagsConversionMismatchException(
+ formatToken.getStrFlags(), formatToken
+ .getConversionType());
+ }
+ }
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_SHARP)) {
+ if ('d' == currentConversionType) {
+ throw new FormatFlagsConversionMismatchException(
+ formatToken.getStrFlags(), formatToken
+ .getConversionType());
+ } else if ('o' == currentConversionType) {
+ result.append("0"); //$NON-NLS-1$
+ startIndex += 1;
+ } else {
+ result.append("0x"); //$NON-NLS-1$
+ startIndex += 2;
+ }
+ }
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ throw new IllegalFormatFlagsException(formatToken.getStrFlags());
+ }
+
+ if (value < 0) {
+ isNegative = true;
+ }
+
+ if ('d' == currentConversionType) {
+ NumberFormat numberFormat = getNumberFormat();
+ if (formatToken.isFlagSet(FormatToken.FLAG_COMMA)) {
+ numberFormat.setGroupingUsed(true);
+ } else {
+ numberFormat.setGroupingUsed(false);
+ }
+ result.append(numberFormat.format(arg));
+ } else {
+ long BYTE_MASK = 0x00000000000000FFL;
+ long SHORT_MASK = 0x000000000000FFFFL;
+ long INT_MASK = 0x00000000FFFFFFFFL;
+ if (isNegative) {
+ if (arg instanceof Byte) {
+ value &= BYTE_MASK;
+ } else if (arg instanceof Short) {
+ value &= SHORT_MASK;
+ } else if (arg instanceof Integer) {
+ value &= INT_MASK;
+ }
+ }
+ if ('o' == currentConversionType) {
+ result.append(Long.toOctalString(value));
+ } else {
+ result.append(Long.toHexString(value));
+ }
+ isNegative = false;
+ }
+
+ if (!isNegative) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)) {
+ result.insert(0, '+');
+ startIndex += 1;
+ }
+ if (formatToken.isFlagSet(FormatToken.FLAG_SPACE)) {
+ result.insert(0, ' ');
+ startIndex += 1;
+ }
+ }
+
+ /* pad paddingChar to the output */
+ if (isNegative
+ && formatToken.isFlagSet(FormatToken.FLAG_PARENTHESIS)) {
+ result = wrapParentheses(result);
+ return result.toString();
+
+ }
+ if (isNegative && formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ startIndex++;
+ }
+ return padding(result, startIndex);
+ }
+
+ /*
+ * add () to the output,if the value is negative and
+ * formatToken.FLAG_PARENTHESIS is set. 'result' is used as an in-out
+ * parameter.
+ */
+ private StringBuilder wrapParentheses(StringBuilder result) {
+ // delete the '-'
+ result.deleteCharAt(0);
+ result.insert(0, '(');
+ if (formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ formatToken.setWidth(formatToken.getWidth() - 1);
+ padding(result, 1);
+ result.append(')');
+ } else {
+ result.append(')');
+ padding(result, 0);
+ }
+ return result;
+ }
+
+ private String transformFromSpecialNumber() {
+ String source = null;
+
+ if (!(arg instanceof Number) || arg instanceof BigDecimal) {
+ return null;
+ }
+
+ Number number = (Number) arg;
+ double d = number.doubleValue();
+ if (Double.isNaN(d)) {
+ source = "NaN"; //$NON-NLS-1$
+ } else if (Double.isInfinite(d)) {
+ if (d >= 0) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)) {
+ source = "+Infinity"; //$NON-NLS-1$
+ } else if (formatToken.isFlagSet(FormatToken.FLAG_SPACE)) {
+ source = " Infinity"; //$NON-NLS-1$
+ } else {
+ source = "Infinity"; //$NON-NLS-1$
+ }
+ } else {
+ if (formatToken.isFlagSet(FormatToken.FLAG_PARENTHESIS)) {
+ source = "(Infinity)"; //$NON-NLS-1$
+ } else {
+ source = "-Infinity"; //$NON-NLS-1$
+ }
+ }
+ }
+
+ if (null != source) {
+ formatToken.setPrecision(FormatToken.UNSET);
+ formatToken.setFlags(formatToken.getFlags()
+ & (~FormatToken.FLAG_ZERO));
+ source = padding(new StringBuilder(source), 0);
+ }
+ return source;
+ }
+
+ private String transformFromNull() {
+ formatToken.setFlags(formatToken.getFlags()
+ & (~FormatToken.FLAG_ZERO));
+ return padding(new StringBuilder("null"), 0); //$NON-NLS-1$
+ }
+
+ /*
+ * Transforms a BigInteger to a formatted string.
+ */
+ private String transformFromBigInteger() {
+ int startIndex = 0;
+ boolean isNegative = false;
+ StringBuilder result = new StringBuilder();
+ BigInteger bigInt = (BigInteger) arg;
+ char currentConversionType = formatToken.getConversionType();
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ || formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ if (!formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException(formatToken
+ .getStrFlags());
+ }
+ }
+
+ // Combination of '+' & ' ' is illegal.
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)
+ && formatToken.isFlagSet(FormatToken.FLAG_SPACE)) {
+ throw new IllegalFormatFlagsException(formatToken.getStrFlags());
+ }
+
+ // Combination of '-' & '0' is illegal.
+ if (formatToken.isFlagSet(FormatToken.FLAG_ZERO)
+ && formatToken.isFlagSet(FormatToken.FLAG_MINUS)) {
+ throw new IllegalFormatFlagsException(formatToken.getStrFlags());
+ }
+
+ if (formatToken.isPrecisionSet()) {
+ throw new IllegalFormatPrecisionException(formatToken
+ .getPrecision());
+ }
+
+ if ('d' != currentConversionType
+ && formatToken.isFlagSet(FormatToken.FLAG_COMMA)) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), currentConversionType);
+ }
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_SHARP)
+ && 'd' == currentConversionType) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), currentConversionType);
+ }
+
+ if (null == bigInt) {
+ return transformFromNull();
+ }
+
+ isNegative = (bigInt.compareTo(BigInteger.ZERO) < 0);
+
+ if ('d' == currentConversionType) {
+ NumberFormat numberFormat = getNumberFormat();
+ boolean readableName = formatToken
+ .isFlagSet(FormatToken.FLAG_COMMA);
+ numberFormat.setGroupingUsed(readableName);
+ result.append(numberFormat.format(bigInt));
+ } else if ('o' == currentConversionType) {
+ // convert BigInteger to a string presentation using radix 8
+ result.append(bigInt.toString(8));
+ } else {
+ // convert BigInteger to a string presentation using radix 16
+ result.append(bigInt.toString(16));
+ }
+ if (formatToken.isFlagSet(FormatToken.FLAG_SHARP)) {
+ startIndex = isNegative ? 1 : 0;
+ if ('o' == currentConversionType) {
+ result.insert(startIndex, "0"); //$NON-NLS-1$
+ startIndex += 1;
+ } else if ('x' == currentConversionType
+ || 'X' == currentConversionType) {
+ result.insert(startIndex, "0x"); //$NON-NLS-1$
+ startIndex += 2;
+ }
+ }
+
+ if (!isNegative) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)) {
+ result.insert(0, '+');
+ startIndex += 1;
+ }
+ if (formatToken.isFlagSet(FormatToken.FLAG_SPACE)) {
+ result.insert(0, ' ');
+ startIndex += 1;
+ }
+ }
+
+ /* pad paddingChar to the output */
+ if (isNegative
+ && formatToken.isFlagSet(FormatToken.FLAG_PARENTHESIS)) {
+ result = wrapParentheses(result);
+ return result.toString();
+
+ }
+ if (isNegative && formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ startIndex++;
+ }
+ return padding(result, startIndex);
+ }
+
+ /*
+ * Transforms a Float,Double or BigDecimal to a formatted string.
+ */
+ private String transformFromFloat() {
+ StringBuilder result = new StringBuilder();
+ int startIndex = 0;
+ char currentConversionType = formatToken.getConversionType();
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS
+ | FormatToken.FLAG_ZERO)) {
+ if (!formatToken.isWidthSet()) {
+ throw new MissingFormatWidthException(formatToken
+ .getStrFlags());
+ }
+ }
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)
+ && formatToken.isFlagSet(FormatToken.FLAG_SPACE)) {
+ throw new IllegalFormatFlagsException(formatToken.getStrFlags());
+ }
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && formatToken.isFlagSet(FormatToken.FLAG_ZERO)) {
+ throw new IllegalFormatFlagsException(formatToken.getStrFlags());
+ }
+
+ if ('e' == Character.toLowerCase(currentConversionType)) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_COMMA)) {
+ throw new FormatFlagsConversionMismatchException(
+ formatToken.getStrFlags(), currentConversionType);
+ }
+ }
+
+ if ('g' == Character.toLowerCase(currentConversionType)) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_SHARP)) {
+ throw new FormatFlagsConversionMismatchException(
+ formatToken.getStrFlags(), currentConversionType);
+ }
+ }
+
+ if ('a' == Character.toLowerCase(currentConversionType)) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_COMMA)
+ || formatToken.isFlagSet(FormatToken.FLAG_PARENTHESIS)) {
+ throw new FormatFlagsConversionMismatchException(
+ formatToken.getStrFlags(), currentConversionType);
+ }
+ }
+
+ if (null == arg) {
+ return transformFromNull();
+ }
+
+ Object arg2 = arg;
+
+ if (!(arg2 instanceof Float || arg2 instanceof Double || arg2 instanceof BigDecimal)) {
+ if (arg2 instanceof Number) {
+ arg2 = Double.valueOf(((Number)arg2).doubleValue());
+ }
+ else {
+ throw new IllegalFormatConversionException(currentConversionType, arg.getClass());
+ }
+ }
+
+ String specialNumberResult = transformFromSpecialNumber();
+ if (null != specialNumberResult) {
+ return specialNumberResult;
+ }
+
+ if ('a' != Character.toLowerCase(currentConversionType)) {
+ formatToken
+ .setPrecision(formatToken.isPrecisionSet() ? formatToken
+ .getPrecision()
+ : FormatToken.DEFAULT_PRECISION);
+ }
+ // output result
+ FloatUtil floatUtil = new FloatUtil(result, formatToken,
+ (DecimalFormat) NumberFormat.getInstance(locale), arg2);
+ floatUtil.transform(formatToken, result);
+
+ formatToken.setPrecision(FormatToken.UNSET);
+
+ if (getDecimalFormatSymbols().getMinusSign() == result.charAt(0)) {
+ if (formatToken.isFlagSet(FormatToken.FLAG_PARENTHESIS)) {
+ result = wrapParentheses(result);
+ return result.toString();
+ }
+ } else {
+ if (formatToken.isFlagSet(FormatToken.FLAG_SPACE)) {
+ result.insert(0, ' ');
+ startIndex++;
+ }
+ if (formatToken.isFlagSet(FormatToken.FLAG_ADD)) {
+ result.insert(0, floatUtil.getAddSign());
+ startIndex++;
+ }
+ }
+
+ char firstChar = result.charAt(0);
+ if (formatToken.isFlagSet(FormatToken.FLAG_ZERO)
+ && (firstChar == floatUtil.getAddSign() || firstChar == floatUtil
+ .getMinusSign())) {
+ startIndex = 1;
+ }
+
+ if ('a' == Character.toLowerCase(currentConversionType)) {
+ startIndex += 2;
+ }
+ return padding(result, startIndex);
+ }
+
+ /*
+ * Transforms a Date to a formatted string.
+ */
+ private String transformFromDateTime() {
+ int startIndex = 0;
+ char currentConversionType = formatToken.getConversionType();
+
+ if (formatToken.isPrecisionSet()) {
+ throw new IllegalFormatPrecisionException(formatToken
+ .getPrecision());
+ }
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_SHARP)) {
+ throw new FormatFlagsConversionMismatchException(formatToken
+ .getStrFlags(), currentConversionType);
+ }
+
+ if (formatToken.isFlagSet(FormatToken.FLAG_MINUS)
+ && FormatToken.UNSET == formatToken.getWidth()) {
+ throw new MissingFormatWidthException("-" //$NON-NLS-1$
+ + currentConversionType);
+ }
+
+ if (null == arg) {
+ return transformFromNull();
+ }
+
+ Calendar calendar;
+ if (arg instanceof Calendar) {
+ calendar = (Calendar) arg;
+ } else {
+ Date date = null;
+ if (arg instanceof Number) {
+ date = new Date(((Number) arg).longValue());
+ } else if (arg instanceof Date) {
+ date = (Date) arg;
+ } else {
+ throw new IllegalFormatConversionException(
+ currentConversionType, arg.getClass());
+ }
+ calendar = Calendar.getInstance(locale);
+ calendar.setTime(date);
+ }
+
+ if (null == dateTimeUtil) {
+ dateTimeUtil = new DateTimeUtil(locale);
+ }
+ StringBuilder result = new StringBuilder();
+ // output result
+ dateTimeUtil.transform(formatToken, calendar, result);
+ return padding(result, startIndex);
+ }
+ }
+
+ private static class FloatUtil {
+ private StringBuilder result;
+
+ private DecimalFormat decimalFormat;
+
+ private FormatToken formatToken;
+
+ private Object argument;
+
+ private char minusSign;
+
+ FloatUtil(StringBuilder result, FormatToken formatToken,
+ DecimalFormat decimalFormat, Object argument) {
+ this.result = result;
+ this.formatToken = formatToken;
+ this.decimalFormat = decimalFormat;
+ this.argument = argument;
+ this.minusSign = decimalFormat.getDecimalFormatSymbols()
+ .getMinusSign();
+ }
+
+ void transform(FormatToken aFormatToken, StringBuilder aResult) {
+ this.result = aResult;
+ this.formatToken = aFormatToken;
+ switch (formatToken.getConversionType()) {
+ case 'e':
+ case 'E': {
+ transform_e();
+ break;
+ }
+ case 'f': {
+ transform_f();
+ break;
+ }
+ case 'g':
+ case 'G': {
+ transform_g();
+ break;
+ }
+ case 'a':
+ case 'A': {
+ transform_a();
+ break;
+ }
+ default: {
+ throw new UnknownFormatConversionException(String
+ .valueOf(formatToken.getConversionType()));
+ }
+ }
+ }
+
+ char getMinusSign() {
+ return minusSign;
+ }
+
+ char getAddSign() {
+ return '+';
+ }
+
+ void transform_e() {
+ StringBuilder pattern = new StringBuilder();
+ pattern.append('0');
+ if (formatToken.getPrecision() > 0) {
+ pattern.append('.');
+ char[] zeros = new char[formatToken.getPrecision()];
+ Arrays.fill(zeros, '0');
+ pattern.append(zeros);
+ }
+ pattern.append('E');
+ pattern.append("+00"); //$NON-NLS-1$
+ decimalFormat.applyPattern(pattern.toString());
+ String formattedString = decimalFormat.format(argument);
+ result.append(formattedString.replace('E', 'e'));
+
+ // if the flag is sharp and decimal seperator is always given
+ // out.
+ if (formatToken.isFlagSet(FormatToken.FLAG_SHARP)
+ && 0 == formatToken.getPrecision()) {
+ int indexOfE = result.indexOf("e"); //$NON-NLS-1$
+ char dot = decimalFormat.getDecimalFormatSymbols()
+ .getDecimalSeparator();
+ result.insert(indexOfE, dot);
+ }
+ }
+
+ void transform_g() {
+ int precision = formatToken.getPrecision();
+ precision = (0 == precision ? 1 : precision);
+ formatToken.setPrecision(precision);
+
+ if (0.0 == ((Number) argument).doubleValue()) {
+ precision--;
+ formatToken.setPrecision(precision);
+ transform_f();
+ return;
+ }
+
+ boolean requireScientificRepresentation = true;
+ double d = ((Number) argument).doubleValue();
+ d = Math.abs(d);
+ if (Double.isInfinite(d)) {
+ precision = formatToken.getPrecision();
+ precision--;
+ formatToken.setPrecision(precision);
+ transform_e();
+ return;
+ }
+ BigDecimal b = new BigDecimal(d, new MathContext(precision));
+ d = b.doubleValue();
+ long l = b.longValue();
+
+ if (d >= 1 && d < Math.pow(10, precision)) {
+ if (l < Math.pow(10, precision)) {
+ requireScientificRepresentation = false;
+ precision -= String.valueOf(l).length();
+ precision = precision < 0 ? 0 : precision;
+ l = Math.round(d * Math.pow(10, precision + 1));
+ if (String.valueOf(l).length() <= formatToken
+ .getPrecision()) {
+ precision++;
+ }
+ formatToken.setPrecision(precision);
+ }
+
+ } else {
+ l = b.movePointRight(4).longValue();
+ if (d >= Math.pow(10, -4) && d < 1) {
+ requireScientificRepresentation = false;
+ precision += 4 - String.valueOf(l).length();
+ l = b.movePointRight(precision + 1).longValue();
+ if (String.valueOf(l).length() <= formatToken
+ .getPrecision()) {
+ precision++;
+ }
+ l = b.movePointRight(precision).longValue();
+ if (l >= Math.pow(10, precision - 4)) {
+ formatToken.setPrecision(precision);
+ }
+ }
+ }
+ if (requireScientificRepresentation) {
+ precision = formatToken.getPrecision();
+ precision--;
+ formatToken.setPrecision(precision);
+ transform_e();
+ } else {
+ transform_f();
+ }
+
+ }
+
+ void transform_f() {
+ StringBuilder pattern = new StringBuilder();
+ if (formatToken.isFlagSet(FormatToken.FLAG_COMMA)) {
+ pattern.append(',');
+ int groupingSize = decimalFormat.getGroupingSize();
+ if (groupingSize > 1) {
+ char[] sharps = new char[groupingSize - 1];
+ Arrays.fill(sharps, '#');
+ pattern.append(sharps);
+ }
+ }
+
+ pattern.append(0);
+
+ if (formatToken.getPrecision() > 0) {
+ pattern.append('.');
+ char[] zeros = new char[formatToken.getPrecision()];
+ Arrays.fill(zeros, '0');
+ pattern.append(zeros);
+ }
+ decimalFormat.applyPattern(pattern.toString());
+ result.append(decimalFormat.format(argument));
+ // if the flag is sharp and decimal seperator is always given
+ // out.
+ if (formatToken.isFlagSet(FormatToken.FLAG_SHARP)
+ && 0 == formatToken.getPrecision()) {
+ char dot = decimalFormat.getDecimalFormatSymbols()
+ .getDecimalSeparator();
+ result.append(dot);
+ }
+
+ }
+
+ void transform_a() {
+ char currentConversionType = formatToken.getConversionType();
+
+ if (argument instanceof Float) {
+ Float F = (Float) argument;
+ result.append(Float.toHexString(F.floatValue()));
+
+ } else if (argument instanceof Double) {
+ Double D = (Double) argument;
+ result.append(Double.toHexString(D.doubleValue()));
+ } else {
+ // BigInteger is not supported.
+ throw new IllegalFormatConversionException(
+ currentConversionType, argument.getClass());
+ }
+
+ if (!formatToken.isPrecisionSet()) {
+ return;
+ }
+
+ int precision = formatToken.getPrecision();
+ precision = (0 == precision ? 1 : precision);
+ int indexOfFirstFracitoanlDigit = result.indexOf(".") + 1; //$NON-NLS-1$
+ int indexOfP = result.indexOf("p"); //$NON-NLS-1$
+ int fractionalLength = indexOfP - indexOfFirstFracitoanlDigit;
+
+ if (fractionalLength == precision) {
+ return;
+ }
+
+ if (fractionalLength < precision) {
+ char zeros[] = new char[precision - fractionalLength];
+ Arrays.fill(zeros, '0');
+ result.insert(indexOfP, zeros);
+ return;
+ }
+ result.delete(indexOfFirstFracitoanlDigit + precision, indexOfP);
+ }
+ }
+
+ private static class DateTimeUtil {
+ private Calendar calendar;
+
+ private Locale locale;
+
+ private StringBuilder result;
+
+ private DateFormatSymbols dateFormatSymbols;
+
+ DateTimeUtil(Locale locale) {
+ this.locale = locale;
+ }
+
+ void transform(FormatToken formatToken, Calendar aCalendar,
+ StringBuilder aResult) {
+ this.result = aResult;
+ this.calendar = aCalendar;
+ char suffix = formatToken.getDateSuffix();
+
+ switch (suffix) {
+ case 'H': {
+ transform_H();
+ break;
+ }
+ case 'I': {
+ transform_I();
+ break;
+ }
+ case 'M': {
+ transform_M();
+ break;
+ }
+ case 'S': {
+ transform_S();
+ break;
+ }
+ case 'L': {
+ transform_L();
+ break;
+ }
+ case 'N': {
+ transform_N();
+ break;
+ }
+ case 'k': {
+ transform_k();
+ break;
+ }
+ case 'l': {
+ transform_l();
+ break;
+ }
+ case 'p': {
+ transform_p(true);
+ break;
+ }
+ case 's': {
+ transform_s();
+ break;
+ }
+ case 'z': {
+ transform_z();
+ break;
+ }
+ case 'Z': {
+ transform_Z();
+ break;
+ }
+ case 'Q': {
+ transform_Q();
+ break;
+ }
+ case 'B': {
+ transform_B();
+ break;
+ }
+ case 'b':
+ case 'h': {
+ transform_b();
+ break;
+ }
+ case 'A': {
+ transform_A();
+ break;
+ }
+ case 'a': {
+ transform_a();
+ break;
+ }
+ case 'C': {
+ transform_C();
+ break;
+ }
+ case 'Y': {
+ transform_Y();
+ break;
+ }
+ case 'y': {
+ transform_y();
+ break;
+ }
+ case 'j': {
+ transform_j();
+ break;
+ }
+ case 'm': {
+ transform_m();
+ break;
+ }
+ case 'd': {
+ transform_d();
+ break;
+ }
+ case 'e': {
+ transform_e();
+ break;
+ }
+ case 'R': {
+ transform_R();
+ break;
+ }
+
+ case 'T': {
+ transform_T();
+ break;
+ }
+ case 'r': {
+ transform_r();
+ break;
+ }
+ case 'D': {
+ transform_D();
+ break;
+ }
+ case 'F': {
+ transform_F();
+ break;
+ }
+ case 'c': {
+ transform_c();
+ break;
+ }
+ default: {
+ throw new UnknownFormatConversionException(String
+ .valueOf(formatToken.getConversionType())
+ + formatToken.getDateSuffix());
+ }
+ }
+ }
+
+ private void transform_e() {
+ int day = calendar.get(Calendar.DAY_OF_MONTH);
+ result.append(day);
+ }
+
+ private void transform_d() {
+ int day = calendar.get(Calendar.DAY_OF_MONTH);
+ result.append(paddingZeros(day, 2));
+ }
+
+ private void transform_m() {
+ int month = calendar.get(Calendar.MONTH);
+ // The returned month starts from zero, which needs to be
+ // incremented by 1.
+ month++;
+ result.append(paddingZeros(month, 2));
+ }
+
+ private void transform_j() {
+ int day = calendar.get(Calendar.DAY_OF_YEAR);
+ result.append(paddingZeros(day, 3));
+ }
+
+ private void transform_y() {
+ int year = calendar.get(Calendar.YEAR);
+ year %= 100;
+ result.append(paddingZeros(year, 2));
+ }
+
+ private void transform_Y() {
+ int year = calendar.get(Calendar.YEAR);
+ result.append(paddingZeros(year, 4));
+ }
+
+ private void transform_C() {
+ int year = calendar.get(Calendar.YEAR);
+ year /= 100;
+ result.append(paddingZeros(year, 2));
+ }
+
+ private void transform_a() {
+ int day = calendar.get(Calendar.DAY_OF_WEEK);
+ result.append(getDateFormatSymbols().getShortWeekdays()[day]);
+ }
+
+ private void transform_A() {
+ int day = calendar.get(Calendar.DAY_OF_WEEK);
+ result.append(getDateFormatSymbols().getWeekdays()[day]);
+ }
+
+ private void transform_b() {
+ int month = calendar.get(Calendar.MONTH);
+ result.append(getDateFormatSymbols().getShortMonths()[month]);
+ }
+
+ private void transform_B() {
+ int month = calendar.get(Calendar.MONTH);
+ result.append(getDateFormatSymbols().getMonths()[month]);
+ }
+
+ private void transform_Q() {
+ long milliSeconds = calendar.getTimeInMillis();
+ result.append(milliSeconds);
+ }
+
+ private void transform_s() {
+ long milliSeconds = calendar.getTimeInMillis();
+ milliSeconds /= 1000;
+ result.append(milliSeconds);
+ }
+
+ private void transform_Z() {
+ TimeZone timeZone = calendar.getTimeZone();
+ result.append(timeZone
+ .getDisplayName(
+ timeZone.inDaylightTime(calendar.getTime()),
+ TimeZone.SHORT, locale));
+ }
+
+ private void transform_z() {
+ int zoneOffset = calendar.get(Calendar.ZONE_OFFSET);
+ zoneOffset /= 3600000;
+ zoneOffset *= 100;
+ if (zoneOffset >= 0) {
+ result.append('+');
+ }
+ result.append(paddingZeros(zoneOffset, 4));
+ }
+
+ private void transform_p(boolean isLowerCase) {
+ int i = calendar.get(Calendar.AM_PM);
+ String s = getDateFormatSymbols().getAmPmStrings()[i];
+ if (isLowerCase) {
+ s = s.toLowerCase(locale);
+ }
+ result.append(s);
+ }
+
+ private void transform_N() {
+ // TODO System.nanoTime();
+ long nanosecond = calendar.get(Calendar.MILLISECOND) * 1000000L;
+ result.append(paddingZeros(nanosecond, 9));
+ }
+
+ private void transform_L() {
+ int millisecond = calendar.get(Calendar.MILLISECOND);
+ result.append(paddingZeros(millisecond, 3));
+ }
+
+ private void transform_S() {
+ int second = calendar.get(Calendar.SECOND);
+ result.append(paddingZeros(second, 2));
+ }
+
+ private void transform_M() {
+ int minute = calendar.get(Calendar.MINUTE);
+ result.append(paddingZeros(minute, 2));
+ }
+
+ private void transform_l() {
+ int hour = calendar.get(Calendar.HOUR);
+ if (0 == hour) {
+ hour = 12;
+ }
+ result.append(hour);
+ }
+
+ private void transform_k() {
+ int hour = calendar.get(Calendar.HOUR_OF_DAY);
+ result.append(hour);
+ }
+
+ private void transform_I() {
+ int hour = calendar.get(Calendar.HOUR);
+ if (0 == hour) {
+ hour = 12;
+ }
+ result.append(paddingZeros(hour, 2));
+ }
+
+ private void transform_H() {
+ int hour = calendar.get(Calendar.HOUR_OF_DAY);
+ result.append(paddingZeros(hour, 2));
+ }
+
+ private void transform_R() {
+ transform_H();
+ result.append(':');
+ transform_M();
+ }
+
+ private void transform_T() {
+ transform_H();
+ result.append(':');
+ transform_M();
+ result.append(':');
+ transform_S();
+ }
+
+ private void transform_r() {
+ transform_I();
+ result.append(':');
+ transform_M();
+ result.append(':');
+ transform_S();
+ result.append(' ');
+ transform_p(false);
+ }
+
+ private void transform_D() {
+ transform_m();
+ result.append('/');
+ transform_d();
+ result.append('/');
+ transform_y();
+ }
+
+ private void transform_F() {
+ transform_Y();
+ result.append('-');
+ transform_m();
+ result.append('-');
+ transform_d();
+ }
+
+ private void transform_c() {
+ transform_a();
+ result.append(' ');
+ transform_b();
+ result.append(' ');
+ transform_d();
+ result.append(' ');
+ transform_T();
+ result.append(' ');
+ transform_Z();
+ result.append(' ');
+ transform_Y();
+ }
+
+ private static String paddingZeros(long number, int length) {
+ int len = length;
+ StringBuilder result = new StringBuilder();
+ result.append(number);
+ int startIndex = 0;
+ if (number < 0) {
+ len++;
+ startIndex = 1;
+ }
+ len -= result.length();
+ if (len > 0) {
+ char[] zeros = new char[len];
+ Arrays.fill(zeros, '0');
+ result.insert(startIndex, zeros);
+ }
+ return result.toString();
+ }
+
+ private DateFormatSymbols getDateFormatSymbols() {
+ if (null == dateFormatSymbols) {
+ dateFormatSymbols = new DateFormatSymbols(locale);
+ }
+ return dateFormatSymbols;
+ }
+ }
+
+ private static class ParserStateMachine {
+
+ private static final char EOS = (char) -1;
+
+ private static final int EXIT_STATE = 0;
+
+ private static final int ENTRY_STATE = 1;
+
+ private static final int START_CONVERSION_STATE = 2;
+
+ private static final int FLAGS_STATE = 3;
+
+ private static final int WIDTH_STATE = 4;
+
+ private static final int PRECISION_STATE = 5;
+
+ private static final int CONVERSION_TYPE_STATE = 6;
+
+ private static final int SUFFIX_STATE = 7;
+
+ private FormatToken token;
+
+ private int state = ENTRY_STATE;
+
+ private char currentChar = 0;
+
+ private CharBuffer format = null;
+
+ ParserStateMachine(CharBuffer format) {
+ this.format = format;
+ }
+
+ void reset() {
+ this.currentChar = (char) FormatToken.UNSET;
+ this.state = ENTRY_STATE;
+ this.token = null;
+ }
+
+ /*
+ * Gets the information about the current format token. Information is
+ * recorded in the FormatToken returned and the position of the stream
+ * for the format string will be advanced till the next format token.
+ */
+ FormatToken getNextFormatToken() {
+ token = new FormatToken();
+ token.setFormatStringStartIndex(format.position());
+
+ // FINITE AUTOMATIC MACHINE
+ while (true) {
+
+ if (ParserStateMachine.EXIT_STATE != state) {
+ // exit state does not need to get next char
+ currentChar = getNextFormatChar();
+ if (EOS == currentChar
+ && ParserStateMachine.ENTRY_STATE != state) {
+ throw new UnknownFormatConversionException(
+ getFormatString());
+ }
+ }
+
+ switch (state) {
+ // exit state
+ case ParserStateMachine.EXIT_STATE: {
+ process_EXIT_STATE();
+ return token;
+ }
+ // plain text state, not yet applied converter
+ case ParserStateMachine.ENTRY_STATE: {
+ process_ENTRY_STATE();
+ break;
+ }
+ // begins converted string
+ case ParserStateMachine.START_CONVERSION_STATE: {
+ process_START_CONVERSION_STATE();
+ break;
+ }
+ case ParserStateMachine.FLAGS_STATE: {
+ process_FlAGS_STATE();
+ break;
+ }
+ case ParserStateMachine.WIDTH_STATE: {
+ process_WIDTH_STATE();
+ break;
+ }
+ case ParserStateMachine.PRECISION_STATE: {
+ process_PRECISION_STATE();
+ break;
+ }
+ case ParserStateMachine.CONVERSION_TYPE_STATE: {
+ process_CONVERSION_TYPE_STATE();
+ break;
+ }
+ case ParserStateMachine.SUFFIX_STATE: {
+ process_SUFFIX_STATE();
+ break;
+ }
+ }
+ }
+ }
+
+ /*
+ * Gets next char from the format string.
+ */
+ private char getNextFormatChar() {
+ if (format.hasRemaining()) {
+ return format.get();
+ }
+ return EOS;
+ }
+
+ private String getFormatString() {
+ int end = format.position();
+ format.rewind();
+ String formatString = format.subSequence(
+ token.getFormatStringStartIndex(), end).toString();
+ format.position(end);
+ return formatString;
+ }
+
+ private void process_ENTRY_STATE() {
+ if (EOS == currentChar) {
+ state = ParserStateMachine.EXIT_STATE;
+ } else if ('%' == currentChar) {
+ // change to conversion type state
+ state = START_CONVERSION_STATE;
+ }
+ // else remains in ENTRY_STATE
+ }
+
+ private void process_START_CONVERSION_STATE() {
+ if (Character.isDigit(currentChar)) {
+ int position = format.position() - 1;
+ int number = parseInt(format);
+ char nextChar = 0;
+ if (format.hasRemaining()) {
+ nextChar = format.get();
+ }
+ if ('$' == nextChar) {
+ // the digital sequence stands for the argument
+ // index.
+ int argIndex = number;
+ // k$ stands for the argument whose index is k-1 except that
+ // 0$ and 1$ both stands for the first element.
+ if (argIndex > 0) {
+ token.setArgIndex(argIndex - 1);
+ } else if (argIndex == FormatToken.UNSET) {
+ throw new MissingFormatArgumentException(
+ getFormatString());
+ }
+ state = FLAGS_STATE;
+ } else {
+ // the digital zero stands for one format flag.
+ if ('0' == currentChar) {
+ state = FLAGS_STATE;
+ format.position(position);
+ } else {
+ // the digital sequence stands for the width.
+ state = WIDTH_STATE;
+ // do not get the next char.
+ format.position(format.position() - 1);
+ token.setWidth(number);
+ }
+ }
+ currentChar = nextChar;
+ } else if ('<' == currentChar) {
+ state = FLAGS_STATE;
+ token.setArgIndex(FormatToken.LAST_ARGUMENT_INDEX);
+ } else {
+ state = FLAGS_STATE;
+ // do not get the next char.
+ format.position(format.position() - 1);
+ }
+
+ }
+
+ private void process_FlAGS_STATE() {
+ if (token.setFlag(currentChar)) {
+ // remains in FLAGS_STATE
+ } else if (Character.isDigit(currentChar)) {
+ token.setWidth(parseInt(format));
+ state = WIDTH_STATE;
+ } else if ('.' == currentChar) {
+ state = PRECISION_STATE;
+ } else {
+ state = CONVERSION_TYPE_STATE;
+ // do not get the next char.
+ format.position(format.position() - 1);
+ }
+ }
+
+ private void process_WIDTH_STATE() {
+ if ('.' == currentChar) {
+ state = PRECISION_STATE;
+ } else {
+ state = CONVERSION_TYPE_STATE;
+ // do not get the next char.
+ format.position(format.position() - 1);
+ }
+ }
+
+ private void process_PRECISION_STATE() {
+ if (Character.isDigit(currentChar)) {
+ token.setPrecision(parseInt(format));
+ } else {
+ // the precision is required but not given by the
+ // format string.
+ throw new UnknownFormatConversionException(getFormatString());
+ }
+ state = CONVERSION_TYPE_STATE;
+ }
+
+ private void process_CONVERSION_TYPE_STATE() {
+ token.setConversionType(currentChar);
+ if ('t' == currentChar || 'T' == currentChar) {
+ state = SUFFIX_STATE;
+ } else {
+ state = EXIT_STATE;
+ }
+
+ }
+
+ private void process_SUFFIX_STATE() {
+ token.setDateSuffix(currentChar);
+ state = EXIT_STATE;
+ }
+
+ private void process_EXIT_STATE() {
+ token.setPlainText(getFormatString());
+ }
+
+ /*
+ * Parses integer value from the given buffer
+ */
+ private int parseInt(CharBuffer buffer) {
+ int start = buffer.position() - 1;
+ int end = buffer.limit();
+ while (buffer.hasRemaining()) {
+ if (!Character.isDigit(buffer.get())) {
+ end = buffer.position() - 1;
+ break;
+ }
+ }
+ buffer.position(0);
+ String intStr = buffer.subSequence(start, end).toString();
+ buffer.position(end);
+ try {
+ return Integer.parseInt(intStr);
+ } catch (NumberFormatException e) {
+ return FormatToken.UNSET;
+ }
+ }
+ }
+}
diff --git a/infrastructure/net.appjet.common/util/LimitedSizeMapping.java b/infrastructure/net.appjet.common/util/LimitedSizeMapping.java
new file mode 100644
index 0000000..331baca
--- /dev/null
+++ b/infrastructure/net.appjet.common/util/LimitedSizeMapping.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright 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 net.appjet.common.util;
+
+public class LimitedSizeMapping<K,V> extends ExpiringMapping<K,V> {
+
+ public LimitedSizeMapping(final int maxSize) {
+ super(new ExpiryPolicy() {
+ public boolean hasExpired(long timeStamp, long now, int rank) {
+ return rank > maxSize;
+ }
+ });
+ }
+}