Merge pull request #93 from cbusbey/gen_cleanup

cbusbey · cbusbey · commit b44654039871 · 2016-04-18T13:15:52.000-05:00
refactoring data dictionary pkg
diff --git a/datadictionary/build.go b/datadictionary/build.go
@@ -68,7 +68,7 @@ func (b builder) buildComponentType(xmlComponent *XMLComponent) (*ComponentType,
 	var parts []MessagePart
 
 	for _, member := range xmlComponent.Members {
-		if member.XMLName.Local == "component" {
+		if member.isComponent() {
 			var childComponentType *ComponentType
 			var err error
 			if childComponentType, err = b.findOrBuildComponentType(member); err != nil {
@@ -77,7 +77,7 @@ func (b builder) buildComponentType(xmlComponent *XMLComponent) (*ComponentType,
 
 			childComponent := Component{
 				ComponentType: childComponentType,
-				required:      (member.Required == "Y"),
+				required:      member.isRequired(),
 			}
 
 			parts = append(parts, childComponent)
@@ -126,57 +126,34 @@ func (b builder) buildMessageDefs() error {
 }
 
 func (b builder) buildMessageDef(xmlMessage *XMLComponent) (*MessageDef, error) {
-	m := &MessageDef{Name: xmlMessage.Name, MsgType: xmlMessage.MsgType}
-	m.Fields = make(map[int]*FieldDef)
-	m.RequiredTags = make(TagSet)
-	m.Tags = make(TagSet)
-
+	var parts []MessagePart
 	for _, member := range xmlMessage.Members {
-		if member.XMLName.Local == "component" {
+		if member.isComponent() {
 			var ok bool
 			var comp *ComponentType
 			if comp, ok = b.dict.ComponentTypes[member.Name]; !ok {
 				return nil, newUnknownComponent(member.Name)
 			}
 
-			for _, f := range comp.Fields() {
-				m.Fields[f.Tag] = f
-			}
-
-			m.Parts = append(m.Parts, Component{ComponentType: comp, required: (member.Required == "Y")})
+			parts = append(parts, Component{ComponentType: comp, required: member.isRequired()})
 		} else {
 			var field *FieldDef
 			var err error
 			if field, err = b.buildFieldDef(member); err != nil {
 				return nil, err
 			}
-			m.Fields[field.Tag] = field
-			m.Parts = append(m.Parts, field)
-		}
-	}
-
-	for _, f := range m.Fields {
-		m.Tags.Add(f.Tag)
-		for _, t := range f.childTags() {
-			m.Tags.Add(t)
-		}
-
-		if f.Required() {
-			m.RequiredTags.Add(f.Tag)
-			for _, t := range f.requiredChildTags() {
-				m.RequiredTags.Add(t)
-			}
+			parts = append(parts, field)
 		}
 	}
 
-	return m, nil
+	return NewMessageDef(xmlMessage.Name, xmlMessage.MsgType, parts), nil
 }
 
 func (b builder) buildGroupFieldDef(xmlField *XMLComponentMember, groupFieldType *FieldType) (*FieldDef, error) {
 	var parts []MessagePart
 
 	for _, member := range xmlField.Members {
-		if member.XMLName.Local == "component" {
+		if member.isComponent() {
 			var err error
 			var compType *ComponentType
 			if compType, err = b.findOrBuildComponentType(member); err != nil {
@@ -185,7 +162,7 @@ func (b builder) buildGroupFieldDef(xmlField *XMLComponentMember, groupFieldType
 
 			comp := Component{
 				ComponentType: compType,
-				required:      (member.Required == "Y"),
+				required:      member.isRequired(),
 			}
 
 			parts = append(parts, comp)
@@ -199,7 +176,7 @@ func (b builder) buildGroupFieldDef(xmlField *XMLComponentMember, groupFieldType
 		}
 	}
 
-	return NewGroupFieldDef(groupFieldType, (xmlField.Required == "Y"), parts), nil
+	return NewGroupFieldDef(groupFieldType, xmlField.isRequired(), parts), nil
 }
 
 func (b builder) buildFieldDef(xmlField *XMLComponentMember) (*FieldDef, error) {
@@ -210,12 +187,12 @@ func (b builder) buildFieldDef(xmlField *XMLComponentMember) (*FieldDef, error)
 		return nil, newUnknownField(xmlField.Name)
 	}
 
-	if xmlField.XMLName.Local == "group" {
+	if xmlField.isGroup() {
 		f, err := b.buildGroupFieldDef(xmlField, fieldType)
 		return f, err
 	}
 
-	return NewFieldDef(fieldType, (xmlField.Required == "Y")), nil
+	return NewFieldDef(fieldType, xmlField.isRequired()), nil
 }
 
 func (b builder) buildFieldTypes() {
diff --git a/datadictionary/datadictionary.go b/datadictionary/datadictionary.go
@@ -106,8 +106,10 @@ type FieldDef struct {
 	*FieldType
 	required bool
 
-	Parts       []MessagePart
-	ChildFields []*FieldDef
+	Parts          []MessagePart
+	ChildFields    []*FieldDef
+	requiredParts  []MessagePart
+	requiredFields []*FieldDef
 }
 
 //NewFieldDef returns an initialized FieldDef
@@ -127,11 +129,23 @@ func NewGroupFieldDef(fieldType *FieldType, required bool, parts []MessagePart)
 	}
 
 	for _, part := range parts {
+		if part.Required() {
+			field.requiredParts = append(field.requiredParts, part)
+		}
+
 		if comp, ok := part.(Component); ok {
 			field.ChildFields = append(field.ChildFields, comp.Fields()...)
+
+			if comp.required {
+				field.requiredFields = append(field.requiredFields, comp.requiredFields...)
+			}
 		} else {
 			if child, ok := part.(*FieldDef); ok {
 				field.ChildFields = append(field.ChildFields, child)
+
+				if child.required {
+					field.requiredFields = append(field.requiredFields, child)
+				}
 			} else {
 				panic("unknown part")
 			}
@@ -150,6 +164,14 @@ func (f FieldDef) IsGroup() bool {
 	return len(f.ChildFields) > 0
 }
 
+//RequiredParts returns those parts that are required for this FieldDef. IsGroup
+//must return true
+func (f FieldDef) RequiredParts() []MessagePart { return f.requiredParts }
+
+//RequiredFields returns those fields that are required for this FieldDef. IsGroup
+//must return true
+func (f FieldDef) RequiredFields() []*FieldDef { return f.requiredFields }
+
 func (f FieldDef) childTags() []int {
 	tags := make([]int, 0, len(f.ChildFields))
 
@@ -219,6 +241,46 @@ type MessageDef struct {
 	Tags         TagSet
 }
 
+//NewMessageDef returns a pointer to an initialized MessageDef
+func NewMessageDef(name, msgType string, parts []MessagePart) *MessageDef {
+	msg := MessageDef{
+		Name:         name,
+		MsgType:      msgType,
+		Fields:       make(map[int]*FieldDef),
+		RequiredTags: make(TagSet),
+		Tags:         make(TagSet),
+		Parts:        parts,
+	}
+
+	for _, part := range parts {
+		if comp, ok := part.(Component); ok {
+			for _, f := range comp.Fields() {
+				msg.Fields[f.Tag] = f
+			}
+		} else if field, ok := part.(*FieldDef); ok {
+			msg.Fields[field.Tag] = field
+		} else {
+			panic("Unknown Part")
+		}
+	}
+
+	for _, f := range msg.Fields {
+		msg.Tags.Add(f.Tag)
+		for _, t := range f.childTags() {
+			msg.Tags.Add(t)
+		}
+
+		if f.Required() {
+			msg.RequiredTags.Add(f.Tag)
+			for _, t := range f.requiredChildTags() {
+				msg.RequiredTags.Add(t)
+			}
+		}
+	}
+
+	return &msg
+}
+
 //Parse loads and and build a datadictionary instance from an xml file.
 func Parse(path string) (*DataDictionary, error) {
 	var xmlFile *os.File
diff --git a/datadictionary/xml.go b/datadictionary/xml.go
@@ -49,3 +49,15 @@ type XMLComponentMember struct {
 
 	Members []*XMLComponentMember `xml:",any"`
 }
+
+func (member XMLComponentMember) isComponent() bool {
+	return member.XMLName.Local == "component"
+}
+
+func (member XMLComponentMember) isGroup() bool {
+	return member.XMLName.Local == "group"
+}
+
+func (member XMLComponentMember) isRequired() bool {
+	return member.Required == "Y"
+}
diff --git a/datadictionary/xml_test.go b/datadictionary/xml_test.go
@@ -126,17 +126,17 @@ func TestComponentMembers(t *testing.T) {
 		Value        *XMLComponentMember
 		XMLNameLocal string
 		Name         string
-		Required     string
+		Required     bool
 	}{
-		{doc.Header.Members[0], "field", "BeginString", "Y"},
-		{doc.Header.Members[1], "group", "NoHops", "N"},
-		{doc.Header.Members[1].Members[0], "field", "HopCompID", "N"},
-		{doc.Trailer.Members[0], "field", "SignatureLength", "N"},
-		{doc.Messages[0].Members[0], "field", "TestReqID", "N"},
-		{doc.Messages[1].Members[3], "component", "Instrument", "Y"},
-		{doc.Messages[1].Members[4], "group", "NoRoutingIDs", "N"},
-		{doc.Messages[1].Members[4].Members[0], "field", "RoutingType", "N"},
-		{doc.Messages[1].Members[4].Members[1], "field", "RoutingID", "N"},
+		{doc.Header.Members[0], "field", "BeginString", true},
+		{doc.Header.Members[1], "group", "NoHops", false},
+		{doc.Header.Members[1].Members[0], "field", "HopCompID", false},
+		{doc.Trailer.Members[0], "field", "SignatureLength", false},
+		{doc.Messages[0].Members[0], "field", "TestReqID", false},
+		{doc.Messages[1].Members[3], "component", "Instrument", true},
+		{doc.Messages[1].Members[4], "group", "NoRoutingIDs", false},
+		{doc.Messages[1].Members[4].Members[0], "field", "RoutingType", false},
+		{doc.Messages[1].Members[4].Members[1], "field", "RoutingID", false},
 	}
 
 	for _, test := range tests {
@@ -148,8 +148,8 @@ func TestComponentMembers(t *testing.T) {
 			t.Errorf("%v: Expected Name %v got %v", test.Name, test.Name, test.Value.Name)
 		}
 
-		if test.Value.Required != test.Required {
-			t.Errorf("%v: Expected Required %v got %v", test.Name, test.Required, test.Value.Required)
+		if test.Value.isRequired() != test.Required {
+			t.Errorf("%v: Expected Required %v got %v", test.Name, test.Required, test.Value.isRequired())
 		}
 	}
 }
