From 668ad3ec552bc13b20d511c7593279ca89d0c3c4 Mon Sep 17 00:00:00 2001
From: "ray.j.greenwell" <ray.j.greenwell@6335cc39-0255-0410-8fd6-9bcaacd3b74c>
Date: Tue, 20 Apr 2010 01:50:37 +0000
Subject: [PATCH] - Fixed parsing of byte[]s to not parse them as strings and
 then   lose precision during the cast. Now it will freak out if the   "byte"
 is out of range. - A bit less hashing in our static initializer.

git-svn-id: https://samskivert.googlecode.com/svn/trunk@2782 6335cc39-0255-0410-8fd6-9bcaacd3b74c
---
 .../com/samskivert/util/ValueMarshaller.java  | 53 +++++++++++--------
 1 file changed, 30 insertions(+), 23 deletions(-)

diff --git a/src/java/com/samskivert/util/ValueMarshaller.java b/src/java/com/samskivert/util/ValueMarshaller.java
index 868adf05..bb189dcc 100644
--- a/src/java/com/samskivert/util/ValueMarshaller.java
+++ b/src/java/com/samskivert/util/ValueMarshaller.java
@@ -59,6 +59,7 @@ public class ValueMarshaller
 
     protected static Map<Class<?>,Parser> _parsers = new HashMap<Class<?>,Parser>();
     static {
+        Parser p;
         // we can parse strings
         _parsers.put(String.class, new Parser() {
             public Object parse (String source) throws Exception {
@@ -67,61 +68,67 @@ public class ValueMarshaller
         });
 
         // and bytes
-        _parsers.put(Byte.TYPE, new Parser() {
+        p = new Parser() {
             public Object parse (String source) throws Exception {
                 return Byte.valueOf(source);
             }
-        });
-        _parsers.put(Byte.class, _parsers.get(Byte.TYPE));
+        };
+        _parsers.put(Byte.class, p);
+        _parsers.put(Byte.TYPE, p);
 
         // and shorts
-        _parsers.put(Short.TYPE, new Parser() {
+        p = new Parser() {
             public Object parse (String source) throws Exception {
                 return Short.valueOf(source);
             }
-        });
-        _parsers.put(Short.class, _parsers.get(Short.TYPE));
+        };
+        _parsers.put(Short.class, p);
+        _parsers.put(Short.TYPE, p);
 
         // and ints
-        _parsers.put(Integer.TYPE, new Parser() {
+        p = new Parser() {
             public Object parse (String source) throws Exception {
                 return Integer.valueOf(source);
             }
-        });
-        _parsers.put(Integer.class, _parsers.get(Integer.TYPE));
+        };
+        _parsers.put(Integer.class, p);
+        _parsers.put(Integer.TYPE, p);
 
         // and longs
-        _parsers.put(Long.TYPE, new Parser() {
+        p = new Parser() {
             public Object parse (String source) throws Exception {
                 return Long.valueOf(source);
             }
-        });
-        _parsers.put(Long.class, _parsers.get(Long.TYPE));
+        };
+        _parsers.put(Long.class, p);
+        _parsers.put(Long.TYPE, p);
 
         // and floats
-        _parsers.put(Float.TYPE, new Parser() {
+        p = new Parser() {
             public Object parse (String source) throws Exception {
                 return Float.valueOf(source);
             }
-        });
-        _parsers.put(Float.class, _parsers.get(Float.TYPE));
+        };
+        _parsers.put(Float.class, p);
+        _parsers.put(Float.TYPE, p);
 
         // and booleans
-        _parsers.put(Boolean.TYPE, new Parser() {
+        p = new Parser() {
             public Object parse (String source) throws Exception {
                 return Boolean.valueOf(source);
             }
-        });
-        _parsers.put(Boolean.class, _parsers.get(Boolean.TYPE));
+        };
+        _parsers.put(Boolean.class, p);
+        _parsers.put(Boolean.TYPE, p);
 
         // and byte arrays
         _parsers.put(byte[].class, new Parser() {
             public Object parse (String source) throws Exception {
-                int[] values = StringUtil.parseIntArray(source);
-                int vcount = values.length;
-                byte[] bytes = new byte[vcount];
-                for (int ii = 0; ii < vcount; ii++) {
-                    bytes[ii] = (byte)values[ii];
+                String[] strs = StringUtil.parseStringArray(source);
+                int count = strs.length;
+                byte[] bytes = new byte[count];
+                for (int ii = 0; ii < count; ii++) {
+                    bytes[ii] = Byte.valueOf(strs[ii]);
                 }
                 return bytes;
             }