message cap, removed cruft

Author: Chris Busbey

field.go

@@ -8,22 +8,14 @@ type FieldValueWriter interface {
 
 //FieldValueReader is an interface for reading field values
 type FieldValueReader interface {
-	//Parameter to Read is TagValues.  For most fields, only the first TagValue will be required.
-	//The length of the slice extends from the TagValue mapped to the field to be read through the
-	//following fields. This can be useful for FieldValues made up of repeating groups.
-	//
-	//The Read function returns the remaining TagValues not processed by the FieldValue. If there was a
-	//problem reading the field, an error may be returned
-	Read(TagValues) (TagValues, error)
+	//Reads the contents of the []byte into FieldValue.  Returns an error if there are issues in the data processing
+	Read([]byte) error
 }
 
 //The FieldValue interface is used to write/extract typed field values to/from raw bytes
 type FieldValue interface {
 	FieldValueWriter
 	FieldValueReader
-
-	//Returns a new FieldValue cloned from this one
-	Clone() FieldValue
 }
 
 //FieldWriter is an interface for a writing a field

field_map.go

@@ -96,6 +96,19 @@ func (m FieldMap) GetField(tag Tag, parser FieldValueReader) MessageRejectError
 		return conditionallyRequiredFieldMissing(tag)
 	}
 
+	if err := parser.Read(tagValues[0].Value); err != nil {
+		return incorrectDataFormatForValue(tag)
+	}
+
+	return nil
+}
+
+func (m FieldMap) GetGroupField(tag Tag, parser *RepeatingGroup) MessageRejectError {
+	tagValues, ok := m.tagLookup[tag]
+	if !ok {
+		return conditionallyRequiredFieldMissing(tag)
+	}
+
 	if _, err := parser.Read(tagValues); err != nil {
 		return incorrectDataFormatForValue(tag)
 	}

fix_boolean.go

@@ -13,18 +13,17 @@ func NewFIXBoolean(val bool) *FIXBoolean {
 	return &b
 }
 
-func (f *FIXBoolean) Read(tv TagValues) (TagValues, error) {
-	bytes := tv[0].Value
+func (f *FIXBoolean) Read(bytes []byte) error {
 	switch string(bytes) {
 	case "Y":
 		*f = true
 	case "N":
 		*f = false
 	default:
-		return tv, errors.New("Invalid Value for bool: " + string(bytes))
+		return errors.New("Invalid Value for bool: " + string(bytes))
 	}
 
-	return tv[1:], nil
+	return nil
 }
 
 func (f FIXBoolean) Write() []byte {
@@ -34,8 +33,3 @@ func (f FIXBoolean) Write() []byte {
 
 	return []byte("N")
 }
-
-func (f FIXBoolean) Clone() FieldValue {
-	clone := f
-	return &clone
-}

fix_boolean_test.go

@@ -37,7 +37,7 @@ func TestFIXBooleanFieldRead(t *testing.T) {
 
 	for _, test := range tests {
 		var val FIXBoolean
-		_, err := val.Read([]TagValue{TagValue{Value: test.bytes}})
+		err := val.Read(test.bytes)
 
 		if test.expectError && err == nil {
 			t.Errorf("Expected error for %v", test.bytes)

fix_float.go

@@ -15,28 +15,22 @@ func NewFIXFloat(val float64) *FIXFloat {
 	return &f
 }
 
-func (f *FIXFloat) Read(tv TagValues) (TagValues, error) {
-	bytes := tv[0].Value
+func (f *FIXFloat) Read(bytes []byte) error {
 	val, err := strconv.ParseFloat(string(bytes), 64)
 	if err != nil {
-		return tv, err
+		return err
 	}
 
 	//strconv allows values like "+100.00", which is not allowed for FIX float types
 	if valid, _ := regexp.MatchString("^[0-9.-]+$", string(bytes)); !valid {
-		return tv, fmt.Errorf("invalid value %v", string(bytes))
+		return fmt.Errorf("invalid value %v", string(bytes))
 	}
 
 	*f = FIXFloat(val)
 
-	return tv[1:], err
+	return err
 }
 
 func (f FIXFloat) Write() []byte {
 	return []byte(strconv.FormatFloat(float64(f), 'f', -1, 64))
 }
-
-func (f FIXFloat) Clone() FieldValue {
-	clone := f
-	return &clone
-}

fix_float_test.go

@@ -35,7 +35,7 @@ func TestFloatRead(t *testing.T) {
 
 	for _, test := range tests {
 		var field FIXFloat
-		if _, err := field.Read([]TagValue{TagValue{Value: test.bytes}}); err != nil {
+		if err := field.Read(test.bytes); err != nil {
 			if !test.expectError {
 				t.Errorf("UnExpected '%v'", err)
 			}

fix_int.go

@@ -52,20 +52,15 @@ func NewFIXInt(val int) *FIXInt {
 	return &i
 }
 
-func (f *FIXInt) Read(tv TagValues) (TagValues, error) {
-	i, err := atoi(tv[0].Value)
+func (f *FIXInt) Read(bytes []byte) error {
+	i, err := atoi(bytes)
 	if err != nil {
-		return tv, err
+		return err
 	}
 	*f = FIXInt(i)
-	return tv[1:], nil
+	return nil
 }
 
 func (f FIXInt) Write() []byte {
 	return []byte(strconv.Itoa(int(f)))
 }
-
-func (f FIXInt) Clone() FieldValue {
-	clone := f
-	return &clone
-}

fix_int_test.go

@@ -15,7 +15,7 @@ func TestInt_Write(t *testing.T) {
 
 func TestInt_Read(t *testing.T) {
 	var field FIXInt
-	_, err := field.Read([]TagValue{TagValue{Value: []byte("15")}})
+	err := field.Read([]byte("15"))
 
 	if err != nil {
 		t.Error("Unexpected error", err)
@@ -25,7 +25,7 @@ func TestInt_Read(t *testing.T) {
 		t.Error("unexpected value", field)
 	}
 
-	_, err = field.Read([]TagValue{TagValue{Value: []byte("blah")}})
+	err = field.Read([]byte("blah"))
 
 	if err == nil {
 		t.Error("expected error")
@@ -37,6 +37,6 @@ func BenchmarkInt_Read(b *testing.B) {
 	var field FIXInt
 
 	for i := 0; i < b.N; i++ {
-		field.Read([]TagValue{TagValue{Value: intBytes}})
+		field.Read(intBytes)
 	}
 }

fix_string.go

@@ -13,16 +13,11 @@ func (f FIXString) String() string {
 	return string(f)
 }
 
-func (f *FIXString) Read(tv TagValues) (TagValues, error) {
-	*f = FIXString(tv[0].Value)
-	return tv[1:], nil
+func (f *FIXString) Read(bytes []byte) (err error) {
+	*f = FIXString(bytes)
+	return
 }
 
 func (f FIXString) Write() []byte {
 	return []byte(f)
 }
-
-func (f FIXString) Clone() FieldValue {
-	clone := f
-	return &clone
-}

fix_string_test.go

@@ -33,7 +33,7 @@ func TestFIXStringRead(t *testing.T) {
 
 	for _, test := range tests {
 		var field FIXString
-		_, err := field.Read([]TagValue{TagValue{Value: test.bytes}})
+		err := field.Read(test.bytes)
 
 		if test.expectError && err == nil {
 			t.Errorf("Expected error for %v", test.bytes)

fix_utc_timestamp.go

@@ -15,20 +15,19 @@ const (
 	utcTimestampNoMillisFormat = "20060102-15:04:05"
 )
 
-func (f *FIXUTCTimestamp) Read(tv TagValues) (TagValues, error) {
-	bytes := tv[0].Value
+func (f *FIXUTCTimestamp) Read(bytes []byte) error {
 	var err error
 	//with millisecs
 	if f.Value, err = time.Parse(utcTimestampFormat, string(bytes)); err == nil {
-		return tv[1:], nil
+		return nil
 	}
 
 	//w/o millisecs
 	if f.Value, err = time.Parse(utcTimestampNoMillisFormat, string(bytes)); err != nil {
-		return tv, err
+		return err
 	}
 
-	return tv[1:], nil
+	return nil
 }
 
 func (f FIXUTCTimestamp) Write() []byte {
@@ -38,7 +37,3 @@ func (f FIXUTCTimestamp) Write() []byte {
 
 	return []byte(f.Value.UTC().Format(utcTimestampFormat))
 }
-
-func (f FIXUTCTimestamp) Clone() FieldValue {
-	return &FIXUTCTimestamp{f.Value, f.NoMillis}
-}

parser.go

@@ -114,7 +114,7 @@ func (p *parser) ReadMessage() ([]byte, error) {
 		return []byte{}, err
 	}
 
-	msgBytes := p.buffer[:index]
+	msgBytes := p.buffer[:index:index]
 	p.buffer = p.buffer[index:]
 
 	return msgBytes, nil

parser_test.go

@@ -128,6 +128,10 @@ func TestParser_ReadMessage(t *testing.T) {
 			t.Errorf("Expected %v got %v", tc.expectedBytes, string(msg))
 		}
 
+		if len(tc.expectedBytes) != cap(msg) {
+			t.Errorf("Expected capacity %v got %v", len(tc.expectedBytes), cap(msg))
+		}
+
 		if cap(parser.buffer) != tc.expectedBufferCap {
 			t.Errorf("Expected capacity %v got %v", tc.expectedBufferCap, cap(parser.buffer))
 		}

repeating_group.go

@@ -7,19 +7,49 @@ import (
 	"strconv"
 )
 
-type RepeatingGroupField struct {
-	Tag
-	FieldValue
+//GroupItem interface is used to construct repeating group templates
+type GroupItem interface {
+	//Tag returns the tag identifying this GroupItem
+	Tag() Tag
+
+	//Parameter to Read is TagValues.  For most fields, only the first TagValue will be required.
+	//The length of the slice extends from the TagValue mapped to the field to be read through the
+	//following fields. This can be useful for GroupItems made up of repeating groups.
+	//
+	//The Read function returns the remaining TagValues not processed by the GroupItem. If there was a
+	//problem reading the field, an error may be returned
+	Read(TagValues) (TagValues, error)
 }
 
-type GroupTemplate []RepeatingGroupField
+type protoGroupElement struct {
+	tagMethod func() Tag
+}
+
+func (t protoGroupElement) Tag() Tag { return t.tagMethod() }
+func (t protoGroupElement) Read(tv TagValues) (TagValues, error) {
+	if tv[0].Tag == t.tagMethod() {
+		return tv[1:], nil
+	}
+
+	return tv, nil
+}
+
+//GroupElement returns a GroupItem made up of a single field
+func GroupElement(tag Tag) GroupItem {
+	t := struct{ protoGroupElement }{}
+	t.tagMethod = func() Tag { return tag }
+	return t
+}
+
+type GroupTemplate []GroupItem
 type Group struct{ FieldMap }
 
 type RepeatingGroup struct {
 	GroupTemplate
 	Groups []Group
 }
 
+//Add appends a new group to the RepeatingGroup and returns the new Group
 func (f *RepeatingGroup) Add() Group {
 	var g Group
 	g.init(f.groupTagOrder())
@@ -41,12 +71,11 @@ func (f RepeatingGroup) Write() []byte {
 	return bytes[:len(bytes)-1]
 }
 
-func (f RepeatingGroup) findFieldInGroupTemplate(t Tag) (field RepeatingGroupField, ok bool) {
+func (f RepeatingGroup) findItemInGroupTemplate(t Tag) (item GroupItem, ok bool) {
 	for _, templateField := range f.GroupTemplate {
-		if t == templateField.Tag {
+		if t == templateField.Tag() {
 			ok = true
-			field.Tag = templateField.Tag
-			field.FieldValue = templateField.Clone()
+			item = templateField
 			break
 		}
 	}
@@ -57,7 +86,7 @@ func (f RepeatingGroup) findFieldInGroupTemplate(t Tag) (field RepeatingGroupFie
 func (f RepeatingGroup) groupTagOrder() tagOrder {
 	tagMap := make(map[Tag]int)
 	for i, f := range f.GroupTemplate {
-		tagMap[f.Tag] = i
+		tagMap[f.Tag()] = i
 	}
 
 	return func(i, j Tag) bool {
@@ -77,7 +106,7 @@ func (f RepeatingGroup) groupTagOrder() tagOrder {
 }
 
 func (f RepeatingGroup) isDelimiter(t Tag) bool {
-	return t == f.GroupTemplate[0].Tag
+	return t == f.GroupTemplate[0].Tag()
 }
 
 func (f *RepeatingGroup) Read(tv TagValues) (TagValues, error) {
@@ -96,43 +125,28 @@ func (f *RepeatingGroup) Read(tv TagValues) (TagValues, error) {
 	var group Group
 	group.init(tagOrdering)
 	for len(tv) > 0 {
-		field, ok := f.findFieldInGroupTemplate(tv[0].Tag)
+		field, ok := f.findItemInGroupTemplate(tv[0].Tag)
 		if !ok {
 			break
 		}
 
+		tvRange := tv
 		if tv, err = field.Read(tv); err != nil {
 			return tv, err
 		}
 
-		if f.isDelimiter(field.Tag) {
+		if f.isDelimiter(field.Tag()) {
 			group = Group{}
 			group.init(tagOrdering)
 
 			f.Groups = append(f.Groups, group)
 		}
 
-		group.SetField(field.Tag, field)
+		group.tagLookup[tvRange[0].Tag] = tvRange
 	}
 
 	if len(f.Groups) != expectedGroupSize {
 		return tv, fmt.Errorf("Only found %v instead of %v expected groups, is template wrong?", len(f.Groups), expectedGroupSize)
 	}
 	return tv, err
 }
-
-func (f RepeatingGroup) Clone() FieldValue {
-	var clone RepeatingGroup
-	clone.GroupTemplate = make(GroupTemplate, len(f.GroupTemplate))
-	clone.Groups = make([]Group, len(f.Groups))
-
-	for i, field := range f.GroupTemplate {
-		clone.GroupTemplate[i] = RepeatingGroupField{field.Tag, field.FieldValue.Clone()}
-	}
-
-	for i, group := range f.Groups {
-		clone.Groups[i].init(group.tagOrder)
-	}
-
-	return &clone
-}