// Copyright 2014 Julien Schmidt. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be found

// in the LICENSE file.

package main

import (

"fmt"

"io"

"log"

"net/http"

"os"

"regexp"

"runtime"

// If you add new routers please:

// - Keep the benchmark functions etc. alphabetically sorted

// - Make a pull request (without benchmark results) at

// https://github.com/julienschmidt/go-http-routing-benchmark

"github.com/ant0ine/go-json-rest/rest"

"github.com/astaxie/beego"

"github.com/astaxie/beego/context"

"github.com/bmizerany/pat"

"github.com/go-playground/lars"

// "github.com/daryl/zeus"

cloudykitrouter "github.com/cloudykit/router"

"github.com/dimfeld/httptreemux"

"github.com/emicklei/go-restful"

"github.com/gin-gonic/gin"

"github.com/go-chi/chi"

"github.com/go-martini/martini"

"github.com/go-zoo/bone"

"github.com/gocraft/web"

"github.com/gorilla/mux"

gowwwrouter "github.com/gowww/router"

"github.com/julienschmidt/httprouter"

"github.com/labstack/echo/v4"

llog "github.com/lunny/log"

"github.com/lunny/tango"

vulcan "github.com/mailgun/route"

"github.com/mikespook/possum"

possumrouter "github.com/mikespook/possum/router"

possumview "github.com/mikespook/possum/view"

"github.com/naoina/denco"

urlrouter "github.com/naoina/kocha-urlrouter"

_ "github.com/naoina/kocha-urlrouter/doublearray"

"github.com/pilu/traffic"

"github.com/plimble/ace"

"github.com/rcrowley/go-tigertonic"

// "github.com/revel/pathtree"

// "github.com/revel/revel"

"github.com/aerogo/aero"

"github.com/typepress/rivet"

"github.com/ursiform/bear"

"github.com/vanng822/r2router"

goji "github.com/zenazn/goji/web"

gojiv2 "goji.io"

gojiv2pat "goji.io/pat"

"gopkg.in/macaron.v1"

)

type route struct {

method string

path string

}

type mockResponseWriter struct{}

func (m *mockResponseWriter) Header() (h http.Header) {

return http.Header{}

}

func (m *mockResponseWriter) Write(p []byte) (n int, err error) {

return len(p), nil

}

func (m *mockResponseWriter) WriteString(s string) (n int, err error) {

return len(s), nil

}

func (m *mockResponseWriter) WriteHeader(int) {}

var nullLogger *log.Logger

// flag indicating if the normal or the test handler should be loaded

var loadTestHandler = false

func init() {

}

// Common

func httpHandlerFunc(_ http.ResponseWriter, _ *http.Request) {}

func httpHandlerFuncTest(w http.ResponseWriter, r *http.Request) {

io.WriteString(w, r.RequestURI)

}

// Ace

func aceHandle(_ *ace.C) {}

func aceHandleWrite(c *ace.C) {

io.WriteString(c.Writer, c.Param("name"))

}

func aceHandleTest(c *ace.C) {

io.WriteString(c.Writer, c.Request.RequestURI)

}

func loadAce(routes []route) http.Handler {

}

func loadAceSingle(method, path string, handle ace.HandlerFunc) http.Handler {

}

// Aero

func aeroHandler(c aero.Context) error {

return nil

}

func aeroHandlerWrite(ctx aero.Context) error {

io.WriteString(ctx.Response().Internal(), ctx.Get("name"))

return nil

}

func aeroHandlerTest(ctx aero.Context) error {

io.WriteString(ctx.Response().Internal(), ctx.Request().Path())

return nil

}

func loadAero(routes []route) http.Handler {

}

func loadAeroSingle(method, path string, h aero.Handler) http.Handler {

}

// bear

func bearHandler(_ http.ResponseWriter, _ *http.Request, _ *bear.Context) {}

func bearHandlerWrite(w http.ResponseWriter, _ *http.Request, ctx *bear.Context) {

io.WriteString(w, ctx.Params["name"])

}

func bearHandlerTest(w http.ResponseWriter, r *http.Request, _ *bear.Context) {

io.WriteString(w, r.RequestURI)

}

func loadBear(routes []route) http.Handler {

}

func loadBearSingle(method string, path string, handler bear.HandlerFunc) http.Handler {

}

// beego

func beegoHandler(ctx *context.Context) {}

func beegoHandlerWrite(ctx *context.Context) {

ctx.WriteString(ctx.Input.Param(":name"))

}

func beegoHandlerTest(ctx *context.Context) {

ctx.WriteString(ctx.Request.RequestURI)

}

func initBeego() {

beego.BConfig.RunMode = beego.PROD

beego.BeeLogger.Close()

}

func loadBeego(routes []route) http.Handler {

}

func loadBeegoSingle(method, path string, handler beego.FilterFunc) http.Handler {

}

// bone

func boneHandlerWrite(rw http.ResponseWriter, req *http.Request) {

io.WriteString(rw, bone.GetValue(req, "name"))

}

func loadBone(routes []route) http.Handler {

}

func loadBoneSingle(method, path string, handler http.Handler) http.Handler {

}

// chi

// chi

func chiHandleWrite(w http.ResponseWriter, r *http.Request) {

io.WriteString(w, chi.URLParam(r, "name"))

}

func loadChi(routes []route) http.Handler {

}

func loadChiSingle(method, path string, handler http.HandlerFunc) http.Handler {

}

// CloudyKit Router

func cloudyKitRouterHandler(_ http.ResponseWriter, _ *http.Request, _ cloudykitrouter.Parameter) {}

func cloudyKitRouterHandlerWrite(w http.ResponseWriter, _ *http.Request, ps cloudykitrouter.Parameter) {

io.WriteString(w, ps.ByName("name"))

}

func cloudyKitRouterHandlerTest(w http.ResponseWriter, r *http.Request, _ cloudykitrouter.Parameter) {

io.WriteString(w, r.RequestURI)

}

func loadCloudyKitRouter(routes []route) http.Handler {

}

func loadCloudyKitRouterSingle(method, path string, handler cloudykitrouter.Handler) http.Handler {

}

// Denco

func dencoHandler(w http.ResponseWriter, r *http.Request, params denco.Params) {}

func dencoHandlerWrite(w http.ResponseWriter, r *http.Request, params denco.Params) {

io.WriteString(w, params.Get("name"))

}

func dencoHandlerTest(w http.ResponseWriter, r *http.Request, params denco.Params) {

io.WriteString(w, r.RequestURI)

}

func loadDenco(routes []route) http.Handler {

}

func loadDencoSingle(method, path string, h denco.HandlerFunc) http.Handler {

}

// Echo

func echoHandler(c echo.Context) error {

return nil

}

func echoHandlerWrite(c echo.Context) error {

io.WriteString(c.Response(), c.Param("name"))

return nil

}

func echoHandlerTest(c echo.Context) error {

io.WriteString(c.Response(), c.Request().RequestURI)

return nil

}

func loadEcho(routes []route) http.Handler {

}

func loadEchoSingle(method, path string, h echo.HandlerFunc) http.Handler {

}

// Gin

func ginHandle(_ *gin.Context) {}

func ginHandleWrite(c *gin.Context) {

io.WriteString(c.Writer, c.Params.ByName("name"))

}

func ginHandleTest(c *gin.Context) {

io.WriteString(c.Writer, c.Request.RequestURI)

}

func initGin() {

gin.SetMode(gin.ReleaseMode)

}

func loadGin(routes []route) http.Handler {

}

func loadGinSingle(method, path string, handle gin.HandlerFunc) http.Handler {

}

// gocraft/web

type gocraftWebContext struct{}

func gocraftWebHandler(w web.ResponseWriter, r *web.Request) {}

func gocraftWebHandlerWrite(w web.ResponseWriter, r *web.Request) {

io.WriteString(w, r.PathParams["name"])

}

func gocraftWebHandlerTest(w web.ResponseWriter, r *web.Request) {

io.WriteString(w, r.RequestURI)

}

func loadGocraftWeb(routes []route) http.Handler {

}

func loadGocraftWebSingle(method, path string, handler interface{}) http.Handler {

}

// goji

func gojiFuncWrite(c goji.C, w http.ResponseWriter, r *http.Request) {

io.WriteString(w, c.URLParams["name"])

}

func loadGoji(routes []route) http.Handler {

}

func loadGojiSingle(method, path string, handler interface{}) http.Handler {

}

// goji v2 (github.com/goji/goji)

func gojiv2Handler(w http.ResponseWriter, r *http.Request) {}

func gojiv2HandlerWrite(w http.ResponseWriter, r *http.Request) {

io.WriteString(w, gojiv2pat.Param(r, "name"))

}

func gojiv2HandlerTest(w http.ResponseWriter, r *http.Request) {

io.WriteString(w, r.RequestURI)

}

func loadGojiv2(routes []route) http.Handler {

}

func loadGojiv2Single(method, path string, handler func(http.ResponseWriter, *http.Request)) http.Handler {

}

// go-json-rest/rest

func goJsonRestHandler(w rest.ResponseWriter, req *rest.Request) {}

func goJsonRestHandlerWrite(w rest.ResponseWriter, req *rest.Request) {

io.WriteString(w.(io.Writer), req.PathParam("name"))

}

func goJsonRestHandlerTest(w rest.ResponseWriter, req *rest.Request) {

io.WriteString(w.(io.Writer), req.RequestURI)

}

func loadGoJsonRest(routes []route) http.Handler {

}

func loadGoJsonRestSingle(method, path string, hfunc rest.HandlerFunc) http.Handler {

}

// go-restful

func goRestfulHandler(r *restful.Request, w *restful.Response) {}

func goRestfulHandlerWrite(r *restful.Request, w *restful.Response) {

io.WriteString(w, r.PathParameter("name"))

}

func goRestfulHandlerTest(r *restful.Request, w *restful.Response) {

io.WriteString(w, r.Request.RequestURI)

}

func loadGoRestful(routes []route) http.Handler {

}

func loadGoRestfulSingle(method, path string, handler restful.RouteFunction) http.Handler {

}

// gorilla/mux

func gorillaHandlerWrite(w http.ResponseWriter, r *http.Request) {

params := mux.Vars(r)

io.WriteString(w, params["name"])

}

func loadGorillaMux(routes []route) http.Handler {

}

func loadGorillaMuxSingle(method, path string, handler http.HandlerFunc) http.Handler {

}

// gowww/router

func gowwwRouterHandleWrite(w http.ResponseWriter, r *http.Request) {

io.WriteString(w, gowwwrouter.Parameter(r, "name"))

}

func loadGowwwRouter(routes []route) http.Handler {

}

func loadGowwwRouterSingle(method, path string, handler http.Handler) http.Handler {

}

// HttpRouter

func httpRouterHandle(_ http.ResponseWriter, _ *http.Request, _ httprouter.Params) {}

func httpRouterHandleWrite(w http.ResponseWriter, _ *http.Request, ps httprouter.Params) {

io.WriteString(w, ps.ByName("name"))

}

func httpRouterHandleTest(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {

io.WriteString(w, r.RequestURI)

}

func loadHttpRouter(routes []route) http.Handler {

}

func loadHttpRouterSingle(method, path string, handle httprouter.Handle) http.Handler {

}

// net/http.ServeMux

func httpServeMuxHandleWrite(w http.ResponseWriter, r *http.Request) {

io.WriteString(w, r.PathValue("name"))

}

func loadHttpServeMux(routes []route) http.Handler {

}

func loadHttpServeMuxSingle(method, path string, handle http.HandlerFunc) http.Handler {

}

// httpTreeMux

func httpTreeMuxHandler(_ http.ResponseWriter, _ *http.Request, _ map[string]string) {}

func httpTreeMuxHandlerWrite(w http.ResponseWriter, _ *http.Request, vars map[string]string) {

io.WriteString(w, vars["name"])

}

func httpTreeMuxHandlerTest(w http.ResponseWriter, r *http.Request, _ map[string]string) {

io.WriteString(w, r.RequestURI)

}

func loadHttpTreeMux(routes []route) http.Handler {

}

func loadHttpTreeMuxSingle(method, path string, handler httptreemux.HandlerFunc) http.Handler {

}

// Kocha-urlrouter

type kochaHandler struct {

routerMap map[string]urlrouter.URLRouter

params []urlrouter.Param

}

func (h *kochaHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {

}

func (h *kochaHandler) Get(w http.ResponseWriter, r *http.Request) {}

func (h *kochaHandler) Post(w http.ResponseWriter, r *http.Request) {}

func (h *kochaHandler) Put(w http.ResponseWriter, r *http.Request) {}

func (h *kochaHandler) Patch(w http.ResponseWriter, r *http.Request) {}

func (h *kochaHandler) Delete(w http.ResponseWriter, r *http.Request) {}