func writeMap(w io.Writer, val *reflect.MapValue) (err os.Error) {
key := val.Type().(*reflect.MapType).Key()
if _, ok := key.(*reflect.StringType); !ok {
return &MarshalError{val.Type()}
}
keys := val.Keys()
if _, err = fmt.Fprint(w, "{"); err != nil {
return
}
for i := 0; i < len(keys); i++ {
if _, err = fmt.Fprintf(w, "%s:", Quote(keys[i].(*reflect.StringValue).Get())); err != nil {
return
}
if err = writeValue(w, val.Elem(keys[i])); err != nil {
return
}
if i < len(keys)-1 {
if _, err = fmt.Fprint(w, ","); err != nil {
return
}
}
}
_, err = fmt.Fprint(w, "}")
return
}
func writeMap(w io.Writer, val *reflect.MapValue) (err os.Error) {
key := val.Type().(*reflect.MapType).Key()
if _, ok := key.(*reflect.StringType); !ok {
return &MarshalError{val.Type()}
}
_, err = fmt.Fprint(w, "d")
if err != nil {
return
}
keys := val.Keys()
// Sort keys
svList := make(StringValueArray, len(keys))
for i, key := range keys {
svList[i].key = key.(*reflect.StringValue).Get()
svList[i].value = val.Elem(key)
}
err = writeSVList(w, svList)
if err != nil {
return
}
_, err = fmt.Fprint(w, "e")
if err != nil {
return
}
return
}
// encodeMap encodes a map as unsigned count followed by key:value pairs.
// Because map internals are not exposed, we must use reflection rather than
// addresses.
func (enc *Encoder) encodeMap(b *bytes.Buffer, mv *reflect.MapValue, keyOp, elemOp encOp, keyIndir, elemIndir int) {
state := enc.newEncoderState(b)
state.fieldnum = -1
state.sendZero = true
keys := mv.Keys()
state.encodeUint(uint64(len(keys)))
for _, key := range keys {
encodeReflectValue(state, key, keyOp, keyIndir)
encodeReflectValue(state, mv.Elem(key), elemOp, elemIndir)
}
enc.freeEncoderState(state)
}
func (e *encodeState) writeMap(v *reflect.MapValue) {
if v.IsNil() {
return
}
if _, ok := v.Type().(*reflect.MapType).Key().(*reflect.StringType); !ok {
e.abort(&EncodeTypeError{v.Type()})
}
offset := e.beginDoc()
for _, k := range v.Keys() {
e.encodeValue(k.(*reflect.StringValue).Get(), v.Elem(k))
}
e.WriteByte(0)
e.endDoc(offset)
}
func writeMap(w io.Writer, val *reflect.MapValue) os.Error {
writeByte(w, SMALL_TUPLE);
writeByte(w, 3);
writeAtom(w, "bert");
writeAtom(w, "dict");
keys := val.Keys();
writeByte(w, LIST);
binary.Write(w, binary.BigEndian, uint32(len(keys)));
for i := 0; i < len(keys); i++ {
w.Write([]byte {SMALL_TUPLE, 2});
writeValue(w, keys[i]);
writeValue(w, val.Elem(keys[i]));
}
writeByte(w, NIL);
return nil;
}
func writeMap(w io.Writer, val *reflect.MapValue) os.Error {
key := val.Type().(*reflect.MapType).Key()
if _, ok := key.(*reflect.StringType); !ok {
return &MarshalError{val.Type()}
}
keys := val.Keys()
fmt.Fprint(w, "{")
for i := 0; i < len(keys); i++ {
fmt.Fprintf(w, "%q:", keys[i].(*reflect.StringValue).Get())
if err := writeValue(w, val.Elem(keys[i])); err != nil {
return err
}
if i < len(keys)-1 {
fmt.Fprint(w, ",")
}
}
fmt.Fprint(w, "}")
return nil
}
func fuzzyEqualMap(a *reflect.MapValue, b *reflect.MapValue) bool {
key := a.Type().(*reflect.MapType).Key()
if _, ok := key.(*reflect.StringType); !ok {
return false
}
key = b.Type().(*reflect.MapType).Key()
if _, ok := key.(*reflect.StringType); !ok {
return false
}
aKeys, bKeys := a.Keys(), b.Keys()
if len(aKeys) != len(bKeys) {
return false
}
for _, k := range aKeys {
if !fuzzyEqualValue(a.Elem(k), b.Elem(k)) {
return false
}
}
return true
}
func PackMap(writer io.Writer, value *reflect.MapValue) (n int, err os.Error) {
keys := value.Keys()
if value.Len() < 16 {
n, err := writer.Write([]byte{0x80 | byte(len(keys))})
if err != nil {
return n, err
}
for _, k := range keys {
_n, err := PackValue(writer, k)
if err != nil {
return n, err
}
n += _n
_n, err = PackValue(writer, value.Elem(k))
if err != nil {
return n, err
}
n += _n
}
} else if value.Len() < 65536 {
n, err := writer.Write([]byte{0xde, byte(len(keys) >> 8), byte(len(keys))})
if err != nil {
return n, err
}
for _, k := range keys {
_n, err := PackValue(writer, k)
if err != nil {
return n, err
}
n += _n
_n, err = PackValue(writer, value.Elem(k))
if err != nil {
return n, err
}
n += _n
}
} else {
n, err := writer.Write([]byte{0xdf, byte(len(keys) >> 24), byte(len(keys) >> 16), byte(len(keys) >> 8), byte(len(keys))})
if err != nil {
return n, err
}
for _, k := range keys {
_n, err := PackValue(writer, k)
if err != nil {
return n, err
}
n += _n
_n, err = PackValue(writer, value.Elem(k))
if err != nil {
return n, err
}
n += _n
}
}
return n, nil
}