From 9c6f92b16b3cf7f00ed3cd55af202040cd5b6134 Mon Sep 17 00:00:00 2001
From: 3ocene <7623873+ben-turner@users.noreply.github.com>
Date: Sat, 29 Oct 2022 15:24:43 -0700
Subject: [PATCH] add GetContext and ReleaseContext methods

- Add a method for retrieving a new *Context given an http.ResponseWriter and *http.Request.
- Add a method for returning to the pool *Contexts which were provided by *Engine.GetRequest to the pool

This allows contexts to be manipulated prior to handling whereas ServeHTTP does not provide the caller with access to the context.
---
 gin.go | 29 ++++++++++++++++++++++++++---
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/gin.go b/gin.go
index a2e2e67c..46cff494 100644
--- a/gin.go
+++ b/gin.go
@@ -562,16 +562,39 @@ func (engine *Engine) RunListener(listener net.Listener) (err error) {
 	return
 }
 
-// ServeHTTP conforms to the http.Handler interface.
-func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+// GetContext transforms a http.ResponseWriter and *http.Request into a new
+// *Context without handling the request. This new context can then be passed
+// to *Engine.HandleContext for handling.
+//
+// Any contexts created with this method are not automatically returned to the
+// pool, so it is recommended that you call *Engine.ReleaseContext when you are
+// done with it, though this is not required.
+func (engine *Engine) GetContext(w http.ResponseWriter, req *http.Request) *Context {
 	c := engine.pool.Get().(*Context)
 	c.writermem.reset(w)
 	c.Request = req
 	c.reset()
 
+	return c
+}
+
+// ReleaseContext releases a context created with *Engine.GetContext back into
+// the pool. Releasing a context marks it as available for reuse and therefore
+// must only be called once the context is no longer in use. Releasing a context
+// is not required, but it is recommended to improve performance. Calling this
+// method on a context that is not created with *Engine.GetContext will result
+// in undefined behavior.
+func (engine *Engine) ReleaseContext(c *Context) {
+	engine.pool.Put(c)
+}
+
+// ServeHTTP conforms to the http.Handler interface.
+func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	c := engine.GetContext(w, req)
+
 	engine.handleHTTPRequest(c)
 
-	engine.pool.Put(c)
+	engine.ReleaseContext(c)
 }
 
 // HandleContext re-enters a context that has been rewritten.