Merge pull request #265 from cbusbey/reduced_allocs3

reduces allocs more

Author: cbusbey

field_map.go

@@ -3,6 +3,7 @@ package quickfix
 import (
 	"bytes"
 	"sort"
+	"time"
 )
 
 //FieldMap is a collection of fix fields that make up a fix message.
@@ -91,11 +92,32 @@ func (m FieldMap) GetBool(tag Tag) (bool, MessageRejectError) {
 
 //GetInt is a GetField wrapper for int fields
 func (m FieldMap) GetInt(tag Tag) (int, MessageRejectError) {
-	var val FIXInt
-	if err := m.GetField(tag, &val); err != nil {
+	bytes, err := m.GetBytes(tag)
+	if err != nil {
 		return 0, err
 	}
-	return int(val), nil
+
+	var val FIXInt
+	if val.Read(bytes) != nil {
+		err = IncorrectDataFormatForValue(tag)
+	}
+
+	return int(val), err
+}
+
+//GetTime is a GetField wrapper for utc timestamp fields
+func (m FieldMap) GetTime(tag Tag) (t time.Time, err MessageRejectError) {
+	bytes, err := m.GetBytes(tag)
+	if err != nil {
+		return
+	}
+
+	var val FIXUTCTimestamp
+	if val.Read(bytes) != nil {
+		err = IncorrectDataFormatForValue(tag)
+	}
+
+	return val.Time, err
 }
 
 //GetString is a GetField wrapper for string fields

message.go

@@ -195,12 +195,12 @@ func ParseMessage(rawMessage []byte) (Message, error) {
 		}
 	}
 
-	var bodyLength FIXInt
-	if err := msg.Header.GetField(tagBodyLength, &bodyLength); err != nil {
+	bodyLength, err := msg.Header.GetInt(tagBodyLength)
+	if err != nil {
 		return msg, parseError{OrigError: err.Error()}
 	}
 
-	if length != int(bodyLength) {
+	if length != bodyLength {
 		return msg, parseError{OrigError: fmt.Sprintf("Incorrect Message Length, expected %d, got %d", bodyLength, length)}
 	}
 

message_router.go

@@ -29,12 +29,12 @@ func (c MessageRouter) AddRoute(beginString string, msgType string, router Messa
 
 //Route may be called from the fromApp/fromAdmin callbacks. Messages that cannot be routed will be rejected with UnsupportedMessageType.
 func (c MessageRouter) Route(msg Message, sessionID SessionID) MessageRejectError {
-	var beginString FIXString
-	if err := msg.Header.GetField(tagBeginString, &beginString); err != nil {
+	beginString, err := msg.Header.GetBytes(tagBeginString)
+	if err != nil {
 		return nil
 	}
 
-	msgType, err := msg.MsgType()
+	msgType, err := msg.Header.GetBytes(tagMsgType)
 	if err != nil {
 		return err
 	}

session.go

@@ -522,24 +522,34 @@ func (s *session) fromCallback(msg Message) MessageRejectError {
 }
 
 func (s *session) checkTargetTooLow(msg Message) MessageRejectError {
-	var seqNum FIXInt
-	switch err := msg.Header.GetField(tagMsgSeqNum, &seqNum); {
-	case err != nil:
+	if !msg.Header.Has(tagMsgSeqNum) {
 		return RequiredTagMissing(tagMsgSeqNum)
-	case int(seqNum) < s.store.NextTargetMsgSeqNum():
-		return targetTooLow{ReceivedTarget: int(seqNum), ExpectedTarget: s.store.NextTargetMsgSeqNum()}
+	}
+
+	seqNum, err := msg.Header.GetInt(tagMsgSeqNum)
+	if err != nil {
+		return err
+	}
+
+	if seqNum < s.store.NextTargetMsgSeqNum() {
+		return targetTooLow{ReceivedTarget: seqNum, ExpectedTarget: s.store.NextTargetMsgSeqNum()}
 	}
 
 	return nil
 }
 
 func (s *session) checkTargetTooHigh(msg Message) MessageRejectError {
-	var seqNum FIXInt
-	switch err := msg.Header.GetField(tagMsgSeqNum, &seqNum); {
-	case err != nil:
+	if !msg.Header.Has(tagMsgSeqNum) {
 		return RequiredTagMissing(tagMsgSeqNum)
-	case int(seqNum) > s.store.NextTargetMsgSeqNum():
-		return targetTooHigh{ReceivedTarget: int(seqNum), ExpectedTarget: s.store.NextTargetMsgSeqNum()}
+	}
+
+	seqNum, err := msg.Header.GetInt(tagMsgSeqNum)
+	if err != nil {
+		return err
+	}
+
+	if seqNum > s.store.NextTargetMsgSeqNum() {
+		return targetTooHigh{ReceivedTarget: seqNum, ExpectedTarget: s.store.NextTargetMsgSeqNum()}
 	}
 
 	return nil
@@ -570,12 +580,12 @@ func (s *session) checkSendingTime(msg Message) MessageRejectError {
 		return RequiredTagMissing(tagSendingTime)
 	}
 
-	sendingTime := new(FIXUTCTimestamp)
-	if err := msg.Header.GetField(tagSendingTime, sendingTime); err != nil {
+	sendingTime, err := msg.Header.GetTime(tagSendingTime)
+	if err != nil {
 		return err
 	}
 
-	if delta := time.Since(sendingTime.Time); delta <= -1*time.Duration(120)*time.Second || delta >= time.Duration(120)*time.Second {
+	if delta := time.Since(sendingTime); delta <= -1*time.Duration(120)*time.Second || delta >= time.Duration(120)*time.Second {
 		return sendingTimeAccuracyProblem()
 	}