src/java/org/opensrf/util/JSONWriter.java

   1 package org.opensrf.util;
   2
   3 import java.io.*;
   4 import java.util.*;
   5
   6
   7 /**
   8  * JSONWriter
   9  */
  10 public class JSONWriter {
  11
  12     /** The object to serialize to JSON */
  13     private Object obj;
  14
  15     /**
  16      * @param obj The object to encode
  17      */
  18     public JSONWriter(Object obj) {
  19         this.obj = obj;
  20     }
  21
  22
  23     /**
  24      * @see write(Object, StringBuffer)
  25      */
  26     public String write() {
  27         StringBuffer sb = new StringBuffer();
  28         write(sb);
  29         return sb.toString();
  30     }
  31
  32
  33
  34     /**
  35      * Encodes a java object to JSON.
  36      * Maps (HashMaps, etc.) are encoded as JSON objects.
  37      * Iterable's (Lists, etc.) are encoded as JSON arrays
  38      */
  39     public void write(StringBuffer sb) {
  40         write(obj, sb);
  41     }
  42
  43     /**
  44      * Encodes the object as JSON into the provided buffer
  45      */
  46     public void write(Object obj, StringBuffer sb) {
  47
  48         /** JSON null */
  49         if(obj == null) {
  50             sb.append("null");
  51             return;
  52         }
  53
  54         /** JSON string */
  55         if(obj instanceof String) {
  56             sb.append('"');
  57             Utils.escape((String) obj, sb);
  58             sb.append('"');
  59             return;
  60         }
  61
  62         /** JSON number */
  63         if(obj instanceof Number) {
  64             sb.append(obj.toString());
  65             return;
  66         }
  67
  68         /** JSON array */
  69         if(obj instanceof Iterable) {
  70             encodeJSONArray((Iterable) obj, sb);
  71             return;
  72         }
  73
  74         /** OpenSRF serializable objects */
  75         if(obj instanceof OSRFSerializable) {
  76             encodeOSRFSerializable((OSRFSerializable) obj, sb);
  77             return;
  78         }
  79
  80         /** JSON object */
  81         if(obj instanceof Map) {
  82             encodeJSONObject((Map) obj, sb);
  83             return;
  84         }
  85
  86         /** JSON boolean */
  87         if(obj instanceof Boolean) {
  88             sb.append((((Boolean) obj).booleanValue() ? "true" : "false"));
  89             return;
  90         }
  91     }
  92
  93
  94     /**
  95      * Encodes a List as a JSON array
  96      */
  97     private void encodeJSONArray(Iterable iterable, StringBuffer sb) {
  98         Iterator itr = iterable.iterator();
  99         sb.append("[");
 100         boolean some = false;
 101
 102         while(itr.hasNext()) {
 103             some = true;
 104             write(itr.next(), sb);
 105             sb.append(',');
 106         }
 107
 108         /* remove the trailing comma if the array has any items*/
 109         if(some)
 110             sb.deleteCharAt(sb.length()-1);
 111         sb.append("]");
 112     }
 113
 114
 115     /**
 116      * Encodes a Map as a JSON object
 117      */
 118     private void encodeJSONObject(Map map, StringBuffer sb) {
 119         Iterator itr = map.keySet().iterator();
 120         sb.append("{");
 121         Object key = null;
 122
 123         while(itr.hasNext()) {
 124             key = itr.next();
 125             write(key, sb);
 126             sb.append(':');
 127             write(map.get(key), sb);
 128             sb.append(',');
 129         }
 130
 131         /* remove the trailing comma if the object has any items*/
 132         if(key != null)
 133             sb.deleteCharAt(sb.length()-1);
 134         sb.append("}");
 135     }
 136
 137
 138     /**
 139      * Encodes a network-serializable OpenSRF object
 140      */
 141     private void encodeOSRFSerializable(OSRFSerializable obj, StringBuffer sb) {
 142
 143         OSRFRegistry reg = obj.getRegistry();
 144         String[] fields = reg.getFields();
 145         Map<String, Object> map = new HashMap<String, Object>();
 146         map.put(JSONReader.JSON_CLASS_KEY, reg.getNetClass());
 147
 148         if( reg.getWireProtocol() == OSRFRegistry.WireProtocol.ARRAY ) {
 149
 150             /** encode arrays as lists */
 151             List<Object> list = new ArrayList<Object>(fields.length);
 152             for(String s : fields)
 153                 list.add(obj.get(s));
 154             map.put(JSONReader.JSON_PAYLOAD_KEY, list);
 155
 156         } else {
 157
 158             /** encode hashes as maps */
 159             Map<String, Object> subMap = new HashMap<String, Object>();
 160             for(String s : fields)
 161                 subMap.put(s, obj.get(s));
 162             map.put(JSONReader.JSON_PAYLOAD_KEY, subMap);
 163
 164         }
 165
 166         /** now serialize the encoded object */
 167         write(map, sb);
 168     }
 169 }
 170
 171
 172