mirror of
https://github.com/kataras/iris.git
synced 2025-01-30 05:56:34 +01:00
77 lines
2.7 KiB
Go
77 lines
2.7 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strconv"
|
|
|
|
"github.com/kataras/iris"
|
|
"github.com/kataras/iris/context"
|
|
// "github.com/kataras/iris/core/memstore"
|
|
"github.com/kataras/iris/hero"
|
|
)
|
|
|
|
func main() {
|
|
app := iris.New()
|
|
app.Logger().SetLevel("debug")
|
|
|
|
// Let's see how we can register a custom macro such as ":uint32" or ":small" for its alias (optionally) for Uint32 types.
|
|
// app.Macros().Register("uint32", "small", false, false, func(paramValue string) bool {
|
|
// _, err := strconv.ParseUint(paramValue, 10, 32)
|
|
// return err == nil
|
|
// }).
|
|
// RegisterFunc("min", func(min uint32) func(string) bool {
|
|
// return func(paramValue string) bool {
|
|
// n, err := strconv.ParseUint(paramValue, 10, 32)
|
|
// if err != nil {
|
|
// return false
|
|
// }
|
|
|
|
// return uint32(n) >= min
|
|
// }
|
|
// })
|
|
|
|
/* TODO:
|
|
somehow define one-time how the parameter should be parsed to a particular type (go std or custom)
|
|
tip: we can change the original value from string to X using the entry's.ValueRaw
|
|
^ Done 27 sep 2018.
|
|
*/
|
|
|
|
app.Macros().Register("uint32", "small", false, false, func(paramValue string) (interface{}, bool) {
|
|
v, err := strconv.ParseUint(paramValue, 10, 32)
|
|
return uint32(v), err == nil
|
|
}).
|
|
RegisterFunc("min", func(min uint32) func(uint32) bool {
|
|
return func(paramValue uint32) bool {
|
|
return paramValue >= min
|
|
}
|
|
})
|
|
|
|
// optionally, only when mvc or hero features are used for this custom macro/parameter type.
|
|
context.ParamResolvers[reflect.Uint32] = func(paramIndex int) interface{} {
|
|
/* both works but second is faster, we omit the duplication of the type conversion over and over as of 27 Sep of 2018 (this patch)*/
|
|
// return func(ctx context.Context) uint32 {
|
|
// param := ctx.Params().GetEntryAt(paramIndex)
|
|
// paramValueAsUint32, _ := strconv.ParseUint(param.String(), 10, 32)
|
|
// return uint32(paramValueAsUint32)
|
|
// }
|
|
return func(ctx context.Context) uint32 {
|
|
return ctx.Params().GetEntryAt(paramIndex).ValueRaw.(uint32)
|
|
} /* TODO: find a way to automative it based on the macro's first return value type, if thats the case then we must not return nil even if not found,
|
|
we must return a value i.e 0 for int for its interface{} */
|
|
}
|
|
//
|
|
|
|
app.Get("/test_uint32/{myparam:uint32 min(10)}", hero.Handler(func(paramValue uint32) string {
|
|
return fmt.Sprintf("Value of the parameter is: %d\n", paramValue)
|
|
}))
|
|
|
|
app.Get("test_uint64/{myparam:uint64 min(5)}", func(ctx context.Context) {
|
|
// works: ctx.Writef("Value of the parameter is: %s\n", ctx.Params().Get("myparam"))
|
|
// but better and faster because the macro converts the string to uint64 automatically:
|
|
ctx.Writef("Value of the parameter is: %d\n", ctx.Params().GetUint64Default("myparam", 0))
|
|
})
|
|
|
|
app.Run(iris.Addr(":8080"))
|
|
}
|