func (b *Bubble) Next() error {
	if b.queueIndex < len(b.mux.middlewares) {
		qi := b.queueIndex
		b.queueIndex++
		m := b.mux.middlewares[qi]
		err := m(b)
		return err
	}
	return b.do()
}
Next passes the bubble to next middleware.
If the bubble reaches at last, RequestHandler will be called.
package ucon
import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"reflect"
)
var ErrInvalidRequestHandler = errors.New("invalid request handler. not function")
var ErrInvalidArgumentLength = errors.New("invalid arguments")
var ErrInvalidArgumentValue = errors.New("invalid argument value")
type Bubble struct {
	R              *http.Request
	W              http.ResponseWriter
	Context        context.Context
	RequestHandler HandlerContainer
	Debug bool
	Handled       bool
	ArgumentTypes []reflect.Type
	Arguments     []reflect.Value
	Returns       []reflect.Value
	queueIndex int
	mux        *ServeMux
}
func (b *Bubble) checkHandlerType() error {
	if _, ok := b.RequestHandler.(HandlerContainer); ok {
		return nil
	}
	hv := reflect.ValueOf(b.RequestHandler)
	if hv.Type().Kind() == reflect.Func {
		return nil
	}
	return ErrInvalidRequestHandler
}
func (b *Bubble) handler() interface{} {
	if hv, ok := b.RequestHandler.(HandlerContainer); ok {
		return hv.Handler()
	}
	hv := reflect.ValueOf(b.RequestHandler)
	if hv.Type().Kind() == reflect.Func {
		return b.RequestHandler
	}
	return nil
}
func (b *Bubble) init(m *ServeMux) error {
	err := b.checkHandlerType()
	if err != nil {
		return err
	}
	hv := reflect.ValueOf(b.handler())
	numIn := hv.Type().NumIn()
	b.ArgumentTypes = make([]reflect.Type, numIn)
	for i := 0; i < numIn; i++ {
		b.ArgumentTypes[i] = hv.Type().In(i)
	}
	b.Arguments = make([]reflect.Value, numIn)
	b.mux = m
	b.Debug = m.Debug
	return nil
}