deserialize.fmt

   1         func readBuf(r io.Reader, n int) []byte {
   2                 buf := make([]byte, n)
   3                 _, err := io.ReadFull(r, buf)
   4                 chk(err)
   5                 return buf
   6         }
   7
   8         func read8 (r io.Reader) uint8  { return readBuf(r, 1)[0] }
   9         func read16(r io.Reader) uint16 { return be.Uint16(readBuf(r, 2)) }
  10         func read32(r io.Reader) uint32 { return be.Uint32(readBuf(r, 4)) }
  11         func read64(r io.Reader) uint64 { return be.Uint64(readBuf(r, 8)) }
  12
  13 byte    *p = read8(r)
  14 uint8   *p = read8(r)
  15 uint16  *p = read16(r)
  16 uint32  *p = read32(r)
  17 uint64  *p = read64(r)
  18
  19 int8    *p = int8(read8(r))
  20 int16   *p = int16(read16(r))
  21 int32   *p = int32(read32(r))
  22 int64   *p = int64(read64(r))
  23
  24 bool    switch n := read8(r); n {
  25         case 0:
  26                 *p = false
  27         case 1:
  28                 *p = true
  29         default:
  30                 chk(fmt.Errorf("invalid bool: %d", n))
  31         }
  32
  33 float32 *p = math.Float32frombits(read32(r))
  34 float64 *p = math.Float64frombits(read64(r))
  35
  36 AOMsg   {
  37                 var err error
  38                 *p, err = readAOMsg(r)
  39                 chk(err)
  40         }
  41
  42 image/color.NRGBA       *p = color.NRGBA{A: read8(r), R: read8(r), G: read8(r), B: read8(r)}
  43
  44 map[uint16]*NodeMeta    {
  45                 r, err := zlib.NewReader(byteReader{r})
  46                 chk(err)
  47
  48                 switch ver := read8(r); ver {
  49                 case 0:
  50                         *p = nil
  51                 case 2:
  52                         n := read16(r)
  53                         *p = make(map[uint16]*NodeMeta, n)
  54                         for ; n > 0; n-- {
  55                                 pos := read16(r)
  56                                 nm := new(NodeMeta)
  57                                 chk(deserialize(r, nm))
  58                                 (*p)[pos] = nm
  59                         }
  60                 default:
  61                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
  62                 }
  63
  64                 chk(r.Close())
  65         }
  66
  67 map[[3]int16]*NodeMeta  {
  68                 r, err := zlib.NewReader(byteReader{r})
  69                 chk(err)
  70
  71                 switch ver := read8(r); ver {
  72                 case 0:
  73                         *p = nil
  74                 case 2:
  75                         n := read16(r)
  76                         *p = make(map[[3]int16]*NodeMeta, n)
  77                         for ; n > 0; n-- {
  78                                 var pos [3]int16
  79                                 for i := range pos {
  80                                         pos[i] = int16(read16(r))
  81                                 }
  82                                 nm := new(NodeMeta)
  83                                 chk(deserialize(r, nm))
  84                                 (*p)[pos] = nm
  85                         }
  86                 default:
  87                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
  88                 }
  89
  90                 chk(r.Close())
  91         }
  92
  93 PointedThing    {
  94                 var err error
  95                 *p, err = readPointedThing(r)
  96                 chk(err)
  97         }
  98
  99 []AOMsg { // For AOInitData.Msgs.
 100                 *p = make([]AOMsg, read8(r))
 101                 for i := range *p {
 102                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
 103                         msg, err := readAOMsg(r)
 104                         chk(err)
 105                         (*p)[i] = msg
 106                         if r.N > 0 {
 107                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
 108                         }
 109                 }
 110         }
 111
 112 []NodeDef       { // For ToCltNodeDefs.Defs.
 113                 *p = make([]NodeDef, read16(r))
 114                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
 115                 for i := range *p {
 116                         (*p)[i].deserialize(r)
 117                 }
 118                 if r.N > 0 {
 119                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 120                 }
 121         }