tango.text.json.Json

License:

BSD style: see license.txt

Version:

July 2008: Initial release

Authors:

Aaron, Kris
class Json(T) : private JsonParser!(T) #
Parse json text into a set of inter-related structures. Typical usage is as follows: 
1
2

auto json = new Json!(char);
json.parse (`{"t": true, "n":null, "array":["world", [4, 5]]}`);
Converting back to text format employs a delegate. This one emits document content to the console: 
1

json.print ((char[] s) {Stdout(s);});

Constructing json within your code leverages a handful of factories within a document instance. This example creates a document from an array of values: 

1
2
3
4
5

auto json = new Json!(char);

// [true, false, null, "text"]
with (json)
      value = array (true, false, null, "text");

Setting the document to contain a simple object instead: 

1
2
3

// {"a" : 10}
with (json)
      value = object (pair("a", value(10)));

Objects may be constructed with multiple attribute pairs like so: 

1
2
3

// {"a" : 10, "b", true}
with (json)
      value = object (pair("a", value(10)), pair("b", value(true)));

Substitute arrays, or other objects as values where appropriate: 

1
2
3

// {"a" : [10, true, {"b" : null}]}
with (json)
      value = object (pair("a", array(10, true, object(pair("b")))));

TODO:

document how to extract content
alias JsonValue* Value [public] #
use these types for external references
enum Type [public] #
enumerates the seven acceptable JSON value types
this() #
Construct a json instance, with a default value of null
Value parse(T[] json) [final] #
Parse the given text and return a resultant Value type. Also sets the document value.
void print(void delegate(T[]) append) [final] #
Emit a text representation of this document to the given delegate
Value value() [final] #
Returns the root value of this document
Value value(Value v) [final] #
Set the root value of this document
Value value(T[] v) [final] #
Create a text value
Value value(bool v) [final] #
Create a boolean value
Value value(double v) [final] #
Create a numeric value
Value array(...) [final] #
Create an array of values
Attribute pair(T[] name, Value value = null) #
Create an attribute/value pair, where value defaults to null
Value object(Attribute set[] set...) [final] #
Create a composite from zero or more pairs, and return as a value
Value createValue() [private] #
Internal factory to create values
Composite createObject() [private] #
Internal factory to create composites
Attribute createAttribute() [private] #
Internal factory to create attributes
void exception(char[] msg) [private] #
Throw a generic exception
Value parseValue() [private] #
Parse an instance of a value
Composite parseObject() [private] #
Parse an object declaration
Value[] parseArray() [private] #
Parse an array declaration
void print(Value root, void delegate(T[]) append) [private, static] #
Convert a tree to printable representation
struct NameValue #
Represents an attribute/value pair. Aliased as Attribute
Attribute set(T[] key, Value val) #
Set a name and a value for this attribute
Returns itself, for use with Composite.add()
struct JsonObject #
Represents a single json Object (a composite of named attribute/value pairs).
This is aliased as Composite
Composite reset() #
Composite append(Attribute a) #
Append an attribute/value pair
Composite add(Attribute[] set...) #
Add a set of attribute/value pairs
Value[T[]] hashmap() #
Construct and return a hashmap of Object attributes. This will be a fairly costly operation, so consider alternatives where appropriate
Value value(T[] name) #
Return a corresponding value for the given attribute name. Does a linear lookup across the attribute set
int opApply(int delegate(inout T[] key, ref Value val) dg) #
Iterate over our attribute names
struct JsonValue #
Represents a json value that is one of the seven types specified via the Json.Type enum
Type type [public] #
the type of this node
bool opEquals(Type t) #
return true if this node is of the given type
bool toBool() #
Return true if this value represent True
T[] toString(T[] dst = null) #
Return the string content. Returns null if this value is not a string.
Uses dst for escape conversion where possible.
void toString(void delegate(T[]) dg) #
Emit the string content to the given delegate, with escape conversion as required.
Does nothing if this is not a String value
Composite toObject() #
Return the content as a Composite/Object. Returns null if this value is not a Composite.
real toNumber() #
Return the content as a double. Returns nan where the value is not numeric.
Value[] toArray() #
Return the content as an array. Returns null where the value is not an array.
Value set(T[] str, bool escaped = false) #
Set this value to represent a string. If 'escaped' is set, the string is assumed to have pre-converted escaping of reserved characters (such as \t).
Value set(Composite obj) #
Set this value to represent an object.
Value set(real num) #
Set this value to represent a number.
Value set(bool b) #
Set this value to represent a boolean.
Value set(Value[] a) #
Set this value to represent an array of values.
Value set(Json host, TypeInfo[] info, va_list args) [private] #
Set a variety of values into an array type
alias reset set #
Set this value to represent null
Value print(void delegate(T[]) dg) #
Emit a text representation of this value to the provided delegate
Value set(Type type) [private] #
Set to a specified type
struct Allocator(T) #
Internal allocation mechansim
struct Array [private] #
Internal use for parsing array values
alias Allocator!(NameValue) Attrib [private] #
Internal document representation