Added a tasker

_example/e1/main.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+
+	"dev.hexasoftware.com/x/seq"
+
+	"dev.hexasoftware.com/hxs/prettylog"
+)
+
+type Xpto struct {
+	ID string
+}
+
+func GenXpto(i int) (*Xpto, error) {
+	return &Xpto{fmt.Sprintf("ID:%d", i)}, nil
+}
+
+func AnotherRandomFunc() error {
+	return errors.New("I have a error")
+}
+func NextXpto(id string) error {
+	return nil
+}
+
+func MyFunc() func(...interface{}) error {
+	s := seq.NewSeq()
+	return s.Exec
+}
+
+func main() {
+	prettylog.Global()
+
+	t := seq.NewTasker()
+
+	s := t.Define("RUN")
+	val := &Xpto{}
+	s.Add("GenXpto", GenXpto, 10).Grab(&val)
+	s.Add("NextXpto", func() error { return NextXpto(val.ID) })
+	s.Add("NextXpto2", func(p *Xpto) error { return NextXpto(p.ID) }, seq.RetFrom(0, 0))
+	s.Add("Again", NextXpto, seq.ExecParam(0))
+
+	t.Exec("RUN", "abc")
+
+	s2 := seq.NewSeq()
+	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()
+
+}

_example/main.go

@@ -1,59 +1,18 @@
 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
-}
+import "dev.hexasoftware.com/x/seq"
 
 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")
+	s := seq.NewNexter()
 
-	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)
-		})
+	s.Next(func() error {
+		// Do whatever
 
-	s2.Exec()
+		return nil
+	})
+	s.Next(func() error {
 
+		return nil
+	})
 }

param.go

@@ -0,0 +1,30 @@
+package seq
+
+import "reflect"
+
+const (
+	TypRetParam  = 1
+	TypExecParam = 2
+)
+
+//Param for execution
+type Param struct {
+	typ  byte
+	nres int
+	ires int
+	// Or
+	param reflect.Value
+}
+
+//RetFrom use return from
+// n func Number
+// i return index
+func RetFrom(n, i int) Param {
+	return Param{TypRetParam, n, i, reflect.Value{}}
+}
+
+//ExecParam
+// n Param number
+func ExecParam(n int) Param {
+	return Param{TypExecParam, n, 0, reflect.Value{}}
+}

sequencer.go

@@ -14,25 +14,11 @@ type Entry struct {
 	desc  string
 	fn    reflect.Value
 	seqFn func(sc *Context) error
-	param []SeqParam
-	ret   []reflect.Value
+	param []Param
 	grab  []reflect.Value
 }
-type SeqParam struct {
-	typ  byte
-	nres int
-	ires int
-	// Or
-	param reflect.Value
-}
 
 // Helper
-func SeqReturn(n, i int) SeqParam {
-	return SeqParam{1, n, i, reflect.Value{}}
-}
-func ExecParam(n int) SeqParam {
-	return SeqParam{2, n, 0, reflect.Value{}}
-}
 
 type Seq struct {
 	seq  []*Entry
@@ -42,7 +28,7 @@ type Seq struct {
 	rep []string
 }
 
-func New() *Seq {
+func NewSeq() *Seq {
 	return &Seq{[]*Entry{}, nil, map[string]interface{}{}, nil}
 }
 
@@ -65,12 +51,12 @@ func (s *Seq) Add(params ...interface{}) *Seq {
 		if fnTyp.Kind() != reflect.Func {
 			log.Fatal("First param must be a function")
 		}
-		vparam := []SeqParam{}
+		vparam := []Param{}
 
 		for _, p := range params[fni+1:] {
-			sp := SeqParam{}
+			sp := Param{}
 			switch v := p.(type) {
-			case SeqParam:
+			case Param:
 				sp = v
 			default:
 				sp.typ = 0

tasker.go

@@ -0,0 +1,26 @@
+package seq
+
+import "errors"
+
+type Tasker struct {
+	seq map[string]*Seq
+}
+
+func NewTasker() *Tasker {
+	return &Tasker{map[string]*Seq{}}
+}
+
+func (t *Tasker) Define(name string) *Seq {
+	s := NewSeq()
+	t.seq[name] = s
+
+	return s
+}
+
+func (t *Tasker) Exec(name string, params ...interface{}) error {
+	s, ok := t.seq[name]
+	if !ok {
+		return errors.New("Task Not found")
+	}
+	return s.Exec(params...)
+}