array_record.go

package binxml

import (
	"bytes"
	"encoding/binary"
	"encoding/xml"
	"fmt"
	"strings"

	"wcfproxy/assert"
	dt "wcfproxy/datatype"
)

type ArrayRecord struct {
	Record
	Element  IElementRecord
	ItemType byte
	ItemCnt  int
	Items    []ITextRecord
}

var byteSizeMap = map[byte]int{
	RTBoolTextWithEndElement:     1,
	RTInt16TextWithEndElement:    2,
	RTInt32TextWithEndElement:    4,
	RTInt64TextWithEndElement:    8,
	RTFloatTextWithEndElement:    4,
	RTDoubleTextWithEndElement:   8,
	RTDecimalTextWithEndElement:  16,
	RTDateTimeTextWithEndElement: 8,
	RTTimeSpanTextWithEndElement: 8,
	RTUuidTextWithEndElement:     16,
}

func NewArrayRecord(elementRecord IElementRecord, itemType byte, items []ITextRecord) ArrayRecord {
	_, ok := byteSizeMap[itemType]
	assert.Assertf(ok, "invalid array item type: %v", itemType)

	return ArrayRecord{
		Record:   Record{Type: RTArray},
		Element:  elementRecord,
		ItemType: itemType,
		ItemCnt:  len(items),
		Items:    items,
	}
}

func (r *ArrayRecord) ReadFromBuffer(buf []byte) (int, error) {
	n, buf, err := r.Record.ReadFromBufferExpectType(buf, RTArray)
	if err != nil {
		return 0, err
	}

	element, nElement, err := readElementRecord(buf)
	if err != nil {
		return 0, err
	}

	buf = buf[nElement:]
	endElement := Record{}
	nEndElement, buf, err := endElement.ReadFromBufferExpectType(buf, RTEndElement)
	if err != nil {
		return 0, err
	}

	if len(buf) < 2 {
		return 0, ErrBufferTooShort
	}

	itemType := buf[0]
	buf = buf[1:]
	itemSize := dataSizeFromItemType(itemType)

	itemCnt, nItemCnt, err := dt.ReadMBI31FromBuffer(buf)
	if err != nil {
		return 0, err
	}
	buf = buf[nItemCnt:]

	cnt := int(itemCnt)
	if len(buf) < cnt*itemSize {
		return 0, ErrBufferTooShort
	}

	items := make([]ITextRecord, cnt)
	var tr ITextRecord
	readItemBytes := 0
	reader := bytes.NewReader(buf)
	rec := Record{Type: itemType}
	for i := 0; i < cnt; i++ {
		switch itemType {
		case RTBoolTextWithEndElement:
			if len(buf) == 0 {
				err = ErrBufferTooShort
				break
			}
			boolVal := buf[0]
			tr = &BoolTextRecord{Record: rec, Value: boolVal != 0}
		case RTInt16TextWithEndElement:
			var val int16
			err = binary.Read(reader, binary.LittleEndian, &val)
			tr = &IntTextRecord{Record: rec, Value: int64(val)}
		case RTInt32TextWithEndElement:
			var val int32
			err = binary.Read(reader, binary.LittleEndian, &val)
			tr = &IntTextRecord{Record: rec, Value: int64(val)}
		case RTInt64TextWithEndElement:
			var val int64
			err = binary.Read(reader, binary.LittleEndian, &val)
			tr = &IntTextRecord{Record: rec, Value: val}
		case RTFloatTextWithEndElement:
			var val float32
			err = binary.Read(reader, binary.LittleEndian, &val)
			tr = &FloatTextRecord{Record: rec, Value: val}
		case RTDoubleTextWithEndElement:
			var val float64
			err = binary.Read(reader, binary.LittleEndian, &val)
			tr = &DoubleTextRecord{Record: rec, Value: val}
		case RTDecimalTextWithEndElement:
			var val dt.Decimal
			val, _, err = dt.ReadDecimalFromBuffer(buf)
			tr = &DecimalTextRecord{Record: rec, Value: val}
		case RTDateTimeTextWithEndElement:
			var val dt.DateTime
			val, _, err = dt.ReadDateTimeFromBuffer(buf)
			tr = &DateTimeTextRecord{Record: rec, Value: val}
		case RTTimeSpanTextWithEndElement:
			var val dt.TimeSpan
			val, _, err = dt.ReadTimeSpanFromBuffer(buf)
			tr = &TimeSpanTextRecord{Record: rec, Value: val}
		case RTUuidTextWithEndElement:
			var val *dt.UUID
			val, _, err = dt.ReadUUIDFromBuffer(buf)
			tr = &UUIDTextRecord{Record: rec, Uuid: *val}
		default:
			err = fmt.Errorf("illegal text record in array: %v", itemType)
		}

		if err != nil {
			return 0, err
		}

		readItemBytes += itemSize
		buf = buf[itemSize:]
		items[i] = tr
	}

	r.Element = element
	r.ItemType = itemType
	r.ItemCnt = cnt
	r.Items = items
	return n + nElement + nEndElement + 1 + nItemCnt + readItemBytes, nil
}

func (r *ArrayRecord) WriteToBuffer(buf []byte) (int, error) {
	rLen := r.ByteLength()
	if rLen > len(buf) {
		return 0, fmt.Errorf("cannot write %v bytes to buffer of size %v", rLen, len(buf))
	}

	n, _ := r.Record.WriteToBuffer(buf)
	buf = buf[n:]
	n, _ = r.Element.WriteToBuffer(buf)
	buf = buf[n:]
	buf[0] = RTEndElement
	buf[1] = r.ItemType
	buf = buf[2:]
	lenBytes := dt.MBI31Bytes(uint32(r.ItemCnt))
	copy(buf, lenBytes)
	buf = buf[len(lenBytes):]

	for _, e := range r.Items {
		switch e := e.(type) {
		case *BoolTextRecord:
			if e.Value {
				buf[0] = 1
			} else {
				buf[0] = 0
			}
		case *IntTextRecord:
			switch t := IntTextRecordBitLengths[r.ItemType]; t {
			case 16:
				binary.Encode(buf, binary.LittleEndian, int16(e.Value))
			case 32:
				binary.Encode(buf, binary.LittleEndian, int32(e.Value))
			case 64:
				binary.Encode(buf, binary.LittleEndian, e.Value)
			default:
				return 0, fmt.Errorf("illegal bit length: %d", t)
			}
		case *FloatTextRecord:
			binary.Encode(buf, binary.LittleEndian, e.Value)
		case *DoubleTextRecord:
			binary.Encode(buf, binary.LittleEndian, e.Value)
		case *DecimalTextRecord:
			dt.WriteDecimalToBuffer(e.Value, buf)
		case *DateTimeTextRecord:
			dt.WriteDateTimeToBuffer(buf, e.Value)
		case *TimeSpanTextRecord:
			dt.WriteTimeSpanToBuffer(buf, e.Value)
		case *UUIDTextRecord:
			dt.WriteUUIDToBuffer(buf, &e.Uuid)
		default:
			return 0, fmt.Errorf("illegal text record in array: %v", r.ItemType)
		}

		itemSize := dataSizeFromItemType(r.ItemType)
		buf = buf[itemSize:]
	}

	return rLen, nil
}

func (r *ArrayRecord) ToString(dict *StringDict, context byte, typehint bool) string {
	var sb strings.Builder
	for _, tr := range r.Items {
		sb.WriteString(r.Element.ToString(dict, typehint))
		sb.WriteString(tr.ToString(dict, ContextText, typehint))
		sb.WriteString(r.Element.GetClosingTag(dict))
	}

	return sb.String()
}

func (r *ArrayRecord) GetElements(dict *StringDict, typehint bool) []xml.Token {
	var tokens []xml.Token
	for _, tr := range r.Items {
		tokens = append(tokens, r.Element.StartElement(dict, typehint))
		tokens = append(tokens, tr.ToXMLChars(dict, ContextText, typehint))
		tokens = append(tokens, r.Element.EndElement(dict))
	}

	return tokens
}

func (r *ArrayRecord) ByteLength() int {
	dataSize := dataSizeFromItemType(r.ItemType)
	return r.Record.ByteLength() + r.Element.ByteLength() + 2 + dt.MBI31ByteLength(uint32(r.ItemCnt)) + r.ItemCnt*dataSize
}

func dataSizeFromItemType(itemType byte) int {
	size, ok := byteSizeMap[itemType]
	assert.Assertf(ok, "illegal item type: %v", itemType)
	return size
}