| // Copyright 2009 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Represents JSON data structure using native Go types: booleans, floats, |
| // strings, arrays, and maps. |
| |
| package json |
| |
| import ( |
| "container/vector" |
| "os" |
| ) |
| |
| // Decode a JSON string |
| |
| // Decode parses the string s as a JSON-syntax string and returns the |
| // generic JSON object representation. The object representation is a tree |
| // of Go data types. The data return value may be one of float64, string, |
| // bool, nil, []interface{} or map[string]interface{}. The array and map |
| // elements may in turn contain any of the types listed above and so on. |
| // |
| // If Decode encounters a syntax error, it returns with err set to an |
| // instance of ParseError. See ParseError documentation for details. |
| func Decode(s string) (data interface{}, err os.Error) { |
| jb := newDecoder(nil, nil) |
| ok, errPos, errTok := Parse(s, jb) |
| if ok { |
| data = jb.Data() |
| } else { |
| err = &ParseError{Index: errPos, Token: errTok} |
| } |
| return |
| } |
| |
| type decoder struct { |
| // A value being constructed. |
| value interface{} |
| // Container entity to flush into. Can be either vector.Vector or |
| // map[string]interface{}. |
| container interface{} |
| // The index into the container interface. Either int or string. |
| index interface{} |
| } |
| |
| func newDecoder(container interface{}, key interface{}) *decoder { |
| return &decoder{container: container, index: key} |
| } |
| |
| func (j *decoder) Int64(i int64) { j.value = float64(i) } |
| |
| func (j *decoder) Uint64(i uint64) { j.value = float64(i) } |
| |
| func (j *decoder) Float64(f float64) { j.value = float64(f) } |
| |
| func (j *decoder) String(s string) { j.value = s } |
| |
| func (j *decoder) Bool(b bool) { j.value = b } |
| |
| func (j *decoder) Null() { j.value = nil } |
| |
| func (j *decoder) Array() { j.value = new(vector.Vector) } |
| |
| func (j *decoder) Map() { j.value = make(map[string]interface{}) } |
| |
| func (j *decoder) Elem(i int) Builder { |
| v, ok := j.value.(*vector.Vector) |
| if !ok { |
| v = new(vector.Vector) |
| j.value = v |
| } |
| if v.Len() <= i { |
| v.Resize(i+1, (i+1)*2) |
| } |
| return newDecoder(v, i) |
| } |
| |
| func (j *decoder) Key(s string) Builder { |
| m, ok := j.value.(map[string]interface{}) |
| if !ok { |
| m = make(map[string]interface{}) |
| j.value = m |
| } |
| return newDecoder(m, s) |
| } |
| |
| func (j *decoder) Flush() { |
| switch c := j.container.(type) { |
| case *vector.Vector: |
| index := j.index.(int) |
| c.Set(index, j.Data()) |
| case map[string]interface{}: |
| index := j.index.(string) |
| c[index] = j.Data() |
| } |
| } |
| |
| // Get the value built by this builder. |
| func (j *decoder) Data() interface{} { |
| switch v := j.value.(type) { |
| case *vector.Vector: |
| return v.Data() |
| } |
| return j.value |
| } |