Change to storing fields into slices for retreival consistency

Author: saedx1

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