serialize.fmt

   1         func write8(w io.Writer, x uint8) {
   2                 _, err := w.Write([]byte{x})
   3                 chk(err)
   4         }
   5
   6         func write16(w io.Writer, x uint16) {
   7                 buf := make([]byte, 2)
   8                 be.PutUint16(buf, x)
   9                 _, err := w.Write(buf)
  10                 chk(err)
  11         }
  12
  13         func write32(w io.Writer, x uint32) {
  14                 buf := make([]byte, 4)
  15                 be.PutUint32(buf, x)
  16                 _, err := w.Write(buf)
  17                 chk(err)
  18         }
  19
  20         func write64(w io.Writer, x uint64) {
  21                 buf := make([]byte, 8)
  22                 be.PutUint64(buf, x)
  23                 _, err := w.Write(buf)
  24                 chk(err)
  25         }
  26
  27 byte    write8(w, uint8(x))
  28 uint8   write8(w, uint8(x))
  29 uint16  write16(w, uint16(x))
  30 uint32  write32(w, uint32(x))
  31 uint64  write64(w, uint64(x))
  32
  33 int8    write8(w, uint8(x))
  34 int16   write16(w, uint16(x))
  35 int32   write32(w, uint32(x))
  36 int64   write64(w, uint64(x))
  37
  38 bool    if x { write8(w, 1) } else { write8(w, 0) }
  39
  40 float32 write32(w, math.Float32bits(x))
  41 float64 write64(w, math.Float64bits(x))
  42
  43 AOMsg   writeAOMsg(w, x)
  44
  45 image/color.NRGBA       w.Write([]byte{x.A, x.R, x.G, x.B})
  46
  47 map[uint16]*NodeMeta    {
  48                 if x == nil {
  49                         write8(w, 0)
  50                 } else {
  51                         write8(w, 2)
  52                         // len(map[uint16]...) always < math.MaxUint16
  53                         write16(w, uint16(len(x)))
  54                         keys := make([]uint16, 0, len(x))
  55                         for key := range x {
  56                                 keys = append(keys, key)
  57                         }
  58                         sort.Slice(keys, func(i, j int) bool {
  59                                 i2pos := func(i int) [3]int16 {
  60                                         return Blkpos2Pos([3]int16{}, keys[i])
  61                                 }
  62
  63                                 p, q := i2pos(i), i2pos(j)
  64
  65                                 for i := range p {
  66                                         switch {
  67                                         case p[i] < q[i]:
  68                                                 return true
  69                                         case p[i] > q[i]:
  70                                                 return false
  71                                         }
  72                                 }
  73
  74                                 return false
  75                         })
  76                         for _, key := range keys {
  77                                 write16(w, key)
  78                                 chk(serialize(w, x[key]))
  79                         }
  80                 }
  81         }
  82
  83 map[[3]int16]*NodeMeta  {
  84                 w := zlib.NewWriter(w)
  85
  86                 if x == nil {
  87                         write8(w, 0)
  88                 } else {
  89                         write8(w, 2)
  90                         if len(x) > math.MaxUint16 {
  91                                 chk(ErrTooLong)
  92                         }
  93                         write16(w, uint16(len(x)))
  94                         keys := make([][3]int16, 0, len(x))
  95                         for key := range x {
  96                                 keys = append(keys, key)
  97                         }
  98                         sort.Slice(keys, func(i, j int) bool {
  99                                 p, q := keys[i], keys[j]
 100
 101                                 for i := range p {
 102                                         switch {
 103                                         case p[i] < q[i]:
 104                                                 return true
 105                                         case p[i] > q[i]:
 106                                                 return false
 107                                         }
 108                                 }
 109
 110                                 return false
 111                         })
 112                         for _, key := range keys {
 113                                 for _, n := range key {
 114                                         write16(w, uint16(n))
 115                                 }
 116                                 chk(serialize(w, x[key]))
 117                         }
 118                 }
 119
 120                 chk(w.Close())
 121         }
 122
 123 PointedThing    chk(writePointedThing(w, x))
 124
 125 []AOMsg { // For AOInitData.Msgs.
 126                 if len(x) > math.MaxUint8 {
 127                         chk(ErrTooLong)
 128                 }
 129                 write8(w, uint8(len(x)))
 130                 for _, msg := range x {
 131                         var b bytes.Buffer
 132                         chk(writeAOMsg(&b, msg))
 133                         if b.Len() > math.MaxUint32 {
 134                                 chk(ErrTooLong)
 135                         }
 136                         write32(w, uint32(b.Len()))
 137                         _, err := b.WriteTo(w)
 138                         chk(err)
 139                 }
 140         }
 141
 142 []NodeDef       { // For ToCltNodeDefs.Defs.
 143                 if len(x) > math.MaxUint16 {
 144                         chk(ErrTooLong)
 145                 }
 146                 write16(w, uint16(len(x)))
 147                 var b bytes.Buffer
 148                 for i := range x {
 149                         x[i].Serialize(&b)
 150                 }
 151                 if b.Len() > math.MaxUint32 {
 152                         chk(ErrTooLong)
 153                 }
 154                 write32(w, uint32(b.Len()))
 155                 _, err := b.WriteTo(w)
 156                 chk(err)
 157         }