Implementing uint64 SeqNums

Author: SNORRIS721

field_map.go

@@ -176,6 +176,21 @@ func (m FieldMap) GetInt(tag Tag) (int, MessageRejectError) {
 	return int(val), err
 }
 
+// GetInt is a GetField wrapper for int fields.
+func (m FieldMap) GetUint64(tag Tag) (uint64, MessageRejectError) {
+	bytes, err := m.GetBytes(tag)
+	if err != nil {
+		return 0, err
+	}
+
+	var val FIXUint64
+	if val.Read(bytes) != nil {
+		err = IncorrectDataFormatForValue(tag)
+	}
+
+	return uint64(val), err
+}
+
 // GetInt is a lock free GetField wrapper for int fields.
 func (m FieldMap) getIntNoLock(tag Tag) (int, MessageRejectError) {
 	bytes, err := m.getBytesNoLock(tag)
@@ -270,6 +285,12 @@ func (m *FieldMap) SetInt(tag Tag, value int) *FieldMap {
 	return m.SetBytes(tag, v.Write())
 }
 
+// SetUint64 is a SetField wrapper for int fields.
+func (m *FieldMap) SetUint64(tag Tag, value uint64) *FieldMap {
+	v := FIXUint64(value)
+	return m.SetBytes(tag, v.Write())
+}
+
 // SetString is a SetField wrapper for string fields.
 func (m *FieldMap) SetString(tag Tag, value string) *FieldMap {
 	return m.SetBytes(tag, []byte(value))

fix_uint.go

@@ -0,0 +1,69 @@
+// Copyright (c) quickfixengine.org  All rights reserved.
+//
+// This file may be distributed under the terms of the quickfixengine.org
+// license as defined by quickfixengine.org and appearing in the file
+// LICENSE included in the packaging of this file.
+//
+// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING
+// THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// See http://www.quickfixengine.org/LICENSE for licensing information.
+//
+// Contact [email protected] if any conditions of this licensing
+// are not clear to you.
+
+package quickfix
+
+import (
+	"errors"
+	"strconv"
+)
+
+// atoi is similar to the function in strconv, but is tuned for ints appearing in FIX field types.
+func atou(d []byte) (uint64, error) {
+	// if d[0] == asciiMinus {
+	// 	n, err := parseUInt64(d[1:])
+	// 	return (-1) * n, err
+	// }
+
+	return parseUInt64(d)
+}
+
+// parseUInt is similar to the function in strconv, but is tuned for ints appearing in FIX field types.
+func parseUInt64(d []byte) (n uint64, err error) {
+	if len(d) == 0 {
+		err = errors.New("empty bytes")
+		return
+	}
+
+	for _, dec := range d {
+		if dec < ascii0 || dec > ascii9 {
+			err = errors.New("invalid format")
+			return
+		}
+
+		n = n*10 + (uint64(dec) - ascii0)
+	}
+
+	return
+}
+
+// FIXInt is a FIX Int Value, implements FieldValue.
+type FIXUint64 uint64
+
+// Int converts the FIXInt value to int.
+func (f FIXUint64) Uint64() uint64 { return uint64(f) }
+
+func (f *FIXUint64) Read(bytes []byte) error {
+	i, err := atou(bytes)
+	if err != nil {
+		return err
+	}
+	*f = FIXUint64(i)
+	return nil
+}
+
+func (f FIXUint64) Write() []byte {
+	return strconv.AppendInt(nil, int64(f), 10)
+}

fix_uint_test.go

@@ -0,0 +1,52 @@
+// Copyright (c) quickfixengine.org  All rights reserved.
+//
+// This file may be distributed under the terms of the quickfixengine.org
+// license as defined by quickfixengine.org and appearing in the file
+// LICENSE included in the packaging of this file.
+//
+// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING
+// THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A
+// PARTICULAR PURPOSE.
+//
+// See http://www.quickfixengine.org/LICENSE for licensing information.
+//
+// Contact [email protected] if any conditions of this licensing
+// are not clear to you.
+
+package quickfix
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFIXUInt_Write(t *testing.T) {
+	field := FIXUint64(5)
+
+	assert.Equal(t, "5", string(field.Write()))
+}
+
+func TestFIXUInt_Read(t *testing.T) {
+	var field FIXUint64
+	err := field.Read([]byte("15"))
+	assert.Nil(t, err, "Unexpected error")
+	assert.Equal(t, uint64(15), uint64(field))
+
+	err = field.Read([]byte("blah"))
+	assert.NotNil(t, err, "Unexpected error")
+}
+
+func TestFIXUInt_UInt(t *testing.T) {
+	f := FIXUint64(4)
+	assert.Equal(t, uint64(4), f.Uint64())
+}
+
+func BenchmarkFIXUInt_Read(b *testing.B) {
+	intBytes := []byte("1500")
+	var field FIXUint64
+
+	for i := 0; i < b.N; i++ {
+		_ = field.Read(intBytes)
+	}
+}

in_session.go

@@ -240,7 +240,7 @@ func (state inSession) resendMessages(session *session, beginSeqNo, endSeqNo uin
 			return err // We cant continue with a message that cant be parsed correctly.
 		}
 		msgType, _ := msg.Header.GetBytes(tagMsgType)
-		sentMessageSeqNum, _ := msg.Header.GetInt(tagMsgSeqNum)
+		sentMessageSeqNum, _ := msg.Header.GetUint64(tagMsgSeqNum)
 
 		if isAdminMessageType(msgType) {
 			nextSeqNum = sentMessageSeqNum + 1
@@ -297,7 +297,7 @@ func (state inSession) processReject(session *session, msg *Message, rej Message
 		}
 
 		if nextState.messageStash == nil {
-			nextState.messageStash = make(map[int]*Message)
+			nextState.messageStash = make(map[uint64]*Message)
 		}
 
 		nextState.messageStash[TypedError.ReceivedTarget] = msg
@@ -387,7 +387,7 @@ func (state inSession) doTargetTooLow(session *session, msg *Message, rej target
 	return state
 }
 
-func (state *inSession) generateSequenceReset(session *session, beginSeqNo uint64, endSeqNo int, inReplyTo Message) (err error) {
+func (state *inSession) generateSequenceReset(session *session, beginSeqNo uint64, endSeqNo uint64, inReplyTo Message) (err error) {
 	sequenceReset := NewMessage()
 	session.fillDefaultHeader(sequenceReset, &inReplyTo)
 

in_session_test.go

@@ -198,8 +198,8 @@ func (s *InSessionTestSuite) TestFIXMsgInTargetTooHigh() {
 }
 func (s *InSessionTestSuite) TestFIXMsgInTargetTooHighResendRequestChunkSize() {
 	var tests = []struct {
-		chunkSize        int
-		expectedEndSeqNo int
+		chunkSize        uint64
+		expectedEndSeqNo uint64
 	}{
 		{0, 0},
 		{10, 0},

internal/session_settings.go

@@ -12,7 +12,7 @@ type SessionSettings struct {
 	HeartBtIntOverride           bool
 	SessionTime                  *TimeRange
 	InitiateLogon                bool
-	ResendRequestChunkSize       int
+	ResendRequestChunkSize       uint64
 	EnableLastMsgSeqNumProcessed bool
 	EnableNextExpectedMsgSeqNum  bool
 	SkipCheckLatency             bool

internal/testsuite/store_suite.go

@@ -39,23 +39,23 @@ func (s *StoreTestSuite) TestMessageStoreSetNextMsgSeqNumRefreshIncrNextMsgSeqNu
 	s.Require().Nil(s.MsgStore.Refresh())
 
 	// Then the sender and target seqnums should still be
-	s.Equal(867, s.MsgStore.NextSenderMsgSeqNum())
-	s.Equal(5309, s.MsgStore.NextTargetMsgSeqNum())
+	s.Equal(uint64(867), s.MsgStore.NextSenderMsgSeqNum())
+	s.Equal(uint64(5309), s.MsgStore.NextTargetMsgSeqNum())
 
 	// When the sender and target seqnums are incremented
 	s.Require().Nil(s.MsgStore.IncrNextSenderMsgSeqNum())
 	s.Require().Nil(s.MsgStore.IncrNextTargetMsgSeqNum())
 
 	// Then the sender and target seqnums should be
-	s.Equal(868, s.MsgStore.NextSenderMsgSeqNum())
-	s.Equal(5310, s.MsgStore.NextTargetMsgSeqNum())
+	s.Equal(uint64(868), s.MsgStore.NextSenderMsgSeqNum())
+	s.Equal(uint64(5310), s.MsgStore.NextTargetMsgSeqNum())
 
 	// When the store is refreshed from its backing store
 	s.Require().Nil(s.MsgStore.Refresh())
 
 	// Then the sender and target seqnums should still be
-	s.Equal(868, s.MsgStore.NextSenderMsgSeqNum())
-	s.Equal(5310, s.MsgStore.NextTargetMsgSeqNum())
+	s.Equal(uint64(868), s.MsgStore.NextSenderMsgSeqNum())
+	s.Equal(uint64(5310), s.MsgStore.NextTargetMsgSeqNum())
 }
 
 func (s *StoreTestSuite) TestMessageStoreReset() {
@@ -67,18 +67,18 @@ func (s *StoreTestSuite) TestMessageStoreReset() {
 	s.Require().Nil(s.MsgStore.Reset())
 
 	// Then the sender and target seqnums should be
-	s.Equal(1, s.MsgStore.NextSenderMsgSeqNum())
-	s.Equal(1, s.MsgStore.NextTargetMsgSeqNum())
+	s.Equal(uint64(1), s.MsgStore.NextSenderMsgSeqNum())
+	s.Equal(uint64(1), s.MsgStore.NextTargetMsgSeqNum())
 
 	// When the store is refreshed from its backing store
 	s.Require().Nil(s.MsgStore.Refresh())
 
 	// Then the sender and target seqnums should still be
-	s.Equal(1, s.MsgStore.NextSenderMsgSeqNum())
-	s.Equal(1, s.MsgStore.NextTargetMsgSeqNum())
+	s.Equal(uint64(1), s.MsgStore.NextSenderMsgSeqNum())
+	s.Equal(uint64(1), s.MsgStore.NextTargetMsgSeqNum())
 }
 
-func (s *StoreTestSuite) fetchMessages(beginSeqNum, endSeqNum int) (msgs [][]byte) {
+func (s *StoreTestSuite) fetchMessages(beginSeqNum, endSeqNum uint64) (msgs [][]byte) {
 	s.T().Helper()
 
 	// Fetch messages from the new iterator
@@ -102,16 +102,16 @@ func (s *StoreTestSuite) fetchMessages(beginSeqNum, endSeqNum int) (msgs [][]byt
 
 func (s *StoreTestSuite) TestMessageStoreSaveMessageGetMessage() {
 	// Given the following saved messages
-	expectedMsgsBySeqNum := map[int]string{
+	expectedMsgsBySeqNum := map[uint64]string{
 		1: "In the frozen land of Nador",
 		2: "they were forced to eat Robin's minstrels",
 		3: "and there was much rejoicing",
 	}
-	var seqNums []int
+	var seqNums []uint64
 	for seqNum := range expectedMsgsBySeqNum {
 		seqNums = append(seqNums, seqNum)
 	}
-	sort.Ints(seqNums)
+	sort.Slice(seqNums, func(i, j int) bool { return seqNums[i] < seqNums[j] })
 	for _, seqNum := range seqNums {
 		s.Require().Nil(s.MsgStore.SaveMessage(seqNum, []byte(expectedMsgsBySeqNum[seqNum])))
 	}
@@ -142,20 +142,20 @@ func (s *StoreTestSuite) TestMessageStoreSaveMessageAndIncrementGetMessage() {
 	s.Require().Nil(s.MsgStore.SetNextSenderMsgSeqNum(420))
 
 	// Given the following saved messages
-	expectedMsgsBySeqNum := map[int]string{
+	expectedMsgsBySeqNum := map[uint64]string{
 		1: "In the frozen land of Nador",
 		2: "they were forced to eat Robin's minstrels",
 		3: "and there was much rejoicing",
 	}
-	var seqNums []int
+	var seqNums []uint64
 	for seqNum := range expectedMsgsBySeqNum {
 		seqNums = append(seqNums, seqNum)
 	}
-	sort.Ints(seqNums)
+	sort.Slice(seqNums, func(i, j int) bool { return seqNums[i] < seqNums[j] })
 	for _, seqNum := range seqNums {
 		s.Require().Nil(s.MsgStore.SaveMessageAndIncrNextSenderMsgSeqNum(seqNum, []byte(expectedMsgsBySeqNum[seqNum])))
 	}
-	s.Equal(423, s.MsgStore.NextSenderMsgSeqNum())
+	s.Equal(uint64(423), s.MsgStore.NextSenderMsgSeqNum())
 
 	// When the messages are retrieved from the MessageStore
 	actualMsgs := s.fetchMessages(1, 3)
@@ -172,7 +172,7 @@ func (s *StoreTestSuite) TestMessageStoreSaveMessageAndIncrementGetMessage() {
 	// And the messages are retrieved from the MessageStore
 	actualMsgs = s.fetchMessages(1, 3)
 
-	s.Equal(423, s.MsgStore.NextSenderMsgSeqNum())
+	s.Equal(uint64(423), s.MsgStore.NextSenderMsgSeqNum())
 
 	// Then the messages should still be
 	s.Require().Len(actualMsgs, 3)
@@ -199,7 +199,7 @@ func (s *StoreTestSuite) TestMessageStoreGetMessagesVariousRanges() {
 
 	// When the following requests are made to the store
 	var testCases = []struct {
-		beginSeqNo, endSeqNo int
+		beginSeqNo, endSeqNo uint64
 		expectedBytes        [][]byte
 	}{
 		{beginSeqNo: 1, endSeqNo: 1, expectedBytes: [][]byte{[]byte("hello")}},

memory_store.go

@@ -22,16 +22,16 @@ import (
 )
 
 type memoryStore struct {
-	senderMsgSeqNum, targetMsgSeqNum int
+	senderMsgSeqNum, targetMsgSeqNum uint64
 	creationTime                     time.Time
-	messageMap                       map[int][]byte
+	messageMap                       map[uint64][]byte
 }
 
-func (store *memoryStore) NextSenderMsgSeqNum() int {
+func (store *memoryStore) NextSenderMsgSeqNum() uint64 {
 	return store.senderMsgSeqNum + 1
 }
 
-func (store *memoryStore) NextTargetMsgSeqNum() int {
+func (store *memoryStore) NextTargetMsgSeqNum() uint64 {
 	return store.targetMsgSeqNum + 1
 }
 
@@ -45,11 +45,11 @@ func (store *memoryStore) IncrNextTargetMsgSeqNum() error {
 	return nil
 }
 
-func (store *memoryStore) SetNextSenderMsgSeqNum(nextSeqNum int) error {
+func (store *memoryStore) SetNextSenderMsgSeqNum(nextSeqNum uint64) error {
 	store.senderMsgSeqNum = nextSeqNum - 1
 	return nil
 }
-func (store *memoryStore) SetNextTargetMsgSeqNum(nextSeqNum int) error {
+func (store *memoryStore) SetNextTargetMsgSeqNum(nextSeqNum uint64) error {
 	store.targetMsgSeqNum = nextSeqNum - 1
 	return nil
 }
@@ -80,24 +80,24 @@ func (store *memoryStore) Close() error {
 	return nil
 }
 
-func (store *memoryStore) SaveMessage(seqNum int, msg []byte) error {
+func (store *memoryStore) SaveMessage(seqNum uint64, msg []byte) error {
 	if store.messageMap == nil {
-		store.messageMap = make(map[int][]byte)
+		store.messageMap = make(map[uint64][]byte)
 	}
 
 	store.messageMap[seqNum] = msg
 	return nil
 }
 
-func (store *memoryStore) SaveMessageAndIncrNextSenderMsgSeqNum(seqNum int, msg []byte) error {
+func (store *memoryStore) SaveMessageAndIncrNextSenderMsgSeqNum(seqNum uint64, msg []byte) error {
 	err := store.SaveMessage(seqNum, msg)
 	if err != nil {
 		return err
 	}
 	return store.IncrNextSenderMsgSeqNum()
 }
 
-func (store *memoryStore) IterateMessages(beginSeqNum, endSeqNum int, cb func([]byte) error) error {
+func (store *memoryStore) IterateMessages(beginSeqNum, endSeqNum uint64, cb func([]byte) error) error {
 	for seqNum := beginSeqNum; seqNum <= endSeqNum; seqNum++ {
 		if m, ok := store.messageMap[seqNum]; ok {
 			if err := cb(m); err != nil {
@@ -108,7 +108,7 @@ func (store *memoryStore) IterateMessages(beginSeqNum, endSeqNum int, cb func([]
 	return nil
 }
 
-func (store *memoryStore) GetMessages(beginSeqNum, endSeqNum int) ([][]byte, error) {
+func (store *memoryStore) GetMessages(beginSeqNum, endSeqNum uint64) ([][]byte, error) {
 	var msgs [][]byte
 	err := store.IterateMessages(beginSeqNum, endSeqNum, func(m []byte) error {
 		msgs = append(msgs, m)