123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866 |
- package chi
-
- // Radix tree implementation below is a based on the original work by
- // Armon Dadgar in https://github.com/armon/go-radix/blob/master/radix.go
- // (MIT licensed). It's been heavily modified for use as a HTTP routing tree.
-
- import (
- "fmt"
- "net/http"
- "regexp"
- "sort"
- "strconv"
- "strings"
- )
-
- type methodTyp uint
-
- const (
- mSTUB methodTyp = 1 << iota
- mCONNECT
- mDELETE
- mGET
- mHEAD
- mOPTIONS
- mPATCH
- mPOST
- mPUT
- mTRACE
- )
-
- var mALL = mCONNECT | mDELETE | mGET | mHEAD |
- mOPTIONS | mPATCH | mPOST | mPUT | mTRACE
-
- var methodMap = map[string]methodTyp{
- http.MethodConnect: mCONNECT,
- http.MethodDelete: mDELETE,
- http.MethodGet: mGET,
- http.MethodHead: mHEAD,
- http.MethodOptions: mOPTIONS,
- http.MethodPatch: mPATCH,
- http.MethodPost: mPOST,
- http.MethodPut: mPUT,
- http.MethodTrace: mTRACE,
- }
-
- // RegisterMethod adds support for custom HTTP method handlers, available
- // via Router#Method and Router#MethodFunc
- func RegisterMethod(method string) {
- if method == "" {
- return
- }
- method = strings.ToUpper(method)
- if _, ok := methodMap[method]; ok {
- return
- }
- n := len(methodMap)
- if n > strconv.IntSize-2 {
- panic(fmt.Sprintf("chi: max number of methods reached (%d)", strconv.IntSize))
- }
- mt := methodTyp(2 << n)
- methodMap[method] = mt
- mALL |= mt
- }
-
- type nodeTyp uint8
-
- const (
- ntStatic nodeTyp = iota // /home
- ntRegexp // /{id:[0-9]+}
- ntParam // /{user}
- ntCatchAll // /api/v1/*
- )
-
- type node struct {
- // subroutes on the leaf node
- subroutes Routes
-
- // regexp matcher for regexp nodes
- rex *regexp.Regexp
-
- // HTTP handler endpoints on the leaf node
- endpoints endpoints
-
- // prefix is the common prefix we ignore
- prefix string
-
- // child nodes should be stored in-order for iteration,
- // in groups of the node type.
- children [ntCatchAll + 1]nodes
-
- // first byte of the child prefix
- tail byte
-
- // node type: static, regexp, param, catchAll
- typ nodeTyp
-
- // first byte of the prefix
- label byte
- }
-
- // endpoints is a mapping of http method constants to handlers
- // for a given route.
- type endpoints map[methodTyp]*endpoint
-
- type endpoint struct {
- // endpoint handler
- handler http.Handler
-
- // pattern is the routing pattern for handler nodes
- pattern string
-
- // parameter keys recorded on handler nodes
- paramKeys []string
- }
-
- func (s endpoints) Value(method methodTyp) *endpoint {
- mh, ok := s[method]
- if !ok {
- mh = &endpoint{}
- s[method] = mh
- }
- return mh
- }
-
- func (n *node) InsertRoute(method methodTyp, pattern string, handler http.Handler) *node {
- var parent *node
- search := pattern
-
- for {
- // Handle key exhaustion
- if len(search) == 0 {
- // Insert or update the node's leaf handler
- n.setEndpoint(method, handler, pattern)
- return n
- }
-
- // We're going to be searching for a wild node next,
- // in this case, we need to get the tail
- var label = search[0]
- var segTail byte
- var segEndIdx int
- var segTyp nodeTyp
- var segRexpat string
- if label == '{' || label == '*' {
- segTyp, _, segRexpat, segTail, _, segEndIdx = patNextSegment(search)
- }
-
- var prefix string
- if segTyp == ntRegexp {
- prefix = segRexpat
- }
-
- // Look for the edge to attach to
- parent = n
- n = n.getEdge(segTyp, label, segTail, prefix)
-
- // No edge, create one
- if n == nil {
- child := &node{label: label, tail: segTail, prefix: search}
- hn := parent.addChild(child, search)
- hn.setEndpoint(method, handler, pattern)
-
- return hn
- }
-
- // Found an edge to match the pattern
-
- if n.typ > ntStatic {
- // We found a param node, trim the param from the search path and continue.
- // This param/wild pattern segment would already be on the tree from a previous
- // call to addChild when creating a new node.
- search = search[segEndIdx:]
- continue
- }
-
- // Static nodes fall below here.
- // Determine longest prefix of the search key on match.
- commonPrefix := longestPrefix(search, n.prefix)
- if commonPrefix == len(n.prefix) {
- // the common prefix is as long as the current node's prefix we're attempting to insert.
- // keep the search going.
- search = search[commonPrefix:]
- continue
- }
-
- // Split the node
- child := &node{
- typ: ntStatic,
- prefix: search[:commonPrefix],
- }
- parent.replaceChild(search[0], segTail, child)
-
- // Restore the existing node
- n.label = n.prefix[commonPrefix]
- n.prefix = n.prefix[commonPrefix:]
- child.addChild(n, n.prefix)
-
- // If the new key is a subset, set the method/handler on this node and finish.
- search = search[commonPrefix:]
- if len(search) == 0 {
- child.setEndpoint(method, handler, pattern)
- return child
- }
-
- // Create a new edge for the node
- subchild := &node{
- typ: ntStatic,
- label: search[0],
- prefix: search,
- }
- hn := child.addChild(subchild, search)
- hn.setEndpoint(method, handler, pattern)
- return hn
- }
- }
-
- // addChild appends the new `child` node to the tree using the `pattern` as the trie key.
- // For a URL router like chi's, we split the static, param, regexp and wildcard segments
- // into different nodes. In addition, addChild will recursively call itself until every
- // pattern segment is added to the url pattern tree as individual nodes, depending on type.
- func (n *node) addChild(child *node, prefix string) *node {
- search := prefix
-
- // handler leaf node added to the tree is the child.
- // this may be overridden later down the flow
- hn := child
-
- // Parse next segment
- segTyp, _, segRexpat, segTail, segStartIdx, segEndIdx := patNextSegment(search)
-
- // Add child depending on next up segment
- switch segTyp {
-
- case ntStatic:
- // Search prefix is all static (that is, has no params in path)
- // noop
-
- default:
- // Search prefix contains a param, regexp or wildcard
-
- if segTyp == ntRegexp {
- rex, err := regexp.Compile(segRexpat)
- if err != nil {
- panic(fmt.Sprintf("chi: invalid regexp pattern '%s' in route param", segRexpat))
- }
- child.prefix = segRexpat
- child.rex = rex
- }
-
- if segStartIdx == 0 {
- // Route starts with a param
- child.typ = segTyp
-
- if segTyp == ntCatchAll {
- segStartIdx = -1
- } else {
- segStartIdx = segEndIdx
- }
- if segStartIdx < 0 {
- segStartIdx = len(search)
- }
- child.tail = segTail // for params, we set the tail
-
- if segStartIdx != len(search) {
- // add static edge for the remaining part, split the end.
- // its not possible to have adjacent param nodes, so its certainly
- // going to be a static node next.
-
- search = search[segStartIdx:] // advance search position
-
- nn := &node{
- typ: ntStatic,
- label: search[0],
- prefix: search,
- }
- hn = child.addChild(nn, search)
- }
-
- } else if segStartIdx > 0 {
- // Route has some param
-
- // starts with a static segment
- child.typ = ntStatic
- child.prefix = search[:segStartIdx]
- child.rex = nil
-
- // add the param edge node
- search = search[segStartIdx:]
-
- nn := &node{
- typ: segTyp,
- label: search[0],
- tail: segTail,
- }
- hn = child.addChild(nn, search)
-
- }
- }
-
- n.children[child.typ] = append(n.children[child.typ], child)
- n.children[child.typ].Sort()
- return hn
- }
-
- func (n *node) replaceChild(label, tail byte, child *node) {
- for i := 0; i < len(n.children[child.typ]); i++ {
- if n.children[child.typ][i].label == label && n.children[child.typ][i].tail == tail {
- n.children[child.typ][i] = child
- n.children[child.typ][i].label = label
- n.children[child.typ][i].tail = tail
- return
- }
- }
- panic("chi: replacing missing child")
- }
-
- func (n *node) getEdge(ntyp nodeTyp, label, tail byte, prefix string) *node {
- nds := n.children[ntyp]
- for i := 0; i < len(nds); i++ {
- if nds[i].label == label && nds[i].tail == tail {
- if ntyp == ntRegexp && nds[i].prefix != prefix {
- continue
- }
- return nds[i]
- }
- }
- return nil
- }
-
- func (n *node) setEndpoint(method methodTyp, handler http.Handler, pattern string) {
- // Set the handler for the method type on the node
- if n.endpoints == nil {
- n.endpoints = make(endpoints)
- }
-
- paramKeys := patParamKeys(pattern)
-
- if method&mSTUB == mSTUB {
- n.endpoints.Value(mSTUB).handler = handler
- }
- if method&mALL == mALL {
- h := n.endpoints.Value(mALL)
- h.handler = handler
- h.pattern = pattern
- h.paramKeys = paramKeys
- for _, m := range methodMap {
- h := n.endpoints.Value(m)
- h.handler = handler
- h.pattern = pattern
- h.paramKeys = paramKeys
- }
- } else {
- h := n.endpoints.Value(method)
- h.handler = handler
- h.pattern = pattern
- h.paramKeys = paramKeys
- }
- }
-
- func (n *node) FindRoute(rctx *Context, method methodTyp, path string) (*node, endpoints, http.Handler) {
- // Reset the context routing pattern and params
- rctx.routePattern = ""
- rctx.routeParams.Keys = rctx.routeParams.Keys[:0]
- rctx.routeParams.Values = rctx.routeParams.Values[:0]
-
- // Find the routing handlers for the path
- rn := n.findRoute(rctx, method, path)
- if rn == nil {
- return nil, nil, nil
- }
-
- // Record the routing params in the request lifecycle
- rctx.URLParams.Keys = append(rctx.URLParams.Keys, rctx.routeParams.Keys...)
- rctx.URLParams.Values = append(rctx.URLParams.Values, rctx.routeParams.Values...)
-
- // Record the routing pattern in the request lifecycle
- if rn.endpoints[method].pattern != "" {
- rctx.routePattern = rn.endpoints[method].pattern
- rctx.RoutePatterns = append(rctx.RoutePatterns, rctx.routePattern)
- }
-
- return rn, rn.endpoints, rn.endpoints[method].handler
- }
-
- // Recursive edge traversal by checking all nodeTyp groups along the way.
- // It's like searching through a multi-dimensional radix trie.
- func (n *node) findRoute(rctx *Context, method methodTyp, path string) *node {
- nn := n
- search := path
-
- for t, nds := range nn.children {
- ntyp := nodeTyp(t)
- if len(nds) == 0 {
- continue
- }
-
- var xn *node
- xsearch := search
-
- var label byte
- if search != "" {
- label = search[0]
- }
-
- switch ntyp {
- case ntStatic:
- xn = nds.findEdge(label)
- if xn == nil || !strings.HasPrefix(xsearch, xn.prefix) {
- continue
- }
- xsearch = xsearch[len(xn.prefix):]
-
- case ntParam, ntRegexp:
- // short-circuit and return no matching route for empty param values
- if xsearch == "" {
- continue
- }
-
- // serially loop through each node grouped by the tail delimiter
- for idx := 0; idx < len(nds); idx++ {
- xn = nds[idx]
-
- // label for param nodes is the delimiter byte
- p := strings.IndexByte(xsearch, xn.tail)
-
- if p < 0 {
- if xn.tail == '/' {
- p = len(xsearch)
- } else {
- continue
- }
- } else if ntyp == ntRegexp && p == 0 {
- continue
- }
-
- if ntyp == ntRegexp && xn.rex != nil {
- if !xn.rex.MatchString(xsearch[:p]) {
- continue
- }
- } else if strings.IndexByte(xsearch[:p], '/') != -1 {
- // avoid a match across path segments
- continue
- }
-
- prevlen := len(rctx.routeParams.Values)
- rctx.routeParams.Values = append(rctx.routeParams.Values, xsearch[:p])
- xsearch = xsearch[p:]
-
- if len(xsearch) == 0 {
- if xn.isLeaf() {
- h := xn.endpoints[method]
- if h != nil && h.handler != nil {
- rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)
- return xn
- }
-
- // flag that the routing context found a route, but not a corresponding
- // supported method
- rctx.methodNotAllowed = true
- }
- }
-
- // recursively find the next node on this branch
- fin := xn.findRoute(rctx, method, xsearch)
- if fin != nil {
- return fin
- }
-
- // not found on this branch, reset vars
- rctx.routeParams.Values = rctx.routeParams.Values[:prevlen]
- xsearch = search
- }
-
- rctx.routeParams.Values = append(rctx.routeParams.Values, "")
-
- default:
- // catch-all nodes
- rctx.routeParams.Values = append(rctx.routeParams.Values, search)
- xn = nds[0]
- xsearch = ""
- }
-
- if xn == nil {
- continue
- }
-
- // did we find it yet?
- if len(xsearch) == 0 {
- if xn.isLeaf() {
- h := xn.endpoints[method]
- if h != nil && h.handler != nil {
- rctx.routeParams.Keys = append(rctx.routeParams.Keys, h.paramKeys...)
- return xn
- }
-
- // flag that the routing context found a route, but not a corresponding
- // supported method
- rctx.methodNotAllowed = true
- }
- }
-
- // recursively find the next node..
- fin := xn.findRoute(rctx, method, xsearch)
- if fin != nil {
- return fin
- }
-
- // Did not find final handler, let's remove the param here if it was set
- if xn.typ > ntStatic {
- if len(rctx.routeParams.Values) > 0 {
- rctx.routeParams.Values = rctx.routeParams.Values[:len(rctx.routeParams.Values)-1]
- }
- }
-
- }
-
- return nil
- }
-
- func (n *node) findEdge(ntyp nodeTyp, label byte) *node {
- nds := n.children[ntyp]
- num := len(nds)
- idx := 0
-
- switch ntyp {
- case ntStatic, ntParam, ntRegexp:
- i, j := 0, num-1
- for i <= j {
- idx = i + (j-i)/2
- if label > nds[idx].label {
- i = idx + 1
- } else if label < nds[idx].label {
- j = idx - 1
- } else {
- i = num // breaks cond
- }
- }
- if nds[idx].label != label {
- return nil
- }
- return nds[idx]
-
- default: // catch all
- return nds[idx]
- }
- }
-
- func (n *node) isLeaf() bool {
- return n.endpoints != nil
- }
-
- func (n *node) findPattern(pattern string) bool {
- nn := n
- for _, nds := range nn.children {
- if len(nds) == 0 {
- continue
- }
-
- n = nn.findEdge(nds[0].typ, pattern[0])
- if n == nil {
- continue
- }
-
- var idx int
- var xpattern string
-
- switch n.typ {
- case ntStatic:
- idx = longestPrefix(pattern, n.prefix)
- if idx < len(n.prefix) {
- continue
- }
-
- case ntParam, ntRegexp:
- idx = strings.IndexByte(pattern, '}') + 1
-
- case ntCatchAll:
- idx = longestPrefix(pattern, "*")
-
- default:
- panic("chi: unknown node type")
- }
-
- xpattern = pattern[idx:]
- if len(xpattern) == 0 {
- return true
- }
-
- return n.findPattern(xpattern)
- }
- return false
- }
-
- func (n *node) routes() []Route {
- rts := []Route{}
-
- n.walk(func(eps endpoints, subroutes Routes) bool {
- if eps[mSTUB] != nil && eps[mSTUB].handler != nil && subroutes == nil {
- return false
- }
-
- // Group methodHandlers by unique patterns
- pats := make(map[string]endpoints)
-
- for mt, h := range eps {
- if h.pattern == "" {
- continue
- }
- p, ok := pats[h.pattern]
- if !ok {
- p = endpoints{}
- pats[h.pattern] = p
- }
- p[mt] = h
- }
-
- for p, mh := range pats {
- hs := make(map[string]http.Handler)
- if mh[mALL] != nil && mh[mALL].handler != nil {
- hs["*"] = mh[mALL].handler
- }
-
- for mt, h := range mh {
- if h.handler == nil {
- continue
- }
- m := methodTypString(mt)
- if m == "" {
- continue
- }
- hs[m] = h.handler
- }
-
- rt := Route{subroutes, hs, p}
- rts = append(rts, rt)
- }
-
- return false
- })
-
- return rts
- }
-
- func (n *node) walk(fn func(eps endpoints, subroutes Routes) bool) bool {
- // Visit the leaf values if any
- if (n.endpoints != nil || n.subroutes != nil) && fn(n.endpoints, n.subroutes) {
- return true
- }
-
- // Recurse on the children
- for _, ns := range n.children {
- for _, cn := range ns {
- if cn.walk(fn) {
- return true
- }
- }
- }
- return false
- }
-
- // patNextSegment returns the next segment details from a pattern:
- // node type, param key, regexp string, param tail byte, param starting index, param ending index
- func patNextSegment(pattern string) (nodeTyp, string, string, byte, int, int) {
- ps := strings.Index(pattern, "{")
- ws := strings.Index(pattern, "*")
-
- if ps < 0 && ws < 0 {
- return ntStatic, "", "", 0, 0, len(pattern) // we return the entire thing
- }
-
- // Sanity check
- if ps >= 0 && ws >= 0 && ws < ps {
- panic("chi: wildcard '*' must be the last pattern in a route, otherwise use a '{param}'")
- }
-
- var tail byte = '/' // Default endpoint tail to / byte
-
- if ps >= 0 {
- // Param/Regexp pattern is next
- nt := ntParam
-
- // Read to closing } taking into account opens and closes in curl count (cc)
- cc := 0
- pe := ps
- for i, c := range pattern[ps:] {
- if c == '{' {
- cc++
- } else if c == '}' {
- cc--
- if cc == 0 {
- pe = ps + i
- break
- }
- }
- }
- if pe == ps {
- panic("chi: route param closing delimiter '}' is missing")
- }
-
- key := pattern[ps+1 : pe]
- pe++ // set end to next position
-
- if pe < len(pattern) {
- tail = pattern[pe]
- }
-
- var rexpat string
- if idx := strings.Index(key, ":"); idx >= 0 {
- nt = ntRegexp
- rexpat = key[idx+1:]
- key = key[:idx]
- }
-
- if len(rexpat) > 0 {
- if rexpat[0] != '^' {
- rexpat = "^" + rexpat
- }
- if rexpat[len(rexpat)-1] != '$' {
- rexpat += "$"
- }
- }
-
- return nt, key, rexpat, tail, ps, pe
- }
-
- // Wildcard pattern as finale
- if ws < len(pattern)-1 {
- panic("chi: wildcard '*' must be the last value in a route. trim trailing text or use a '{param}' instead")
- }
- return ntCatchAll, "*", "", 0, ws, len(pattern)
- }
-
- func patParamKeys(pattern string) []string {
- pat := pattern
- paramKeys := []string{}
- for {
- ptyp, paramKey, _, _, _, e := patNextSegment(pat)
- if ptyp == ntStatic {
- return paramKeys
- }
- for i := 0; i < len(paramKeys); i++ {
- if paramKeys[i] == paramKey {
- panic(fmt.Sprintf("chi: routing pattern '%s' contains duplicate param key, '%s'", pattern, paramKey))
- }
- }
- paramKeys = append(paramKeys, paramKey)
- pat = pat[e:]
- }
- }
-
- // longestPrefix finds the length of the shared prefix
- // of two strings
- func longestPrefix(k1, k2 string) int {
- max := len(k1)
- if l := len(k2); l < max {
- max = l
- }
- var i int
- for i = 0; i < max; i++ {
- if k1[i] != k2[i] {
- break
- }
- }
- return i
- }
-
- func methodTypString(method methodTyp) string {
- for s, t := range methodMap {
- if method == t {
- return s
- }
- }
- return ""
- }
-
- type nodes []*node
-
- // Sort the list of nodes by label
- func (ns nodes) Sort() { sort.Sort(ns); ns.tailSort() }
- func (ns nodes) Len() int { return len(ns) }
- func (ns nodes) Swap(i, j int) { ns[i], ns[j] = ns[j], ns[i] }
- func (ns nodes) Less(i, j int) bool { return ns[i].label < ns[j].label }
-
- // tailSort pushes nodes with '/' as the tail to the end of the list for param nodes.
- // The list order determines the traversal order.
- func (ns nodes) tailSort() {
- for i := len(ns) - 1; i >= 0; i-- {
- if ns[i].typ > ntStatic && ns[i].tail == '/' {
- ns.Swap(i, len(ns)-1)
- return
- }
- }
- }
-
- func (ns nodes) findEdge(label byte) *node {
- num := len(ns)
- idx := 0
- i, j := 0, num-1
- for i <= j {
- idx = i + (j-i)/2
- if label > ns[idx].label {
- i = idx + 1
- } else if label < ns[idx].label {
- j = idx - 1
- } else {
- i = num // breaks cond
- }
- }
- if ns[idx].label != label {
- return nil
- }
- return ns[idx]
- }
-
- // Route describes the details of a routing handler.
- // Handlers map key is an HTTP method
- type Route struct {
- SubRoutes Routes
- Handlers map[string]http.Handler
- Pattern string
- }
-
- // WalkFunc is the type of the function called for each method and route visited by Walk.
- type WalkFunc func(method string, route string, handler http.Handler, middlewares ...func(http.Handler) http.Handler) error
-
- // Walk walks any router tree that implements Routes interface.
- func Walk(r Routes, walkFn WalkFunc) error {
- return walk(r, walkFn, "")
- }
-
- func walk(r Routes, walkFn WalkFunc, parentRoute string, parentMw ...func(http.Handler) http.Handler) error {
- for _, route := range r.Routes() {
- mws := make([]func(http.Handler) http.Handler, len(parentMw))
- copy(mws, parentMw)
- mws = append(mws, r.Middlewares()...)
-
- if route.SubRoutes != nil {
- if err := walk(route.SubRoutes, walkFn, parentRoute+route.Pattern, mws...); err != nil {
- return err
- }
- continue
- }
-
- for method, handler := range route.Handlers {
- if method == "*" {
- // Ignore a "catchAll" method, since we pass down all the specific methods for each route.
- continue
- }
-
- fullRoute := parentRoute + route.Pattern
- fullRoute = strings.Replace(fullRoute, "/*/", "/", -1)
-
- if chain, ok := handler.(*ChainHandler); ok {
- if err := walkFn(method, fullRoute, chain.Endpoint, append(mws, chain.Middlewares...)...); err != nil {
- return err
- }
- } else {
- if err := walkFn(method, fullRoute, handler, mws...); err != nil {
- return err
- }
- }
- }
- }
-
- return nil
- }
|