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