Changed folders

_example/main.go

@@ -0,0 +1,59 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"log"
+
+	"dev.hexasoftware.com/x/seq"
+
+	"dev.hexasoftware.com/hxs/prettylog"
+)
+
+type Xpto struct {
+	ID string
+}
+
+func GenXpto(i int) (*Xpto, error) {
+	log.Println("Generating xpto")
+	return &Xpto{fmt.Sprintf("ID:%d", i)}, nil
+}
+
+func AnotherRandomFunc() error {
+	return errors.New("I have a error")
+}
+func NextXpto(id string) error {
+	log.Println("The id was:", id)
+	return nil
+}
+
+func main() {
+	prettylog.Global()
+	s := seq.New()
+
+	log.Println("Adding GenXPto")
+
+	val := &Xpto{}
+	s.Add(GenXpto, 10).Grab(&val)
+	s.Add(func() error { return NextXpto(val.ID) })
+	s.Add(func(p *Xpto) error { return NextXpto(p.ID) }, seq.SeqReturn(0, 0))
+	s.Add(NextXpto, seq.ExecParam(0))
+
+	s.Exec("abc")
+
+	s2 := seq.New()
+	s2.Add("Generate Xpto",
+		func(s *seq.Context) error {
+			xpto, err := GenXpto(10)
+			s.Set("xpto", xpto)
+			return err
+		})
+	s2.Add("Consume xpto",
+		func(s *seq.Context) error {
+			var v *Xpto = s.Get("xpto").(*Xpto)
+			return NextXpto(v.ID)
+		})
+
+	s2.Exec()
+
+}

context.go

@@ -0,0 +1,49 @@
+package seq
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type Context struct {
+	vars map[string]interface{}
+	ret  [][]interface{}
+
+	rep []string
+}
+
+func NewContext() *Context {
+	return &Context{
+		vars: map[string]interface{}{},
+		ret:  [][]interface{}{},
+		rep:  []string{},
+	}
+}
+
+func (sc *Context) Log(param ...interface{}) {
+	sc.rep = append(sc.rep, fmt.Sprint(param...))
+}
+func (sc *Context) LogRep() {
+	log.Println("Report:")
+	for _, r := range sc.rep {
+		log.Println(r)
+	}
+}
+
+// Context
+func (sc *Context) Set(name string, value interface{}) {
+	sc.vars[name] = value
+}
+func (sc *Context) Get(name string, valPtr ...interface{}) interface{} {
+	if len(valPtr) > 0 {
+		pv := reflect.ValueOf(valPtr[0])
+		pv.Elem().Set(reflect.ValueOf(sc.vars[name]))
+	}
+
+	return sc.vars[name]
+}
+
+//Ret return the value from previous returns
+func (sc *Context) Ret(n, i int) interface{} {
+	return sc.ret[n][i]
+}

main.go

@@ -1,45 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"hexasoftware/x/sequencer/seq"
-	"log"
-)
-
-type Xpto struct {
-	ID string
-}
-
-func GenXpto(i int) (*Xpto, error) {
-	log.Println("Generating xpto")
-	return &Xpto{fmt.Sprintf("ID:%d", i)}, nil
-}
-
-func AnotherRandomFunc() error {
-	return errors.New("I have a error")
-}
-func NextXpto(id string) error {
-	log.Println("The id was:", id)
-	return nil
-}
-
-func main() {
-
-	s := seq.New()
-
-	log.Println("Adding GenXPto")
-
-	val := &Xpto{}
-	s.Add("Generate Xpto", GenXpto, 10).Grab(&val)
-	s.Add("Consume xpto", func() error {
-		return NextXpto(val.ID)
-	})
-	s.Add(NextXpto, seq.EP(0))
-	err := s.Exec("abc")
-	log.Println("Val:", val)
-	if err != nil {
-		log.Println("Error on sequence", err)
-	}
-
-}

seq/sequencer.go

@@ -1,17 +1,19 @@
 package seq
 
 import (
-	"fmt"
-	"log"
 	"reflect"
+
+	"dev.hexasoftware.com/hxs/prettylog"
 )
 
-type SeqFunc func(s *Seq) error
+var (
+	log = prettylog.New("Seq")
+)
 
 type Entry struct {
 	desc  string
 	fn    reflect.Value
-	seqFn SeqFunc
+	seqFn func(sc *Context) error
 	param []SeqParam
 	ret   []reflect.Value
 	grab  []reflect.Value
@@ -24,10 +26,11 @@ type SeqParam struct {
 	param reflect.Value
 }
 
-func P(n, i int) SeqParam {
+// Helper
+func SeqReturn(n, i int) SeqParam {
 	return SeqParam{1, n, i, reflect.Value{}}
 }
-func EP(n int) SeqParam {
+func ExecParam(n int) SeqParam {
 	return SeqParam{2, n, 0, reflect.Value{}}
 }
 
@@ -52,7 +55,8 @@ func (s *Seq) Add(params ...interface{}) *Seq {
 	}
 	fn := params[fni]
 
-	if v, ok := fn.(SeqFunc); ok {
+	if v, ok := fn.(func(s *Context) error); ok {
+		log.Println("Special func")
 		entry.seqFn = v
 	} else {
 		entry.fn = reflect.ValueOf(fn)
@@ -95,19 +99,18 @@ func (s *Seq) Grab(grab ...interface{}) {
 	}
 }
 
-func (s *Seq) Log(param...interface{){
-
-}
-
 func (s *Seq) Exec(eparam ...interface{}) error {
+	sCon := NewContext()
 	s.rep = []string{}
 	for _, e := range s.seq {
 
 		if e.seqFn != nil {
-			err := e.seqFn(s)
+			err := e.seqFn(sCon)
+			sCon.Log("E:", e.desc, "=>", err)
 			if err != nil {
 				return err
 			}
+			continue
 		}
 		param := []reflect.Value{}
 		for _, p := range e.param {
@@ -116,33 +119,30 @@ func (s *Seq) Exec(eparam ...interface{}) error {
 			case 0:
 				val = p.param
 			case 1:
-				val = s.seq[p.nres].ret[p.ires]
+				val = reflect.ValueOf(sCon.Ret(p.nres, p.ires))
 			case 2:
 				val = reflect.Indirect(reflect.ValueOf(eparam[p.nres]))
 			}
 			param = append(param, val)
 		}
-		e.ret = e.fn.Call(param)
-		for i, r := range e.ret { // Populate grabs
+		retVal := e.fn.Call(param)
+		iretList := []interface{}{}
+		for i, r := range retVal { // Populate grabs
 			if i < len(e.grab) {
 				e.grab[i].Elem().Set(r)
 			}
-			if err, ok := r.Interface().(error); ok {
+			iret := r.Interface()
+			if err, ok := iret.(error); ok {
 				return err
 			}
+			iretList = append(iretList, iret)
 		}
+		sCon.ret = append(sCon.ret, iretList)
 		if e.desc != "" { // Only if we have a description
-			iret := []interface{}{}
-			for _, r := range e.ret {
-				iret = append(iret, reflect.Indirect(r).Interface())
-			}
-			s.rep = append(s.rep, fmt.Sprintf("E: %s => %s", e.desc, iret))
+			sCon.Log("E:", e.desc, "=>", iretList)
 		}
 	}
-	log.Println("Report:")
-	for _, r := range s.rep {
-		log.Println(r)
-	}
+	sCon.LogRep()
 
 	return nil
 }