properties.Map now keeps the insertion ordering

Author: cmaglie

objects.go

@@ -36,24 +36,24 @@ import (
 // GetBoolean returns true if the map contains the specified key and the value
 // equals to the string "true", in any other case returns false.
 func (m Map) GetBoolean(key string) bool {
-	value, ok := m[key]
+	value, ok := m.GetOk(key)
 	return ok && value == "true"
 }
 
 // SetBoolean sets the specified key to the string "true" or "false" if the value
 // is respectively true or false.
 func (m Map) SetBoolean(key string, value bool) {
 	if value {
-		m[key] = "true"
+		m.Set(key, "true")
 	} else {
-		m[key] = "false"
+		m.Set(key, "false")
 	}
 }
 
 // GetPath returns a paths.Path object using the map value as path. The function
 // returns nil if the key is not present.
 func (m Map) GetPath(key string) *paths.Path {
-	value, ok := m[key]
+	value, ok := m.GetOk(key)
 	if !ok {
 		return nil
 	}
@@ -63,8 +63,8 @@ func (m Map) GetPath(key string) *paths.Path {
 // SetPath saves the paths.Path object in the map using the path as value of the map
 func (m Map) SetPath(key string, value *paths.Path) {
 	if value == nil {
-		m[key] = ""
+		m.Set(key, "")
 	} else {
-		m[key] = value.String()
+		m.Set(key, value.String())
 	}
 }

properties.go

@@ -56,6 +56,9 @@ syntax, for example:
 
 This library has methods to parse this kind of files into a Map object.
 
+The Map internally keeps the insertion order so it can be retrieved later when
+cycling through the key sets.
+
 The Map object has many helper methods to accomplish some common operation
 on this kind of data like cloning, merging, comparing and also extracting
 a submap or generating a map-of-submaps from the first "level" of the hierarchy.
@@ -72,14 +75,16 @@ import (
 	"reflect"
 	"regexp"
 	"runtime"
-	"sort"
 	"strings"
 
 	"github.com/arduino/go-paths-helper"
 )
 
 // Map is a container of properties
-type Map map[string]string
+type Map struct {
+	kv map[string]string
+	o  []string
+}
 
 var osSuffix string
 
@@ -94,8 +99,16 @@ func init() {
 	}
 }
 
+// New returns a new Map
+func New() *Map {
+	return &Map{
+		kv: map[string]string{},
+		o:  []string{},
+	}
+}
+
 // Load reads a properties file and makes a Map out of it.
-func Load(filepath string) (Map, error) {
+func Load(filepath string) (*Map, error) {
 	bytes, err := ioutil.ReadFile(filepath)
 	if err != nil {
 		return nil, fmt.Errorf("Error reading file: %s", err)
@@ -105,7 +118,7 @@ func Load(filepath string) (Map, error) {
 	text = strings.Replace(text, "\r\n", "\n", -1)
 	text = strings.Replace(text, "\r", "\n", -1)
 
-	properties := make(Map)
+	properties := New()
 
 	for lineNum, line := range strings.Split(text, "\n") {
 		if err := properties.parseLine(line); err != nil {
@@ -117,14 +130,14 @@ func Load(filepath string) (Map, error) {
 }
 
 // LoadFromPath reads a properties file and makes a Map out of it.
-func LoadFromPath(path *paths.Path) (Map, error) {
+func LoadFromPath(path *paths.Path) (*Map, error) {
 	return Load(path.String())
 }
 
 // LoadFromSlice reads a properties file from an array of string
 // and makes a Map out of it
-func LoadFromSlice(lines []string) (Map, error) {
-	properties := make(Map)
+func LoadFromSlice(lines []string) (*Map, error) {
+	properties := New()
 
 	for lineNum, line := range lines {
 		if err := properties.parseLine(line); err != nil {
@@ -135,7 +148,7 @@ func LoadFromSlice(lines []string) (Map, error) {
 	return properties, nil
 }
 
-func (m Map) parseLine(line string) error {
+func (m *Map) parseLine(line string) error {
 	line = strings.TrimSpace(line)
 
 	// Skip empty lines or comments
@@ -151,23 +164,23 @@ func (m Map) parseLine(line string) error {
 	value := strings.TrimSpace(lineParts[1])
 
 	key = strings.Replace(key, "."+osSuffix, "", 1)
-	m[key] = value
+	m.Set(key, value)
 
 	return nil
 }
 
 // SafeLoadFromPath is like LoadFromPath, except that it returns an empty Map if
 // the specified file doesn't exists
-func SafeLoadFromPath(path *paths.Path) (Map, error) {
+func SafeLoadFromPath(path *paths.Path) (*Map, error) {
 	return SafeLoad(path.String())
 }
 
 // SafeLoad is like Load, except that it returns an empty Map if the specified
 // file doesn't exists
-func SafeLoad(filepath string) (Map, error) {
+func SafeLoad(filepath string) (*Map, error) {
 	_, err := os.Stat(filepath)
 	if os.IsNotExist(err) {
-		return make(Map), nil
+		return New(), nil
 	}
 
 	properties, err := Load(filepath)
@@ -177,6 +190,49 @@ func SafeLoad(filepath string) (Map, error) {
 	return properties, nil
 }
 
+// Get retrieve the value corresponding to key
+func (m *Map) Get(key string) string {
+	return m.kv[key]
+}
+
+// GetOk retrieve the value corresponding to key and return a true/false indicator
+// to check if the key is present in the map (true if the key is present)
+func (m *Map) GetOk(key string) (string, bool) {
+	v, ok := m.kv[key]
+	return v, ok
+}
+
+// ContainsKey returns true
+func (m *Map) ContainsKey(key string) bool {
+	_, has := m.kv[key]
+	return has
+}
+
+// Set inserts or replaces an existing key-value pair in the map
+func (m *Map) Set(key, value string) {
+	if _, has := m.kv[key]; has {
+		m.Remove(key)
+	}
+	m.kv[key] = value
+	m.o = append(m.o, key)
+}
+
+// Size return the number of elements in the map
+func (m *Map) Size() int {
+	return len(m.kv)
+}
+
+// Remove removes the key from the map
+func (m *Map) Remove(key string) {
+	delete(m.kv, key)
+	for i, k := range m.o {
+		if k == key {
+			m.o = append(m.o[:i], m.o[i+1:]...)
+			return
+		}
+	}
+}
+
 // FirstLevelOf generates a map-of-Maps using the first level of the hierarchy
 // of the current Map. For example the following Map:
 //
@@ -209,17 +265,18 @@ func SafeLoad(filepath string) (Map, error) {
 //      "bootloader.low_fuses": "0xFF",
 //    }
 //  }
-func (m Map) FirstLevelOf() map[string]Map {
-	newMap := make(map[string]Map)
-	for key, value := range m {
+func (m *Map) FirstLevelOf() map[string]*Map {
+	newMap := make(map[string]*Map)
+	for _, key := range m.o {
 		if strings.Index(key, ".") == -1 {
 			continue
 		}
 		keyParts := strings.SplitN(key, ".", 2)
 		if newMap[keyParts[0]] == nil {
-			newMap[keyParts[0]] = make(Map)
+			newMap[keyParts[0]] = New()
 		}
-		newMap[keyParts[0]][keyParts[1]] = value
+		value := m.kv[key]
+		newMap[keyParts[0]].Set(keyParts[1], value)
 	}
 	return newMap
 }
@@ -248,14 +305,15 @@ func (m Map) FirstLevelOf() map[string]Map {
 //    "upload.protocol": "arduino",
 //    "upload.maximum_size": "32256",
 //  },
-func (m Map) SubTree(rootKey string) Map {
+func (m *Map) SubTree(rootKey string) *Map {
 	rootKey += "."
-	newMap := Map{}
-	for key, value := range m {
+	newMap := New()
+	for _, key := range m.o {
 		if !strings.HasPrefix(key, rootKey) {
 			continue
 		}
-		newMap[key[len(rootKey):]] = value
+		value := m.kv[key]
+		newMap.Set(key[len(rootKey):], value)
 	}
 	return newMap
 }
@@ -268,10 +326,10 @@ func (m Map) SubTree(rootKey string) Map {
 // Each marker is replaced by the corresponding value of the Map.
 // The values in the Map may contains other markers, they are evaluated
 // recursively up to 10 times.
-func (m Map) ExpandPropsInString(str string) string {
+func (m *Map) ExpandPropsInString(str string) string {
 	for i := 0; i < 10; i++ {
 		newStr := str
-		for key, value := range m {
+		for key, value := range m.kv {
 			newStr = strings.Replace(newStr, "{"+key+"}", value, -1)
 		}
 		if str == newStr {
@@ -284,54 +342,49 @@ func (m Map) ExpandPropsInString(str string) string {
 
 // Merge merges a Map into this one. Each key/value of the merged Maps replaces
 // the key/value present in the original Map.
-func (m Map) Merge(sources ...Map) Map {
+func (m *Map) Merge(sources ...*Map) *Map {
 	for _, source := range sources {
-		for key, value := range source {
-			m[key] = value
+		for _, key := range source.o {
+			value := source.kv[key]
+			m.Set(key, value)
 		}
 	}
 	return m
 }
 
 // Keys returns an array of the keys contained in the Map
-func (m Map) Keys() []string {
-	keys := make([]string, len(m))
-	i := 0
-	for key := range m {
-		keys[i] = key
-		i++
-	}
+func (m *Map) Keys() []string {
+	keys := make([]string, len(m.o))
+	copy(keys, m.o)
 	return keys
 }
 
 // Values returns an array of the values contained in the Map. Duplicated
 // values are repeated in the list accordingly.
 func (m Map) Values() []string {
-	values := make([]string, len(m))
-	i := 0
-	for _, value := range m {
-		values[i] = value
-		i++
+	values := make([]string, len(m.o))
+	for i, key := range m.o {
+		values[i] = m.kv[key]
 	}
 	return values
 }
 
 // Clone makes a copy of the Map
-func (m Map) Clone() Map {
-	clone := make(Map)
+func (m *Map) Clone() *Map {
+	clone := New()
 	clone.Merge(m)
 	return clone
 }
 
 // Equals returns true if the current Map contains the same key/value pairs of
-// the Map passed as argument.
-func (m Map) Equals(other Map) bool {
+// the Map passed as argument with the same order of insertion.
+func (m *Map) Equals(other *Map) bool {
 	return reflect.DeepEqual(m, other)
 }
 
 // MergeMapsOfProperties merge the map-of-Maps (obtained from the method FirstLevelOf()) into the
 // target map-of-Maps.
-func MergeMapsOfProperties(target map[string]Map, sources ...map[string]Map) map[string]Map {
+func MergeMapsOfProperties(target map[string]*Map, sources ...map[string]*Map) map[string]*Map {
 	for _, source := range sources {
 		for key, value := range source {
 			target[key] = value
@@ -348,15 +401,10 @@ func DeleteUnexpandedPropsFromString(str string) string {
 }
 
 // Dump returns a representation of the map in golang source format
-func (m Map) Dump() string {
+func (m *Map) Dump() string {
 	res := "properties.Map{\n"
-	keys := []string{}
-	for k := range m {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, k := range keys {
-		res += fmt.Sprintf("  \"%s\": \"%s\",\n", strings.Replace(k, `"`, `\"`, -1), strings.Replace(m[k], `"`, `\"`, -1))
+	for _, k := range m.o {
+		res += fmt.Sprintf("  \"%s\": \"%s\",\n", strings.Replace(k, `"`, `\"`, -1), strings.Replace(m.Get(k), `"`, `\"`, -1))
 	}
 	res += "}"
 	return res