-
-
Notifications
You must be signed in to change notification settings - Fork 2.5k
/
aliases.go
139 lines (135 loc) · 6.5 KB
/
aliases.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
package iris
import (
"github.com/kataras/iris/v12/context"
"github.com/kataras/iris/v12/core/host"
"github.com/kataras/iris/v12/core/router"
"github.com/kataras/iris/v12/hero"
)
type (
// Context is the middle-man server's "object" for the clients.
//
// A New context is being acquired from a sync.Pool on each connection.
// The Context is the most important thing on the iris's http flow.
//
// Developers send responses to the client's request through a Context.
// Developers get request information from the client's request by a Context.
Context = context.Context
// UnmarshalerFunc a shortcut, an alias for the `context#UnmarshalerFunc` type
// which implements the `context#Unmarshaler` interface for reading request's body
// via custom decoders, most of them already implement the `context#UnmarshalerFunc`
// like the json.Unmarshal, xml.Unmarshal, yaml.Unmarshal and every library which
// follows the best practises and is aligned with the Go standards.
//
// See 'context#UnmarshalBody` for more.
//
// Example: https://github.com/kataras/iris/blob/master/_examples/request-body/read-custom-via-unmarshaler/main.go
UnmarshalerFunc = context.UnmarshalerFunc
// A Handler responds to an HTTP request.
// It writes reply headers and data to the Context.ResponseWriter() and then return.
// Returning signals that the request is finished;
// it is not valid to use the Context after or concurrently with the completion of the Handler call.
//
// Depending on the HTTP client software, HTTP protocol version,
// and any intermediaries between the client and the iris server,
// it may not be possible to read from the Context.Request().Body after writing to the context.ResponseWriter().
// Cautious handlers should read the Context.Request().Body first, and then reply.
//
// Except for reading the body, handlers should not modify the provided Context.
//
// If Handler panics, the server (the caller of Handler) assumes that the effect of the panic was isolated to the active request.
// It recovers the panic, logs a stack trace to the server error log, and hangs up the connection.
Handler = context.Handler
// Filter is just a type of func(Handler) bool which reports whether an action must be performed
// based on the incoming request.
//
// See `NewConditionalHandler` for more.
// An alias for the `context/Filter`.
Filter = context.Filter
// A Map is an alias of map[string]interface{}.
Map = context.Map
// Problem Details for HTTP APIs.
// Pass a Problem value to `context.Problem` to
// write an "application/problem+json" response.
//
// Read more at: https://github.com/kataras/iris/wiki/Routing-error-handlers
//
// It is an alias of the `context#Problem` type.
Problem = context.Problem
// ProblemOptions the optional settings when server replies with a Problem.
// See `Context.Problem` method and `Problem` type for more details.
//
// It is an alias of the `context#ProblemOptions` type.
ProblemOptions = context.ProblemOptions
// JSON the optional settings for JSON renderer.
//
// It is an alias of the `context#JSON` type.
JSON = context.JSON
// ProtoMarshalOptions is a type alias for protojson.MarshalOptions.
ProtoMarshalOptions = context.ProtoMarshalOptions
// ProtoUnmarshalOptions is a type alias for protojson.UnmarshalOptions.
ProtoUnmarshalOptions = context.ProtoUnmarshalOptions
// XML the optional settings for XML renderer.
//
// It is an alias of the `context#XML` type.
XML = context.XML
// Supervisor is a shortcut of the `host#Supervisor`.
// Used to add supervisor configurators on common Runners
// without the need of importing the `core/host` package.
Supervisor = host.Supervisor
// Party is just a group joiner of routes which have the same prefix and share same middleware(s) also.
// Party could also be named as 'Join' or 'Node' or 'Group' , Party chosen because it is fun.
//
// Look the `core/router#APIBuilder` for its implementation.
//
// A shortcut for the `core/router#Party`, useful when `PartyFunc` is being used.
Party = router.Party
// APIContainer is a wrapper of a common `Party` featured by Dependency Injection.
// See `Party.ConfigureContainer` for more.
//
// A shortcut for the `core/router#APIContainer`.
APIContainer = router.APIContainer
// ResultHandler describes the function type which should serve the "v" struct value.
// See `APIContainer.UseResultHandler`.
ResultHandler = hero.ResultHandler
// DirOptions contains the optional settings that
// `FileServer` and `Party#HandleDir` can use to serve files and assets.
// A shortcut for the `router.DirOptions`, useful when `FileServer` or `HandleDir` is being used.
DirOptions = router.DirOptions
// Attachments options for files to be downloaded and saved locally by the client.
// See `DirOptions`.
Attachments = router.Attachments
// DirListRichOptions the options for the `DirListRich` helper function.
// A shortcut for the `router.DirListRichOptions`.
// Useful when `DirListRich` function is passed to `DirOptions.DirList` field.
DirListRichOptions = router.DirListRichOptions
// ExecutionRules gives control to the execution of the route handlers outside of the handlers themselves.
// Usage:
// Party#SetExecutionRules(ExecutionRules {
// Done: ExecutionOptions{Force: true},
// })
//
// See `core/router/Party#SetExecutionRules` for more.
// Example: https://github.com/kataras/iris/tree/master/_examples/mvc/middleware/without-ctx-next
ExecutionRules = router.ExecutionRules
// ExecutionOptions is a set of default behaviors that can be changed in order to customize the execution flow of the routes' handlers with ease.
//
// See `ExecutionRules` and `core/router/Party#SetExecutionRules` for more.
ExecutionOptions = router.ExecutionOptions
// CookieOption is the type of function that is accepted on
// context's methods like `SetCookieKV`, `RemoveCookie` and `SetCookie`
// as their (last) variadic input argument to amend the end cookie's form.
//
// Any custom or builtin `CookieOption` is valid,
// see `CookiePath`, `CookieCleanPath`, `CookieExpires` and `CookieHTTPOnly` for more.
//
// An alias for the `context/Context#CookieOption`.
CookieOption = context.CookieOption
// N is a struct which can be passed on the `Context.Negotiate` method.
// It contains fields which should be filled based on the `Context.Negotiation()`
// server side values. If no matched mime then its "Other" field will be sent,
// which should be a string or []byte.
// It completes the `context/context.ContentSelector` interface.
//
// An alias for the `context/Context#N`.
N = context.N
)