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                 w := zlib.NewWriter(w)
  49
  50                 if x == nil {
  51                         write8(w, 0)
  52                 } else {
  53                         write8(w, 2)
  54                         // len(map[uint16]...) always < math.MaxUint16
  55                         write16(w, uint16(len(x)))
  56                         keys := make([]uint16, 0, len(x))
  57                         for key := range x {
  58                                 keys = append(keys, key)
  59                         }
  60                         sort.Slice(keys, func(i, j int) bool {
  61                                 i2pos := func(i int) [3]int16 {
  62                                         return Blkpos2Pos([3]int16{}, keys[i])
  63                                 }
  64
  65                                 p, q := i2pos(i), i2pos(j)
  66
  67                                 for i := range p {
  68                                         switch {
  69                                         case p[i] < q[i]:
  70                                                 return true
  71                                         case p[i] > q[i]:
  72                                                 return false
  73                                         }
  74                                 }
  75
  76                                 return false
  77                         })
  78                         for _, key := range keys {
  79                                 write16(w, key)
  80                                 chk(serialize(w, x[key]))
  81                         }
  82                 }
  83
  84                 chk(w.Close())
  85         }
  86
  87 map[[3]int16]*NodeMeta  {
  88                 w := zlib.NewWriter(w)
  89
  90                 if x == nil {
  91                         write8(w, 0)
  92                 } else {
  93                         write8(w, 2)
  94                         if len(x) > math.MaxUint16 {
  95                                 chk(ErrTooLong)
  96                         }
  97                         write16(w, uint16(len(x)))
  98                         keys := make([][3]int16, 0, len(x))
  99                         for key := range x {
 100                                 keys = append(keys, key)
 101                         }
 102                         sort.Slice(keys, func(i, j int) bool {
 103                                 p, q := keys[i], keys[j]
 104
 105                                 for i := range p {
 106                                         switch {
 107                                         case p[i] < q[i]:
 108                                                 return true
 109                                         case p[i] > q[i]:
 110                                                 return false
 111                                         }
 112                                 }
 113
 114                                 return false
 115                         })
 116                         for _, key := range keys {
 117                                 for _, n := range key {
 118                                         write16(w, uint16(n))
 119                                 }
 120                                 chk(serialize(w, x[key]))
 121                         }
 122                 }
 123
 124                 chk(w.Close())
 125         }
 126
 127 PointedThing    chk(writePointedThing(w, x))
 128
 129 []AOMsg { // For AOInitData.Msgs.
 130                 if len(x) > math.MaxUint8 {
 131                         chk(ErrTooLong)
 132                 }
 133                 write8(w, uint8(len(x)))
 134                 for _, msg := range x {
 135                         var b bytes.Buffer
 136                         chk(writeAOMsg(&b, msg))
 137                         if b.Len() > math.MaxUint32 {
 138                                 chk(ErrTooLong)
 139                         }
 140                         write32(w, uint32(b.Len()))
 141                         _, err := b.WriteTo(w)
 142                         chk(err)
 143                 }
 144         }
 145
 146 []NodeDef       { // For ToCltNodeDefs.Defs.
 147                 if len(x) > math.MaxUint16 {
 148                         chk(ErrTooLong)
 149                 }
 150                 write16(w, uint16(len(x)))
 151                 var b bytes.Buffer
 152                 for i := range x {
 153                         x[i].serialize(&b)
 154                 }
 155                 if b.Len() > math.MaxUint32 {
 156                         chk(ErrTooLong)
 157                 }
 158                 write32(w, uint32(b.Len()))
 159                 _, err := b.WriteTo(w)
 160                 chk(err)
 161         }