JSON support

public class Json {
        
        /** Parse or decode a JSON encoded data from a String ... into a Java object*/
        public static Object decode(String str) throws IOException { ... }
        public static Object decode(InputStream is) throws IOException { ... }
        public static Object decode(Reader reader) throws IOException { ... }
        public static Object decode(URL url) throws IOException { ... }
        
        /** Decoding JSON objects into Maps where the order of the elements are to be preserved */
        public static Object decode(String str, boolean ordered) throws IOException { ... }
        public static Object decode(InputStream is, boolean ordered) throws IOException { ... }
        public static Object decode(Reader reader, boolean ordered) throws IOException { ... }
        public static Object decode(URL url, boolean ordered) throws IOException { ... }      
        
        /** Decoding JSON objects/arrays into custom Java Objects */
        public static Object decode(String str, JsonParserCallback cb) throws IOException { ... }
 	public static Object decode(InputStream is, JsonParserCallback cb) throws IOException { ... }
        public static Object decode(Reader reader, JsonParserCallback cb) throws IOException { ... }
        public static Object decode(URL url, JsonParserCallback cb) throws IOException { ... }
              
        /** Serialize or encode a Java object as JSON data */
        public static String encode(Object obj) throws IllegalArgumentException, ...{ ... } 
        public static void encode(Object obj, OutputStream os) throws IllegalArgumentException, { ... }
        public static void encode(Object obj, Writer writer) throws IllegalArgumentException { ... }
        
        /** Encode a Java object with formatting */
        public static String encode(Object obj, boolean formatted) throws IllegalArgumentException, { ... }
        public static void encode(Object obj, OutputStream os, boolean formatted) throws IllegalArgumentException, { ... }
        public static void encode(Object obj, Writer writer, boolean formatted) throws IllegalArgumentException, { ... }
        
        /** Convert a decoded object into a custom Java object */
        public static <T> T toObject(Object jsonObj, Class<T> type) { ... }
        
}

<?php

// The raw post body is available in the variable $HTTP_RAW_POST_DATA
$employee = json_decode($HTTP_RAW_POST_DATA);

$sql = "SELECT * FROM employees WHERE employeeid = ".$employee['id'];

?>

<?php
$input = fopen("php://input", 'r);

$employee = json_decode(fread($input, 999));

$sql = "SELECT * FROM employees WHERE employeeid = ".$employee['id'];

?>

<?php
	$indexedArray = array(
		"a", "b", "c"
		);
	$result = json_encode($indexedArray);
	echo "Indexed array = " . $result . "<br/>";
	$keyedArray = array(
		1 => "a", 
		2 => "b", 
		3 => "c"
	);
	$result = json_encode($keyedArray);
	echo "Keyed array = " . $result . "<br/>";
?>

Indexed array = [ "a", "b", "c" ]
Keyed array = { "1": "a", "2": "b", "3": "c" }

public class A {
        public B b;
}

public class B {
        public Foo[] foos;
}

public class Foo {
        public Bar bar;
}

public class Bar {
        public Foo y;
}

...
A a = new A();
a.b = new B();
a.b.foos = new Foo[1];

Foo foo = new Foo();
Bar x = new Bar();

foo.bar = x;
x.y = foo;

a.b.foos[0] = foo;

String result = Json.encode(a);
// result = {"b" : {"foos" : [{"bar" : {"y" : "$jref:this.b.foos[0]"}}]}

zput("/request/view", "JSON");
zput("/request/json/output", obj);
zero.core.views.ViewEngine.render();

request.view="JSON"
request.json.output=obj
render()

<?php
	$customer = array('name' => 'John Smith');
	zput('/request/view', 'JSON');
	zput('/request/json/output', $customer);
	render_view();
?>

{"name":"John Smith"}

{"name":"Bob"}

{
   "name": "Bob"
}

public interface Converter extends Encoder {
        /**
        * Convert JSON representation to a Java object.
        */
        public Object toObject(Object json);
        
}

public interface Encoder {
        /**
        * The implementer of this interface serializes a custom Java object as JSON using the serializer provided. 
        * The custom encoder is declared using the global context. This interface provides a object reference map 
        * as a parameter which can be used find and add references to Java objects that might already be serialized. 
        * It is a good practice to add a reference to the object being serialized prior to serializing it so that any circular
        * references to the object can be resolved. Any complex (array or object) attribute added to the serialized stream
        * should be updated in reference map with the object reference as a key and its JSON reference as its value.
        *
        * In general the JSON reference to complex attributes are computed as follows. Any array reference to a complex
        * attribute concatenates the index of the attribute enclosed by "[" and "]" to the JSON reference of the containing
        * object. For instance jref + "[" + index + "]". Any object reference to a complex attribute appends
        * the name of the attribute separated by a period to the containing jref. For instance 
        *  jref + "." + attributeName .
        * 
        * @param object The object that needs to be serialized.
        * @param refMap a reference Map of objects that have been serialized to their JSON references. 
        * This map should updated with the reference of the object being serialized and any of its elements.
        * @param jref the JSON reference for the containing object. 
        * @param serializer the serializer object that needs to be used to create the custom json encoding for the object.
        */
        public void write(Object obj, Map<Object, String> refMap, String jref,  Serializer serializer) throws IllegalArgumentException, IntrospectionException, IllegalAccessException, InvocationTargetException, IOException ;
        
}