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                 switch ver := read8(r); ver {
  46                 case 0:
  47                         *p = nil
  48                 case 2:
  49                         n := read16(r)
  50                         *p = make(map[uint16]*NodeMeta, n)
  51                         for ; n > 0; n-- {
  52                                 pos := read16(r)
  53                                 nm := new(NodeMeta)
  54                                 chk(deserialize(r, nm))
  55                                 (*p)[pos] = nm
  56                         }
  57                 default:
  58                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
  59                 }
  60         }
  61
  62 map[[3]int16]*NodeMeta  {
  63                 r, err := zlib.NewReader(byteReader{r})
  64                 chk(err)
  65
  66                 switch ver := read8(r); ver {
  67                 case 0:
  68                         *p = nil
  69                 case 2:
  70                         n := read16(r)
  71                         *p = make(map[[3]int16]*NodeMeta, n)
  72                         for ; n > 0; n-- {
  73                                 var pos [3]int16
  74                                 for i := range pos {
  75                                         pos[i] = int16(read16(r))
  76                                 }
  77                                 nm := new(NodeMeta)
  78                                 chk(deserialize(r, nm))
  79                                 (*p)[pos] = nm
  80                         }
  81                 default:
  82                         chk(fmt.Errorf("unsupported nodemetas version: %d", ver))
  83                 }
  84
  85                 chk(r.Close())
  86         }
  87
  88 PointedThing    {
  89                 var err error
  90                 *p, err = readPointedThing(r)
  91                 chk(err)
  92         }
  93
  94 []AOMsg { // For AOInitData.Msgs.
  95                 *p = make([]AOMsg, read8(r))
  96                 for i := range *p {
  97                         r := &io.LimitedReader{R: r, N: int64(read32(r))}
  98                         msg, err := readAOMsg(r)
  99                         chk(err)
 100                         (*p)[i] = msg
 101                         if r.N > 0 {
 102                                 chk(fmt.Errorf("%d bytes of trailing data", r.N))
 103                         }
 104                 }
 105         }
 106
 107 []NodeDef       { // For ToCltNodeDefs.Defs.
 108                 *p = make([]NodeDef, read16(r))
 109                 r := &io.LimitedReader{R: r, N: int64(read32(r))}
 110                 for i := range *p {
 111                         (*p)[i].Deserialize(r)
 112                 }
 113                 if r.N > 0 {
 114                         chk(fmt.Errorf("%d bytes of trailing data", r.N))
 115                 }
 116         }