Merge pull request #18 from saedx1/master

Change to storing fields into slices for retrieval consistency

Author: Ompluscator

builder.go

@@ -83,12 +83,13 @@ type (
 	}
 
 	builderImpl struct {
-		fields map[string]*fieldConfigImpl
+		fields []*fieldConfigImpl
 	}
 
 	fieldConfigImpl struct {
-		typ interface{}
-		tag string
+		name string
+		typ  interface{}
+		tag  string
 	}
 
 	dynamicStructImpl struct {
@@ -103,7 +104,7 @@ type (
 //
 func NewStruct() Builder {
 	return &builderImpl{
-		fields: map[string]*fieldConfigImpl{},
+		fields: []*fieldConfigImpl{},
 	}
 }
 
@@ -139,38 +140,49 @@ func MergeStructs(values ...interface{}) Builder {
 }
 
 func (b *builderImpl) AddField(name string, typ interface{}, tag string) Builder {
-	b.fields[name] = &fieldConfigImpl{
-		typ: typ,
-		tag: tag,
-	}
+	b.fields = append(b.fields, &fieldConfigImpl{
+		name: name,
+		typ:  typ,
+		tag:  tag,
+	})
 
 	return b
 }
 
 func (b *builderImpl) RemoveField(name string) Builder {
-	delete(b.fields, name)
-
+	for i := range b.fields {
+		if b.fields[i].name == name {
+			b.fields = append(b.fields[:i], b.fields[i+1:]...)
+			break
+		}
+	}
 	return b
 }
 
 func (b *builderImpl) HasField(name string) bool {
-	_, ok := b.fields[name]
-	return ok
+	for i := range b.fields {
+		if b.fields[i].name == name {
+			return true
+		}
+	}
+	return false
 }
 
 func (b *builderImpl) GetField(name string) FieldConfig {
-	if !b.HasField(name) {
-		return nil
+	for i := range b.fields {
+		if b.fields[i].name == name {
+			return b.fields[i]
+		}
 	}
-	return b.fields[name]
+	return nil
 }
 
 func (b *builderImpl) Build() DynamicStruct {
 	var structFields []reflect.StructField
 
-	for name, field := range b.fields {
+	for _, field := range b.fields {
 		structFields = append(structFields, reflect.StructField{
-			Name: name,
+			Name: field.name,
 			Type: reflect.TypeOf(field.typ),
 			Tag:  reflect.StructTag(field.tag),
 		})
@@ -191,14 +203,14 @@ func (f *fieldConfigImpl) SetTag(tag string) FieldConfig {
 	return f
 }
 
-func (ds *dynamicStructImpl) New() interface{}  {
+func (ds *dynamicStructImpl) New() interface{} {
 	return reflect.New(ds.definition).Interface()
 }
 
-func (ds *dynamicStructImpl) NewSliceOfStructs() interface{}  {
+func (ds *dynamicStructImpl) NewSliceOfStructs() interface{} {
 	return reflect.New(reflect.SliceOf(ds.definition)).Interface()
 }
 
-func (ds *dynamicStructImpl) NewMapOfStructs(key interface{}) interface{}  {
+func (ds *dynamicStructImpl) NewMapOfStructs(key interface{}) interface{} {
 	return reflect.New(reflect.MapOf(reflect.Indirect(reflect.ValueOf(key)).Type(), ds.definition)).Interface()
 }

builder_test.go

@@ -40,14 +40,15 @@ func TestExtendStruct(t *testing.T) {
 		t.Errorf(`TestExtendStruct - expected length of fields map to be 1 got %d`, len(builder.fields))
 	}
 
-	field, ok := builder.fields["Field"]
-	if !ok {
+	field := builder.GetField("Field")
+	if field == nil {
 		t.Error(`TestExtendStruct - expected to have field "Field"`)
 	}
 
 	expected := &fieldConfigImpl{
-		typ: 0,
-		tag: `key:"value"`,
+		name: "Field",
+		typ:  0,
+		tag:  `key:"value"`,
 	}
 
 	if !reflect.DeepEqual(field, expected) {
@@ -78,28 +79,30 @@ func TestMergeStructs(t *testing.T) {
 		t.Errorf(`TestMergeStructs - expected length of fields map to be 1 got %d`, len(builder.fields))
 	}
 
-	fieldOne, ok := builder.fields["FieldOne"]
-	if !ok {
+	fieldOne := builder.GetField("FieldOne")
+	if fieldOne == nil {
 		t.Error(`TestMergeStructs - expected to have field "FieldOne"`)
 	}
 
 	expectedOne := &fieldConfigImpl{
-		typ: 0,
-		tag: `keyOne:"valueOne"`,
+		name: "FieldOne",
+		typ:  0,
+		tag:  `keyOne:"valueOne"`,
 	}
 
 	if !reflect.DeepEqual(fieldOne, expectedOne) {
 		t.Errorf(`TestMergeStructs - expected field "FieldOne" to be %#v got %#v`, expectedOne, fieldOne)
 	}
 
-	fieldTwo, ok := builder.fields["FieldTwo"]
-	if !ok {
+	fieldTwo := builder.GetField("FieldTwo")
+	if fieldTwo == nil {
 		t.Error(`TestMergeStructs - expected to have field "FieldTwo"`)
 	}
 
 	expectedTwo := &fieldConfigImpl{
-		typ: "",
-		tag: `keyTwo:"valueTwo"`,
+		name: "FieldTwo",
+		typ:  "",
+		tag:  `keyTwo:"valueTwo"`,
 	}
 
 	if !reflect.DeepEqual(fieldTwo, expectedTwo) {
@@ -109,19 +112,20 @@ func TestMergeStructs(t *testing.T) {
 
 func TestBuilderImpl_AddField(t *testing.T) {
 	builder := &builderImpl{
-		fields: map[string]*fieldConfigImpl{},
+		fields: []*fieldConfigImpl{},
 	}
 
 	builder.AddField("Field", 1, `key:"value"`)
 
-	field, ok := builder.fields["Field"]
-	if !ok {
+	field := builder.GetField("Field")
+	if field == nil {
 		t.Error(`TestBuilder_AddField - expected to have field "Field"`)
 	}
 
 	expected := &fieldConfigImpl{
-		typ: 1,
-		tag: `key:"value"`,
+		name: "Field",
+		typ:  1,
+		tag:  `key:"value"`,
 	}
 
 	if !reflect.DeepEqual(field, expected) {
@@ -131,50 +135,53 @@ func TestBuilderImpl_AddField(t *testing.T) {
 
 func TestBuilderImpl_RemoveField(t *testing.T) {
 	builder := &builderImpl{
-		fields: map[string]*fieldConfigImpl{
-			"Field": {
-				tag: `key:"value"`,
-				typ: 1,
+		fields: []*fieldConfigImpl{
+			{
+				name: "Field",
+				tag:  `key:"value"`,
+				typ:  1,
 			},
 		},
 	}
 
 	builder.RemoveField("Field")
 
-	if _, ok := builder.fields["Field"]; ok {
+	if ok := builder.HasField("Field"); ok {
 		t.Error(`TestBuilder_RemoveField - expected not to have field "Field"`)
 	}
 }
 
 func TestBuilderImpl_HasField(t *testing.T) {
 	builder := &builderImpl{
-		fields: map[string]*fieldConfigImpl{},
+		fields: []*fieldConfigImpl{},
 	}
 
-	if builder.HasField("Field") {
+	if ok := builder.HasField("Field"); ok {
 		t.Error(`TestBuilder_HasField - expected not to have field "Field"`)
 	}
 
 	builder = &builderImpl{
-		fields: map[string]*fieldConfigImpl{
-			"Field": {
-				tag: `key:"value"`,
-				typ: 1,
+		fields: []*fieldConfigImpl{
+			{
+				name: "Field",
+				tag:  `key:"value"`,
+				typ:  1,
 			},
 		},
 	}
 
-	if !builder.HasField("Field") {
+	if ok := builder.HasField("Field"); !ok {
 		t.Error(`TestBuilder_HasField - expected to have field "Field"`)
 	}
 }
 
 func TestBuilderImpl_GetField(t *testing.T) {
 	builder := &builderImpl{
-		fields: map[string]*fieldConfigImpl{
-			"Field": {
-				tag: `key:"value"`,
-				typ: 1,
+		fields: []*fieldConfigImpl{
+			{
+				name: "Field",
+				tag:  `key:"value"`,
+				typ:  1,
 			},
 		},
 	}
@@ -187,8 +194,9 @@ func TestBuilderImpl_GetField(t *testing.T) {
 	}
 
 	expected := &fieldConfigImpl{
-		typ: 1,
-		tag: `key:"value"`,
+		name: "Field",
+		typ:  1,
+		tag:  `key:"value"`,
 	}
 
 	if !reflect.DeepEqual(field, expected) {