Merge branch 'master' of github.com:quickfixgo/quickfix

Author: mgatny

_gen/generate-messages/main.go

@@ -88,6 +88,12 @@ func genMessage(msg *datadictionary.MessageDef) string {
 	return fileOut
 }
 
+func genMessageNew(msg *datadictionary.MessageDef) string {
+	writer := new(bytes.Buffer)
+	gen.WriteNewMessage(writer, *msg)
+	return writer.String()
+}
+
 func genMessageSetters(msg *datadictionary.MessageDef) string {
 	writer := new(bytes.Buffer)
 	if err := gen.WriteFieldSetters(writer, "Message", msg.Parts); err != nil {
@@ -142,6 +148,7 @@ func genMessagePkg(msg *datadictionary.MessageDef) {
 	fileOut += writer.String()
 	fileOut += genGroupDeclarations(msg)
 	fileOut += genMessage(msg)
+	fileOut += genMessageNew(msg)
 	fileOut += genMessageSetters(msg)
 	fileOut += genMessageRoute(msg)
 

_gen/helpers.go

@@ -15,7 +15,7 @@ var genTemplate *template.Template
 
 func init() {
 	tmplFuncs := template.FuncMap{
-		"fixFieldTypeToGoType": FixFieldTypeToGoType,
+		"fixFieldTypeToGoType": fixFieldTypeToGoType,
 		"toLower":              strings.ToLower,
 		"partAsGoType":         partAsGoType,
 	}
@@ -33,19 +33,48 @@ import ({{ range .}}
 )
 		{{ end}}
 
-		{{/* template writes out a constructor for message/component/group */}}
-		{{define "new"}}
-func New(
-	{{- range $index, $field := .RequiredParts -}}
-{{if $index}},{{end}}{{toLower $field.Name}} {{partAsGoType $field}}
-	{{- end }}) *{{.Name}} {
+
+{{/* template writes out a constructor for component type */}}
+{{define "newcomponent"}}
+//New returns an initialized {{.Name}} instance
+func New({{ template "parts_args" .RequiredParts}}) *{{.Name}} {
 	var m {{.Name}}
-	{{- range .RequiredFields}}
-	m.Set{{.Name}}({{toLower .Name}})
-	{{- end}}
+	{{- template "set_parts" .RequiredParts}}
 	return &m
 }
-		{{end}}
+{{end}}
+
+{{/* template writes out a constructor for message type */}}
+{{define "newmessage"}}
+//New returns an initialized {{.Name}} instance
+func New({{ template "parts_args" .RequiredParts}}) *Message {
+	var m Message
+	{{- template "set_parts" .RequiredParts}}
+	return &m
+}
+{{end}}
+
+{{/* template writes out a constructor for group */}}
+{{define "newgroup"}}
+//New{{.Name}} returns an initialized {{.Name}} instance
+func New{{.Name}}({{ template "parts_args" .RequiredParts}}) *{{.Name}} {
+	var m {{.Name}}
+	{{- template "set_parts" .RequiredParts}}
+	return &m
+}
+{{end}}
+
+{{/* template writes out a comma delimited list of parts to be used as an argument list*/}}
+{{define "parts_args"}}
+{{- range $index, $field := . }}{{if $index}},{{end}}{{toLower $field.Name}} {{partAsGoType $field}}{{ end }}
+{{- end }}
+
+{{/* template sets  parts*/}}
+{{define "set_parts"}}
+{{- range .}}
+m.Set{{.Name}}({{toLower .Name}})
+{{- end}}
+{{- end}}
 
 {{define "fieldSetter"}}
 func (m *{{.Receiver}}) Set{{.Name}}(v {{ if .IsGroup}}[]{{.Name}}{{else}}{{fixFieldTypeToGoType .Type}}{{end}}) {
@@ -62,7 +91,11 @@ func (m *{{.Receiver}}) Set{{.Name}}(v {{toLower .Name}}.{{ .Name}}) {
 }
 
 func WriteNewComponent(writer io.Writer, comp datadictionary.ComponentType) error {
-	return genTemplate.ExecuteTemplate(writer, "new", comp)
+	return genTemplate.ExecuteTemplate(writer, "newcomponent", comp)
+}
+
+func WriteNewMessage(writer io.Writer, msg datadictionary.MessageDef) error {
+	return genTemplate.ExecuteTemplate(writer, "newmessage", msg)
 }
 
 //WriteFieldSetters generates setters appropriate for Messages, Components or Repeating Groups
@@ -148,7 +181,7 @@ func collectRequiredImports(imports map[string]interface{}, pkg string, part dat
 		panic("Expected FieldDef")
 	}
 
-	if fieldType := FixFieldTypeToGoType(field.Type); fieldType == "time.Time" {
+	if fieldType := fixFieldTypeToGoType(field.Type); fieldType == "time.Time" {
 		imports["time"] = nil
 	}
 
@@ -168,10 +201,13 @@ func WriteGroupDeclaration(fixSpecMajor, fixSpecMinor int, field *datadictionary
 	fileOut += fmt.Sprintf("//%v is a repeating group in %v\n", field.Name(), parent)
 	fileOut += fmt.Sprintf("type %v struct {\n", field.Name())
 	fileOut += WriteFieldDeclarations(fixSpecMajor, fixSpecMinor, field.Parts, field.Name())
-
 	fileOut += "}\n"
 
 	writer := new(bytes.Buffer)
+	if err := genTemplate.ExecuteTemplate(writer, "newgroup", *field); err != nil {
+		panic(err)
+	}
+
 	if err := WriteFieldSetters(writer, field.Name(), field.Parts); err != nil {
 		panic(err)
 	}
@@ -209,7 +245,7 @@ func writeFieldDeclaration(fixSpecMajor int, fixSpecMinor int, part datadictiona
 			return
 		}
 
-		goType := FixFieldTypeToGoType(field.Type)
+		goType := fixFieldTypeToGoType(field.Type)
 		fixTags := strconv.Itoa(field.Tag)
 		if field.Tag == 8 {
 			if fixSpecMajor == 4 {
@@ -242,10 +278,10 @@ func partAsGoType(part datadictionary.MessagePart) string {
 		return fmt.Sprintf("[]%v", field.Name())
 	}
 
-	return FixFieldTypeToGoType(field.Type)
+	return fixFieldTypeToGoType(field.Type)
 }
 
-func FixFieldTypeToGoType(fieldType string) string {
+func fixFieldTypeToGoType(fieldType string) string {
 	switch fieldType {
 	case "MULTIPLESTRINGVALUE", "MULTIPLEVALUESTRING":
 		fallthrough

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() {

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))
 
@@ -213,12 +235,60 @@ type MessageDef struct {
 	Fields  map[int]*FieldDef
 	//Parts are the MessageParts of contained in this MessageDef in declaration
 	//order
-	Parts []MessagePart
+	Parts         []MessagePart
+	requiredParts []MessagePart
 
 	RequiredTags TagSet
 	Tags         TagSet
 }
 
+//RequiredParts returns those parts that are required for this Message
+func (m MessageDef) RequiredParts() []MessagePart { return m.requiredParts }
+
+//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 part.Required() {
+			msg.requiredParts = append(msg.requiredParts, part)
+		}
+
+		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

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"
+}