Add Header.{GetMsgType, HasMsgTypeOf}

Created by: reedom

Utility methods.

To me, they are useful. How are they to you? Speaking of the method name HasMsgTypeOf, IsMsgTypeOf would be more appropriate? Or more better name we can have?

Thank you.

in_session.go

@@ -12,12 +12,12 @@ type inSession struct{ loggedOn }
 func (state inSession) String() string { return "In Session" }
 
 func (state inSession) FixMsgIn(session *session, msg Message) sessionState {
-	var msgType FIXString
-	if err := msg.Header.GetField(tagMsgType, &msgType); err != nil {
+	msgType, err := msg.MsgType()
+	if err != nil {
 		return handleStateError(session, err)
 	}
 
-	switch enum.MsgType(msgType) {
+	switch msgType {
 	case enum.MsgType_LOGON:
 		if err := session.handleLogon(msg); err != nil {
 			if err := session.initiateLogout(""); err != nil {

logon_state.go

@@ -10,12 +10,12 @@ type logonState struct{ connectedNotLoggedOn }
 func (s logonState) String() string { return "Logon State" }
 
 func (s logonState) FixMsgIn(session *session, msg Message) (nextState sessionState) {
-	var msgType FIXString
-	if err := msg.Header.GetField(tagMsgType, &msgType); err != nil {
+	msgType, err := msg.MsgType()
+	if err != nil {
 		return handleStateError(session, err)
 	}
 
-	if enum.MsgType(msgType) != enum.MsgType_LOGON {
+	if msgType != enum.MsgType_LOGON {
 		session.log.OnEventf("Invalid Session State: Received Msg %s while waiting for Logon", msg)
 		return latentState{}
 	}

message.go

@@ -203,6 +203,23 @@ func ParseMessage(rawMessage []byte) (Message, error) {
 	return msg, nil
 }
 
+// MsgType returns MsgType (tag 35) field's value
+func (m Message) MsgType() (enum.MsgType, MessageRejectError) {
+	s, err := m.Header.GetString(tagMsgType)
+	if err != nil {
+		return enum.MsgType(""), err
+	}
+	return enum.MsgType(s), nil
+}
+
+// IsMsgTypeOf returns true if the Header contains MsgType (tag 35) field and its value is the specified one.
+func (m Message) IsMsgTypeOf(msgType enum.MsgType) bool {
+	if v, err := m.MsgType(); err == nil {
+		return v == msgType
+	}
+	return false
+}
+
 //reverseRoute returns a message builder with routing header fields initialized as the reverse of this message.
 func (m Message) reverseRoute() Message {
 	reverseMsg := NewMessage()

message_router.go

@@ -34,8 +34,8 @@ func (c MessageRouter) Route(msg Message, sessionID SessionID) MessageRejectErro
 		return nil
 	}
 
-	var msgType FIXString
-	if err := msg.Header.GetField(tagMsgType, &msgType); err != nil {
+	msgType, err := msg.MsgType()
+	if err != nil {
 		return err
 	}
 

message_test.go

@@ -42,6 +42,23 @@ func TestMessage_ParseMessage(t *testing.T) {
 	if len(msg.fields) != expectedLenFields {
 		t.Errorf("Expected %v fields, got %v", expectedLenFields, len(msg.fields))
 	}
+
+	msgType, err := msg.MsgType()
+	if err != nil {
+		t.Error("Unexpected error, ", err)
+	}
+
+	if msgType != enum.MsgType_ORDER_SINGLE {
+		t.Errorf("Expected msgType MsgType_ORDER_SINGLE, got %#v", msgType)
+	}
+
+	if !msg.IsMsgTypeOf(enum.MsgType_ORDER_SINGLE) {
+		t.Errorf("Expected Header.HasMsgTypeOf(MsgType_ORDER_SINGLE) is true")
+	}
+
+	if msg.IsMsgTypeOf(enum.MsgType_LOGON) {
+		t.Errorf("Expected Header.HasMsgTypeOf(MsgType_LOGON) is false")
+	}
 }
 
 func TestMessage_parseOutOfOrder(t *testing.T) {

session.go

@@ -234,15 +234,15 @@ func (s *session) prepMessageForSend(msg *Message) error {
 	seqNum := s.store.NextSenderMsgSeqNum()
 	msg.Header.SetField(tagMsgSeqNum, FIXInt(seqNum))
 
-	var msgType FIXString
-	if err := msg.Header.GetField(tagMsgType, &msgType); err != nil {
+	msgType, err := msg.MsgType()
+	if err != nil {
 		return err
 	}
 
 	if isAdminMessageType(string(msgType)) {
 		s.application.ToAdmin(*msg, s.sessionID)
 
-		if enum.MsgType(msgType) == enum.MsgType_LOGON {
+		if msgType == enum.MsgType_LOGON {
 			var resetSeqNumFlag FIXBoolean
 			if msg.Body.Has(tagResetSeqNumFlag) {
 				if err := msg.Body.GetField(tagResetSeqNumFlag, &resetSeqNumFlag); err != nil {
@@ -267,12 +267,11 @@ func (s *session) prepMessageForSend(msg *Message) error {
 		}
 	}
 
-	msgBytes, err := msg.Build()
-	if err == nil {
-		err = s.persist(seqNum, msgBytes)
+	if msgBytes, err := msg.Build(); err != nil {
+		return err
+	} else {
+		return s.persist(seqNum, msgBytes)
 	}
-
-	return err
 }
 
 func (s *session) persist(seqNum int, msgBytes []byte) error {
@@ -466,8 +465,8 @@ func (s *session) verifySelect(msg Message, checkTooHigh bool, checkTooLow bool)
 }
 
 func (s *session) fromCallback(msg Message) MessageRejectError {
-	var msgType FIXString
-	if err := msg.Header.GetField(tagMsgType, &msgType); err != nil {
+	msgType, err := msg.MsgType()
+	if err != nil {
 		return err
 	}