Method insert

router.go:66–150

insert walks the tree and registers handlers at the terminal node.

(method, path string, handlers []Handler, paramNames []string)

// insert walks the tree and registers handlers at the terminal node.
func (n *node) insert(method, path string, handlers []Handler, paramNames []string) {
	// Reached the end of the path — this is the leaf.
	if path == "" {
		if n.handlers == nil {
			n.handlers = make(map[string][]Handler)
		}
		n.handlers[method] = handlers
		n.paramNames = paramNames
		return
	}

	// Consume the next segment (up to the next '/' or end of string).
	seg, rest := nextSegment(path)

	if seg == "" {
		// Consecutive or trailing slash — skip and continue.
		n.insert(method, rest, handlers, paramNames)
		return
	}

	firstByte := seg[0]

	switch firstByte {
	case ':':
		// Parametric segment.
		paramName := seg[1:]
		if n.paramChild == nil {
			n.paramChild = &node{}
		}
		n.paramChild.insert(method, rest, handlers, append(paramNames, paramName))

	case '*':
		// Catch-all wildcard. Remaining path captured as one param.
		paramName := seg[1:]
		if paramName == "" {
			paramName = "wildcard"
		}
		if n.wildcard == nil {
			n.wildcard = &node{}
		}
		if n.wildcard.handlers == nil {
			n.wildcard.handlers = make(map[string][]Handler)
		}
		n.wildcard.handlers[method] = handlers
		n.wildcard.paramNames = append(paramNames, paramName)

	default:
		// Static segment.
		if n.children == nil {
			n.children = make(map[byte]*node)
		}
		child, ok := n.children[firstByte]
		if !ok {
			child = &node{path: seg}
			n.children[firstByte] = child
			child.insert(method, rest, handlers, paramNames)
			return
		}