Merge pull request #127 from logic-building/Distinct-For-Struct

Auto generated code for struct includes new function - DistinctP, Dis…

Author: logic-building

README.md

@@ -172,13 +172,22 @@ Note:
    C. "Employee, Teacher" :  User defined data types
    
 Options on go:generate :
-    A. -sort: generate sorting functions for struct will override default behavior of generating sorting functions by each member of sturct of basic types 
+    A: -only: overrides default behavior of generating all the functions. But it always includes Map and Filter
+     //go:generate gofp -destination fp.go -pkg employee -type "Employee" -only "Distinct, DistinctPtr, DistinctP"
+     full-list-values-for-only: "Distinct, DistinctPtr, DistinctP, DistinctPPtr, DropLast, DropLastPtr, 
+                                 DropWhile, DropWhileErr, DropWhilePtr, DropWhilePtrErr, Every, EveryErr, EveryPtr, 
+                                 EveryPtrErr, FilterMap, FilterMapErr, FilterMapPtr, FilterMapPtrErr, 
+                                 Remove, RemoveErr, RemovePtr, RemovePtrErr, Reduce, ReduceErr, ReducePtr, ReducePtrErr, Rest, RestPtr, 
+                                 Reverse, ReversePtr, Some, SomeErr, SomePtr, SomePtrErr, Take, TakePtr,
+                                 TakeWhile, TakeWhileErr, TakeWhilePtr, TakeWhilePtrErr"
+                                 
+    B. -sort: generate sorting functions for struct will override default behavior of generating sorting functions by each member of sturct of basic types 
       //go:generate gofp -destination fp.go -pkg employee -type "Employee" -sort "Employee:Name, Employee:Salary"
       
-    B. -set: generate set functions-Union, Intersection, Difference, Set, Superset, Subset for struct will override default behavior of generating set functions by each member of struct of basic types
+    C. -set: generate set functions-Union, Intersection, Difference, Set, Superset, Subset for struct will override default behavior of generating set functions by each member of struct of basic types
       //go:generate gofp -destination fp.go -pkg employee -type "Employee" -set "Employee:Name:string"
       
-    C. -mapfun: To generate Merge & Zip functions for struct
+    D. -mapfun: To generate Merge & Zip functions for struct
       //go:generate gofp -destination fp.go -pkg employee -type "Employee" -mapfun "true"
       Caution: It will complain at runtime if struct contains slice or array 
 

gofp/gofp.go

@@ -256,45 +256,43 @@ func generateFPCode(pkg, dataTypes, imports string) (string, error) {
 		template = r.Replace(template)
 
 		if len(onlyList) > 0 {
-			if fp.ExistsStrIgnoreCase("Map", onlyList) {
-				template += template2.Map()
-				template = r.Replace(template)
-			}
+			// Always include these functions
 
-			if fp.ExistsStrIgnoreCase("MapPtr", onlyList) {
-				template += template2.MapPtr()
-				template = r.Replace(template)
-			}
+			template += template2.Map()
+			template = r.Replace(template)
 
-			if fp.ExistsStrIgnoreCase("MapPtrErr", onlyList) {
-				template += basic.MapPtrErr()
-				template = r2.Replace(template)
-			}
+			template += template2.MapPtr()
+			template = r.Replace(template)
 
-			if fp.ExistsStrIgnoreCase("MapErr", onlyList) {
-				template += basic.MapErr()
-				template = r2.Replace(template)
-			}
+			template += basic.MapPtrErr()
+			template = r2.Replace(template)
 
-			if fp.ExistsStrIgnoreCase("Filter", onlyList) {
-				template += template2.Filter()
-				template = r.Replace(template)
-			}
+			template += basic.MapErr()
+			template = r2.Replace(template)
 
-			if fp.ExistsStrIgnoreCase("FilterPtr", onlyList) {
-				template += template2.FilterPtr()
-				template = r.Replace(template)
-			}
+			template += template2.Pmap()
+			template = r.Replace(template)
 
-			if fp.ExistsStrIgnoreCase("FilterPtrErr", onlyList) {
-				template += basic.FilterPtrErr()
-				template = r2.Replace(template)
-			}
+			template += template2.PmapPtr()
+			template = r.Replace(template)
 
-			if fp.ExistsStrIgnoreCase("FilterErr", onlyList) {
-				template += basic.FilterErr()
-				template = r2.Replace(template)
-			}
+			template += basic.PMapPtrErr()
+			template = r2.Replace(template)
+
+			template += basic.PMapErr()
+			template = r2.Replace(template)
+
+			template += template2.Filter()
+			template = r.Replace(template)
+
+			template += template2.FilterPtr()
+			template = r.Replace(template)
+
+			template += basic.FilterPtrErr()
+			template = r2.Replace(template)
+
+			template += basic.FilterErr()
+			template = r2.Replace(template)
 
 			if fp.ExistsStrIgnoreCase("Remove", onlyList) {
 				template += template2.Remove()
@@ -396,26 +394,6 @@ func generateFPCode(pkg, dataTypes, imports string) (string, error) {
 				template = r2.Replace(template)
 			}
 
-			if fp.ExistsStrIgnoreCase("Pmap", onlyList) {
-				template += template2.Pmap()
-				template = r.Replace(template)
-			}
-
-			if fp.ExistsStrIgnoreCase("PmapPtr", onlyList) {
-				template += template2.PmapPtr()
-				template = r.Replace(template)
-			}
-
-			if fp.ExistsStrIgnoreCase("PMapPtrErr", onlyList) {
-				template += basic.PMapPtrErr()
-				template = r2.Replace(template)
-			}
-
-			if fp.ExistsStrIgnoreCase("PMapErr", onlyList) {
-				template += basic.PMapErr()
-				template = r2.Replace(template)
-			}
-
 			if fp.ExistsStrIgnoreCase("FilterMap", onlyList) {
 				template += template2.FilterMap()
 				template = r.Replace(template)
@@ -481,11 +459,41 @@ func generateFPCode(pkg, dataTypes, imports string) (string, error) {
 				template = r2.Replace(template)
 			}
 
+			if fp.ExistsStrIgnoreCase("ReversePtr", onlyList) {
+				template += basic.ReversePtr()
+				template = r2.Replace(template)
+			}
+
 			if fp.ExistsStrIgnoreCase("Take", onlyList) {
 				template += basic.Take()
 				template = r2.Replace(template)
 			}
 
+			if fp.ExistsStrIgnoreCase("TakePtr", onlyList) {
+				template += basic.TakePtr()
+				template = r2.Replace(template)
+			}
+
+			if fp.ExistsStrIgnoreCase("DistinctP", onlyList) {
+				template += basic.DistinctP()
+				template = r2.Replace(template)
+			}
+
+			if fp.ExistsStrIgnoreCase("DistinctPPtr", onlyList) {
+				template += basic.DistinctPPtr()
+				template = r2.Replace(template)
+			}
+
+			if fp.ExistsStrIgnoreCase("Distinct", onlyList) {
+				template += basic.Distinct()
+				template = r2.Replace(template)
+			}
+
+			if fp.ExistsStrIgnoreCase("DistinctPtr", onlyList) {
+				template += basic.DistinctPtr()
+				template = r2.Replace(template)
+			}
+
 		} else {
 			template += template2.Map()
 			template = r.Replace(template)
@@ -622,8 +630,26 @@ func generateFPCode(pkg, dataTypes, imports string) (string, error) {
 			template += basic.Reverse()
 			template = r2.Replace(template)
 
+			template += basic.ReversePtr()
+			template = r2.Replace(template)
+
 			template += basic.Take()
 			template = r2.Replace(template)
+
+			template += basic.TakePtr()
+			template = r2.Replace(template)
+
+			template += basic.DistinctP()
+			template = r2.Replace(template)
+
+			template += basic.DistinctPPtr()
+			template = r2.Replace(template)
+
+			template += basic.Distinct()
+			template = r2.Replace(template)
+
+			template += basic.DistinctPtr()
+			template = r2.Replace(template)
 		}
 
 	}