Support node meta version 0

diff --git a/deserialize.go b/deserialize.go
index 7980ca6ff8968989fd31ae901e3f7b44647b9125..e055348035e3011038eb8b191741988c66f8e3ba 100644 (file)
--- a/deserialize.go
+++ b/deserialize.go
@@ -86,65 +86,67 @@ func Deserialize(r io.Reader, idNameMap map[string]mt.Content) *MapBlk {
                        panic(err)
                }
 
-               if version != NodeMetaVer {
-                       panic(ErrInvalidNodeMetaVer)
-               }
-
-               var count uint16
-               if err := binary.Read(r, binary.BigEndian, &count); err != nil {
-                       panic(err)
-               }
-
-               for i := uint16(0); i < count; i++ {
-                       var pos uint16
-                       if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
-                               panic(err)
+               if version != 0 {
+                       if version != NodeMetaVer {
+                               panic(ErrInvalidNodeMetaVer)
                        }
 
-                       var num uint32
-                       if err := binary.Read(r, binary.BigEndian, &num); err != nil {
+                       var count uint16
+                       if err := binary.Read(r, binary.BigEndian, &count); err != nil {
                                panic(err)
                        }
 
-                       var data = &mt.NodeMeta{}
-                       data.Fields = make([]mt.NodeMetaField, 0)
-                       for j := uint32(0); j < num; j++ {
-                               var field mt.NodeMetaField
-
-                               var lenName uint16
-                               if err := binary.Read(r, binary.BigEndian, &lenName); err != nil {
+                       for i := uint16(0); i < count; i++ {
+                               var pos uint16
+                               if err := binary.Read(r, binary.BigEndian, &pos); err != nil {
                                        panic(err)
                                }
 
-                               var name = make([]byte, lenName)
-                               if err := binary.Read(r, binary.BigEndian, &name); err != nil {
+                               var num uint32
+                               if err := binary.Read(r, binary.BigEndian, &num); err != nil {
                                        panic(err)
                                }
-                               field.Name = string(name)
 
-                               var lenValue uint32
-                               if err := binary.Read(r, binary.BigEndian, &lenValue); err != nil {
-                                       panic(err)
+                               var data = &mt.NodeMeta{}
+                               data.Fields = make([]mt.NodeMetaField, 0)
+                               for j := uint32(0); j < num; j++ {
+                                       var field mt.NodeMetaField
+
+                                       var lenName uint16
+                                       if err := binary.Read(r, binary.BigEndian, &lenName); err != nil {
+                                               panic(err)
+                                       }
+
+                                       var name = make([]byte, lenName)
+                                       if err := binary.Read(r, binary.BigEndian, &name); err != nil {
+                                               panic(err)
+                                       }
+                                       field.Name = string(name)
+
+                                       var lenValue uint32
+                                       if err := binary.Read(r, binary.BigEndian, &lenValue); err != nil {
+                                               panic(err)
+                                       }
+
+                                       var value = make([]byte, lenValue)
+                                       if err := binary.Read(r, binary.BigEndian, &value); err != nil {
+                                               panic(err)
+                                       }
+                                       field.Value = string(value)
+
+                                       if err := binary.Read(r, binary.BigEndian, &field.Private); err != nil {
+                                               panic(err)
+                                       }
+
+                                       data.Fields = append(data.Fields, field)
                                }
 
-                               var value = make([]byte, lenValue)
-                               if err := binary.Read(r, binary.BigEndian, &value); err != nil {
+                               if err := data.Inv.Deserialize(r); err != nil {
                                        panic(err)
                                }
-                               field.Value = string(value)
 
-                               if err := binary.Read(r, binary.BigEndian, &field.Private); err != nil {
-                                       panic(err)
-                               }
-
-                               data.Fields = append(data.Fields, field)
+                               blk.NodeMetas[pos] = data
                        }
-
-                       if err := data.Inv.Deserialize(r); err != nil {
-                               panic(err)
-                       }
-
-                       blk.NodeMetas[pos] = data
                }
 
                if _, err := io.Copy(io.Discard, r); err != nil {

diff --git a/serialize.go b/serialize.go
index b89a32e7cfc6ee834680c064316ba7a552674e10..3cf601ce53737ec8608cad7a44791e972cc491b2 100644 (file)
--- a/serialize.go
+++ b/serialize.go
@@ -50,53 +50,60 @@ func Serialize(blk *MapBlk, w io.Writer, nameIdMap map[mt.Content]string) {
                var buf bytes.Buffer
                zw := zlib.NewWriter(&buf)
 
-               if err := binary.Write(zw, binary.BigEndian, &NodeMetaVer); err != nil {
-                       panic(err)
+               var version = NodeMetaVer
+               if len(blk.NodeMetas) == 0 {
+                       version = 0
                }
 
-               var count = uint16(len(blk.NodeMetas))
-               if err := binary.Write(zw, binary.BigEndian, &count); err != nil {
+               if err := binary.Write(zw, binary.BigEndian, &version); err != nil {
                        panic(err)
                }
 
-               for pos, data := range blk.NodeMetas {
-                       if err := binary.Write(zw, binary.BigEndian, &pos); err != nil {
-                               panic(err)
-                       }
-
-                       var num = uint32(len(data.Fields))
-                       if err := binary.Write(zw, binary.BigEndian, &num); err != nil {
+               if version != 0 {
+                       var count = uint16(len(blk.NodeMetas))
+                       if err := binary.Write(zw, binary.BigEndian, &count); err != nil {
                                panic(err)
                        }
 
-                       for _, field := range data.Fields {
-                               var lenName = uint16(len(field.Name))
-                               if err := binary.Write(zw, binary.BigEndian, &lenName); err != nil {
+                       for pos, data := range blk.NodeMetas {
+                               if err := binary.Write(zw, binary.BigEndian, &pos); err != nil {
                                        panic(err)
                                }
 
-                               var name = []byte(field.Name)
-                               if err := binary.Write(zw, binary.BigEndian, &name); err != nil {
+                               var num = uint32(len(data.Fields))
+                               if err := binary.Write(zw, binary.BigEndian, &num); err != nil {
                                        panic(err)
                                }
 
-                               var lenValue = uint32(len(field.Value))
-                               if err := binary.Write(zw, binary.BigEndian, &lenValue); err != nil {
-                                       panic(err)
+                               for _, field := range data.Fields {
+                                       var lenName = uint16(len(field.Name))
+                                       if err := binary.Write(zw, binary.BigEndian, &lenName); err != nil {
+                                               panic(err)
+                                       }
+
+                                       var name = []byte(field.Name)
+                                       if err := binary.Write(zw, binary.BigEndian, &name); err != nil {
+                                               panic(err)
+                                       }
+
+                                       var lenValue = uint32(len(field.Value))
+                                       if err := binary.Write(zw, binary.BigEndian, &lenValue); err != nil {
+                                               panic(err)
+                                       }
+
+                                       var value = []byte(field.Value)
+                                       if err := binary.Write(zw, binary.BigEndian, &value); err != nil {
+                                               panic(err)
+                                       }
+
+                                       if err := binary.Write(zw, binary.BigEndian, &field.Private); err != nil {
+                                               panic(err)
+                                       }
                                }
 
-                               var value = []byte(field.Value)
-                               if err := binary.Write(zw, binary.BigEndian, &value); err != nil {
+                               if err := data.Inv.Serialize(zw); err != nil {
                                        panic(err)
                                }
-
-                               if err := binary.Write(zw, binary.BigEndian, &field.Private); err != nil {
-                                       panic(err)
-                               }
-                       }
-
-                       if err := data.Inv.Serialize(zw); err != nil {
-                               panic(err)
                        }
                }