diff --git a/ChangeLog b/ChangeLog
index 4aa3c15..834f813 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,5 @@
+* Fri Mar 07 17:00:00 PDT 2014 Vikram Kadi <vikram.kadi@gmail.com> 1.5.0
+Changes to emit a json form of the lwes event.
 * Tue Aug 07 08:00:00 PDT 2013 Robert Wong <rob@openx.com> 1.4.1
 Fix bug where sampleRate was not correctly set.
 * Tue Jul 30 08:00:00 PDT 2013 Robert Wong <rob@openx.com> 1.4.0
diff --git a/pom.xml b/pom.xml
index abf34fd..6d88bf3 100644
--- a/pom.xml
+++ b/pom.xml
@@ -12,7 +12,7 @@
     <groupId>org.lwes</groupId>
     <artifactId>lwes-java</artifactId>
     <packaging>jar</packaging>
-    <version>1.4.3-SNAPSHOT</version>
+    <version>1.5.0-SNAPSHOT</version>
     <name>lwes-java</name>
     <description>Lightweight event system, java implementation</description>
     <url>http://lwes.org</url>
@@ -48,6 +48,13 @@
     </developers>
 
     <dependencies>
+    
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.2.4</version>
+        </dependency>
+    
         <dependency>
             <groupId>junit</groupId>
             <artifactId>junit</artifactId>
diff --git a/src/main/java/org/lwes/ArrayEvent.java b/src/main/java/org/lwes/ArrayEvent.java
index 74d68f6..76ee39b 100644
--- a/src/main/java/org/lwes/ArrayEvent.java
+++ b/src/main/java/org/lwes/ArrayEvent.java
@@ -18,6 +18,7 @@
 import java.util.EnumMap;
 import java.util.Enumeration;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.SortedSet;
@@ -26,8 +27,10 @@
 import org.apache.commons.lang3.mutable.MutableInt;
 import org.lwes.serializer.Deserializer;
 import org.lwes.serializer.DeserializerState;
+import org.lwes.serializer.JsonSerializer;
 import org.lwes.serializer.Serializer;
 import org.lwes.util.EncodedString;
+import org.lwes.util.EventTranslator;
 
 public final class ArrayEvent extends DefaultEvent {
 
@@ -679,4 +682,16 @@ public Object getValue() {
             return value;
         }
     }
+    
+    public String json() {
+        return EventTranslator.arrayToMapEvent(this).json();
+    }
+    
+    public String unTypedJson() {
+        return EventTranslator.arrayToMapEvent(this).unTypedJson();
+    }
+    
+    public Map<String,BaseType> getAttributeNameTypeValues(){
+        return EventTranslator.arrayToMapEvent(this).getAttributeNameTypeValues();
+    }
 }
diff --git a/src/main/java/org/lwes/BaseType.java b/src/main/java/org/lwes/BaseType.java
index db1fd71..88d0c4f 100644
--- a/src/main/java/org/lwes/BaseType.java
+++ b/src/main/java/org/lwes/BaseType.java
@@ -13,9 +13,12 @@
 package org.lwes;
 
 import java.lang.reflect.Array;
+import java.math.BigInteger;
 
+import org.lwes.serializer.StringConverter;
 import org.lwes.serializer.StringParser;
 import org.lwes.util.EncodedString;
+import org.lwes.util.IPAddress;
 
 /**
  * This class provides a base type for the base types in the event system. acts
@@ -366,6 +369,84 @@ public BaseType cloneBaseType() {
     public String toString() {
         return typeObject.toString();
     }
+    
+    /**
+     * This method returns the correct string representation of the underlying data,
+     * 
+     * e.g. for cases where the data is an array of integers, the default toString will just print out 
+     * the internal java representation of array class type, but this method would convert the
+     * individual elements into strings and return a string array
+     * @return
+     */
+    
+    public Object stringyfy(){
+        
+        if(typeObject == null)
+            return null;
+        
+        switch (type) {
+             case BOOLEAN:
+             case BYTE:
+             case DOUBLE:
+             case FLOAT:
+             case INT16:
+             case INT32:
+             case INT64:
+             case UINT16:
+             case UINT32:
+             case UINT64:
+             case STRING:
+             case IPADDR:
+                 return typeObject.toString();
+             case BOOLEAN_ARRAY:
+                 return StringConverter.strArray((boolean[]) typeObject);
+             case BYTE_ARRAY:
+                 return StringConverter.strArray((byte[]) typeObject);
+             case DOUBLE_ARRAY:
+                 return StringConverter.strArray((double[]) typeObject);
+             case FLOAT_ARRAY:
+                 return StringConverter.strArray((float[]) typeObject);
+             case INT16_ARRAY:
+                 return StringConverter.strArray((short[]) typeObject);
+             case INT32_ARRAY:
+                 return StringConverter.strArray((int[]) typeObject);
+             case INT64_ARRAY:
+                 return StringConverter.strArray((long[]) typeObject);
+             case IP_ADDR_ARRAY:
+                 return StringConverter.<IPAddress>strArray((IPAddress[]) typeObject);
+             case STRING_ARRAY:
+                 return StringConverter.<String>strArray((String[]) typeObject);
+             case UINT16_ARRAY:
+                 return StringConverter.strArray((int[]) typeObject);
+             case UINT32_ARRAY:
+                 return StringConverter.strArray((long[]) typeObject);
+             case UINT64_ARRAY:
+                 return StringConverter.<BigInteger>strArray((BigInteger[]) typeObject);
+             case NBOOLEAN_ARRAY:
+                 return StringConverter.<Boolean>strArray((Boolean[]) typeObject);
+             case NBYTE_ARRAY:
+                 return StringConverter.<Byte>strArray((Byte[]) typeObject);
+             case NDOUBLE_ARRAY:
+                 return StringConverter.<Double>strArray((Double[]) typeObject);
+             case NFLOAT_ARRAY:
+                 return StringConverter.<Float>strArray((Float[]) typeObject);
+             case NINT16_ARRAY:
+                 return StringConverter.<Short>strArray((Short[]) typeObject);
+             case NINT32_ARRAY:
+                 return StringConverter.<Integer>strArray((Integer[]) typeObject);
+             case NINT64_ARRAY:
+                 return StringConverter.<Long>strArray((Long[]) typeObject);
+             case NSTRING_ARRAY:
+                 return StringConverter.<String>strArray((String[]) typeObject);
+             case NUINT16_ARRAY:
+                 return StringConverter.<Integer>strArray((Integer[]) typeObject);
+             case NUINT32_ARRAY:
+                 return StringConverter.<Long>strArray((Long[]) typeObject);
+             case NUINT64_ARRAY:
+                 return StringConverter.<BigInteger>strArray((BigInteger[]) typeObject);
+         }
+         return null;
+     }
 
     public String getComment() {
         return comment;
diff --git a/src/main/java/org/lwes/Event.java b/src/main/java/org/lwes/Event.java
index 704b306..abf18d2 100644
--- a/src/main/java/org/lwes/Event.java
+++ b/src/main/java/org/lwes/Event.java
@@ -19,6 +19,7 @@
 import java.net.InetAddress;
 import java.util.Enumeration;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.Set;
 
 import org.lwes.util.CharacterEncoding;
@@ -226,7 +227,13 @@ public interface Event extends Iterable<FieldAccessor> {
     void deserialize(DataInput stream, int length) throws IOException;
 
     int getBytesSize();
-
+    
+    String json();
+    
+    String unTypedJson();
+    
+    Map<String,BaseType> getAttributeNameTypeValues();
+            
     // MISCELLANEOUS
 
     Event copy();
diff --git a/src/main/java/org/lwes/EventFactory.java b/src/main/java/org/lwes/EventFactory.java
index 3c0e711..4dee32b 100644
--- a/src/main/java/org/lwes/EventFactory.java
+++ b/src/main/java/org/lwes/EventFactory.java
@@ -13,6 +13,7 @@
 package org.lwes;
 
 import org.lwes.db.EventTemplateDB;
+import org.lwes.serializer.JsonDeserializer;
 
 import java.io.File;
 import java.io.InputStream;
@@ -189,5 +190,22 @@ public Event createEvent(byte[] bytes, boolean validate) throws EventSystemExcep
         }
         return new MapEvent(bytes, validate, eventTemplateDB);
     }
+    
+    /**
+     * Create an event from its json representation
+     * @param json
+     * @param type
+     * @return
+     */
+    public Event createEventFromJson(String json, EventImplementation type){
+        JsonDeserializer deSerializer = JsonDeserializer.getInstance();
+        switch (type) {
+        case MAP_EVENT:
+            return deSerializer.fromJson(json, new MapEvent());
+        case ARRAY_EVENT:
+            return deSerializer.fromJson(json, new ArrayEvent());
+        }
+        return null;
+    }
 
 }
diff --git a/src/main/java/org/lwes/EventImplementation.java b/src/main/java/org/lwes/EventImplementation.java
new file mode 100644
index 0000000..07b12e4
--- /dev/null
+++ b/src/main/java/org/lwes/EventImplementation.java
@@ -0,0 +1,5 @@
+package org.lwes;
+
+public enum EventImplementation {
+    MAP_EVENT, ARRAY_EVENT;
+}
diff --git a/src/main/java/org/lwes/FieldType.java b/src/main/java/org/lwes/FieldType.java
index d8d6a29..2ba0a1d 100644
--- a/src/main/java/org/lwes/FieldType.java
+++ b/src/main/java/org/lwes/FieldType.java
@@ -16,73 +16,78 @@
 import org.lwes.util.IPAddress;
 
 public enum FieldType {
-    UINT16(0x01, "uint16", 0),
-    INT16(0x02, "int16", (short) 0),
-    UINT32(0x03, "uint32", 0L),
-    INT32(0x04, "int32", 0),
-    STRING(0x05, "string", ""),
-    IPADDR(0x06, "ip_addr", new IPAddress()),
-    INT64(0x07, "int64", 0L),
-    UINT64(0x08, "uint64", BigInteger.ZERO),
-    BOOLEAN(0x09, "boolean", true),
-    BYTE(0x0A, "byte", (byte) 0),
-    FLOAT(0x0B, "float", (float) 0.0),
-    DOUBLE(0x0C, "double", 0.0),
+    UINT16(0x01, "uint16", 0, "uint16"),
+    INT16(0x02, "int16", (short) 0, "int16"),
+    UINT32(0x03, "uint32", 0L, "uint32"),
+    INT32(0x04, "int32", 0, "int32"),
+    STRING(0x05, "string", "", "string"),
+    IPADDR(0x06, "ip_addr", new IPAddress(), "ip_addr"),
+    INT64(0x07, "int64", 0L, "int64"),
+    UINT64(0x08, "uint64", BigInteger.ZERO, "uint64"),
+    BOOLEAN(0x09, "boolean", true, "boolean"),
+    BYTE(0x0A, "byte", (byte) 0, "byte"),
+    FLOAT(0x0B, "float", (float) 0.0, "float"),
+    DOUBLE(0x0C, "double", 0.0, "double"),
 
     // Primitive Arrays
-    UINT16_ARRAY(0x81, "[Luint16", new short[0]),
-    INT16_ARRAY(0x82, "[Lint16", new int[0]),
-    UINT32_ARRAY(0x83, "[Luint32", new int[0]),
-    INT32_ARRAY(0x84, "[Lint32", new long[0]),
-    STRING_ARRAY(0x85, "[Lstring", new String[0]),
-    IP_ADDR_ARRAY(0x86, "[Lip_addr", new IPAddress[0]),
-    INT64_ARRAY(0x87, "[Lint64", new long[0]),
-    UINT64_ARRAY(0x88, "[Luint64", new BigInteger[0]),
-    BOOLEAN_ARRAY(0x89, "[Lboolean", new boolean[0]),
-    BYTE_ARRAY(0x8A, "[Lbyte", new byte[0]),
-    FLOAT_ARRAY(0x8B, "[Lfloat", new float[0]),
-    DOUBLE_ARRAY(0x8C, "[Ldouble", new double[0]),
+    UINT16_ARRAY(0x81, "[Luint16", new short[0], "uint16_array"),
+    INT16_ARRAY(0x82, "[Lint16", new int[0], "int16_array"),
+    UINT32_ARRAY(0x83, "[Luint32", new int[0], "uint32_array"),
+    INT32_ARRAY(0x84, "[Lint32", new long[0], "int32_array"),
+    STRING_ARRAY(0x85, "[Lstring", new String[0], "string_array"),
+    IP_ADDR_ARRAY(0x86, "[Lip_addr", new IPAddress[0], "ip_addr_array"),
+    INT64_ARRAY(0x87, "[Lint64", new long[0], "int64_array"),
+    UINT64_ARRAY(0x88, "[Luint64", new BigInteger[0], "uint64_array"),
+    BOOLEAN_ARRAY(0x89, "[Lboolean", new boolean[0], "boolean_array"),
+    BYTE_ARRAY(0x8A, "[Lbyte", new byte[0], "byte_array"),
+    FLOAT_ARRAY(0x8B, "[Lfloat", new float[0], "float_array"),
+    DOUBLE_ARRAY(0x8C, "[Ldouble", new double[0], "double_array"),
 
     // Nullable, object backed arrays
-    NUINT16_ARRAY(0x8D, "[LNuint16", new Short[0]),
-    NINT16_ARRAY(0x8E, "[LNint16", new Integer[0]),
-    NUINT32_ARRAY(0x8F, "[LNuint32", new Integer[0]),
-    NINT32_ARRAY(0x90, "[LNint32", new Long[0]),
-    NSTRING_ARRAY(0x91, "[LString", new String[0]),
+    NUINT16_ARRAY(0x8D, "[LNuint16", new Short[0], "nullable_uint16_array"),
+    NINT16_ARRAY(0x8E, "[LNint16", new Integer[0], "nullable_int16_array"),
+    NUINT32_ARRAY(0x8F, "[LNuint32", new Integer[0], "nullable_uint32_array"),
+    NINT32_ARRAY(0x90, "[LNint32", new Long[0], "nullable_int32_array"),
+    NSTRING_ARRAY(0x91, "[LString", new String[0], "nullable_string_array"),
     // N_IP_ADDR_ARRAY not implemented... 0x92
-    NINT64_ARRAY(0x93, "[LNint64", new Long[0]),
-    NUINT64_ARRAY(0x94, "[LNuint64", new BigInteger[0]),
-    NBOOLEAN_ARRAY(0x95, "[LBoolean", new Boolean[0]),
-    NBYTE_ARRAY(0x96, "[LByte", new Byte[0]),
-    NFLOAT_ARRAY(0x97, "[LFloat", new Float[0]),
-    NDOUBLE_ARRAY(0x98, "[LDouble", new Double[0]);
+    NINT64_ARRAY(0x93, "[LNint64", new Long[0], "nullable_int64_array"),
+    NUINT64_ARRAY(0x94, "[LNuint64", new BigInteger[0], "nullable_uint64_array"),
+    NBOOLEAN_ARRAY(0x95, "[LBoolean", new Boolean[0], "nullable_boolean_array"),
+    NBYTE_ARRAY(0x96, "[LByte", new Byte[0], "nullable_byte_array"),
+    NFLOAT_ARRAY(0x97, "[LFloat", new Float[0], "nullable_float_array"),
+    NDOUBLE_ARRAY(0x98, "[LDouble", new Double[0], "nullable_double_array");
 
     public final byte                           token;
     public final String                         name;
+    public final String                         typeDesc;
     private Integer                             constantSize;
     private final boolean                       array, nullableArray;
     private FieldType                           componentType, arrayType, nullableArrayType;
     private final Object                        defaultValue;
     private static final FieldType[]            TYPES_BY_TOKEN = new FieldType[256];
     private static final Map<String, FieldType> TYPES_BY_NAME;
+    private static final Map<String, FieldType> TYPES_BY_DESC;
 
     private FieldType(int token, String name) {
-        this(token, name, null);
+        this(token, name, null, null);
     }
 
-    private FieldType(int token, String name, Object defaultValue) {
+    private FieldType(int token, String name, Object defaultValue, String typeDesc) {
         this.token = (byte) token;
         this.name = name;
         this.array = name.startsWith("[L");
         this.nullableArray = this.array && name().startsWith("N");
         this.defaultValue = defaultValue;
+        this.typeDesc = typeDesc;
     }
 
     static {
         TYPES_BY_NAME        = new HashMap<String, FieldType>();
+        TYPES_BY_DESC        = new HashMap<String, FieldType>();
         for (FieldType type : values()) {
             TYPES_BY_TOKEN[type.token & 0xff] = type;
             TYPES_BY_NAME.put(type.name, type);
+            TYPES_BY_DESC.put(type.typeDesc, type);
             
             if (type.isArray()) {
                 // This will fail if our naming becomes inconsistent or a type starts with N.
@@ -128,6 +133,14 @@ public static FieldType byName(String name) {
         return type;
     }
 
+    public static FieldType byTypeDesc(String typeDesc) {
+        final FieldType type = TYPES_BY_DESC.get(typeDesc);
+        if (type == null) {
+            throw new IllegalArgumentException("Bad type description: " + typeDesc);
+        }
+        return type;
+    }
+    
     @Override
     public String toString() {
         return name;
diff --git a/src/main/java/org/lwes/MapEvent.java b/src/main/java/org/lwes/MapEvent.java
index 0db5336..4500d04 100644
--- a/src/main/java/org/lwes/MapEvent.java
+++ b/src/main/java/org/lwes/MapEvent.java
@@ -13,6 +13,8 @@
 import java.io.DataOutput;
 import java.io.IOException;
 import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Map.Entry;
 import java.util.SortedSet;
 import java.util.TreeSet;
@@ -23,6 +25,7 @@
 import org.lwes.db.EventTemplateDB;
 import org.lwes.serializer.Deserializer;
 import org.lwes.serializer.DeserializerState;
+import org.lwes.serializer.JsonSerializer;
 import org.lwes.serializer.Serializer;
 
 public class MapEvent extends DefaultEvent {
@@ -606,4 +609,16 @@ public FieldType getType(String field) {
     public int getBytesSize() {
         return bytesStoreSize;
     }
+
+    public String json() {
+        return JsonSerializer.getInstance().json(name, attributes);
+    }
+    
+    public String unTypedJson() {
+        return JsonSerializer.getInstance().unTypedJson(name, attributes);
+    }
+    
+    public Map<String,BaseType> getAttributeNameTypeValues(){
+        return attributes;
+    }
 }
diff --git a/src/main/java/org/lwes/TypeValue.java b/src/main/java/org/lwes/TypeValue.java
new file mode 100644
index 0000000..5fc0ac8
--- /dev/null
+++ b/src/main/java/org/lwes/TypeValue.java
@@ -0,0 +1,19 @@
+package org.lwes;
+
+public class TypeValue {
+
+    private String type;
+    private Object value;
+    public String getType() {
+        return type;
+    }
+    public Object getValue() {
+        return value;
+    }
+    public TypeValue(String type, Object value) {
+        super();
+        this.type = type;
+        this.value = value;
+    }
+    
+}
diff --git a/src/main/java/org/lwes/serializer/JsonDeserializer.java b/src/main/java/org/lwes/serializer/JsonDeserializer.java
new file mode 100644
index 0000000..283dc20
--- /dev/null
+++ b/src/main/java/org/lwes/serializer/JsonDeserializer.java
@@ -0,0 +1,187 @@
+package org.lwes.serializer;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.apache.commons.lang3.StringUtils;
+import org.lwes.Event;
+import org.lwes.FieldType;
+import org.lwes.TypeValue;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonNull;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+
+public class JsonDeserializer {
+
+private static JsonDeserializer instance;
+    
+    private JsonParser parser;
+    
+    public static JsonDeserializer getInstance(){
+        if(instance == null){
+            synchronized (JsonSerializer.class) {
+                //Double-checked locking
+                if(instance == null)
+                    instance = new JsonDeserializer();
+            }
+        }
+        return instance;
+    }
+    
+    private JsonDeserializer(){
+        parser = new JsonParser();
+    }
+    
+    public Event fromJson(String json, Event e) throws UnsupportedOperationException{
+        try{
+            Map<String, TypeValue> typedElems;
+            JsonObject root = parser.parse(json).getAsJsonObject();
+            String name = root.getAsJsonPrimitive("name").getAsString();
+            e.setEventName(name);
+            if(StringUtils.isEmpty(name))
+                return null;
+            JsonObject typedContainer = root.getAsJsonObject("typed");
+            JsonObject attributeContainer = root.getAsJsonObject("attributes");
+            if(attributeContainer == null && typedContainer == null)
+                return null;
+            else if(typedContainer != null){
+               typedElems = parseTyped(typedContainer);
+               for(Entry<String, TypeValue> element : typedElems.entrySet()){
+                   TypeValue tv = element.getValue();
+                   FieldType ft = FieldType.byTypeDesc(tv.getType());
+                   if (ft==null)
+                       continue;
+                   
+                   if(tv.getValue() instanceof String)
+                       e.set(element.getKey(),
+                               ft,getObjectForType(ft, (String)tv.getValue(), null));
+                   else if (tv.getValue() instanceof String[])
+                       e.set(element.getKey(), ft, getObjectForType(ft, null, (String[])tv.getValue()));
+               }
+            }else
+                throw new UnsupportedOperationException("Cannot construct the event without the type information for attributes.");
+            
+        }catch(Exception ex){
+            if (ex instanceof UnsupportedOperationException)
+                throw (UnsupportedOperationException)ex;
+            else   
+                return null;
+        }
+        return e;
+    }
+    
+    Map<String, TypeValue> parseTyped(JsonObject typedContainer){
+        Set<Entry<String, JsonElement>> typedElements = typedContainer.entrySet();
+        Map<String, TypeValue> typedValues = new HashMap<String, TypeValue>();
+        for(Entry<String, JsonElement> element : typedElements){
+            String key = element.getKey();
+            if(key==null || element.getValue()==null)
+                continue;
+            JsonObject tv = (JsonObject)element.getValue();
+            String type = tv.get("type").getAsString();
+            JsonElement jsonValue = tv.get("value");
+            
+            if(jsonValue instanceof JsonArray){
+                typedValues.put(element.getKey(), new TypeValue(type, parseJSONArray((JsonArray)jsonValue)));
+            }else{
+                typedValues.put(element.getKey(), new TypeValue(type, jsonValue.getAsString()));
+            }
+        }
+        return typedValues;
+    }
+    
+    private String[] parseJSONArray(JsonArray json){
+        String[] strArr = new String[json.size()];
+        for(int i=0;i<json.size();i++)
+            if(json.get(i) instanceof JsonNull)
+                strArr[i] = null;
+            else
+                strArr[i] = json.get(i).getAsString();
+        
+        return strArr;
+    }
+    
+    private Object getObjectForType(FieldType ft, String str, String[] strArr) {
+        
+        switch (ft) {
+            case BOOLEAN:
+                return StringParser.fromStringBOOLEAN(str);
+            case BYTE:
+                return StringParser.fromStringBYTE(str);
+            case DOUBLE:
+                return StringParser.fromStringDOUBLE(str);
+            case FLOAT:
+                return StringParser.fromStringFLOAT(str);
+            case INT16:
+                return StringParser.fromStringINT16(str);
+            case INT32:
+                return StringParser.fromStringINT32(str);
+            case INT64:
+                return StringParser.fromStringINT64(str);
+            case IPADDR:
+                return StringParser.fromStringIPADDR(str);
+            case STRING:
+                return StringParser.fromStringSTRING(str);
+            case UINT16:
+                return StringParser.fromStringUINT16(str);
+            case UINT32:
+                return StringParser.fromStringUINT32(str);
+            case UINT64:
+                return StringParser.fromStringUINT64(str);
+            case BOOLEAN_ARRAY:
+                return StringParser.fromStringBOOLEANArray(strArr);
+            case BYTE_ARRAY:
+                return StringParser.fromStringBYTEArray(strArr);
+            case DOUBLE_ARRAY:
+                return StringParser.fromStringDOUBLEArray(strArr);
+            case FLOAT_ARRAY:
+                return StringParser.fromStringFLOATArray(strArr);
+            case INT16_ARRAY:
+                return StringParser.fromStringINT16Array(strArr);
+            case INT32_ARRAY:
+                return StringParser.fromStringINT32Array(strArr);
+            case INT64_ARRAY:
+                return StringParser.fromStringINT64Array(strArr);
+            case IP_ADDR_ARRAY:
+                return StringParser.fromStringIPADDRArray(strArr);
+            case STRING_ARRAY:
+                return StringParser.fromStringSTRINGArray(strArr);
+            case UINT16_ARRAY:
+                return StringParser.fromStringUINT16Array(strArr);
+            case UINT32_ARRAY:
+                return StringParser.fromStringUINT32Array(strArr);
+            case UINT64_ARRAY:
+                return StringParser.fromStringUINT64Array(strArr);
+            case NBOOLEAN_ARRAY:
+                return StringParser.fromStringBOOLEANNArray(strArr);
+            case NBYTE_ARRAY:
+                return StringParser.fromStringBYTENArray(strArr);
+            case NDOUBLE_ARRAY:
+                return StringParser.fromStringDOUBLENArray(strArr);
+            case NFLOAT_ARRAY:
+                return StringParser.fromStringFLOATNArray(strArr);
+            case NINT16_ARRAY:
+                return StringParser.fromStringINT16NArray(strArr);
+            case NINT32_ARRAY:
+                return StringParser.fromStringINT32NArray(strArr);
+            case NINT64_ARRAY:
+                return StringParser.fromStringINT64NArray(strArr);
+            case NSTRING_ARRAY:
+                return StringParser.fromStringSTRINGNArray(strArr);
+            case NUINT16_ARRAY:
+                return StringParser.fromStringUINT16NArray(strArr);
+            case NUINT32_ARRAY:
+                return StringParser.fromStringUINT32NArray(strArr);
+            case NUINT64_ARRAY:
+                return StringParser.fromStringUINT64NArray(strArr);
+            default:
+                return str;
+        }
+    }
+    
+}
diff --git a/src/main/java/org/lwes/serializer/JsonSerializer.java b/src/main/java/org/lwes/serializer/JsonSerializer.java
new file mode 100644
index 0000000..7460407
--- /dev/null
+++ b/src/main/java/org/lwes/serializer/JsonSerializer.java
@@ -0,0 +1,79 @@
+package org.lwes.serializer;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.lwes.BaseType;
+import org.lwes.TypeValue;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+public class JsonSerializer {
+
+    private static final int JSON_SERIALIZER_VERSION = 1;
+    
+    private static JsonSerializer instance;
+    
+    private Gson gson;
+    
+    public static JsonSerializer getInstance(){
+        if(instance == null){
+            synchronized (JsonSerializer.class) {
+                //Double-checked locking
+                if(instance == null)
+                    instance = new JsonSerializer();
+            }
+        }
+        return instance;
+    }
+    
+    private JsonSerializer(){
+        gson = new GsonBuilder().disableHtmlEscaping().create();
+    }
+    
+    public String json(String eventName, Map<String,BaseType> attrs){
+        return gson.toJson(typedContainer(eventName, attrs));
+    }
+    
+    public String unTypedJson(String eventName, Map<String, BaseType> attrs){
+        return gson.toJson(unTypedContainer(eventName, attrs));
+    }
+    
+    private Map<String, Object> basicContainer(String eventName){
+        Map<String, Object> container = new HashMap<String, Object>();
+        container.put("name", eventName);
+        container.put("version", JSON_SERIALIZER_VERSION);
+        return container;
+    }
+    
+    private Map<String, Object> unTypedContainer(String eventName, Map<String, BaseType> attrs){
+        Map<String, Object> container = basicContainer(eventName);
+        container.put("attributes", getUnTypedAttributes(eventName, attrs));
+        return container;
+    }
+    
+    private Map<String, Object> typedContainer(String eventName, Map<String, BaseType> attrs){
+        Map<String, Object> container = basicContainer(eventName);
+        container.put("typed", getTypedAttributes(attrs));
+        return container;
+    }
+
+    public Object getTypedAttributes(Map<String, BaseType> attrs) {
+        Map<String,Object> typedAttrs = new HashMap<String, Object>();
+        for(Entry<String, BaseType> attr : attrs.entrySet())
+            typedAttrs.put(attr.getKey(), new TypeValue(attr.getValue().getType().typeDesc, attr.getValue().stringyfy()));
+        
+        return typedAttrs;
+    }
+    
+    public Object getUnTypedAttributes(String eventName, Map<String, BaseType> attributes) {
+        Map<String, Object> unTypedAttributes = new HashMap<String, Object>();
+        unTypedAttributes.put("EventName", eventName);
+        for(Entry<String, BaseType> attr : attributes.entrySet())
+            unTypedAttributes.put(attr.getKey(),attr.getValue().getTypeObject());
+        
+        return unTypedAttributes;
+    }
+}
diff --git a/src/main/java/org/lwes/serializer/StringConverter.java b/src/main/java/org/lwes/serializer/StringConverter.java
new file mode 100644
index 0000000..baa7520
--- /dev/null
+++ b/src/main/java/org/lwes/serializer/StringConverter.java
@@ -0,0 +1,69 @@
+package org.lwes.serializer;
+
+public class StringConverter {
+
+    public static <T> String[] strArray(T[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = arr[i]==null ? null : arr[i].toString();
+        
+        return sArr;
+    }
+    
+    public static String[] strArray(boolean[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = String.valueOf(arr[i]);
+        
+        return sArr;
+    }
+    
+    public static String[] strArray(byte[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = String.valueOf(arr[i]);
+        
+        return sArr;
+    }
+    
+    public static String[] strArray(short[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = String.valueOf(arr[i]);
+        
+        return sArr;
+    }
+    
+    public static String[] strArray(int[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = String.valueOf(arr[i]);
+        
+        return sArr;
+    }
+    
+    public static String[] strArray(long[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = String.valueOf(arr[i]);
+        
+        return sArr;
+    }
+    
+    public static String[] strArray(float[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = String.valueOf(arr[i]);
+        
+        return sArr;
+    }
+    
+    public static String[] strArray(double[] arr){
+        String[] sArr = new String[arr.length];
+        for(int i=0; i<arr.length; i++)
+            sArr[i] = String.valueOf(arr[i]);
+
+        return sArr;
+    }
+    
+}
diff --git a/src/main/java/org/lwes/serializer/StringParser.java b/src/main/java/org/lwes/serializer/StringParser.java
index 80dfac6..8ac44e8 100644
--- a/src/main/java/org/lwes/serializer/StringParser.java
+++ b/src/main/java/org/lwes/serializer/StringParser.java
@@ -12,6 +12,7 @@
 
 package org.lwes.serializer;
 
+import java.math.BigInteger;
 import java.util.regex.Pattern;
 
 import org.apache.commons.logging.Log;
@@ -191,7 +192,6 @@ public static Object fromStringINT32(String string)
         return toReturn;
     }
 
-    // FIXME: why not BigInteger?
     public static Object fromStringUINT64(String string)
             throws EventSystemException {
         Object toReturn = null;
@@ -203,11 +203,11 @@ public static Object fromStringUINT64(String string)
             }
 
             byte[] bytes = NumberCodec.hexStringToByteArray(string);
-            toReturn = NumberCodec.decodeLong(bytes, 0, bytes.length);
+            toReturn = BigInteger.valueOf(NumberCodec.decodeLong(bytes, 0, bytes.length));
         }
         else {
             try {
-                toReturn = Long.valueOf(string);
+                toReturn = new BigInteger(string);
             }
             catch (NumberFormatException nfe) {
                 throw new EventSystemException("Got Exception " + nfe);
@@ -269,4 +269,188 @@ public static Object fromStringIPADDR(String string)
 
         return toReturn;
     }
+    
+    public static byte[] fromStringBYTEArray(String[] arr){
+        byte[] bArr = new byte[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = fromStringBYTE(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Byte[] fromStringBYTENArray(String[] arr){
+        Byte[] bArr = new Byte[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:fromStringBYTE(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static boolean[] fromStringBOOLEANArray(String[] arr){
+        boolean[] bArr = new boolean[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (Boolean)fromStringBOOLEAN(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Boolean[] fromStringBOOLEANNArray(String[] arr){
+        Boolean[] bArr = new Boolean[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:(Boolean)fromStringBOOLEAN(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static short[] fromStringINT16Array(String[] arr){
+        short[] bArr = new short[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (Short)fromStringINT16(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static int[] fromStringUINT16Array(String[] arr){
+        int[] bArr = new int[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (Integer)fromStringUINT16(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Short[] fromStringINT16NArray(String[] arr){
+        Short[] bArr = new Short[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:(Short)fromStringINT16(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Integer[] fromStringUINT16NArray(String[] arr){
+        Integer[] bArr = new Integer[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:(Integer)fromStringUINT16(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static int[] fromStringINT32Array(String[] arr){
+        int[] bArr = new int[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (Integer)fromStringINT32(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static long[] fromStringUINT32Array(String[] arr){
+        long[] bArr = new long[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (Long)fromStringUINT32(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Integer[] fromStringINT32NArray(String[] arr){
+        Integer[] bArr = new Integer[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:(Integer)fromStringINT32(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Long[] fromStringUINT32NArray(String[] arr){
+        Long[] bArr = new Long[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:(Long)fromStringUINT32(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static long[] fromStringINT64Array(String[] arr){
+        long[] bArr = new long[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (Long)fromStringINT64(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static BigInteger[] fromStringUINT64Array(String[] arr){
+        BigInteger[] bArr = new BigInteger[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (BigInteger)fromStringUINT64(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Long[] fromStringINT64NArray(String[] arr){
+        Long[] bArr = new Long[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:(Long)fromStringINT64(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static BigInteger[] fromStringUINT64NArray(String[] arr){
+        BigInteger[] bArr = new BigInteger[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null?null:(BigInteger)fromStringUINT64(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static float[] fromStringFLOATArray(String[] arr){
+        float[] bArr = new float[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (float)fromStringFLOAT(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static Float[] fromStringFLOATNArray(String[] arr){
+        Float[] bArr = new Float[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null? null:(Float)fromStringFLOAT(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static double[] fromStringDOUBLEArray(String[] arr){
+        double[] bArr = new double[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (Double)fromStringDOUBLE(arr[i]);
+        
+        return bArr;
+    }
+
+    public static Double[] fromStringDOUBLENArray(String[] arr){
+        Double[] bArr = new Double[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null? null:(Double)fromStringDOUBLE(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static String[] fromStringSTRINGArray(String[] arr){
+        String[] bArr = new String[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (String)fromStringSTRING(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static String[] fromStringSTRINGNArray(String[] arr){
+        String[] bArr = new String[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = arr[i]==null? null:(String)fromStringSTRING(arr[i]);
+        
+        return bArr;
+    }
+    
+    public static IPAddress[] fromStringIPADDRArray(String[] arr){
+        IPAddress[] bArr = new IPAddress[arr.length];
+        for(int i=0;i<arr.length;i++)
+            bArr[i] = (IPAddress)fromStringIPADDR(arr[i]);
+        
+        return bArr;
+    }
 }
diff --git a/src/main/java/org/lwes/util/EventTranslator.java b/src/main/java/org/lwes/util/EventTranslator.java
new file mode 100644
index 0000000..46f2a79
--- /dev/null
+++ b/src/main/java/org/lwes/util/EventTranslator.java
@@ -0,0 +1,15 @@
+package org.lwes.util;
+
+import org.lwes.ArrayEvent;
+import org.lwes.MapEvent;
+
+public class EventTranslator {
+
+    public static MapEvent arrayToMapEvent(ArrayEvent ae){
+        MapEvent me = new MapEvent();
+        byte[] serialized = ae.serialize();
+        me.deserialize(serialized);
+        return me;
+    }
+    
+}
diff --git a/src/test/java/org/lwes/BaseTypeTest.java b/src/test/java/org/lwes/BaseTypeTest.java
index 2494659..99303d0 100644
--- a/src/test/java/org/lwes/BaseTypeTest.java
+++ b/src/test/java/org/lwes/BaseTypeTest.java
@@ -9,6 +9,8 @@
  *======================================================================*/
 package org.lwes;
 
+import java.math.BigInteger;
+
 import org.junit.Test;
 import org.lwes.util.IPAddress;
 
@@ -29,7 +31,7 @@ public void parsing() {
       assertEquals(Long.valueOf(100), new BaseType(FieldType.INT64).parseFromString("100"));
       assertEquals(Integer.valueOf(100), new BaseType(FieldType.UINT16).parseFromString("100"));
       assertEquals(Long.valueOf(100), new BaseType(FieldType.UINT32).parseFromString("100"));
-      assertEquals(Long.valueOf(100), new BaseType(FieldType.UINT64).parseFromString("100"));  // FIXME: why not BigInteger?
+      assertEquals(BigInteger.valueOf(100), new BaseType(FieldType.UINT64).parseFromString("100"));
       assertEquals("100", new BaseType(FieldType.STRING).parseFromString("100"));
       assertEquals(new IPAddress(new byte[] { 1, 2, 3, 4 }), new BaseType(FieldType.IPADDR).parseFromString("1.2.3.4"));
       assertEquals(Boolean.TRUE, new BaseType(FieldType.BOOLEAN).parseFromString("true"));
diff --git a/src/test/java/org/lwes/serializer/JsonSerializerDeSerializerTest.java b/src/test/java/org/lwes/serializer/JsonSerializerDeSerializerTest.java
new file mode 100644
index 0000000..f0ef711
--- /dev/null
+++ b/src/test/java/org/lwes/serializer/JsonSerializerDeSerializerTest.java
@@ -0,0 +1,100 @@
+package org.lwes.serializer;
+
+import java.math.BigInteger;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.lwes.ArrayEvent;
+import org.lwes.Event;
+import org.lwes.EventFactory;
+import org.lwes.EventImplementation;
+import org.lwes.FieldType;
+import org.lwes.MapEvent;
+import org.lwes.util.IPAddress;
+
+public class JsonSerializerDeSerializerTest {
+
+    JsonDeserializer jDeserializer;
+    EventFactory factory;
+    
+    @Before
+    public void setup(){
+        factory = new EventFactory();
+        jDeserializer = JsonDeserializer.getInstance();
+    }
+    
+    @Test
+    public void testSimpleSerializeDeserializeMapEvent(){
+        Event evt = new MapEvent("json-event");
+        setEventProperties(evt);
+        Event rebornEvt = factory.createEventFromJson(evt.json(), EventImplementation.MAP_EVENT);
+        Assert.assertEquals(evt, rebornEvt);
+    }
+   
+    @Test
+    public void testSimpleSerializeDeserializeArrayEvent(){
+        Event evt = new ArrayEvent("json-event");
+        setEventProperties(evt);
+        Event rebornEvt = factory.createEventFromJson(evt.json(), EventImplementation.ARRAY_EVENT);
+        Assert.assertEquals(evt, rebornEvt);
+    }
+    
+    @Test
+    public void testTypedSerialize(){
+        Event evt = new ArrayEvent("json-event");
+        setEventProperties(evt);
+        System.out.println(evt.json());
+    }
+    
+    @Test
+    public void testUntypedSerialize(){
+        Event evt = new MapEvent("json-event");
+        setEventProperties(evt);
+        System.out.println(evt.unTypedJson());
+    }
+    
+    public void setEventProperties(Event evt){
+        
+        evt.set("key", FieldType.STRING, "value");
+        evt.set("boolean", FieldType.BOOLEAN, true);
+        evt.set("byte", FieldType.BYTE, Byte.parseByte("32"));
+        evt.set("double", FieldType.DOUBLE, 5.0);
+        evt.set("float", FieldType.FLOAT, 1.2f);
+        evt.set("int16", FieldType.INT16, (short) 10);
+        evt.set("uint16", FieldType.UINT16, 10);
+        evt.set("int32", FieldType.INT32, 10);
+        evt.set("uint32", FieldType.UINT32, 10l);
+        evt.set("int64", FieldType.INT64, 10l);
+        evt.set("uint64", FieldType.UINT64, new BigInteger("184467440737095516145"));
+        evt.set("ipaddr", FieldType.IPADDR, new IPAddress("127.0.0.1"));
+        
+        evt.set("int16[]", FieldType.INT16_ARRAY, new short[] {(short) 10});
+        evt.set("uint16[]", FieldType.UINT16_ARRAY, new int[] {10});
+        evt.set("int32[]", FieldType.INT32_ARRAY, new int[] {10});
+        evt.set("uint32[]", FieldType.UINT32_ARRAY, new long[] {10l});
+        evt.set("int64[]", FieldType.INT64_ARRAY, new long[] {10l});
+        evt.set("uint64[]", FieldType.UINT64_ARRAY, new BigInteger[] {new BigInteger("184467440737095516145")});
+        evt.set("boolean[]", FieldType.BOOLEAN_ARRAY, new boolean[] {true});
+        evt.set("byte[]", FieldType.BYTE_ARRAY, new byte[] {Byte.parseByte("32")});
+        evt.set("double[]", FieldType.DOUBLE_ARRAY, new double[] {5.0});
+        evt.set("float[]", FieldType.FLOAT_ARRAY, new float[] {1.2f});
+        evt.set("string[]", FieldType.STRING_ARRAY, new String[] {"value with \" '"});
+        evt.set("ipaddr[]", FieldType.IP_ADDR_ARRAY, new IPAddress[]{new IPAddress("10.0.13.217")});
+
+        evt.set("nint16[]", FieldType.NINT16_ARRAY, new Short[] {null, null, (short) 10});
+        evt.set("nuint16[]", FieldType.NUINT16_ARRAY, new Integer[] {null, 10});
+        evt.set("nint32[]", FieldType.NINT32_ARRAY, new Integer[] {10, null, 20});
+        evt.set("nuint32[]", FieldType.NUINT32_ARRAY, new Long[] {10l, 502l, null});
+        evt.set("nint64[]", FieldType.NINT64_ARRAY, new Long[] {null, 10l,null});
+        evt.set("nuint64[]", FieldType.NUINT64_ARRAY, new BigInteger[] {null,new BigInteger("2342322"),  new BigInteger("184467440737095516145")});
+        evt.set("nboolean[]", FieldType.NBOOLEAN_ARRAY, new Boolean[] {true,null,false,true});
+        evt.set("nbyte[]", FieldType.NBYTE_ARRAY, new Byte[] {null, Byte.parseByte("32")});
+        evt.set("nlong[]", FieldType.NINT64_ARRAY, new Long[] { 5000000000l, null, 8675309l });
+        evt.set("nshort[]", FieldType.NUINT16_ARRAY, new Integer[] { 5, null, 10 });
+        evt.set("ndouble[]", FieldType.NDOUBLE_ARRAY, new Double[] { 1.23, null, 1.26 });
+        evt.set("nfloat[]", FieldType.NFLOAT_ARRAY, new Float[] { 1.11f, 1.12f, null });
+        
+    }
+    
+}
diff --git a/src/test/java/org/lwes/serializer/StringParserTest.java b/src/test/java/org/lwes/serializer/StringParserTest.java
index a3de054..ddf3c03 100644
--- a/src/test/java/org/lwes/serializer/StringParserTest.java
+++ b/src/test/java/org/lwes/serializer/StringParserTest.java
@@ -17,6 +17,8 @@
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
+import java.math.BigInteger;
+
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.junit.Test;
@@ -148,13 +150,13 @@ public void testFromStringUINT32() {
     @Test
     public void testFromStringUINT64() {
         try {
-            Long val = Long.MAX_VALUE;
-            Long v = (Long) StringParser.fromStringUINT64(val.toString());
+            BigInteger val = BigInteger.valueOf(Long.MAX_VALUE);
+            BigInteger v = (BigInteger) StringParser.fromStringUINT64(val.toString());
             assertNotNull(v);
             assertEquals("fromStringINT64 failed", Long.MAX_VALUE, v.longValue());
 
             // now try it as a hex string...
-            v = (Long) StringParser.fromStringUINT64("0x7fffffffffffffff");
+            v = (BigInteger) StringParser.fromStringUINT64("0x7fffffffffffffff");
             assertNotNull(v);
             assertEquals("fromStringINT64 failed", Long.MAX_VALUE, v.longValue());
         }