github.com/loomnetwork/gamechain@v0.0.0-20200406110549-36c47eb97a92/battleground/seriality_serialization.go (about)

     1  package battleground
     2  
     3  import (
     4  	"bytes"
     5  	"encoding/binary"
     6  	"github.com/loomnetwork/gamechain/types/zb/zb_data"
     7  	"io"
     8  	"math/big"
     9  )
    10  
    11  func deserializeRect(r io.Reader) (rect zb_data.Rect, err error) {
    12  	position, err := deserializeVector2Int(r)
    13  	if err != nil {
    14  		return
    15  	}
    16  	rect.Position = &position
    17  
    18  	size, err := deserializeVector2Int(r)
    19  	if err != nil {
    20  		return
    21  	}
    22  	rect.Size_ = &size
    23  
    24  	return rect, nil
    25  }
    26  
    27  func deserializeVector2Int(r io.Reader) (v zb_data.Vector2Int, err error) {
    28  	if err = binary.Read(r, binary.BigEndian, &v.X); err != nil {
    29  		return
    30  	}
    31  
    32  	if err = binary.Read(r, binary.BigEndian, &v.Y); err != nil {
    33  		return
    34  	}
    35  
    36  	return
    37  }
    38  
    39  func serializeString(w io.Writer, str string) (err error) {
    40  	var length = uint32(len(str))
    41  
    42  	chunkCount := length / 32
    43  	if length % 32 > 0 {
    44  		chunkCount++
    45  	}
    46  
    47  	// Write 4 bytes uint32
    48  	if err = binary.Write(w, binary.BigEndian, &length); err != nil {
    49  		return
    50  	}
    51  
    52  	// Write 28 bytes of zeros
    53  	if err = binary.Write(w, binary.BigEndian, make([]byte, 28)); err != nil {
    54  		return
    55  	}
    56  
    57  	chunkedLength := chunkCount * 32
    58  	chunkBuffer := make([]byte, 32)
    59  	for i := uint32(0) ; i < chunkCount; i++ {
    60  		chunkSize := 32
    61  		if i == chunkCount - 1 {
    62  			chunkSize = 32 - int(chunkedLength - length)
    63  		}
    64  
    65  		for i := range chunkBuffer {
    66  			chunkBuffer[i] = 0
    67  		}
    68  
    69  		copy(chunkBuffer[:], []byte(str)[i * 32: i * 32 + uint32(chunkSize)])
    70  
    71  		if _, err = w.Write(chunkBuffer); err != nil {
    72  			return
    73  		}
    74  	}
    75  
    76  	return nil
    77  }
    78  
    79  func deserializeString(r io.Reader) (str string, err error) {
    80  	chunkBuffer := make([]byte, 32)
    81  	if _, err = r.Read(chunkBuffer); err != nil {
    82  		return
    83  	}
    84  
    85  	length := new(big.Int).SetBytes(chunkBuffer).Uint64()
    86  
    87  	chunkCount := length / 32
    88  	if length % 32 > 0 {
    89  		chunkCount++
    90  	}
    91  
    92  	stringBuffer := bytes.NewBuffer(make([]byte, 0, length))
    93  
    94  	chunkedLength := chunkCount * 32
    95  
    96  	for i := uint64(0) ; i < chunkCount; i++ {
    97  		chunkSize := 32
    98  		if i == chunkCount - 1 {
    99  			chunkSize = 32 - int(chunkedLength - length)
   100  		}
   101  
   102  		if _, err = r.Read(chunkBuffer); err != nil {
   103  			return
   104  		}
   105  
   106  		if _, err = stringBuffer.Write(chunkBuffer[:chunkSize]); err != nil {
   107  			return
   108  		}
   109  	}
   110  
   111  	str = string(stringBuffer.Bytes())
   112  
   113  	return
   114  }