Update

vendor/github.com/aws/smithy-go/middleware/step_serialize.go

@@ -1,6 +1,10 @@
+// Code generated by smithy-go/middleware/generate.go DO NOT EDIT.
 package middleware
 
-import "context"
+import (
+	"context"
+	"fmt"
+)
 
 // SerializeInput provides the input parameters for the SerializeMiddleware to
 // consume. SerializeMiddleware may modify the Request value before forwarding
@@ -41,8 +45,8 @@ type SerializeMiddleware interface {
 	)
 }
 
-// SerializeMiddlewareFunc returns a SerializeMiddleware with the unique ID
-// provided, and the func to be invoked.
+// SerializeMiddlewareFunc returns a SerializeMiddleware with the unique ID provided,
+// and the func to be invoked.
 func SerializeMiddlewareFunc(id string, fn func(context.Context, SerializeInput, SerializeHandler) (SerializeOutput, Metadata, error)) SerializeMiddleware {
 	return serializeMiddlewareFunc{
 		id: id,
@@ -75,17 +79,15 @@ var _ SerializeMiddleware = (serializeMiddlewareFunc{})
 // SerializeStep provides the ordered grouping of SerializeMiddleware to be
 // invoked on a handler.
 type SerializeStep struct {
+	head       *decoratedSerializeHandler
+	tail       *decoratedSerializeHandler
 	newRequest func() interface{}
-	ids        *orderedIDs
 }
 
-// NewSerializeStep returns a SerializeStep ready to have middleware for
-// initialization added to it. The newRequest func parameter is used to
-// initialize the transport specific request for the stack SerializeStep to
-// serialize the input parameters into.
+// NewSerializeStep returns an SerializeStep ready to have middleware for
+// serialize added to it.
 func NewSerializeStep(newRequest func() interface{}) *SerializeStep {
 	return &SerializeStep{
-		ids:        newOrderedIDs(),
 		newRequest: newRequest,
 	}
 }
@@ -104,78 +106,162 @@ func (s *SerializeStep) ID() string {
 func (s *SerializeStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) (
 	out interface{}, metadata Metadata, err error,
 ) {
-	order := s.ids.GetOrder()
-
-	var h SerializeHandler = serializeWrapHandler{Next: next}
-	for i := len(order) - 1; i >= 0; i-- {
-		h = decoratedSerializeHandler{
-			Next: h,
-			With: order[i].(SerializeMiddleware),
-		}
-	}
-
 	sIn := SerializeInput{
 		Parameters: in,
 		Request:    s.newRequest(),
 	}
 
-	res, metadata, err := h.HandleSerialize(ctx, sIn)
+	wh := &serializeWrapHandler{next}
+	if s.head == nil {
+		res, metadata, err := wh.HandleSerialize(ctx, sIn)
+		return res.Result, metadata, err
+	}
+
+	s.tail.Next = wh
+	res, metadata, err := s.head.HandleSerialize(ctx, sIn)
 	return res.Result, metadata, err
 }
 
 // Get retrieves the middleware identified by id. If the middleware is not present, returns false.
 func (s *SerializeStep) Get(id string) (SerializeMiddleware, bool) {
-	get, ok := s.ids.Get(id)
-	if !ok {
+	found, _ := s.get(id)
+	if found == nil {
 		return nil, false
 	}
-	return get.(SerializeMiddleware), ok
+
+	return found.With, true
 }
 
 // Add injects the middleware to the relative position of the middleware group.
-// Returns an error if the middleware already exists.
+//
+// Add never returns an error. It used to for duplicate phases but this
+// behavior has since been removed as part of a performance optimization. The
+// return value from Add can be ignored.
 func (s *SerializeStep) Add(m SerializeMiddleware, pos RelativePosition) error {
-	return s.ids.Add(m, pos)
+	if s.head == nil {
+		s.head = &decoratedSerializeHandler{nil, m}
+		s.tail = s.head
+		return nil
+	}
+
+	if pos == Before {
+		s.head = &decoratedSerializeHandler{s.head, m}
+	} else {
+		tail := &decoratedSerializeHandler{nil, m}
+		s.tail.Next = tail
+		s.tail = tail
+	}
+
+	return nil
 }
 
 // Insert injects the middleware relative to an existing middleware ID.
 // Returns error if the original middleware does not exist, or the middleware
 // being added already exists.
 func (s *SerializeStep) Insert(m SerializeMiddleware, relativeTo string, pos RelativePosition) error {
-	return s.ids.Insert(m, relativeTo, pos)
+	found, prev := s.get(relativeTo)
+	if found == nil {
+		return fmt.Errorf("not found: %s", m.ID())
+	}
+
+	if pos == Before {
+		if prev == nil { // at the front
+			s.head = &decoratedSerializeHandler{s.head, m}
+		} else { // somewhere in the middle
+			prev.Next = &decoratedSerializeHandler{found, m}
+		}
+	} else {
+		if found.Next == nil { // at the end
+			tail := &decoratedSerializeHandler{nil, m}
+			s.tail.Next = tail
+			s.tail = tail
+		} else { // somewhere in the middle
+			found.Next = &decoratedSerializeHandler{found.Next, m}
+		}
+	}
+
+	return nil
 }
 
 // Swap removes the middleware by id, replacing it with the new middleware.
 // Returns the middleware removed, or error if the middleware to be removed
 // doesn't exist.
 func (s *SerializeStep) Swap(id string, m SerializeMiddleware) (SerializeMiddleware, error) {
-	removed, err := s.ids.Swap(id, m)
-	if err != nil {
-		return nil, err
+	found, _ := s.get(id)
+	if found == nil {
+		return nil, fmt.Errorf("not found: %s", m.ID())
 	}
 
-	return removed.(SerializeMiddleware), nil
+	swapped := found.With
+	found.With = m
+	return swapped, nil
 }
 
 // Remove removes the middleware by id. Returns error if the middleware
 // doesn't exist.
 func (s *SerializeStep) Remove(id string) (SerializeMiddleware, error) {
-	removed, err := s.ids.Remove(id)
-	if err != nil {
-		return nil, err
+	found, prev := s.get(id)
+	if found == nil {
+		return nil, fmt.Errorf("not found: %s", id)
 	}
 
-	return removed.(SerializeMiddleware), nil
+	if s.head == s.tail { // it's the only one
+		s.head = nil
+		s.tail = nil
+	} else if found == s.head { // at the front
+		s.head = s.head.Next.(*decoratedSerializeHandler)
+	} else if found == s.tail { // at the end
+		prev.Next = nil
+		s.tail = prev
+	} else {
+		prev.Next = found.Next // somewhere in the middle
+	}
+
+	return found.With, nil
 }
 
 // List returns a list of the middleware in the step.
 func (s *SerializeStep) List() []string {
-	return s.ids.List()
+	var ids []string
+	for h := s.head; h != nil; {
+		ids = append(ids, h.With.ID())
+		if h.Next == nil {
+			break
+		}
+
+		// once executed, tail.Next of the list will be set to an
+		// *serializeWrapHandler, make sure to check for that
+		if hnext, ok := h.Next.(*decoratedSerializeHandler); ok {
+			h = hnext
+		} else {
+			break
+		}
+	}
+	return ids
 }
 
 // Clear removes all middleware in the step.
 func (s *SerializeStep) Clear() {
-	s.ids.Clear()
+	s.head = nil
+	s.tail = nil
+}
+
+func (s *SerializeStep) get(id string) (found, prev *decoratedSerializeHandler) {
+	for h := s.head; h != nil; {
+		if h.With.ID() == id {
+			found = h
+			return
+		}
+		prev = h
+		if h.Next == nil {
+			return
+		}
+
+		// once executed, tail.Next of the list will be set to an
+		// *serializeWrapHandler
+		h, _ = h.Next.(*decoratedSerializeHandler)
+	}
+	return
 }
 
 type serializeWrapHandler struct {
@@ -184,7 +270,7 @@ type serializeWrapHandler struct {
 
 var _ SerializeHandler = (*serializeWrapHandler)(nil)
 
-// Implements SerializeHandler, converts types and delegates to underlying
+// HandleSerialize implements SerializeHandler, converts types and delegates to underlying
 // generic handler.
 func (w serializeWrapHandler) HandleSerialize(ctx context.Context, in SerializeInput) (
 	out SerializeOutput, metadata Metadata, err error,
@@ -208,12 +294,12 @@ func (h decoratedSerializeHandler) HandleSerialize(ctx context.Context, in Seria
 	return h.With.HandleSerialize(ctx, in, h.Next)
 }
 
-// SerializeHandlerFunc provides a wrapper around a function to be used as a serialize middleware handler.
+// SerializeHandlerFunc provides a wrapper around a function to be used as serializeMiddleware.
 type SerializeHandlerFunc func(context.Context, SerializeInput) (SerializeOutput, Metadata, error)
 
 // HandleSerialize calls the wrapped function with the provided arguments.
-func (s SerializeHandlerFunc) HandleSerialize(ctx context.Context, in SerializeInput) (SerializeOutput, Metadata, error) {
-	return s(ctx, in)
+func (f SerializeHandlerFunc) HandleSerialize(ctx context.Context, in SerializeInput) (SerializeOutput, Metadata, error) {
+	return f(ctx, in)
 }
 
 var _ SerializeHandler = SerializeHandlerFunc(nil)