API polish

file_log.go

@@ -14,11 +14,11 @@ type fileLog struct {
 	messageLogger *log.Logger
 }
 
-func (l fileLog) OnIncoming(msg string) {
+func (l fileLog) OnIncoming(msg []byte) {
 	l.messageLogger.Print(msg)
 }
 
-func (l fileLog) OnOutgoing(msg string) {
+func (l fileLog) OnOutgoing(msg []byte) {
 	l.messageLogger.Print(msg)
 }
 

file_log_test.go

@@ -107,7 +107,7 @@ func TestFileLog_Append(t *testing.T) {
 	messageScanner := bufio.NewScanner(messageLogFile)
 	eventScanner := bufio.NewScanner(eventLogFile)
 
-	helper.Log.OnIncoming("incoming")
+	helper.Log.OnIncoming([]byte("incoming"))
 	if !messageScanner.Scan() {
 		t.Error("Unexpected EOF")
 	}
@@ -118,7 +118,7 @@ func TestFileLog_Append(t *testing.T) {
 	}
 
 	newHelper := newFileLogHelper(t)
-	newHelper.Log.OnIncoming("incoming")
+	newHelper.Log.OnIncoming([]byte("incoming"))
 	if !messageScanner.Scan() {
 		t.Error("Unexpected EOF")
 	}

in_session.go

@@ -232,10 +232,8 @@ func (state inSession) resendMessages(session *session, beginSeqNo, endSeqNo int
 		}
 
 		session.log.OnEventf("Resending Message: %v", sentMessageSeqNum)
-		if _, err := msg.Build(); err != nil {
-			return err
-		}
-		session.sendBytes(msg.rawMessage)
+		msgBytes = msg.build()
+		session.sendBytes(msgBytes)
 
 		seqNum = sentMessageSeqNum + 1
 		nextSeqNum = seqNum
@@ -374,10 +372,7 @@ func (state *inSession) generateSequenceReset(session *session, beginSeqNo int,
 
 	session.application.ToAdmin(sequenceReset, session.sessionID)
 
-	msgBytes, err := sequenceReset.Build()
-	if err != nil {
-		return
-	}
+	msgBytes := sequenceReset.build()
 
 	session.sendBytes(msgBytes)
 	session.log.OnEventf("Sent SequenceReset TO: %v", endSeqNo)

in_session_test.go

@@ -160,8 +160,8 @@ func (s *InSessionTestSuite) TestFIXMsgInTargetTooHigh() {
 	stashedMsg, ok := resendState.messageStash[6]
 	s.True(ok)
 
-	rawMsg, _ := msgSeqNumTooHigh.Build()
-	stashedRawMsg, _ := stashedMsg.Build()
+	rawMsg := msgSeqNumTooHigh.build()
+	stashedRawMsg := stashedMsg.build()
 	s.Equal(string(rawMsg), string(stashedRawMsg))
 }
 func (s *InSessionTestSuite) TestFIXMsgInTargetTooHighResendRequestChunkSize() {
@@ -198,8 +198,8 @@ func (s *InSessionTestSuite) TestFIXMsgInTargetTooHighResendRequestChunkSize() {
 		stashedMsg, ok := resendState.messageStash[6]
 		s.True(ok)
 
-		rawMsg, _ := msgSeqNumTooHigh.Build()
-		stashedRawMsg, _ := stashedMsg.Build()
+		rawMsg := msgSeqNumTooHigh.build()
+		stashedRawMsg := stashedMsg.build()
 		s.Equal(string(rawMsg), string(stashedRawMsg))
 	}
 }

log.go

@@ -3,10 +3,10 @@ package quickfix
 //Log is a generic interface for logging FIX messages and events.
 type Log interface {
 	//log incoming fix message
-	OnIncoming(string)
+	OnIncoming([]byte)
 
 	//log outgoing fix message
-	OnOutgoing(string)
+	OnOutgoing([]byte)
 
 	//log fix event
 	OnEvent(string)

message.go

@@ -283,26 +283,23 @@ func extractField(parsedFieldBytes *TagValue, buffer []byte) (remBytes []byte, e
 	return buffer[(endIndex + 1):], err
 }
 
-func (m *Message) String() string {
-	return string(m.rawMessage)
+func (m Message) String() string {
+	return string(m.build())
 }
 
 func newCheckSum(value int) FIXString {
 	return FIXString(fmt.Sprintf("%03d", value))
 }
 
 //Build constructs a []byte from a Message instance
-func (m *Message) Build() ([]byte, error) {
+func (m Message) build() []byte {
 	m.cook()
 
 	var b bytes.Buffer
 	m.Header.write(&b)
 	m.Body.write(&b)
 	m.Trailer.write(&b)
-
-	m.rawMessage = b.Bytes()
-
-	return m.rawMessage, nil
+	return b.Bytes()
 }
 
 func (m Message) cook() {

message_test.go

@@ -2,8 +2,9 @@ package quickfix
 
 import (
 	"bytes"
-	"github.com/quickfixgo/quickfix/enum"
 	"testing"
+
+	"github.com/quickfixgo/quickfix/enum"
 )
 
 var msgResult Message
@@ -82,11 +83,7 @@ func TestMessage_Build(t *testing.T) {
 	builder.Body.SetField(Tag(554), FIXString("secret"))
 
 	expectedBytes := []byte("8=FIX.4.4
9=49
35=A
52=20140615-19:49:56
553=my_user
554=secret
10=072
")
-	result, err := builder.Build()
-	if err != nil {
-		t.Error("Unexpected error", err)
-	}
-
+	result := builder.build()
 	if !bytes.Equal(expectedBytes, result) {
 		t.Error("Unexpected bytes, got ", string(result))
 	}
@@ -100,12 +97,12 @@ func TestMessage_ReBuild(t *testing.T) {
 	msg.Header.SetField(tagOrigSendingTime, FIXString("20140515-19:49:56.659"))
 	msg.Header.SetField(tagSendingTime, FIXString("20140615-19:49:56"))
 
-	msg.Build()
+	rebuildBytes := msg.build()
 
 	expectedBytes := []byte("8=FIX.4.2
9=126
35=D
34=2
49=TW
52=20140615-19:49:56
56=ISLD
122=20140515-19:49:56.659
11=100
21=1
40=1
54=1
55=TSLA
60=00010101-00:00:00.000
10=128
")
 
-	if !bytes.Equal(expectedBytes, msg.rawMessage) {
-		t.Errorf("Unexpected bytes,\n +%s\n-%s", msg.rawMessage, expectedBytes)
+	if !bytes.Equal(expectedBytes, rebuildBytes) {
+		t.Errorf("Unexpected bytes,\n +%s\n-%s", rebuildBytes, expectedBytes)
 	}
 
 	expectedBodyBytes := []byte("11=100
21=1
40=1
54=1
55=TSLA
60=00010101-00:00:00.000
")

null_log.go

@@ -2,9 +2,9 @@ package quickfix
 
 type nullLog struct{}
 
-func (l nullLog) OnIncoming(s string)                      {}
-func (l nullLog) OnOutgoing(s string)                      {}
-func (l nullLog) OnEvent(s string)                         {}
+func (l nullLog) OnIncoming([]byte)                        {}
+func (l nullLog) OnOutgoing([]byte)                        {}
+func (l nullLog) OnEvent(string)                           {}
 func (l nullLog) OnEventf(format string, a ...interface{}) {}
 
 type nullLogFactory struct{}

quickfix_test.go

@@ -46,10 +46,9 @@ func (s *QuickFIXSuite) FieldEquals(tag Tag, expectedValue interface{}, fieldMap
 	}
 }
 
-func (s *QuickFIXSuite) MessageEqualsBytes(msgBytes []byte, msg Message) {
-	_, err := msg.Build()
-	s.Require().Nil(err)
-	s.Equal(string(msg.rawMessage), string(msgBytes))
+func (s *QuickFIXSuite) MessageEqualsBytes(expectedBytes []byte, msg Message) {
+	actualBytes := msg.build()
+	s.Equal(string(actualBytes), string(expectedBytes))
 }
 
 //MockStore wraps a memory store and mocks Refresh for convenience

screen_log.go

@@ -9,12 +9,12 @@ type screenLog struct {
 	prefix string
 }
 
-func (l screenLog) OnIncoming(s string) {
+func (l screenLog) OnIncoming(s []byte) {
 	logTime := time.Now().UTC()
 	fmt.Printf("<%v, %s, incoming>\n  (%s)\n", logTime, l.prefix, s)
 }
 
-func (l screenLog) OnOutgoing(s string) {
+func (l screenLog) OnOutgoing(s []byte) {
 	logTime := time.Now().UTC()
 	fmt.Printf("<%v, %s, outgoing>\n  (%s)\n", logTime, l.prefix, s)
 }

session.go

@@ -21,7 +21,7 @@ type session struct {
 	messageIn  <-chan fixIn
 
 	//application messages are queued up for send here
-	toSend []Message
+	toSend [][]byte
 
 	//mutex for access to toSend
 	sendMutex sync.Mutex
@@ -196,11 +196,12 @@ func (s *session) queueForSend(msg Message) error {
 	s.sendMutex.Lock()
 	defer s.sendMutex.Unlock()
 
-	if err := s.prepMessageForSend(&msg, nil); err != nil {
+	msgBytes, err := s.prepMessageForSend(msg, nil)
+	if err != nil {
 		return err
 	}
 
-	s.toSend = append(s.toSend, msg)
+	s.toSend = append(s.toSend, msgBytes)
 
 	select {
 	case s.messageEvent <- true:
@@ -222,11 +223,12 @@ func (s *session) sendInReplyTo(msg Message, inReplyTo *Message) error {
 	s.sendMutex.Lock()
 	defer s.sendMutex.Unlock()
 
-	if err := s.prepMessageForSend(&msg, inReplyTo); err != nil {
+	msgBytes, err := s.prepMessageForSend(msg, inReplyTo)
+	if err != nil {
 		return err
 	}
 
-	s.toSend = append(s.toSend, msg)
+	s.toSend = append(s.toSend, msgBytes)
 	s.sendQueued()
 
 	return nil
@@ -255,42 +257,42 @@ func (s *session) dropAndSendInReplyTo(msg Message, resetStore bool, inReplyTo *
 		}
 	}
 
-	if err := s.prepMessageForSend(&msg, inReplyTo); err != nil {
+	msgBytes, err := s.prepMessageForSend(msg, inReplyTo)
+	if err != nil {
 		return err
 	}
 
 	s.dropQueued()
-	s.toSend = append(s.toSend, msg)
+	s.toSend = append(s.toSend, msgBytes)
 	s.sendQueued()
 
 	return nil
 }
 
-func (s *session) prepMessageForSend(msg, inReplyTo *Message) error {
-	s.fillDefaultHeader(*msg, inReplyTo)
+func (s *session) prepMessageForSend(msg Message, inReplyTo *Message) (msgBytes []byte, err error) {
+	s.fillDefaultHeader(msg, inReplyTo)
 	seqNum := s.store.NextSenderMsgSeqNum()
 	msg.Header.SetField(tagMsgSeqNum, FIXInt(seqNum))
 
-	var err error
 	msgType, err := msg.MsgType()
 	if err != nil {
-		return err
+		return
 	}
 
 	if isAdminMessageType(string(msgType)) {
-		s.application.ToAdmin(*msg, s.sessionID)
+		s.application.ToAdmin(msg, s.sessionID)
 
 		if msgType == enum.MsgType_LOGON {
 			var resetSeqNumFlag FIXBoolean
 			if msg.Body.Has(tagResetSeqNumFlag) {
-				if err := msg.Body.GetField(tagResetSeqNumFlag, &resetSeqNumFlag); err != nil {
-					return err
+				if err = msg.Body.GetField(tagResetSeqNumFlag, &resetSeqNumFlag); err != nil {
+					return
 				}
 			}
 
 			if resetSeqNumFlag.Bool() {
-				if err := s.store.Reset(); err != nil {
-					return err
+				if err = s.store.Reset(); err != nil {
+					return
 				}
 
 				s.sentReset = true
@@ -300,17 +302,15 @@ func (s *session) prepMessageForSend(msg, inReplyTo *Message) error {
 
 		}
 	} else {
-		if err := s.application.ToApp(*msg, s.sessionID); err != nil {
-			return err
+		if err = s.application.ToApp(msg, s.sessionID); err != nil {
+			return
 		}
 	}
 
-	msgBytes, err := msg.Build()
-	if err == nil {
-		err = s.persist(seqNum, msgBytes)
-	}
+	msgBytes = msg.build()
+	err = s.persist(seqNum, msgBytes)
 
-	return err
+	return
 }
 
 func (s *session) persist(seqNum int, msgBytes []byte) error {
@@ -322,8 +322,8 @@ func (s *session) persist(seqNum int, msgBytes []byte) error {
 }
 
 func (s *session) sendQueued() {
-	for _, msg := range s.toSend {
-		s.sendBytes(msg.rawMessage)
+	for _, msgBytes := range s.toSend {
+		s.sendBytes(msgBytes)
 	}
 
 	s.dropQueued()
@@ -334,7 +334,7 @@ func (s *session) dropQueued() {
 }
 
 func (s *session) sendBytes(msg []byte) {
-	s.log.OnOutgoing(string(msg))
+	s.log.OnOutgoing(msg)
 	s.messageOut <- msg
 	s.stateTimer.Reset(s.HeartBtInt)
 }

session_state.go

@@ -67,7 +67,7 @@ func (sm *stateMachine) Incoming(session *session, m fixIn) {
 		return
 	}
 
-	session.log.OnIncoming(string(m.bytes))
+	session.log.OnIncoming(m.bytes)
 	if msg, err := ParseMessage(m.bytes); err != nil {
 		session.log.OnEventf("Msg Parse Error: %v, %q", err.Error(), m.bytes)
 	} else {

session_test.go

@@ -410,9 +410,9 @@ func (s *SessionSuite) TestIncomingNotInSessionTime() {
 		}
 
 		msg := s.NewOrderSingle()
-		msg.Build()
+		msgBytes := msg.build()
 
-		s.session.Incoming(s.session, fixIn{bytes: msg.rawMessage})
+		s.session.Incoming(s.session, fixIn{bytes: msgBytes})
 		s.MockApp.AssertExpectations(s.T())
 		s.State(notSessionTime{})
 	}