Added deduplicate

Author: leaanthony

README.md

@@ -185,6 +185,16 @@ Not supported by: InterfaceSlicer, BoolSlicer
 
 ```
   a := slicer.Int([]int{5,3,4,1,2})
-  a.Sour()
+  a.Sort()
   // a is []int{1,2,3,4,5}
 ```
+
+### Deduplicate
+
+Deduplicate removes all duplicates within a slice.
+
+```
+  a := slicer.Int([]int{5,3,5,1,3})
+  a.Deduplicate()
+  // a is []int{5,3,1}
+```

bool.go

@@ -99,4 +99,18 @@ func (s *BoolSlicer) Join(separator string) string {
 	builder.WriteString(fmt.Sprintf("%v", s.slice[index]))
 	result := builder.String()
 	return result
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *BoolSlicer) Deduplicate() {
+
+	result := Bool()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}

deduplicate_test.go

@@ -0,0 +1,173 @@
+package slicer
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+func TestStringDeduplicate(t *testing.T) {
+
+	s := String()
+	s.Add("one", "four", "two", "three", "two", "one")
+
+	s.Deduplicate()
+	expected := "one four two three"
+	actual := strings.Join(s.AsSlice(), " ")
+	if expected != actual {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestInt64Deduplicate(t *testing.T) {
+
+	s := Int64()
+	s.Add(1, 2, 3, 2, 3, 4, 3, 4, 5)
+
+	s.Deduplicate()
+	expected := "[1,2,3,4,5]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestInt32Deduplicate(t *testing.T) {
+
+	s := Int32()
+	s.Add(1, 2, 3, 2, 3, 4, 3, 4, 5)
+
+	s.Deduplicate()
+	expected := "[1,2,3,4,5]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestInt16Deduplicate(t *testing.T) {
+
+	s := Int16()
+	s.Add(1, 2, 3, 2, 3, 4, 3, 4, 5)
+
+	s.Deduplicate()
+	expected := "[1,2,3,4,5]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestInt8Deduplicate(t *testing.T) {
+
+	s := Int8()
+	s.Add(1, 2, 3, 2, 3, 4, 3, 4, 5)
+
+	s.Deduplicate()
+	expected := "[1,2,3,4,5]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestIntDeduplicate(t *testing.T) {
+
+	s := Int()
+	s.Add(1, 2, 3, 2, 3, 4, 3, 4, 5)
+
+	s.Deduplicate()
+	expected := "[1,2,3,4,5]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestInterfaceDeduplicate(t *testing.T) {
+
+	s := Interface()
+	var a interface{} = 1
+	var b interface{} = "hello"
+	s.Add(a, b, a, b)
+
+	s.Deduplicate()
+	expected := `[1,"hello"]`
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestFloat32Deduplicate(t *testing.T) {
+
+	s := Float32()
+	s.Add(1.5, 2.3, 3.9, 2.3, 3.9, 4.4, 3.9, 4.4, 5.2)
+
+	s.Deduplicate()
+	expected := "[1.5,2.3,3.9,4.4,5.2]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestFloat64Deduplicate(t *testing.T) {
+
+	s := Float64()
+	s.Add(1.5, 2.3, 3.9, 2.3, 3.9, 4.4, 3.9, 4.4, 5.2)
+
+	s.Deduplicate()
+	expected := "[1.5,2.3,3.9,4.4,5.2]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+func TestBoolDeduplicate(t *testing.T) {
+
+	s := Bool()
+	s.Add(true, true, true, false, true, false, false, false)
+
+	s.Deduplicate()
+	expected := "[true,false]"
+	actual, _ := json.Marshal(s.AsSlice())
+	if expected != string(actual) {
+		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+	}
+}
+
+// func TestStringAddSlice(t *testing.T) {
+
+// 	s := String()
+// 	s.Add("one")
+// 	s.Add("two")
+// 	extras := []string{"three", "four"}
+// 	s.AddSlice(extras)
+
+// 	expected := "one two three four"
+// 	actual := strings.Join(s.AsSlice(), " ")
+// 	if expected != actual {
+// 		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+// 	}
+// }
+
+// func TestStringAddSlicer(t *testing.T) {
+
+// 	s := String()
+// 	s.Add("one")
+// 	s.Add("two")
+
+// 	p := String()
+// 	p.Add("three")
+// 	p.Add("four")
+
+// 	s.AddSlicer(p)
+
+// 	expected := "one two three four"
+// 	actual := strings.Join(s.AsSlice(), " ")
+// 	if expected != actual {
+// 		t.Errorf("Expected '%s', but got '%s'", expected, actual)
+// 	}
+// }

float32.go

@@ -101,7 +101,22 @@ func (s *Float32Slicer) Join(separator string) string {
 	result := builder.String()
 	return result
 }
+
 // Sort the slice values
 func (s *Float32Slicer) Sort() {
 	sort.Slice(s.slice, func(i, j int) bool { return s.slice[i] < s.slice[j] })
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *Float32Slicer) Deduplicate() {
+
+	result := Float32()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}

float64.go

@@ -101,7 +101,22 @@ func (s *Float64Slicer) Join(separator string) string {
 	result := builder.String()
 	return result
 }
+
 // Sort the slice values
 func (s *Float64Slicer) Sort() {
 	sort.Slice(s.slice, func(i, j int) bool { return s.slice[i] < s.slice[j] })
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *Float64Slicer) Deduplicate() {
+
+	result := Float64()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}

int.go

@@ -101,7 +101,22 @@ func (s *IntSlicer) Join(separator string) string {
 	result := builder.String()
 	return result
 }
+
 // Sort the slice values
 func (s *IntSlicer) Sort() {
 	sort.Slice(s.slice, func(i, j int) bool { return s.slice[i] < s.slice[j] })
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *IntSlicer) Deduplicate() {
+
+	result := Int()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}

int16.go

@@ -101,7 +101,22 @@ func (s *Int16Slicer) Join(separator string) string {
 	result := builder.String()
 	return result
 }
+
 // Sort the slice values
 func (s *Int16Slicer) Sort() {
 	sort.Slice(s.slice, func(i, j int) bool { return s.slice[i] < s.slice[j] })
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *Int16Slicer) Deduplicate() {
+
+	result := Int16()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}

int32.go

@@ -101,7 +101,22 @@ func (s *Int32Slicer) Join(separator string) string {
 	result := builder.String()
 	return result
 }
+
 // Sort the slice values
 func (s *Int32Slicer) Sort() {
 	sort.Slice(s.slice, func(i, j int) bool { return s.slice[i] < s.slice[j] })
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *Int32Slicer) Deduplicate() {
+
+	result := Int32()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}

int64.go

@@ -101,7 +101,22 @@ func (s *Int64Slicer) Join(separator string) string {
 	result := builder.String()
 	return result
 }
+
 // Sort the slice values
 func (s *Int64Slicer) Sort() {
 	sort.Slice(s.slice, func(i, j int) bool { return s.slice[i] < s.slice[j] })
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *Int64Slicer) Deduplicate() {
+
+	result := Int64()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}

int8.go

@@ -101,7 +101,22 @@ func (s *Int8Slicer) Join(separator string) string {
 	result := builder.String()
 	return result
 }
+
 // Sort the slice values
 func (s *Int8Slicer) Sort() {
 	sort.Slice(s.slice, func(i, j int) bool { return s.slice[i] < s.slice[j] })
-}
+}
+
+// Deduplicate removes duplicate values from the slice
+func (s *Int8Slicer) Deduplicate() {
+
+	result := Int8()
+
+	for _, elem := range s.slice {
+		if !result.Contains(elem) {
+			result.Add(elem)
+		}
+	}
+
+	s.slice = result.AsSlice()
+}