step_deserialize.go

Documentation: github.com/aws/smithy-go/middleware

     1  package middleware
     2  
     3  import (
     4  	"context"
     5  )
     6  
     7  // DeserializeInput provides the input parameters for the DeserializeInput to
     8  // consume. DeserializeMiddleware should not modify the Request, and instead
     9  // forward it along to the next DeserializeHandler.
    10  type DeserializeInput struct {
    11  	Request interface{}
    12  }
    13  
    14  // DeserializeOutput provides the result returned by the next
    15  // DeserializeHandler. The DeserializeMiddleware should deserialize the
    16  // RawResponse into a Result that can be consumed by middleware higher up in
    17  // the stack.
    18  type DeserializeOutput struct {
    19  	RawResponse interface{}
    20  	Result      interface{}
    21  }
    22  
    23  // DeserializeHandler provides the interface for the next handler the
    24  // DeserializeMiddleware will call in the middleware chain.
    25  type DeserializeHandler interface {
    26  	HandleDeserialize(ctx context.Context, in DeserializeInput) (
    27  		out DeserializeOutput, metadata Metadata, err error,
    28  	)
    29  }
    30  
    31  // DeserializeMiddleware provides the interface for middleware specific to the
    32  // serialize step. Delegates to the next DeserializeHandler for further
    33  // processing.
    34  type DeserializeMiddleware interface {
    35  	// ID returns a unique ID for the middleware in the DeserializeStep. The step does not
    36  	// allow duplicate IDs.
    37  	ID() string
    38  
    39  	// HandleDeserialize invokes the middleware behavior which must delegate to the next handler
    40  	// for the middleware chain to continue. The method must return a result or
    41  	// error to its caller.
    42  	HandleDeserialize(ctx context.Context, in DeserializeInput, next DeserializeHandler) (
    43  		out DeserializeOutput, metadata Metadata, err error,
    44  	)
    45  }
    46  
    47  // DeserializeMiddlewareFunc returns a DeserializeMiddleware with the unique ID
    48  // provided, and the func to be invoked.
    49  func DeserializeMiddlewareFunc(id string, fn func(context.Context, DeserializeInput, DeserializeHandler) (DeserializeOutput, Metadata, error)) DeserializeMiddleware {
    50  	return deserializeMiddlewareFunc{
    51  		id: id,
    52  		fn: fn,
    53  	}
    54  }
    55  
    56  type deserializeMiddlewareFunc struct {
    57  	// Unique ID for the middleware.
    58  	id string
    59  
    60  	// Middleware function to be called.
    61  	fn func(context.Context, DeserializeInput, DeserializeHandler) (
    62  		DeserializeOutput, Metadata, error,
    63  	)
    64  }
    65  
    66  // ID returns the unique ID for the middleware.
    67  func (s deserializeMiddlewareFunc) ID() string { return s.id }
    68  
    69  // HandleDeserialize invokes the middleware Fn.
    70  func (s deserializeMiddlewareFunc) HandleDeserialize(ctx context.Context, in DeserializeInput, next DeserializeHandler) (
    71  	out DeserializeOutput, metadata Metadata, err error,
    72  ) {
    73  	return s.fn(ctx, in, next)
    74  }
    75  
    76  var _ DeserializeMiddleware = (deserializeMiddlewareFunc{})
    77  
    78  // DeserializeStep provides the ordered grouping of DeserializeMiddleware to be
    79  // invoked on a handler.
    80  type DeserializeStep struct {
    81  	ids *orderedIDs
    82  }
    83  
    84  // NewDeserializeStep returns a DeserializeStep ready to have middleware for
    85  // initialization added to it.
    86  func NewDeserializeStep() *DeserializeStep {
    87  	return &DeserializeStep{
    88  		ids: newOrderedIDs(),
    89  	}
    90  }
    91  
    92  var _ Middleware = (*DeserializeStep)(nil)
    93  
    94  // ID returns the unique ID of the step as a middleware.
    95  func (s *DeserializeStep) ID() string {
    96  	return "Deserialize stack step"
    97  }
    98  
    99  // HandleMiddleware invokes the middleware by decorating the next handler
   100  // provided. Returns the result of the middleware and handler being invoked.
   101  //
   102  // Implements Middleware interface.
   103  func (s *DeserializeStep) HandleMiddleware(ctx context.Context, in interface{}, next Handler) (
   104  	out interface{}, metadata Metadata, err error,
   105  ) {
   106  	order := s.ids.GetOrder()
   107  
   108  	var h DeserializeHandler = deserializeWrapHandler{Next: next}
   109  	for i := len(order) - 1; i >= 0; i-- {
   110  		h = decoratedDeserializeHandler{
   111  			Next: h,
   112  			With: order[i].(DeserializeMiddleware),
   113  		}
   114  	}
   115  
   116  	sIn := DeserializeInput{
   117  		Request: in,
   118  	}
   119  
   120  	res, metadata, err := h.HandleDeserialize(ctx, sIn)
   121  	return res.Result, metadata, err
   122  }
   123  
   124  // Get retrieves the middleware identified by id. If the middleware is not present, returns false.
   125  func (s *DeserializeStep) Get(id string) (DeserializeMiddleware, bool) {
   126  	get, ok := s.ids.Get(id)
   127  	if !ok {
   128  		return nil, false
   129  	}
   130  	return get.(DeserializeMiddleware), ok
   131  }
   132  
   133  // Add injects the middleware to the relative position of the middleware group.
   134  // Returns an error if the middleware already exists.
   135  func (s *DeserializeStep) Add(m DeserializeMiddleware, pos RelativePosition) error {
   136  	return s.ids.Add(m, pos)
   137  }
   138  
   139  // Insert injects the middleware relative to an existing middleware ID.
   140  // Returns error if the original middleware does not exist, or the middleware
   141  // being added already exists.
   142  func (s *DeserializeStep) Insert(m DeserializeMiddleware, relativeTo string, pos RelativePosition) error {
   143  	return s.ids.Insert(m, relativeTo, pos)
   144  }
   145  
   146  // Swap removes the middleware by id, replacing it with the new middleware.
   147  // Returns the middleware removed, or error if the middleware to be removed
   148  // doesn't exist.
   149  func (s *DeserializeStep) Swap(id string, m DeserializeMiddleware) (DeserializeMiddleware, error) {
   150  	removed, err := s.ids.Swap(id, m)
   151  	if err != nil {
   152  		return nil, err
   153  	}
   154  
   155  	return removed.(DeserializeMiddleware), nil
   156  }
   157  
   158  // Remove removes the middleware by id. Returns error if the middleware
   159  // doesn't exist.
   160  func (s *DeserializeStep) Remove(id string) (DeserializeMiddleware, error) {
   161  	removed, err := s.ids.Remove(id)
   162  	if err != nil {
   163  		return nil, err
   164  	}
   165  
   166  	return removed.(DeserializeMiddleware), nil
   167  }
   168  
   169  // List returns a list of the middleware in the step.
   170  func (s *DeserializeStep) List() []string {
   171  	return s.ids.List()
   172  }
   173  
   174  // Clear removes all middleware in the step.
   175  func (s *DeserializeStep) Clear() {
   176  	s.ids.Clear()
   177  }
   178  
   179  type deserializeWrapHandler struct {
   180  	Next Handler
   181  }
   182  
   183  var _ DeserializeHandler = (*deserializeWrapHandler)(nil)
   184  
   185  // HandleDeserialize implements DeserializeHandler, converts types and delegates to underlying
   186  // generic handler.
   187  func (w deserializeWrapHandler) HandleDeserialize(ctx context.Context, in DeserializeInput) (
   188  	out DeserializeOutput, metadata Metadata, err error,
   189  ) {
   190  	resp, metadata, err := w.Next.Handle(ctx, in.Request)
   191  	return DeserializeOutput{
   192  		RawResponse: resp,
   193  	}, metadata, err
   194  }
   195  
   196  type decoratedDeserializeHandler struct {
   197  	Next DeserializeHandler
   198  	With DeserializeMiddleware
   199  }
   200  
   201  var _ DeserializeHandler = (*decoratedDeserializeHandler)(nil)
   202  
   203  func (h decoratedDeserializeHandler) HandleDeserialize(ctx context.Context, in DeserializeInput) (
   204  	out DeserializeOutput, metadata Metadata, err error,
   205  ) {
   206  	return h.With.HandleDeserialize(ctx, in, h.Next)
   207  }
   208  
   209  // DeserializeHandlerFunc provides a wrapper around a function to be used as a deserialize middleware handler.
   210  type DeserializeHandlerFunc func(context.Context, DeserializeInput) (DeserializeOutput, Metadata, error)
   211  
   212  // HandleDeserialize invokes the wrapped function with the given arguments.
   213  func (d DeserializeHandlerFunc) HandleDeserialize(ctx context.Context, in DeserializeInput) (DeserializeOutput, Metadata, error) {
   214  	return d(ctx, in)
   215  }
   216  
   217  var _ DeserializeHandler = DeserializeHandlerFunc(nil)
   218
View as plain text