safely interface reflect values

diff_bool.go

@@ -8,12 +8,12 @@ import "reflect"
 
 func (d *Differ) diffBool(path []string, a, b reflect.Value, parent interface{}) error {
 	if a.Kind() == reflect.Invalid {
-		d.cl.Add(CREATE, path, nil, b.Interface())
+		d.cl.Add(CREATE, path, nil, exportInterface(b))
 		return nil
 	}
 
 	if b.Kind() == reflect.Invalid {
-		d.cl.Add(DELETE, path, a.Interface(), nil)
+		d.cl.Add(DELETE, path, exportInterface(a), nil)
 		return nil
 	}
 
@@ -22,7 +22,7 @@ func (d *Differ) diffBool(path []string, a, b reflect.Value, parent interface{})
 	}
 
 	if a.Bool() != b.Bool() {
-		d.cl.Add(UPDATE, path, a.Interface(), b.Interface(), parent)
+		d.cl.Add(UPDATE, path, exportInterface(a), exportInterface(b), parent)
 	}
 
 	return nil

diff_float.go

@@ -10,12 +10,12 @@ import (
 
 func (d *Differ) diffFloat(path []string, a, b reflect.Value, parent interface{}) error {
 	if a.Kind() == reflect.Invalid {
-		d.cl.Add(CREATE, path, nil, b.Interface())
+		d.cl.Add(CREATE, path, nil, exportInterface(b))
 		return nil
 	}
 
 	if b.Kind() == reflect.Invalid {
-		d.cl.Add(DELETE, path, a.Interface(), nil)
+		d.cl.Add(DELETE, path, exportInterface(a), nil)
 		return nil
 	}
 
@@ -25,7 +25,7 @@ func (d *Differ) diffFloat(path []string, a, b reflect.Value, parent interface{}
 
 	if a.Float() != b.Float() {
 		if a.CanInterface() {
-			d.cl.Add(UPDATE, path, a.Interface(), b.Interface(), parent)
+			d.cl.Add(UPDATE, path, exportInterface(a), exportInterface(b), parent)
 		} else {
 			d.cl.Add(UPDATE, path, a.Float(), b.Float(), parent)
 		}

diff_int.go

@@ -10,12 +10,12 @@ import (
 
 func (d *Differ) diffInt(path []string, a, b reflect.Value, parent interface{}) error {
 	if a.Kind() == reflect.Invalid {
-		d.cl.Add(CREATE, path, nil, b.Interface())
+		d.cl.Add(CREATE, path, nil, exportInterface(b))
 		return nil
 	}
 
 	if b.Kind() == reflect.Invalid {
-		d.cl.Add(DELETE, path, a.Interface(), nil)
+		d.cl.Add(DELETE, path, exportInterface(a), nil)
 		return nil
 	}
 
@@ -25,7 +25,7 @@ func (d *Differ) diffInt(path []string, a, b reflect.Value, parent interface{})
 
 	if a.Int() != b.Int() {
 		if a.CanInterface() {
-			d.cl.Add(UPDATE, path, a.Interface(), b.Interface(), parent)
+			d.cl.Add(UPDATE, path, exportInterface(a), exportInterface(b), parent)
 		} else {
 			d.cl.Add(UPDATE, path, a.Int(), b.Int(), parent)
 		}

diff_slice.go

@@ -10,12 +10,12 @@ import (
 
 func (d *Differ) diffSlice(path []string, a, b reflect.Value) error {
 	if a.Kind() == reflect.Invalid {
-		d.cl.Add(CREATE, path, nil, b.Interface())
+		d.cl.Add(CREATE, path, nil, exportInterface(b))
 		return nil
 	}
 
 	if b.Kind() == reflect.Invalid {
-		d.cl.Add(DELETE, path, a.Interface(), nil)
+		d.cl.Add(DELETE, path, exportInterface(a), nil)
 		return nil
 	}
 
@@ -56,7 +56,7 @@ func (d *Differ) diffSliceGeneric(path []string, a, b reflect.Value) error {
 		return nil
 	}
 
-	return d.diffComparative(path, missing, a.Interface())
+	return d.diffComparative(path, missing, exportInterface(a))
 }
 
 func (d *Differ) diffSliceComparative(path []string, a, b reflect.Value) error {
@@ -82,7 +82,7 @@ func (d *Differ) diffSliceComparative(path []string, a, b reflect.Value) error {
 		}
 	}
 
-	return d.diffComparative(path, c, a.Interface())
+	return d.diffComparative(path, c, exportInterface(a))
 }
 
 // keeps track of elements that have already been matched, to stop duplicate matches from occurring
@@ -100,7 +100,7 @@ func (st *sliceTracker) has(s, v reflect.Value) bool {
 		}
 
 		x := s.Index(i)
-		if reflect.DeepEqual(x.Interface(), v.Interface()) {
+		if reflect.DeepEqual(exportInterface(x), exportInterface(v)) {
 			(*st)[i] = true
 			return true
 		}
@@ -124,7 +124,7 @@ func hasAtSameIndex(s, v reflect.Value, atIndex int) bool {
 	// check the element in the slice at atIndex to see if it matches Value, if it is a valid index into the slice
 	if atIndex < s.Len() {
 		x := s.Index(atIndex)
-		return reflect.DeepEqual(x.Interface(), v.Interface())
+		return reflect.DeepEqual(exportInterface(x), exportInterface(v))
 	}
 
 	return false

diff_string.go

@@ -8,12 +8,12 @@ import "reflect"
 
 func (d *Differ) diffString(path []string, a, b reflect.Value, parent interface{}) error {
 	if a.Kind() == reflect.Invalid {
-		d.cl.Add(CREATE, path, nil, b.Interface())
+		d.cl.Add(CREATE, path, nil, exportInterface(b))
 		return nil
 	}
 
 	if b.Kind() == reflect.Invalid {
-		d.cl.Add(DELETE, path, a.Interface(), nil)
+		d.cl.Add(DELETE, path, exportInterface(a), nil)
 		return nil
 	}
 
@@ -24,7 +24,7 @@ func (d *Differ) diffString(path []string, a, b reflect.Value, parent interface{
 	if a.String() != b.String() {
 		if a.CanInterface() {
 			// If a and/or b is of a type that is an alias for String, store that type in changelog
-			d.cl.Add(UPDATE, path, a.Interface(), b.Interface(), parent)
+			d.cl.Add(UPDATE, path, exportInterface(a), exportInterface(b), parent)
 		} else {
 			d.cl.Add(UPDATE, path, a.String(), b.String(), parent)
 		}

diff_struct.go

@@ -59,7 +59,7 @@ func (d *Differ) diffStruct(path []string, a, b reflect.Value) error {
 			continue
 		}
 
-		err := d.diff(fpath, af, bf, a.Interface())
+		err := d.diff(fpath, af, bf, exportInterface(a))
 		if err != nil {
 			return err
 		}
@@ -108,7 +108,7 @@ func (d *Differ) structValues(t string, path []string, a reflect.Value) error {
 			continue
 		}
 
-		err := nd.diff(fpath, xf, af, a.Interface())
+		err := nd.diff(fpath, xf, af, exportInterface(a))
 		if err != nil {
 			return err
 		}

diff_time.go

@@ -11,12 +11,12 @@ import (
 
 func (d *Differ) diffTime(path []string, a, b reflect.Value) error {
 	if a.Kind() == reflect.Invalid {
-		d.cl.Add(CREATE, path, nil, b.Interface())
+		d.cl.Add(CREATE, path, nil, exportInterface(b))
 		return nil
 	}
 
 	if b.Kind() == reflect.Invalid {
-		d.cl.Add(DELETE, path, a.Interface(), nil)
+		d.cl.Add(DELETE, path, exportInterface(a), nil)
 		return nil
 	}
 
@@ -25,11 +25,11 @@ func (d *Differ) diffTime(path []string, a, b reflect.Value) error {
 	}
 
 	// Marshal and unmarshal time type will lose accuracy. Using unix nano to compare time type.
-	au := a.Interface().(time.Time).UnixNano()
-	bu := b.Interface().(time.Time).UnixNano()
+	au := exportInterface(a).(time.Time).UnixNano()
+	bu := exportInterface(b).(time.Time).UnixNano()
 
 	if au != bu {
-		d.cl.Add(UPDATE, path, a.Interface(), b.Interface())
+		d.cl.Add(UPDATE, path, exportInterface(a), exportInterface(b))
 	}
 
 	return nil

diff_uint.go

@@ -10,12 +10,12 @@ import (
 
 func (d *Differ) diffUint(path []string, a, b reflect.Value, parent interface{}) error {
 	if a.Kind() == reflect.Invalid {
-		d.cl.Add(CREATE, path, nil, b.Interface())
+		d.cl.Add(CREATE, path, nil, exportInterface(b))
 		return nil
 	}
 
 	if b.Kind() == reflect.Invalid {
-		d.cl.Add(DELETE, path, a.Interface(), nil)
+		d.cl.Add(DELETE, path, exportInterface(a), nil)
 		return nil
 	}
 
@@ -25,7 +25,7 @@ func (d *Differ) diffUint(path []string, a, b reflect.Value, parent interface{})
 
 	if a.Uint() != b.Uint() {
 		if a.CanInterface() {
-			d.cl.Add(UPDATE, path, a.Interface(), b.Interface(), parent)
+			d.cl.Add(UPDATE, path, exportInterface(a), exportInterface(b), parent)
 		} else {
 			d.cl.Add(UPDATE, path, a.Uint(), b.Uint(), parent)
 		}