fix(generator): include async promise output

Author: piotr-roslaniec

.gitignore

@@ -1,3 +1,4 @@
 pkg/**/gen/*/*.go
 tools/**/gen/*/*.go
 !tools/generators/promise/gen/*.go
+!tools/generators/promise/gen/async/*.go

tools/generators/promise/gen/async/big_int_promise.go

@@ -0,0 +1,152 @@
+// This is auto generated code
+package async
+
+import (
+	"fmt"
+	"math/big"
+	"sync"
+)
+
+// Promise represents an eventual completion of an ansynchronous operation
+// and its resulting value. Promise can be either fulfilled or failed and
+// it can happen only one time. All Promise operations are thread-safe.
+//
+// To create a promise use: `&BigIntPromise{}`
+type BigIntPromise struct {
+	mutex      sync.Mutex
+	successFn  func(*big.Int)
+	failureFn  func(error)
+	completeFn func(*big.Int, error)
+
+	isComplete bool
+	value      *big.Int
+	err        error
+}
+
+// OnSuccess registers a function to be called when the Promise
+// has been fulfilled. In case of a failed Promise, function is not
+// called at all. OnSuccess is a non-blocking operation. Only one on success
+// function can be registered for a Promise. If the Promise has been already
+// fulfilled, the function is called immediatelly.
+func (p *BigIntPromise) OnSuccess(onSuccess func(*big.Int)) *BigIntPromise {
+	p.mutex.Lock()
+	defer p.mutex.Unlock()
+
+	p.successFn = onSuccess
+
+	if p.isComplete && p.err == nil {
+		p.callSuccessFn()
+	}
+
+	return p
+}
+
+// OnFailure registers a function to be called when the Promise
+// execution failed. In case of a fulfilled Promise, function is not
+// called at all. OnFailure is a non-blocking operation. Only one on failure
+// function can be registered for a Promise. If the Promise has already failed,
+// the function is called immediatelly.
+func (p *BigIntPromise) OnFailure(onFailure func(error)) *BigIntPromise {
+	p.mutex.Lock()
+	defer p.mutex.Unlock()
+
+	p.failureFn = onFailure
+
+	if p.isComplete && p.err != nil {
+		p.callFailureFn()
+	}
+
+	return p
+}
+
+// OnComplete registers a function to be called when the Promise
+// execution completed no matter if it succeded or failed.
+// In case of a successful execution, error passed to the callback
+// function is nil. In case of a failed execution, there is no
+// value evaluated so the value parameter is nil. OnComplete is
+// a non-blocking operation. Only one on complete function can be
+// registered for a Promise. If the Promise has already completed,
+// the function is called immediatelly.
+func (p *BigIntPromise) OnComplete(onComplete func(*big.Int, error)) *BigIntPromise {
+	p.mutex.Lock()
+	defer p.mutex.Unlock()
+
+	p.completeFn = onComplete
+
+	if p.isComplete {
+		p.callCompleteFn()
+	}
+
+	return p
+}
+
+// Fulfill can happen only once for a Promise and it results in calling
+// the OnSuccess callback, if registered. If Promise has been already
+// completed by either fulfilling or failing, this function reports
+// an error.
+func (p *BigIntPromise) Fulfill(value *big.Int) error {
+	p.mutex.Lock()
+	defer p.mutex.Unlock()
+
+	if p.isComplete {
+		return fmt.Errorf("promise already completed")
+	}
+
+	p.isComplete = true
+	p.value = value
+
+	p.callSuccessFn()
+	p.callCompleteFn()
+
+	return nil
+}
+
+// Fail can happen only once for a Promise and it results in calling
+// the OnFailure callback, if registered. If Promise has been already
+// completed by either fulfilling or failing, this function reports
+// an error. Also, this function reports an error if `err` parameter
+// is `nil`.
+func (p *BigIntPromise) Fail(err error) error {
+	p.mutex.Lock()
+	defer p.mutex.Unlock()
+
+	if err == nil {
+		return fmt.Errorf("error cannot be nil")
+	}
+
+	if p.isComplete {
+		return fmt.Errorf("promise already completed")
+	}
+
+	p.isComplete = true
+	p.err = err
+
+	p.callFailureFn()
+	p.callCompleteFn()
+
+	return nil
+}
+
+func (p *BigIntPromise) callCompleteFn() {
+	if p.completeFn != nil {
+		go func() {
+			p.completeFn(p.value, p.err)
+		}()
+	}
+}
+
+func (p *BigIntPromise) callSuccessFn() {
+	if p.successFn != nil {
+		go func() {
+			p.successFn(p.value)
+		}()
+	}
+}
+
+func (p *BigIntPromise) callFailureFn() {
+	if p.failureFn != nil {
+		go func() {
+			p.failureFn(p.err)
+		}()
+	}
+}