rename dir

argv.go

@@ -18,7 +18,7 @@ type args struct {
 	Marshal   []string `arg:"--marshal"                 help:"what to marshal on"`
 	NoMarshal bool     `arg:"--no-marshal"              help:"do not make a marshal.pb.go file"`
 	NoSort    bool     `arg:"--no-sort"                 help:"do not make a sort.pb.go file"`
-	Mutex     bool     `arg:"--mutex"                   help:"try mutex hack (breaks proto.Marshal()"`
+	Mutex     bool     `arg:"--mutex"                   help:"try mutex hack (breaks proto.Marshal() ???)"`
 	DryRun    bool     `arg:"--dry-run"                 help:"show what would be run"`
 	GoSrc     string   `arg:"--go-src"                  help:"default is ~/go/src. could be set to your go.work path"`
 	GoPath    string   `arg:"--gopath"                  help:"the gopath of this repo"`

auto.proto

@@ -66,10 +66,11 @@ message MsgName {
         string   name	        = 1;    // the name of the message aka struct. for this example: "Shelf"
         string   lockname	= 2;    // ShelfMU
         bool     doMarshal      = 3;    // if "Shelf" should have Marshal & Unmarshal functions
-        bool     doMutex        = 4;    // an experiment to insert a mutex into the protoc generated msg struct (bad idea?)
+        bool     doMutex        = 4;    // true if a mutex is needed for the message struct
-        bool     mutexFound     = 5;    // an experiment to insert a mutex into the protoc generated msg struct (bad idea?)
+        bool     doProtocMutex  = 5;    // an experiment to insert a mutex into the protoc generated msg struct (bad idea?)
-        repeated string sort	= 6;    // "Book", "Picture", etc
+        bool     mutexFound     = 6;    // true if the mutex was added to the protoc pb.go file
-        repeated string unique	= 7;    // if the fields should have AppendUnique() functions
+        repeated string sort	= 7;    // "Book", "Picture", etc
+        repeated string unique	= 8;    // if the fields should have AppendUnique() functions
 }
 
 message File {                                  // `autogenpb:nomarshal`

example/Makefile

@@ -9,10 +9,12 @@ vet:
 	@echo this go binary package should build okay
 
 build:
+	rm -f fruit.newsort.pb.go
 	GO111MODULE=off go build
+	./testfiles
 
 auto:
-	../autogenpb --proto auto.proto --package main
+	../autogenpb --proto fruit.proto --package main
 
 goimports:
 	goimports -w *.go

example/auto.proto

@@ -23,12 +23,13 @@ message Apple {	       	        	// `autogenpb:marshal`
 message Apples {	        	// `autogenpb:marshal` `autogenpb:mutex`
 	string   uuid	        = 1;    // `autogenpb:default:b2a2de35-07b6-443b-8188-709e27bee8a7`
 	string   version        = 2;    // `autogenpb:default:2`
-        repeated Apple Apples   = 3;    // `autogenpb:sort`
+        repeated Apple apples   = 3;    // `autogenpb:sort` `autogenpb:unique`
-        repeated Pears  More    = 4;    // `autogenpb:sort`
+        repeated Pear  pears    = 4;    // `autogenpb:sort` `autogenpb:unique`
-        repeated string  Color  = 5;    // `autogenpb:sort` `autogenpb:unique`
+        repeated Pear  more     = 5;    // `autogenpb:sort` `autogenpb:unique` // not supported. 'More' can only be the string 'Pears'
+        repeated string  color  = 6;    // `autogenpb:sort` `autogenpb:unique`
 }
 
-message Pears {
+message Pear {
 	string   name	        = 1;    //
 	string   favorite       = 2;    // `autogenpb:sort`
 }
@@ -67,7 +68,14 @@ message MsgName {
         bool     marshal        = 2;    // if "Shelf" should have Marshal & Unmarshal functions
         bool     mutex          = 3;    // an experiment to insert a mutex into the protoc generated msg struct (bad idea?)
         repeated string sort	= 4;    // "Book", "Picture", etc
-        repeated string unique	= 5;    // if the fields should have AppendUnique() functions
+        repeated string aq	= 5;    // if the fields should have AppendUnique() functions
+        repeated string uniq    = 6;    // the non-repeating fields that should be unique
+}
+
+message Unique {
+        string   name	        = 1;    // the variable name of the repeatable struct that must be unique
+        string   msgName	= 2;    // the struct that is repeated
+        repeated string keys	= 3;    // the variables in that structure to check are unique
 }
 
 message File {                                  // `autogenpb:nomarshal`
@@ -87,7 +95,7 @@ message File {                                  // `autogenpb:nomarshal`
 // maybe this is already been done and is pointless, but it seems like a good idea
 message Files {                           // `autogenpb:marshal`
         string   uuid	          = 1;    // `autogenpb:uuid:fakeuuid`
-        int64    version          = 2;    // `autogenpb:id:42`
+        string   version          = 2;    // `autogenpb:id:42`
         repeated File Files       = 3;    // an array of each .proto file in the working directory
 }
 

example/fruit.New.go

@@ -0,0 +1,7 @@
+package main
+
+func NewFruits() *Fruits {
+	x := new(Fruits)
+	x.Uuid = "test"
+	return x
+}

example/fruit.proto

@@ -0,0 +1,46 @@
+syntax = "proto3";
+
+// this file is called "fruit.proto"
+//
+// for autogenpb to work, you must have:
+//
+// "Fruit" must exist. you can put anything in it
+//
+// and
+//
+// "Fruits"  MUST EXIST and start exactly this way
+// It must be "Fruit" + 's' and must match the name of this file: "fruit.proto"
+
+package fruit;
+
+import "google/protobuf/timestamp.proto"; // Import the well-known type for Timestamp
+
+message Apple {	       	        	        // `autogenpb:marshal`
+	string name                     = 1;    // `autogenpb:unique` // generates SortByxxx() and AppendUnique() functions
+	string genus                    = 2;    // `autogenpb:unique` // generates same thing here but SortByGenus()
+        google.protobuf.Timestamp ctime = 3;    // when the apple was born
+}
+
+message Pear {
+	string   name	        = 1;    //
+	string   favorite       = 2;    // `autogenpb:sort`
+}
+
+// "Fruit" must exist. you can put anything in it
+message Fruit {                         // `autogenpb:marshal`
+        string brand            = 1;    // `autogenpb:unique`
+        repeated Apple apples   = 2;
+        repeated Pear  pears    = 3;
+        string UPC              = 4;    // `autogenpb:sort` `autogenpb:unique`
+        string city             = 5;    // `autogenpb:sort`
+}
+
+// "Fruits"  MUST EXIST and start exactly this way
+// It must be "Fruit" + 's' and must match the name of this file: "fruit.proto"
+message Fruits {	        	// `autogenpb:marshal` `autogenpb:mutex`
+	string   uuid	        = 1;    // `autogenpb:uuid:be926ad9-f07f-484c-adf2-d96eeabf3079`
+	string   version        = 2;    // `autogenpb:version:v0.0.1`
+	repeated Fruit Fruits   = 3;    // THIS MUST BE "Fruit" and then "Fruit" + "s"
+        // you can add additional things here but the three lines above must conform to the standard above
+        int64    cost           = 4;
+}

example/main.go

@@ -13,10 +13,9 @@ var sortmap map[string]string
 var marshalKeys []string
 var uniqueKeys []string
 
-var pb *Files
+var pb *Fruits
 
 func main() {
-
+	pb = NewFruits()
-	pb = new(Files)
+	log.Info("did nothing yet", pb)
-	log.Info("did nothing yet")
 }

newsort.go

@@ -14,16 +14,19 @@ func (pb *Files) makeNewSortfile(pf *File) {
 
 	for _, msg := range pf.MsgNames {
 		if msg.DoMutex {
-			pf.syncLock(f, msg.Lockname)
+			msg.syncLock(f, msg.Lockname)
-			pf.iterTop(f, msg.Name)
+			for _, key := range msg.Sort {
+				pf.iterTop(f, key)
+				pf.iterNext(f, key)
+			}
 		} else {
 			log.Info("Skipping syncLock() for", msg.Name, "DoMutex = false")
 		}
+		pf.appendUnique(f, msg, sortmap) // Append() enforce no unique keys
 	}
 
-	iterNext(f, sortmap)
+	return
-	iterAppend(f, sortmap) // Append() enforce no unique keys
+	// iterSortAll(f, sortmap)
-	iterSortAll(f, sortmap)
 
 	if argv.Append != "" {
 		sortmap["append"] = string(argv.Append)

protoParse.go

@@ -120,16 +120,6 @@ func (pb *Files) protoParse(f *File) error {
 			// don't sort anything (don't make foo.sort.pb.go)
 			argv.NoSort = true
 		}
-		if strings.Contains(line, "autogenpb:mutex") {
-			// try the mutex hack
-			argv.Mutex = true
-		}
-		if strings.Contains(line, "autogenpb:gover:") {
-			// todo: parse the output here
-			parts := strings.Split(line, "autogenpb:gover:")
-			log.Info("found gover:", parts[1])
-			argv.Mutex = true
-		}
 	}
 	return nil
 }

sort.go

@@ -11,10 +11,10 @@ import (
 func (pb *Files) makeSortfile(pf *File) {
 	f, _ := os.OpenFile(pf.Filebase+".sort.pb.go", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
 
-	header(f, pf)
+	// header(f, pf)
 
-	pf.iterTop(f, sortmap["base"])
+	// pf.iterTop(f, sortmap["base"])
-	iterNext(f, sortmap)
+	// iterNext(f, sortmap)
 	iterAppend(f, sortmap) // Append() enforce no unique keys
 	iterSortAll(f, sortmap)
 
@@ -55,8 +55,8 @@ func (pb *Files) makeSortfile(pf *File) {
 	iterEnd(f, sortmap)
 }
 
-func (pf *File) syncLock(w io.Writer, lock string) {
+func (msg *MsgName) syncLock(w io.Writer, s string) {
-	var LOCK string = lock
+	var LOCK string = msg.Name
 
 	fmt.Fprintln(w, "// bad global lock until modifying the .pb.go file is tested")
 	fmt.Fprintln(w, "// sync.RWMutex or sync.Mutex?")
@@ -64,9 +64,7 @@ func (pf *File) syncLock(w io.Writer, lock string) {
 	fmt.Fprintln(w, "")
 }
 
-func (pf *File) iterTop(w io.Writer, base string) {
+func (pf *File) iterTop(w io.Writer, BASE string) {
-	var BASE string = base
-
 	fmt.Fprintln(w, "type "+BASE+"Iterator struct {")
 	fmt.Fprintln(w, "	sync.RWMutex")
 	fmt.Fprintln(w, "")
@@ -96,9 +94,9 @@ func (pf *File) iterTop(w io.Writer, base string) {
 	fmt.Fprintln(w, "")
 }
 
-func iterNext(w io.Writer, names map[string]string) {
+func (pf *File) iterNext(w io.Writer, BASE string) {
 	fmt.Fprintln(w, "// Next() returns the next thing in the array")
-	fmt.Fprintln(w, "func (it *"+names["Base"]+"Iterator) Next() *"+names["Base"]+" {")
+	fmt.Fprintln(w, "func (it *"+BASE+"Iterator) Next() *"+BASE+" {")
 	fmt.Fprintln(w, "	if it.things[it.index-1] == nil {")
 	fmt.Fprintln(w, "		for i, d := range it.things {")
 	fmt.Fprintln(w, "			fmt.Println(\"i =\", i, d)")
@@ -175,34 +173,32 @@ func iterEnd(w io.Writer, names map[string]string) {
 }
 
 func iterAppend(w io.Writer, names map[string]string) {
-	if names["append"] == "" {
-		fmt.Fprintln(w, "// does not enforce any unique fields")
-	} else {
-		fmt.Fprintln(w, "// enforces "+names["append"]+" is unique")
 }
-	if names["append"] == "" {
+
-		fmt.Fprintln(w, "func (all *"+names["Bases"]+") Append(newP *"+names["Base"]+") bool {")
+func (pf *File) appendUnique(w io.Writer, msg *MsgName, names map[string]string) {
+	var MSG string = msg.Name // msg.Name
+	var BASE string = names["Base"]
+	var LOCK string = names["lock"]
+	if argv.Mutex {
+		LOCK = "Lock"
 	} else {
-		// fmt.Fprintln(w, "func (all *"+names["Bases"]+") Append(newP *"+names["Base"]+") bool { // todo: make unique name here")
+		LOCK = names["lock"] + ".Lock"
-		fmt.Fprintln(w, "func (all *"+names["Bases"]+") AppendUnique"+names["append"]+"(newP *"+names["Base"]+") bool {")
-	}
-	if sortmap["lock"] == "all" {
-		fmt.Fprintln(w, "	"+names["lock"]+".Lock.RLock()")
-		fmt.Fprintln(w, "	defer "+names["lock"]+".Lock.RUnlock()")
-	} else {
-		fmt.Fprintln(w, "	"+names["lock"]+".RLock()")
-		fmt.Fprintln(w, "	defer "+names["lock"]+".RUnlock()")
 	}
+
+	fmt.Fprintln(w, "// enforces "+BASE+" is unique")
+	fmt.Fprintln(w, "func (all *"+MSG+") AppendUnique(newP *"+BASE+") bool {")
+	fmt.Fprintln(w, "	"+LOCK+".RLock()")
+	fmt.Fprintln(w, "	defer "+LOCK+".RUnlock()")
 	fmt.Fprintln(w, "")
-	if names["append"] != "" {
+	fmt.Fprintln(w, "	for _, p := range all."+MSG+" {")
-		fmt.Fprintln(w, "	for _, p := range all."+names["Bases"]+" {")
+	for _, KEY := range msg.Unique {
-		fmt.Fprintln(w, "		if p."+names["append"]+" == newP."+names["append"]+" {")
+		fmt.Fprintln(w, "		if p."+KEY+" == newP."+KEY+" {")
 		fmt.Fprintln(w, "			return false")
 		fmt.Fprintln(w, "		}")
+	}
 	fmt.Fprintln(w, "	}")
 	fmt.Fprintln(w, "")
-	}
+	fmt.Fprintln(w, "	all."+MSG+" = append(all."+MSG+", newP)")
-	fmt.Fprintln(w, "	all."+names["Bases"]+" = append(all."+names["Bases"]+", newP)")
 	fmt.Fprintln(w, "	return true")
 	fmt.Fprintln(w, "}")
 	fmt.Fprintln(w, "")