mirror of
https://github.com/VictoriaMetrics/VictoriaMetrics.git
synced 2026-07-28 19:41:51 +03:00
16180 lines
472 KiB
Go
16180 lines
472 KiB
Go
// Code generated by "httpsnoop/codegen"; DO NOT EDIT.
|
|
|
|
package httpsnoop
|
|
|
|
import (
|
|
"bufio"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"time"
|
|
)
|
|
|
|
// HeaderFunc is part of the http.ResponseWriter interface.
|
|
type HeaderFunc func() http.Header
|
|
|
|
// WriteHeaderFunc is part of the http.ResponseWriter interface.
|
|
type WriteHeaderFunc func(code int)
|
|
|
|
// WriteFunc is part of the http.ResponseWriter interface.
|
|
type WriteFunc func(b []byte) (int, error)
|
|
|
|
// FlushFunc is part of the http.Flusher interface.
|
|
type FlushFunc func()
|
|
|
|
// FlushErrorFunc is part of the httpFlushError interface.
|
|
type FlushErrorFunc func() error
|
|
|
|
// CloseNotifyFunc is part of the http.CloseNotifier interface.
|
|
type CloseNotifyFunc func() <-chan bool
|
|
|
|
// HijackFunc is part of the http.Hijacker interface.
|
|
type HijackFunc func() (net.Conn, *bufio.ReadWriter, error)
|
|
|
|
// ReadFromFunc is part of the io.ReaderFrom interface.
|
|
type ReadFromFunc func(src io.Reader) (int64, error)
|
|
|
|
// SetReadDeadlineFunc is part of the deadliner interface.
|
|
type SetReadDeadlineFunc func(deadline time.Time) error
|
|
|
|
// SetWriteDeadlineFunc is part of the deadliner interface.
|
|
type SetWriteDeadlineFunc func(deadline time.Time) error
|
|
|
|
// EnableFullDuplexFunc is part of the fullDuplexEnabler interface.
|
|
type EnableFullDuplexFunc func() error
|
|
|
|
// PushFunc is part of the http.Pusher interface.
|
|
type PushFunc func(target string, opts *http.PushOptions) error
|
|
|
|
// WriteStringFunc is part of the io.StringWriter interface.
|
|
type WriteStringFunc func(s string) (int, error)
|
|
|
|
// Hooks defines a set of method interceptors for methods included in
|
|
// http.ResponseWriter as well as some others. You can think of them as
|
|
// middleware for the function calls they target. See Wrap for more details.
|
|
//
|
|
// For each method, the exact matching hook takes precedence. For example,
|
|
// WriteString calls the WriteString hook when it is configured, even if a
|
|
// Write hook is also configured. If the exact hook is not configured, most
|
|
// methods call through to the underlying ResponseWriter directly.
|
|
//
|
|
// Two compatibility fallbacks preserve the behavior users had before Wrap
|
|
// learned about newer optional interfaces:
|
|
// - If the underlying ResponseWriter implements io.StringWriter and
|
|
// WriteString is called, but only the Write hook is configured, WriteString
|
|
// is routed through the Write hook with []byte(s). If neither hook is
|
|
// configured, WriteString calls the underlying WriteString method directly.
|
|
// - If the underlying ResponseWriter implements both http.Flusher and
|
|
// FlushError, and FlushError is called, but only the Flush hook is
|
|
// configured, FlushError is routed through the Flush hook while preserving
|
|
// the error returned by the underlying FlushError method. If neither hook is
|
|
// configured, FlushError calls the underlying FlushError method directly.
|
|
type Hooks struct {
|
|
Header func(HeaderFunc) HeaderFunc
|
|
WriteHeader func(WriteHeaderFunc) WriteHeaderFunc
|
|
Write func(WriteFunc) WriteFunc
|
|
Flush func(FlushFunc) FlushFunc
|
|
FlushError func(FlushErrorFunc) FlushErrorFunc
|
|
CloseNotify func(CloseNotifyFunc) CloseNotifyFunc
|
|
Hijack func(HijackFunc) HijackFunc
|
|
ReadFrom func(ReadFromFunc) ReadFromFunc
|
|
SetReadDeadline func(SetReadDeadlineFunc) SetReadDeadlineFunc
|
|
SetWriteDeadline func(SetWriteDeadlineFunc) SetWriteDeadlineFunc
|
|
EnableFullDuplex func(EnableFullDuplexFunc) EnableFullDuplexFunc
|
|
Push func(PushFunc) PushFunc
|
|
WriteString func(WriteStringFunc) WriteStringFunc
|
|
}
|
|
|
|
// Wrap returns a wrapped version of w that provides the exact same interface
|
|
// as w. Specifically if w implements any combination of:
|
|
//
|
|
// - http.Flusher
|
|
// - httpFlushError
|
|
// - http.CloseNotifier
|
|
// - http.Hijacker
|
|
// - io.ReaderFrom
|
|
// - deadliner
|
|
// - fullDuplexEnabler
|
|
// - http.Pusher
|
|
// - io.StringWriter
|
|
//
|
|
// The wrapped version will implement the exact same combination. If no hooks
|
|
// are set, the wrapped version also behaves exactly as w. Hooks targeting
|
|
// methods not supported by w are ignored. Any other hooks will intercept the
|
|
// method they target and may modify the call's arguments and/or return values.
|
|
// The CaptureMetrics implementation serves as a working example for how the
|
|
// hooks can be used.
|
|
func Wrap(w http.ResponseWriter, hooks Hooks) http.ResponseWriter {
|
|
state := &rwState{w: w}
|
|
var combo uint16
|
|
if hooks.Header != nil {
|
|
state.header = hooks.Header(w.Header)
|
|
}
|
|
if hooks.WriteHeader != nil {
|
|
state.writeHeader = hooks.WriteHeader(w.WriteHeader)
|
|
}
|
|
if hooks.Write != nil {
|
|
state.write = hooks.Write(w.Write)
|
|
}
|
|
if t0, i0 := w.(http.Flusher); i0 {
|
|
combo |= 1 << 8
|
|
if hooks.Flush != nil {
|
|
state.flush = hooks.Flush(t0.Flush)
|
|
}
|
|
}
|
|
if t1, i1 := w.(httpFlushError); i1 {
|
|
combo |= 1 << 7
|
|
if hooks.FlushError != nil {
|
|
state.flushError = hooks.FlushError(t1.FlushError)
|
|
} else if state.flush != nil {
|
|
state.flushError = func() (err error) { hooks.Flush(func() { err = t1.FlushError() })(); return err }
|
|
}
|
|
}
|
|
if t2, i2 := w.(http.CloseNotifier); i2 {
|
|
combo |= 1 << 6
|
|
if hooks.CloseNotify != nil {
|
|
state.closeNotify = hooks.CloseNotify(t2.CloseNotify)
|
|
}
|
|
}
|
|
if t3, i3 := w.(http.Hijacker); i3 {
|
|
combo |= 1 << 5
|
|
if hooks.Hijack != nil {
|
|
state.hijack = hooks.Hijack(t3.Hijack)
|
|
}
|
|
}
|
|
if t4, i4 := w.(io.ReaderFrom); i4 {
|
|
combo |= 1 << 4
|
|
if hooks.ReadFrom != nil {
|
|
state.readFrom = hooks.ReadFrom(t4.ReadFrom)
|
|
}
|
|
}
|
|
if t5, i5 := w.(deadliner); i5 {
|
|
combo |= 1 << 3
|
|
if hooks.SetReadDeadline != nil {
|
|
state.setReadDeadline = hooks.SetReadDeadline(t5.SetReadDeadline)
|
|
}
|
|
if hooks.SetWriteDeadline != nil {
|
|
state.setWriteDeadline = hooks.SetWriteDeadline(t5.SetWriteDeadline)
|
|
}
|
|
}
|
|
if t6, i6 := w.(fullDuplexEnabler); i6 {
|
|
combo |= 1 << 2
|
|
if hooks.EnableFullDuplex != nil {
|
|
state.enableFullDuplex = hooks.EnableFullDuplex(t6.EnableFullDuplex)
|
|
}
|
|
}
|
|
if t7, i7 := w.(http.Pusher); i7 {
|
|
combo |= 1 << 1
|
|
if hooks.Push != nil {
|
|
state.push = hooks.Push(t7.Push)
|
|
}
|
|
}
|
|
if t8, i8 := w.(io.StringWriter); i8 {
|
|
combo |= 1 << 0
|
|
if hooks.WriteString != nil {
|
|
state.writeString = hooks.WriteString(t8.WriteString)
|
|
} else if state.write != nil {
|
|
state.writeString = func(s string) (int, error) { return state.write([]byte(s)) }
|
|
}
|
|
}
|
|
switch combo {
|
|
case 0:
|
|
return (*rw0)(state)
|
|
case 1:
|
|
return (*rw1)(state)
|
|
case 2:
|
|
return (*rw2)(state)
|
|
case 3:
|
|
return (*rw3)(state)
|
|
case 4:
|
|
return (*rw4)(state)
|
|
case 5:
|
|
return (*rw5)(state)
|
|
case 6:
|
|
return (*rw6)(state)
|
|
case 7:
|
|
return (*rw7)(state)
|
|
case 8:
|
|
return (*rw8)(state)
|
|
case 9:
|
|
return (*rw9)(state)
|
|
case 10:
|
|
return (*rw10)(state)
|
|
case 11:
|
|
return (*rw11)(state)
|
|
case 12:
|
|
return (*rw12)(state)
|
|
case 13:
|
|
return (*rw13)(state)
|
|
case 14:
|
|
return (*rw14)(state)
|
|
case 15:
|
|
return (*rw15)(state)
|
|
case 16:
|
|
return (*rw16)(state)
|
|
case 17:
|
|
return (*rw17)(state)
|
|
case 18:
|
|
return (*rw18)(state)
|
|
case 19:
|
|
return (*rw19)(state)
|
|
case 20:
|
|
return (*rw20)(state)
|
|
case 21:
|
|
return (*rw21)(state)
|
|
case 22:
|
|
return (*rw22)(state)
|
|
case 23:
|
|
return (*rw23)(state)
|
|
case 24:
|
|
return (*rw24)(state)
|
|
case 25:
|
|
return (*rw25)(state)
|
|
case 26:
|
|
return (*rw26)(state)
|
|
case 27:
|
|
return (*rw27)(state)
|
|
case 28:
|
|
return (*rw28)(state)
|
|
case 29:
|
|
return (*rw29)(state)
|
|
case 30:
|
|
return (*rw30)(state)
|
|
case 31:
|
|
return (*rw31)(state)
|
|
case 32:
|
|
return (*rw32)(state)
|
|
case 33:
|
|
return (*rw33)(state)
|
|
case 34:
|
|
return (*rw34)(state)
|
|
case 35:
|
|
return (*rw35)(state)
|
|
case 36:
|
|
return (*rw36)(state)
|
|
case 37:
|
|
return (*rw37)(state)
|
|
case 38:
|
|
return (*rw38)(state)
|
|
case 39:
|
|
return (*rw39)(state)
|
|
case 40:
|
|
return (*rw40)(state)
|
|
case 41:
|
|
return (*rw41)(state)
|
|
case 42:
|
|
return (*rw42)(state)
|
|
case 43:
|
|
return (*rw43)(state)
|
|
case 44:
|
|
return (*rw44)(state)
|
|
case 45:
|
|
return (*rw45)(state)
|
|
case 46:
|
|
return (*rw46)(state)
|
|
case 47:
|
|
return (*rw47)(state)
|
|
case 48:
|
|
return (*rw48)(state)
|
|
case 49:
|
|
return (*rw49)(state)
|
|
case 50:
|
|
return (*rw50)(state)
|
|
case 51:
|
|
return (*rw51)(state)
|
|
case 52:
|
|
return (*rw52)(state)
|
|
case 53:
|
|
return (*rw53)(state)
|
|
case 54:
|
|
return (*rw54)(state)
|
|
case 55:
|
|
return (*rw55)(state)
|
|
case 56:
|
|
return (*rw56)(state)
|
|
case 57:
|
|
return (*rw57)(state)
|
|
case 58:
|
|
return (*rw58)(state)
|
|
case 59:
|
|
return (*rw59)(state)
|
|
case 60:
|
|
return (*rw60)(state)
|
|
case 61:
|
|
return (*rw61)(state)
|
|
case 62:
|
|
return (*rw62)(state)
|
|
case 63:
|
|
return (*rw63)(state)
|
|
case 64:
|
|
return (*rw64)(state)
|
|
case 65:
|
|
return (*rw65)(state)
|
|
case 66:
|
|
return (*rw66)(state)
|
|
case 67:
|
|
return (*rw67)(state)
|
|
case 68:
|
|
return (*rw68)(state)
|
|
case 69:
|
|
return (*rw69)(state)
|
|
case 70:
|
|
return (*rw70)(state)
|
|
case 71:
|
|
return (*rw71)(state)
|
|
case 72:
|
|
return (*rw72)(state)
|
|
case 73:
|
|
return (*rw73)(state)
|
|
case 74:
|
|
return (*rw74)(state)
|
|
case 75:
|
|
return (*rw75)(state)
|
|
case 76:
|
|
return (*rw76)(state)
|
|
case 77:
|
|
return (*rw77)(state)
|
|
case 78:
|
|
return (*rw78)(state)
|
|
case 79:
|
|
return (*rw79)(state)
|
|
case 80:
|
|
return (*rw80)(state)
|
|
case 81:
|
|
return (*rw81)(state)
|
|
case 82:
|
|
return (*rw82)(state)
|
|
case 83:
|
|
return (*rw83)(state)
|
|
case 84:
|
|
return (*rw84)(state)
|
|
case 85:
|
|
return (*rw85)(state)
|
|
case 86:
|
|
return (*rw86)(state)
|
|
case 87:
|
|
return (*rw87)(state)
|
|
case 88:
|
|
return (*rw88)(state)
|
|
case 89:
|
|
return (*rw89)(state)
|
|
case 90:
|
|
return (*rw90)(state)
|
|
case 91:
|
|
return (*rw91)(state)
|
|
case 92:
|
|
return (*rw92)(state)
|
|
case 93:
|
|
return (*rw93)(state)
|
|
case 94:
|
|
return (*rw94)(state)
|
|
case 95:
|
|
return (*rw95)(state)
|
|
case 96:
|
|
return (*rw96)(state)
|
|
case 97:
|
|
return (*rw97)(state)
|
|
case 98:
|
|
return (*rw98)(state)
|
|
case 99:
|
|
return (*rw99)(state)
|
|
case 100:
|
|
return (*rw100)(state)
|
|
case 101:
|
|
return (*rw101)(state)
|
|
case 102:
|
|
return (*rw102)(state)
|
|
case 103:
|
|
return (*rw103)(state)
|
|
case 104:
|
|
return (*rw104)(state)
|
|
case 105:
|
|
return (*rw105)(state)
|
|
case 106:
|
|
return (*rw106)(state)
|
|
case 107:
|
|
return (*rw107)(state)
|
|
case 108:
|
|
return (*rw108)(state)
|
|
case 109:
|
|
return (*rw109)(state)
|
|
case 110:
|
|
return (*rw110)(state)
|
|
case 111:
|
|
return (*rw111)(state)
|
|
case 112:
|
|
return (*rw112)(state)
|
|
case 113:
|
|
return (*rw113)(state)
|
|
case 114:
|
|
return (*rw114)(state)
|
|
case 115:
|
|
return (*rw115)(state)
|
|
case 116:
|
|
return (*rw116)(state)
|
|
case 117:
|
|
return (*rw117)(state)
|
|
case 118:
|
|
return (*rw118)(state)
|
|
case 119:
|
|
return (*rw119)(state)
|
|
case 120:
|
|
return (*rw120)(state)
|
|
case 121:
|
|
return (*rw121)(state)
|
|
case 122:
|
|
return (*rw122)(state)
|
|
case 123:
|
|
return (*rw123)(state)
|
|
case 124:
|
|
return (*rw124)(state)
|
|
case 125:
|
|
return (*rw125)(state)
|
|
case 126:
|
|
return (*rw126)(state)
|
|
case 127:
|
|
return (*rw127)(state)
|
|
case 128:
|
|
return (*rw128)(state)
|
|
case 129:
|
|
return (*rw129)(state)
|
|
case 130:
|
|
return (*rw130)(state)
|
|
case 131:
|
|
return (*rw131)(state)
|
|
case 132:
|
|
return (*rw132)(state)
|
|
case 133:
|
|
return (*rw133)(state)
|
|
case 134:
|
|
return (*rw134)(state)
|
|
case 135:
|
|
return (*rw135)(state)
|
|
case 136:
|
|
return (*rw136)(state)
|
|
case 137:
|
|
return (*rw137)(state)
|
|
case 138:
|
|
return (*rw138)(state)
|
|
case 139:
|
|
return (*rw139)(state)
|
|
case 140:
|
|
return (*rw140)(state)
|
|
case 141:
|
|
return (*rw141)(state)
|
|
case 142:
|
|
return (*rw142)(state)
|
|
case 143:
|
|
return (*rw143)(state)
|
|
case 144:
|
|
return (*rw144)(state)
|
|
case 145:
|
|
return (*rw145)(state)
|
|
case 146:
|
|
return (*rw146)(state)
|
|
case 147:
|
|
return (*rw147)(state)
|
|
case 148:
|
|
return (*rw148)(state)
|
|
case 149:
|
|
return (*rw149)(state)
|
|
case 150:
|
|
return (*rw150)(state)
|
|
case 151:
|
|
return (*rw151)(state)
|
|
case 152:
|
|
return (*rw152)(state)
|
|
case 153:
|
|
return (*rw153)(state)
|
|
case 154:
|
|
return (*rw154)(state)
|
|
case 155:
|
|
return (*rw155)(state)
|
|
case 156:
|
|
return (*rw156)(state)
|
|
case 157:
|
|
return (*rw157)(state)
|
|
case 158:
|
|
return (*rw158)(state)
|
|
case 159:
|
|
return (*rw159)(state)
|
|
case 160:
|
|
return (*rw160)(state)
|
|
case 161:
|
|
return (*rw161)(state)
|
|
case 162:
|
|
return (*rw162)(state)
|
|
case 163:
|
|
return (*rw163)(state)
|
|
case 164:
|
|
return (*rw164)(state)
|
|
case 165:
|
|
return (*rw165)(state)
|
|
case 166:
|
|
return (*rw166)(state)
|
|
case 167:
|
|
return (*rw167)(state)
|
|
case 168:
|
|
return (*rw168)(state)
|
|
case 169:
|
|
return (*rw169)(state)
|
|
case 170:
|
|
return (*rw170)(state)
|
|
case 171:
|
|
return (*rw171)(state)
|
|
case 172:
|
|
return (*rw172)(state)
|
|
case 173:
|
|
return (*rw173)(state)
|
|
case 174:
|
|
return (*rw174)(state)
|
|
case 175:
|
|
return (*rw175)(state)
|
|
case 176:
|
|
return (*rw176)(state)
|
|
case 177:
|
|
return (*rw177)(state)
|
|
case 178:
|
|
return (*rw178)(state)
|
|
case 179:
|
|
return (*rw179)(state)
|
|
case 180:
|
|
return (*rw180)(state)
|
|
case 181:
|
|
return (*rw181)(state)
|
|
case 182:
|
|
return (*rw182)(state)
|
|
case 183:
|
|
return (*rw183)(state)
|
|
case 184:
|
|
return (*rw184)(state)
|
|
case 185:
|
|
return (*rw185)(state)
|
|
case 186:
|
|
return (*rw186)(state)
|
|
case 187:
|
|
return (*rw187)(state)
|
|
case 188:
|
|
return (*rw188)(state)
|
|
case 189:
|
|
return (*rw189)(state)
|
|
case 190:
|
|
return (*rw190)(state)
|
|
case 191:
|
|
return (*rw191)(state)
|
|
case 192:
|
|
return (*rw192)(state)
|
|
case 193:
|
|
return (*rw193)(state)
|
|
case 194:
|
|
return (*rw194)(state)
|
|
case 195:
|
|
return (*rw195)(state)
|
|
case 196:
|
|
return (*rw196)(state)
|
|
case 197:
|
|
return (*rw197)(state)
|
|
case 198:
|
|
return (*rw198)(state)
|
|
case 199:
|
|
return (*rw199)(state)
|
|
case 200:
|
|
return (*rw200)(state)
|
|
case 201:
|
|
return (*rw201)(state)
|
|
case 202:
|
|
return (*rw202)(state)
|
|
case 203:
|
|
return (*rw203)(state)
|
|
case 204:
|
|
return (*rw204)(state)
|
|
case 205:
|
|
return (*rw205)(state)
|
|
case 206:
|
|
return (*rw206)(state)
|
|
case 207:
|
|
return (*rw207)(state)
|
|
case 208:
|
|
return (*rw208)(state)
|
|
case 209:
|
|
return (*rw209)(state)
|
|
case 210:
|
|
return (*rw210)(state)
|
|
case 211:
|
|
return (*rw211)(state)
|
|
case 212:
|
|
return (*rw212)(state)
|
|
case 213:
|
|
return (*rw213)(state)
|
|
case 214:
|
|
return (*rw214)(state)
|
|
case 215:
|
|
return (*rw215)(state)
|
|
case 216:
|
|
return (*rw216)(state)
|
|
case 217:
|
|
return (*rw217)(state)
|
|
case 218:
|
|
return (*rw218)(state)
|
|
case 219:
|
|
return (*rw219)(state)
|
|
case 220:
|
|
return (*rw220)(state)
|
|
case 221:
|
|
return (*rw221)(state)
|
|
case 222:
|
|
return (*rw222)(state)
|
|
case 223:
|
|
return (*rw223)(state)
|
|
case 224:
|
|
return (*rw224)(state)
|
|
case 225:
|
|
return (*rw225)(state)
|
|
case 226:
|
|
return (*rw226)(state)
|
|
case 227:
|
|
return (*rw227)(state)
|
|
case 228:
|
|
return (*rw228)(state)
|
|
case 229:
|
|
return (*rw229)(state)
|
|
case 230:
|
|
return (*rw230)(state)
|
|
case 231:
|
|
return (*rw231)(state)
|
|
case 232:
|
|
return (*rw232)(state)
|
|
case 233:
|
|
return (*rw233)(state)
|
|
case 234:
|
|
return (*rw234)(state)
|
|
case 235:
|
|
return (*rw235)(state)
|
|
case 236:
|
|
return (*rw236)(state)
|
|
case 237:
|
|
return (*rw237)(state)
|
|
case 238:
|
|
return (*rw238)(state)
|
|
case 239:
|
|
return (*rw239)(state)
|
|
case 240:
|
|
return (*rw240)(state)
|
|
case 241:
|
|
return (*rw241)(state)
|
|
case 242:
|
|
return (*rw242)(state)
|
|
case 243:
|
|
return (*rw243)(state)
|
|
case 244:
|
|
return (*rw244)(state)
|
|
case 245:
|
|
return (*rw245)(state)
|
|
case 246:
|
|
return (*rw246)(state)
|
|
case 247:
|
|
return (*rw247)(state)
|
|
case 248:
|
|
return (*rw248)(state)
|
|
case 249:
|
|
return (*rw249)(state)
|
|
case 250:
|
|
return (*rw250)(state)
|
|
case 251:
|
|
return (*rw251)(state)
|
|
case 252:
|
|
return (*rw252)(state)
|
|
case 253:
|
|
return (*rw253)(state)
|
|
case 254:
|
|
return (*rw254)(state)
|
|
case 255:
|
|
return (*rw255)(state)
|
|
case 256:
|
|
return (*rw256)(state)
|
|
case 257:
|
|
return (*rw257)(state)
|
|
case 258:
|
|
return (*rw258)(state)
|
|
case 259:
|
|
return (*rw259)(state)
|
|
case 260:
|
|
return (*rw260)(state)
|
|
case 261:
|
|
return (*rw261)(state)
|
|
case 262:
|
|
return (*rw262)(state)
|
|
case 263:
|
|
return (*rw263)(state)
|
|
case 264:
|
|
return (*rw264)(state)
|
|
case 265:
|
|
return (*rw265)(state)
|
|
case 266:
|
|
return (*rw266)(state)
|
|
case 267:
|
|
return (*rw267)(state)
|
|
case 268:
|
|
return (*rw268)(state)
|
|
case 269:
|
|
return (*rw269)(state)
|
|
case 270:
|
|
return (*rw270)(state)
|
|
case 271:
|
|
return (*rw271)(state)
|
|
case 272:
|
|
return (*rw272)(state)
|
|
case 273:
|
|
return (*rw273)(state)
|
|
case 274:
|
|
return (*rw274)(state)
|
|
case 275:
|
|
return (*rw275)(state)
|
|
case 276:
|
|
return (*rw276)(state)
|
|
case 277:
|
|
return (*rw277)(state)
|
|
case 278:
|
|
return (*rw278)(state)
|
|
case 279:
|
|
return (*rw279)(state)
|
|
case 280:
|
|
return (*rw280)(state)
|
|
case 281:
|
|
return (*rw281)(state)
|
|
case 282:
|
|
return (*rw282)(state)
|
|
case 283:
|
|
return (*rw283)(state)
|
|
case 284:
|
|
return (*rw284)(state)
|
|
case 285:
|
|
return (*rw285)(state)
|
|
case 286:
|
|
return (*rw286)(state)
|
|
case 287:
|
|
return (*rw287)(state)
|
|
case 288:
|
|
return (*rw288)(state)
|
|
case 289:
|
|
return (*rw289)(state)
|
|
case 290:
|
|
return (*rw290)(state)
|
|
case 291:
|
|
return (*rw291)(state)
|
|
case 292:
|
|
return (*rw292)(state)
|
|
case 293:
|
|
return (*rw293)(state)
|
|
case 294:
|
|
return (*rw294)(state)
|
|
case 295:
|
|
return (*rw295)(state)
|
|
case 296:
|
|
return (*rw296)(state)
|
|
case 297:
|
|
return (*rw297)(state)
|
|
case 298:
|
|
return (*rw298)(state)
|
|
case 299:
|
|
return (*rw299)(state)
|
|
case 300:
|
|
return (*rw300)(state)
|
|
case 301:
|
|
return (*rw301)(state)
|
|
case 302:
|
|
return (*rw302)(state)
|
|
case 303:
|
|
return (*rw303)(state)
|
|
case 304:
|
|
return (*rw304)(state)
|
|
case 305:
|
|
return (*rw305)(state)
|
|
case 306:
|
|
return (*rw306)(state)
|
|
case 307:
|
|
return (*rw307)(state)
|
|
case 308:
|
|
return (*rw308)(state)
|
|
case 309:
|
|
return (*rw309)(state)
|
|
case 310:
|
|
return (*rw310)(state)
|
|
case 311:
|
|
return (*rw311)(state)
|
|
case 312:
|
|
return (*rw312)(state)
|
|
case 313:
|
|
return (*rw313)(state)
|
|
case 314:
|
|
return (*rw314)(state)
|
|
case 315:
|
|
return (*rw315)(state)
|
|
case 316:
|
|
return (*rw316)(state)
|
|
case 317:
|
|
return (*rw317)(state)
|
|
case 318:
|
|
return (*rw318)(state)
|
|
case 319:
|
|
return (*rw319)(state)
|
|
case 320:
|
|
return (*rw320)(state)
|
|
case 321:
|
|
return (*rw321)(state)
|
|
case 322:
|
|
return (*rw322)(state)
|
|
case 323:
|
|
return (*rw323)(state)
|
|
case 324:
|
|
return (*rw324)(state)
|
|
case 325:
|
|
return (*rw325)(state)
|
|
case 326:
|
|
return (*rw326)(state)
|
|
case 327:
|
|
return (*rw327)(state)
|
|
case 328:
|
|
return (*rw328)(state)
|
|
case 329:
|
|
return (*rw329)(state)
|
|
case 330:
|
|
return (*rw330)(state)
|
|
case 331:
|
|
return (*rw331)(state)
|
|
case 332:
|
|
return (*rw332)(state)
|
|
case 333:
|
|
return (*rw333)(state)
|
|
case 334:
|
|
return (*rw334)(state)
|
|
case 335:
|
|
return (*rw335)(state)
|
|
case 336:
|
|
return (*rw336)(state)
|
|
case 337:
|
|
return (*rw337)(state)
|
|
case 338:
|
|
return (*rw338)(state)
|
|
case 339:
|
|
return (*rw339)(state)
|
|
case 340:
|
|
return (*rw340)(state)
|
|
case 341:
|
|
return (*rw341)(state)
|
|
case 342:
|
|
return (*rw342)(state)
|
|
case 343:
|
|
return (*rw343)(state)
|
|
case 344:
|
|
return (*rw344)(state)
|
|
case 345:
|
|
return (*rw345)(state)
|
|
case 346:
|
|
return (*rw346)(state)
|
|
case 347:
|
|
return (*rw347)(state)
|
|
case 348:
|
|
return (*rw348)(state)
|
|
case 349:
|
|
return (*rw349)(state)
|
|
case 350:
|
|
return (*rw350)(state)
|
|
case 351:
|
|
return (*rw351)(state)
|
|
case 352:
|
|
return (*rw352)(state)
|
|
case 353:
|
|
return (*rw353)(state)
|
|
case 354:
|
|
return (*rw354)(state)
|
|
case 355:
|
|
return (*rw355)(state)
|
|
case 356:
|
|
return (*rw356)(state)
|
|
case 357:
|
|
return (*rw357)(state)
|
|
case 358:
|
|
return (*rw358)(state)
|
|
case 359:
|
|
return (*rw359)(state)
|
|
case 360:
|
|
return (*rw360)(state)
|
|
case 361:
|
|
return (*rw361)(state)
|
|
case 362:
|
|
return (*rw362)(state)
|
|
case 363:
|
|
return (*rw363)(state)
|
|
case 364:
|
|
return (*rw364)(state)
|
|
case 365:
|
|
return (*rw365)(state)
|
|
case 366:
|
|
return (*rw366)(state)
|
|
case 367:
|
|
return (*rw367)(state)
|
|
case 368:
|
|
return (*rw368)(state)
|
|
case 369:
|
|
return (*rw369)(state)
|
|
case 370:
|
|
return (*rw370)(state)
|
|
case 371:
|
|
return (*rw371)(state)
|
|
case 372:
|
|
return (*rw372)(state)
|
|
case 373:
|
|
return (*rw373)(state)
|
|
case 374:
|
|
return (*rw374)(state)
|
|
case 375:
|
|
return (*rw375)(state)
|
|
case 376:
|
|
return (*rw376)(state)
|
|
case 377:
|
|
return (*rw377)(state)
|
|
case 378:
|
|
return (*rw378)(state)
|
|
case 379:
|
|
return (*rw379)(state)
|
|
case 380:
|
|
return (*rw380)(state)
|
|
case 381:
|
|
return (*rw381)(state)
|
|
case 382:
|
|
return (*rw382)(state)
|
|
case 383:
|
|
return (*rw383)(state)
|
|
case 384:
|
|
return (*rw384)(state)
|
|
case 385:
|
|
return (*rw385)(state)
|
|
case 386:
|
|
return (*rw386)(state)
|
|
case 387:
|
|
return (*rw387)(state)
|
|
case 388:
|
|
return (*rw388)(state)
|
|
case 389:
|
|
return (*rw389)(state)
|
|
case 390:
|
|
return (*rw390)(state)
|
|
case 391:
|
|
return (*rw391)(state)
|
|
case 392:
|
|
return (*rw392)(state)
|
|
case 393:
|
|
return (*rw393)(state)
|
|
case 394:
|
|
return (*rw394)(state)
|
|
case 395:
|
|
return (*rw395)(state)
|
|
case 396:
|
|
return (*rw396)(state)
|
|
case 397:
|
|
return (*rw397)(state)
|
|
case 398:
|
|
return (*rw398)(state)
|
|
case 399:
|
|
return (*rw399)(state)
|
|
case 400:
|
|
return (*rw400)(state)
|
|
case 401:
|
|
return (*rw401)(state)
|
|
case 402:
|
|
return (*rw402)(state)
|
|
case 403:
|
|
return (*rw403)(state)
|
|
case 404:
|
|
return (*rw404)(state)
|
|
case 405:
|
|
return (*rw405)(state)
|
|
case 406:
|
|
return (*rw406)(state)
|
|
case 407:
|
|
return (*rw407)(state)
|
|
case 408:
|
|
return (*rw408)(state)
|
|
case 409:
|
|
return (*rw409)(state)
|
|
case 410:
|
|
return (*rw410)(state)
|
|
case 411:
|
|
return (*rw411)(state)
|
|
case 412:
|
|
return (*rw412)(state)
|
|
case 413:
|
|
return (*rw413)(state)
|
|
case 414:
|
|
return (*rw414)(state)
|
|
case 415:
|
|
return (*rw415)(state)
|
|
case 416:
|
|
return (*rw416)(state)
|
|
case 417:
|
|
return (*rw417)(state)
|
|
case 418:
|
|
return (*rw418)(state)
|
|
case 419:
|
|
return (*rw419)(state)
|
|
case 420:
|
|
return (*rw420)(state)
|
|
case 421:
|
|
return (*rw421)(state)
|
|
case 422:
|
|
return (*rw422)(state)
|
|
case 423:
|
|
return (*rw423)(state)
|
|
case 424:
|
|
return (*rw424)(state)
|
|
case 425:
|
|
return (*rw425)(state)
|
|
case 426:
|
|
return (*rw426)(state)
|
|
case 427:
|
|
return (*rw427)(state)
|
|
case 428:
|
|
return (*rw428)(state)
|
|
case 429:
|
|
return (*rw429)(state)
|
|
case 430:
|
|
return (*rw430)(state)
|
|
case 431:
|
|
return (*rw431)(state)
|
|
case 432:
|
|
return (*rw432)(state)
|
|
case 433:
|
|
return (*rw433)(state)
|
|
case 434:
|
|
return (*rw434)(state)
|
|
case 435:
|
|
return (*rw435)(state)
|
|
case 436:
|
|
return (*rw436)(state)
|
|
case 437:
|
|
return (*rw437)(state)
|
|
case 438:
|
|
return (*rw438)(state)
|
|
case 439:
|
|
return (*rw439)(state)
|
|
case 440:
|
|
return (*rw440)(state)
|
|
case 441:
|
|
return (*rw441)(state)
|
|
case 442:
|
|
return (*rw442)(state)
|
|
case 443:
|
|
return (*rw443)(state)
|
|
case 444:
|
|
return (*rw444)(state)
|
|
case 445:
|
|
return (*rw445)(state)
|
|
case 446:
|
|
return (*rw446)(state)
|
|
case 447:
|
|
return (*rw447)(state)
|
|
case 448:
|
|
return (*rw448)(state)
|
|
case 449:
|
|
return (*rw449)(state)
|
|
case 450:
|
|
return (*rw450)(state)
|
|
case 451:
|
|
return (*rw451)(state)
|
|
case 452:
|
|
return (*rw452)(state)
|
|
case 453:
|
|
return (*rw453)(state)
|
|
case 454:
|
|
return (*rw454)(state)
|
|
case 455:
|
|
return (*rw455)(state)
|
|
case 456:
|
|
return (*rw456)(state)
|
|
case 457:
|
|
return (*rw457)(state)
|
|
case 458:
|
|
return (*rw458)(state)
|
|
case 459:
|
|
return (*rw459)(state)
|
|
case 460:
|
|
return (*rw460)(state)
|
|
case 461:
|
|
return (*rw461)(state)
|
|
case 462:
|
|
return (*rw462)(state)
|
|
case 463:
|
|
return (*rw463)(state)
|
|
case 464:
|
|
return (*rw464)(state)
|
|
case 465:
|
|
return (*rw465)(state)
|
|
case 466:
|
|
return (*rw466)(state)
|
|
case 467:
|
|
return (*rw467)(state)
|
|
case 468:
|
|
return (*rw468)(state)
|
|
case 469:
|
|
return (*rw469)(state)
|
|
case 470:
|
|
return (*rw470)(state)
|
|
case 471:
|
|
return (*rw471)(state)
|
|
case 472:
|
|
return (*rw472)(state)
|
|
case 473:
|
|
return (*rw473)(state)
|
|
case 474:
|
|
return (*rw474)(state)
|
|
case 475:
|
|
return (*rw475)(state)
|
|
case 476:
|
|
return (*rw476)(state)
|
|
case 477:
|
|
return (*rw477)(state)
|
|
case 478:
|
|
return (*rw478)(state)
|
|
case 479:
|
|
return (*rw479)(state)
|
|
case 480:
|
|
return (*rw480)(state)
|
|
case 481:
|
|
return (*rw481)(state)
|
|
case 482:
|
|
return (*rw482)(state)
|
|
case 483:
|
|
return (*rw483)(state)
|
|
case 484:
|
|
return (*rw484)(state)
|
|
case 485:
|
|
return (*rw485)(state)
|
|
case 486:
|
|
return (*rw486)(state)
|
|
case 487:
|
|
return (*rw487)(state)
|
|
case 488:
|
|
return (*rw488)(state)
|
|
case 489:
|
|
return (*rw489)(state)
|
|
case 490:
|
|
return (*rw490)(state)
|
|
case 491:
|
|
return (*rw491)(state)
|
|
case 492:
|
|
return (*rw492)(state)
|
|
case 493:
|
|
return (*rw493)(state)
|
|
case 494:
|
|
return (*rw494)(state)
|
|
case 495:
|
|
return (*rw495)(state)
|
|
case 496:
|
|
return (*rw496)(state)
|
|
case 497:
|
|
return (*rw497)(state)
|
|
case 498:
|
|
return (*rw498)(state)
|
|
case 499:
|
|
return (*rw499)(state)
|
|
case 500:
|
|
return (*rw500)(state)
|
|
case 501:
|
|
return (*rw501)(state)
|
|
case 502:
|
|
return (*rw502)(state)
|
|
case 503:
|
|
return (*rw503)(state)
|
|
case 504:
|
|
return (*rw504)(state)
|
|
case 505:
|
|
return (*rw505)(state)
|
|
case 506:
|
|
return (*rw506)(state)
|
|
case 507:
|
|
return (*rw507)(state)
|
|
case 508:
|
|
return (*rw508)(state)
|
|
case 509:
|
|
return (*rw509)(state)
|
|
case 510:
|
|
return (*rw510)(state)
|
|
case 511:
|
|
return (*rw511)(state)
|
|
}
|
|
panic("unreachable")
|
|
}
|
|
|
|
type rwState struct {
|
|
w http.ResponseWriter
|
|
header HeaderFunc
|
|
writeHeader WriteHeaderFunc
|
|
write WriteFunc
|
|
flush FlushFunc
|
|
flushError FlushErrorFunc
|
|
closeNotify CloseNotifyFunc
|
|
hijack HijackFunc
|
|
readFrom ReadFromFunc
|
|
setReadDeadline SetReadDeadlineFunc
|
|
setWriteDeadline SetWriteDeadlineFunc
|
|
enableFullDuplex EnableFullDuplexFunc
|
|
push PushFunc
|
|
writeString WriteStringFunc
|
|
}
|
|
|
|
func (r *rwState) doHeader() http.Header {
|
|
if r.header != nil {
|
|
return r.header()
|
|
}
|
|
return r.w.Header()
|
|
}
|
|
|
|
func (r *rwState) doWriteHeader(code int) {
|
|
if r.writeHeader != nil {
|
|
r.writeHeader(code)
|
|
return
|
|
}
|
|
r.w.WriteHeader(code)
|
|
}
|
|
|
|
func (r *rwState) doWrite(b []byte) (int, error) {
|
|
if r.write != nil {
|
|
return r.write(b)
|
|
}
|
|
return r.w.Write(b)
|
|
}
|
|
|
|
func (r *rwState) doFlush() {
|
|
if r.flush != nil {
|
|
r.flush()
|
|
return
|
|
}
|
|
r.w.(http.Flusher).Flush()
|
|
}
|
|
|
|
func (r *rwState) doFlushError() error {
|
|
if r.flushError != nil {
|
|
return r.flushError()
|
|
}
|
|
return r.w.(httpFlushError).FlushError()
|
|
}
|
|
|
|
func (r *rwState) doCloseNotify() <-chan bool {
|
|
if r.closeNotify != nil {
|
|
return r.closeNotify()
|
|
}
|
|
return r.w.(http.CloseNotifier).CloseNotify()
|
|
}
|
|
|
|
func (r *rwState) doHijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
if r.hijack != nil {
|
|
return r.hijack()
|
|
}
|
|
return r.w.(http.Hijacker).Hijack()
|
|
}
|
|
|
|
func (r *rwState) doReadFrom(src io.Reader) (int64, error) {
|
|
if r.readFrom != nil {
|
|
return r.readFrom(src)
|
|
}
|
|
return r.w.(io.ReaderFrom).ReadFrom(src)
|
|
}
|
|
|
|
func (r *rwState) doSetReadDeadline(deadline time.Time) error {
|
|
if r.setReadDeadline != nil {
|
|
return r.setReadDeadline(deadline)
|
|
}
|
|
return r.w.(deadliner).SetReadDeadline(deadline)
|
|
}
|
|
|
|
func (r *rwState) doSetWriteDeadline(deadline time.Time) error {
|
|
if r.setWriteDeadline != nil {
|
|
return r.setWriteDeadline(deadline)
|
|
}
|
|
return r.w.(deadliner).SetWriteDeadline(deadline)
|
|
}
|
|
|
|
func (r *rwState) doEnableFullDuplex() error {
|
|
if r.enableFullDuplex != nil {
|
|
return r.enableFullDuplex()
|
|
}
|
|
return r.w.(fullDuplexEnabler).EnableFullDuplex()
|
|
}
|
|
|
|
func (r *rwState) doPush(target string, opts *http.PushOptions) error {
|
|
if r.push != nil {
|
|
return r.push(target, opts)
|
|
}
|
|
return r.w.(http.Pusher).Push(target, opts)
|
|
}
|
|
|
|
func (r *rwState) doWriteString(s string) (int, error) {
|
|
if r.writeString != nil {
|
|
return r.writeString(s)
|
|
}
|
|
return r.w.(io.StringWriter).WriteString(s)
|
|
}
|
|
|
|
// combination 1/512: http.ResponseWriter
|
|
type rw0 rwState
|
|
|
|
func (w *rw0) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw0) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw0) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw0) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
|
|
// combination 2/512: http.ResponseWriter, io.StringWriter
|
|
type rw1 rwState
|
|
|
|
func (w *rw1) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw1) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw1) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw1) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw1) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 3/512: http.ResponseWriter, http.Pusher
|
|
type rw2 rwState
|
|
|
|
func (w *rw2) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw2) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw2) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw2) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw2) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 4/512: http.ResponseWriter, http.Pusher, io.StringWriter
|
|
type rw3 rwState
|
|
|
|
func (w *rw3) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw3) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw3) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw3) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw3) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw3) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 5/512: http.ResponseWriter, fullDuplexEnabler
|
|
type rw4 rwState
|
|
|
|
func (w *rw4) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw4) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw4) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw4) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw4) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 6/512: http.ResponseWriter, fullDuplexEnabler, io.StringWriter
|
|
type rw5 rwState
|
|
|
|
func (w *rw5) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw5) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw5) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw5) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw5) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw5) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 7/512: http.ResponseWriter, fullDuplexEnabler, http.Pusher
|
|
type rw6 rwState
|
|
|
|
func (w *rw6) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw6) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw6) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw6) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw6) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw6) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 8/512: http.ResponseWriter, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw7 rwState
|
|
|
|
func (w *rw7) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw7) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw7) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw7) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw7) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw7) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw7) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 9/512: http.ResponseWriter, deadliner
|
|
type rw8 rwState
|
|
|
|
func (w *rw8) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw8) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw8) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw8) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw8) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw8) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 10/512: http.ResponseWriter, deadliner, io.StringWriter
|
|
type rw9 rwState
|
|
|
|
func (w *rw9) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw9) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw9) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw9) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw9) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw9) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw9) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 11/512: http.ResponseWriter, deadliner, http.Pusher
|
|
type rw10 rwState
|
|
|
|
func (w *rw10) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw10) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw10) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw10) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw10) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw10) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw10) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 12/512: http.ResponseWriter, deadliner, http.Pusher, io.StringWriter
|
|
type rw11 rwState
|
|
|
|
func (w *rw11) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw11) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw11) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw11) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw11) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw11) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw11) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw11) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 13/512: http.ResponseWriter, deadliner, fullDuplexEnabler
|
|
type rw12 rwState
|
|
|
|
func (w *rw12) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw12) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw12) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw12) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw12) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw12) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw12) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 14/512: http.ResponseWriter, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw13 rwState
|
|
|
|
func (w *rw13) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw13) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw13) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw13) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw13) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw13) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw13) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw13) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 15/512: http.ResponseWriter, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw14 rwState
|
|
|
|
func (w *rw14) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw14) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw14) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw14) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw14) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw14) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw14) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw14) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 16/512: http.ResponseWriter, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw15 rwState
|
|
|
|
func (w *rw15) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw15) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw15) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw15) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw15) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw15) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw15) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw15) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw15) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 17/512: http.ResponseWriter, io.ReaderFrom
|
|
type rw16 rwState
|
|
|
|
func (w *rw16) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw16) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw16) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw16) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw16) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 18/512: http.ResponseWriter, io.ReaderFrom, io.StringWriter
|
|
type rw17 rwState
|
|
|
|
func (w *rw17) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw17) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw17) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw17) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw17) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw17) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 19/512: http.ResponseWriter, io.ReaderFrom, http.Pusher
|
|
type rw18 rwState
|
|
|
|
func (w *rw18) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw18) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw18) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw18) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw18) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw18) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 20/512: http.ResponseWriter, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw19 rwState
|
|
|
|
func (w *rw19) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw19) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw19) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw19) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw19) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw19) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw19) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 21/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler
|
|
type rw20 rwState
|
|
|
|
func (w *rw20) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw20) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw20) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw20) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw20) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw20) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 22/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw21 rwState
|
|
|
|
func (w *rw21) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw21) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw21) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw21) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw21) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw21) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw21) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 23/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw22 rwState
|
|
|
|
func (w *rw22) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw22) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw22) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw22) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw22) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw22) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw22) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 24/512: http.ResponseWriter, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw23 rwState
|
|
|
|
func (w *rw23) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw23) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw23) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw23) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw23) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw23) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw23) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw23) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 25/512: http.ResponseWriter, io.ReaderFrom, deadliner
|
|
type rw24 rwState
|
|
|
|
func (w *rw24) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw24) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw24) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw24) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw24) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw24) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw24) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 26/512: http.ResponseWriter, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw25 rwState
|
|
|
|
func (w *rw25) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw25) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw25) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw25) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw25) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw25) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw25) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw25) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 27/512: http.ResponseWriter, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw26 rwState
|
|
|
|
func (w *rw26) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw26) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw26) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw26) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw26) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw26) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw26) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw26) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 28/512: http.ResponseWriter, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw27 rwState
|
|
|
|
func (w *rw27) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw27) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw27) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw27) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw27) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw27) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw27) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw27) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw27) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 29/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw28 rwState
|
|
|
|
func (w *rw28) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw28) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw28) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw28) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw28) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw28) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw28) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw28) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 30/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw29 rwState
|
|
|
|
func (w *rw29) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw29) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw29) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw29) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw29) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw29) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw29) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw29) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw29) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 31/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw30 rwState
|
|
|
|
func (w *rw30) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw30) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw30) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw30) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw30) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw30) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw30) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw30) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw30) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 32/512: http.ResponseWriter, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw31 rwState
|
|
|
|
func (w *rw31) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw31) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw31) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw31) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw31) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw31) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw31) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw31) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw31) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw31) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 33/512: http.ResponseWriter, http.Hijacker
|
|
type rw32 rwState
|
|
|
|
func (w *rw32) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw32) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw32) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw32) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw32) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 34/512: http.ResponseWriter, http.Hijacker, io.StringWriter
|
|
type rw33 rwState
|
|
|
|
func (w *rw33) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw33) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw33) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw33) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw33) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw33) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 35/512: http.ResponseWriter, http.Hijacker, http.Pusher
|
|
type rw34 rwState
|
|
|
|
func (w *rw34) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw34) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw34) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw34) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw34) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw34) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 36/512: http.ResponseWriter, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw35 rwState
|
|
|
|
func (w *rw35) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw35) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw35) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw35) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw35) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw35) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw35) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 37/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler
|
|
type rw36 rwState
|
|
|
|
func (w *rw36) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw36) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw36) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw36) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw36) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw36) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 38/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw37 rwState
|
|
|
|
func (w *rw37) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw37) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw37) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw37) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw37) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw37) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw37) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 39/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw38 rwState
|
|
|
|
func (w *rw38) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw38) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw38) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw38) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw38) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw38) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw38) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 40/512: http.ResponseWriter, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw39 rwState
|
|
|
|
func (w *rw39) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw39) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw39) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw39) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw39) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw39) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw39) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw39) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 41/512: http.ResponseWriter, http.Hijacker, deadliner
|
|
type rw40 rwState
|
|
|
|
func (w *rw40) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw40) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw40) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw40) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw40) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw40) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw40) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 42/512: http.ResponseWriter, http.Hijacker, deadliner, io.StringWriter
|
|
type rw41 rwState
|
|
|
|
func (w *rw41) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw41) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw41) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw41) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw41) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw41) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw41) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw41) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 43/512: http.ResponseWriter, http.Hijacker, deadliner, http.Pusher
|
|
type rw42 rwState
|
|
|
|
func (w *rw42) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw42) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw42) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw42) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw42) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw42) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw42) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw42) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 44/512: http.ResponseWriter, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw43 rwState
|
|
|
|
func (w *rw43) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw43) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw43) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw43) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw43) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw43) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw43) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw43) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw43) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 45/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw44 rwState
|
|
|
|
func (w *rw44) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw44) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw44) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw44) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw44) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw44) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw44) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw44) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 46/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw45 rwState
|
|
|
|
func (w *rw45) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw45) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw45) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw45) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw45) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw45) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw45) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw45) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw45) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 47/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw46 rwState
|
|
|
|
func (w *rw46) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw46) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw46) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw46) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw46) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw46) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw46) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw46) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw46) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 48/512: http.ResponseWriter, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw47 rwState
|
|
|
|
func (w *rw47) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw47) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw47) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw47) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw47) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw47) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw47) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw47) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw47) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw47) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 49/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom
|
|
type rw48 rwState
|
|
|
|
func (w *rw48) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw48) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw48) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw48) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw48) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw48) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 50/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw49 rwState
|
|
|
|
func (w *rw49) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw49) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw49) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw49) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw49) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw49) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw49) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 51/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw50 rwState
|
|
|
|
func (w *rw50) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw50) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw50) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw50) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw50) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw50) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw50) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 52/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw51 rwState
|
|
|
|
func (w *rw51) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw51) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw51) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw51) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw51) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw51) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw51) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw51) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 53/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw52 rwState
|
|
|
|
func (w *rw52) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw52) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw52) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw52) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw52) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw52) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw52) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 54/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw53 rwState
|
|
|
|
func (w *rw53) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw53) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw53) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw53) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw53) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw53) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw53) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw53) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 55/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw54 rwState
|
|
|
|
func (w *rw54) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw54) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw54) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw54) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw54) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw54) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw54) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw54) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 56/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw55 rwState
|
|
|
|
func (w *rw55) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw55) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw55) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw55) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw55) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw55) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw55) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw55) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw55) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 57/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw56 rwState
|
|
|
|
func (w *rw56) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw56) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw56) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw56) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw56) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw56) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw56) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw56) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 58/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw57 rwState
|
|
|
|
func (w *rw57) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw57) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw57) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw57) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw57) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw57) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw57) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw57) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw57) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 59/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw58 rwState
|
|
|
|
func (w *rw58) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw58) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw58) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw58) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw58) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw58) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw58) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw58) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw58) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 60/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw59 rwState
|
|
|
|
func (w *rw59) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw59) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw59) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw59) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw59) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw59) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw59) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw59) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw59) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw59) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 61/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw60 rwState
|
|
|
|
func (w *rw60) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw60) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw60) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw60) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw60) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw60) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw60) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw60) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw60) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 62/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw61 rwState
|
|
|
|
func (w *rw61) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw61) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw61) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw61) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw61) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw61) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw61) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw61) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw61) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw61) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 63/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw62 rwState
|
|
|
|
func (w *rw62) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw62) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw62) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw62) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw62) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw62) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw62) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw62) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw62) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw62) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 64/512: http.ResponseWriter, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw63 rwState
|
|
|
|
func (w *rw63) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw63) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw63) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw63) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw63) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw63) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw63) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw63) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw63) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw63) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw63) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 65/512: http.ResponseWriter, http.CloseNotifier
|
|
type rw64 rwState
|
|
|
|
func (w *rw64) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw64) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw64) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw64) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw64) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
|
|
// combination 66/512: http.ResponseWriter, http.CloseNotifier, io.StringWriter
|
|
type rw65 rwState
|
|
|
|
func (w *rw65) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw65) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw65) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw65) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw65) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw65) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 67/512: http.ResponseWriter, http.CloseNotifier, http.Pusher
|
|
type rw66 rwState
|
|
|
|
func (w *rw66) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw66) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw66) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw66) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw66) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw66) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 68/512: http.ResponseWriter, http.CloseNotifier, http.Pusher, io.StringWriter
|
|
type rw67 rwState
|
|
|
|
func (w *rw67) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw67) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw67) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw67) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw67) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw67) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw67) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 69/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler
|
|
type rw68 rwState
|
|
|
|
func (w *rw68) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw68) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw68) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw68) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw68) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw68) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 70/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
|
|
type rw69 rwState
|
|
|
|
func (w *rw69) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw69) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw69) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw69) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw69) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw69) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw69) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 71/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, http.Pusher
|
|
type rw70 rwState
|
|
|
|
func (w *rw70) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw70) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw70) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw70) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw70) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw70) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw70) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 72/512: http.ResponseWriter, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw71 rwState
|
|
|
|
func (w *rw71) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw71) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw71) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw71) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw71) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw71) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw71) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw71) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 73/512: http.ResponseWriter, http.CloseNotifier, deadliner
|
|
type rw72 rwState
|
|
|
|
func (w *rw72) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw72) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw72) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw72) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw72) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw72) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw72) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 74/512: http.ResponseWriter, http.CloseNotifier, deadliner, io.StringWriter
|
|
type rw73 rwState
|
|
|
|
func (w *rw73) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw73) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw73) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw73) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw73) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw73) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw73) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw73) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 75/512: http.ResponseWriter, http.CloseNotifier, deadliner, http.Pusher
|
|
type rw74 rwState
|
|
|
|
func (w *rw74) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw74) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw74) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw74) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw74) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw74) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw74) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw74) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 76/512: http.ResponseWriter, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
|
|
type rw75 rwState
|
|
|
|
func (w *rw75) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw75) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw75) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw75) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw75) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw75) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw75) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw75) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw75) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 77/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler
|
|
type rw76 rwState
|
|
|
|
func (w *rw76) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw76) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw76) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw76) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw76) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw76) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw76) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw76) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 78/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw77 rwState
|
|
|
|
func (w *rw77) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw77) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw77) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw77) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw77) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw77) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw77) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw77) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw77) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 79/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw78 rwState
|
|
|
|
func (w *rw78) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw78) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw78) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw78) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw78) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw78) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw78) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw78) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw78) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 80/512: http.ResponseWriter, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw79 rwState
|
|
|
|
func (w *rw79) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw79) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw79) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw79) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw79) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw79) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw79) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw79) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw79) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw79) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 81/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom
|
|
type rw80 rwState
|
|
|
|
func (w *rw80) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw80) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw80) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw80) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw80) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw80) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 82/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, io.StringWriter
|
|
type rw81 rwState
|
|
|
|
func (w *rw81) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw81) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw81) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw81) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw81) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw81) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw81) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 83/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, http.Pusher
|
|
type rw82 rwState
|
|
|
|
func (w *rw82) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw82) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw82) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw82) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw82) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw82) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw82) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 84/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw83 rwState
|
|
|
|
func (w *rw83) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw83) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw83) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw83) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw83) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw83) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw83) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw83) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 85/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
|
|
type rw84 rwState
|
|
|
|
func (w *rw84) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw84) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw84) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw84) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw84) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw84) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw84) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 86/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw85 rwState
|
|
|
|
func (w *rw85) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw85) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw85) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw85) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw85) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw85) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw85) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw85) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 87/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw86 rwState
|
|
|
|
func (w *rw86) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw86) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw86) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw86) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw86) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw86) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw86) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw86) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 88/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw87 rwState
|
|
|
|
func (w *rw87) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw87) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw87) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw87) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw87) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw87) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw87) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw87) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw87) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 89/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner
|
|
type rw88 rwState
|
|
|
|
func (w *rw88) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw88) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw88) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw88) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw88) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw88) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw88) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw88) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 90/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw89 rwState
|
|
|
|
func (w *rw89) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw89) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw89) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw89) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw89) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw89) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw89) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw89) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw89) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 91/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw90 rwState
|
|
|
|
func (w *rw90) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw90) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw90) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw90) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw90) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw90) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw90) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw90) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw90) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 92/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw91 rwState
|
|
|
|
func (w *rw91) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw91) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw91) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw91) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw91) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw91) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw91) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw91) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw91) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw91) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 93/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw92 rwState
|
|
|
|
func (w *rw92) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw92) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw92) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw92) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw92) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw92) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw92) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw92) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw92) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 94/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw93 rwState
|
|
|
|
func (w *rw93) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw93) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw93) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw93) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw93) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw93) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw93) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw93) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw93) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw93) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 95/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw94 rwState
|
|
|
|
func (w *rw94) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw94) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw94) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw94) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw94) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw94) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw94) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw94) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw94) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw94) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 96/512: http.ResponseWriter, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw95 rwState
|
|
|
|
func (w *rw95) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw95) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw95) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw95) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw95) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw95) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw95) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw95) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw95) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw95) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw95) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 97/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker
|
|
type rw96 rwState
|
|
|
|
func (w *rw96) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw96) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw96) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw96) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw96) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw96) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 98/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.StringWriter
|
|
type rw97 rwState
|
|
|
|
func (w *rw97) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw97) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw97) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw97) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw97) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw97) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw97) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 99/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, http.Pusher
|
|
type rw98 rwState
|
|
|
|
func (w *rw98) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw98) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw98) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw98) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw98) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw98) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw98) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 100/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw99 rwState
|
|
|
|
func (w *rw99) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw99) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw99) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw99) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw99) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw99) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw99) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw99) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 101/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
|
|
type rw100 rwState
|
|
|
|
func (w *rw100) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw100) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw100) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw100) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw100) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw100) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw100) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 102/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw101 rwState
|
|
|
|
func (w *rw101) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw101) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw101) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw101) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw101) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw101) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw101) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw101) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 103/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw102 rwState
|
|
|
|
func (w *rw102) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw102) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw102) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw102) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw102) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw102) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw102) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw102) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 104/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw103 rwState
|
|
|
|
func (w *rw103) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw103) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw103) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw103) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw103) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw103) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw103) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw103) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw103) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 105/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner
|
|
type rw104 rwState
|
|
|
|
func (w *rw104) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw104) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw104) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw104) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw104) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw104) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw104) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw104) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 106/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
|
|
type rw105 rwState
|
|
|
|
func (w *rw105) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw105) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw105) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw105) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw105) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw105) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw105) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw105) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw105) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 107/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
|
|
type rw106 rwState
|
|
|
|
func (w *rw106) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw106) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw106) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw106) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw106) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw106) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw106) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw106) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw106) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 108/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw107 rwState
|
|
|
|
func (w *rw107) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw107) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw107) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw107) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw107) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw107) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw107) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw107) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw107) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw107) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 109/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw108 rwState
|
|
|
|
func (w *rw108) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw108) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw108) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw108) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw108) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw108) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw108) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw108) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw108) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 110/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw109 rwState
|
|
|
|
func (w *rw109) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw109) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw109) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw109) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw109) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw109) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw109) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw109) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw109) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw109) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 111/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw110 rwState
|
|
|
|
func (w *rw110) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw110) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw110) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw110) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw110) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw110) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw110) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw110) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw110) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw110) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 112/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw111 rwState
|
|
|
|
func (w *rw111) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw111) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw111) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw111) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw111) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw111) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw111) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw111) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw111) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw111) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw111) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 113/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom
|
|
type rw112 rwState
|
|
|
|
func (w *rw112) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw112) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw112) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw112) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw112) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw112) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw112) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 114/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw113 rwState
|
|
|
|
func (w *rw113) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw113) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw113) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw113) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw113) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw113) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw113) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw113) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 115/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw114 rwState
|
|
|
|
func (w *rw114) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw114) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw114) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw114) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw114) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw114) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw114) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw114) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 116/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw115 rwState
|
|
|
|
func (w *rw115) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw115) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw115) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw115) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw115) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw115) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw115) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw115) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw115) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 117/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw116 rwState
|
|
|
|
func (w *rw116) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw116) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw116) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw116) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw116) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw116) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw116) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw116) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 118/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw117 rwState
|
|
|
|
func (w *rw117) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw117) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw117) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw117) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw117) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw117) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw117) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw117) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw117) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 119/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw118 rwState
|
|
|
|
func (w *rw118) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw118) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw118) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw118) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw118) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw118) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw118) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw118) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw118) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 120/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw119 rwState
|
|
|
|
func (w *rw119) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw119) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw119) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw119) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw119) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw119) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw119) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw119) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw119) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw119) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 121/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw120 rwState
|
|
|
|
func (w *rw120) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw120) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw120) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw120) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw120) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw120) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw120) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw120) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw120) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 122/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw121 rwState
|
|
|
|
func (w *rw121) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw121) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw121) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw121) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw121) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw121) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw121) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw121) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw121) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw121) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 123/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw122 rwState
|
|
|
|
func (w *rw122) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw122) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw122) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw122) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw122) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw122) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw122) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw122) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw122) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw122) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 124/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw123 rwState
|
|
|
|
func (w *rw123) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw123) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw123) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw123) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw123) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw123) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw123) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw123) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw123) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw123) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw123) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 125/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw124 rwState
|
|
|
|
func (w *rw124) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw124) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw124) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw124) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw124) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw124) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw124) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw124) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw124) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw124) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 126/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw125 rwState
|
|
|
|
func (w *rw125) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw125) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw125) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw125) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw125) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw125) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw125) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw125) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw125) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw125) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw125) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 127/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw126 rwState
|
|
|
|
func (w *rw126) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw126) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw126) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw126) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw126) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw126) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw126) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw126) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw126) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw126) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw126) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 128/512: http.ResponseWriter, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw127 rwState
|
|
|
|
func (w *rw127) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw127) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw127) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw127) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw127) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw127) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw127) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw127) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw127) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw127) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw127) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw127) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 129/512: http.ResponseWriter, httpFlushError
|
|
type rw128 rwState
|
|
|
|
func (w *rw128) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw128) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw128) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw128) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw128) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
|
|
// combination 130/512: http.ResponseWriter, httpFlushError, io.StringWriter
|
|
type rw129 rwState
|
|
|
|
func (w *rw129) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw129) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw129) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw129) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw129) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw129) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 131/512: http.ResponseWriter, httpFlushError, http.Pusher
|
|
type rw130 rwState
|
|
|
|
func (w *rw130) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw130) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw130) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw130) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw130) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw130) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 132/512: http.ResponseWriter, httpFlushError, http.Pusher, io.StringWriter
|
|
type rw131 rwState
|
|
|
|
func (w *rw131) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw131) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw131) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw131) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw131) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw131) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw131) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 133/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler
|
|
type rw132 rwState
|
|
|
|
func (w *rw132) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw132) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw132) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw132) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw132) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw132) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 134/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler, io.StringWriter
|
|
type rw133 rwState
|
|
|
|
func (w *rw133) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw133) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw133) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw133) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw133) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw133) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw133) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 135/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler, http.Pusher
|
|
type rw134 rwState
|
|
|
|
func (w *rw134) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw134) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw134) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw134) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw134) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw134) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw134) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 136/512: http.ResponseWriter, httpFlushError, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw135 rwState
|
|
|
|
func (w *rw135) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw135) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw135) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw135) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw135) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw135) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw135) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw135) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 137/512: http.ResponseWriter, httpFlushError, deadliner
|
|
type rw136 rwState
|
|
|
|
func (w *rw136) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw136) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw136) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw136) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw136) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw136) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw136) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 138/512: http.ResponseWriter, httpFlushError, deadliner, io.StringWriter
|
|
type rw137 rwState
|
|
|
|
func (w *rw137) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw137) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw137) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw137) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw137) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw137) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw137) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw137) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 139/512: http.ResponseWriter, httpFlushError, deadliner, http.Pusher
|
|
type rw138 rwState
|
|
|
|
func (w *rw138) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw138) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw138) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw138) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw138) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw138) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw138) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw138) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 140/512: http.ResponseWriter, httpFlushError, deadliner, http.Pusher, io.StringWriter
|
|
type rw139 rwState
|
|
|
|
func (w *rw139) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw139) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw139) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw139) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw139) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw139) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw139) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw139) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw139) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 141/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler
|
|
type rw140 rwState
|
|
|
|
func (w *rw140) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw140) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw140) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw140) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw140) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw140) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw140) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw140) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 142/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw141 rwState
|
|
|
|
func (w *rw141) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw141) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw141) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw141) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw141) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw141) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw141) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw141) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw141) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 143/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw142 rwState
|
|
|
|
func (w *rw142) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw142) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw142) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw142) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw142) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw142) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw142) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw142) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw142) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 144/512: http.ResponseWriter, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw143 rwState
|
|
|
|
func (w *rw143) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw143) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw143) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw143) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw143) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw143) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw143) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw143) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw143) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw143) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 145/512: http.ResponseWriter, httpFlushError, io.ReaderFrom
|
|
type rw144 rwState
|
|
|
|
func (w *rw144) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw144) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw144) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw144) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw144) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw144) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 146/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, io.StringWriter
|
|
type rw145 rwState
|
|
|
|
func (w *rw145) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw145) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw145) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw145) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw145) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw145) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw145) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 147/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, http.Pusher
|
|
type rw146 rwState
|
|
|
|
func (w *rw146) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw146) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw146) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw146) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw146) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw146) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw146) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 148/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw147 rwState
|
|
|
|
func (w *rw147) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw147) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw147) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw147) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw147) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw147) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw147) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw147) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 149/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler
|
|
type rw148 rwState
|
|
|
|
func (w *rw148) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw148) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw148) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw148) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw148) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw148) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw148) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 150/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw149 rwState
|
|
|
|
func (w *rw149) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw149) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw149) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw149) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw149) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw149) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw149) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw149) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 151/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw150 rwState
|
|
|
|
func (w *rw150) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw150) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw150) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw150) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw150) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw150) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw150) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw150) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 152/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw151 rwState
|
|
|
|
func (w *rw151) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw151) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw151) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw151) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw151) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw151) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw151) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw151) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw151) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 153/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner
|
|
type rw152 rwState
|
|
|
|
func (w *rw152) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw152) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw152) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw152) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw152) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw152) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw152) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw152) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 154/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw153 rwState
|
|
|
|
func (w *rw153) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw153) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw153) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw153) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw153) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw153) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw153) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw153) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw153) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 155/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw154 rwState
|
|
|
|
func (w *rw154) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw154) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw154) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw154) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw154) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw154) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw154) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw154) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw154) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 156/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw155 rwState
|
|
|
|
func (w *rw155) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw155) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw155) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw155) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw155) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw155) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw155) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw155) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw155) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw155) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 157/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw156 rwState
|
|
|
|
func (w *rw156) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw156) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw156) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw156) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw156) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw156) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw156) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw156) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw156) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 158/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw157 rwState
|
|
|
|
func (w *rw157) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw157) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw157) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw157) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw157) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw157) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw157) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw157) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw157) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw157) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 159/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw158 rwState
|
|
|
|
func (w *rw158) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw158) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw158) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw158) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw158) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw158) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw158) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw158) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw158) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw158) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 160/512: http.ResponseWriter, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw159 rwState
|
|
|
|
func (w *rw159) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw159) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw159) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw159) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw159) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw159) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw159) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw159) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw159) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw159) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw159) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 161/512: http.ResponseWriter, httpFlushError, http.Hijacker
|
|
type rw160 rwState
|
|
|
|
func (w *rw160) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw160) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw160) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw160) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw160) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw160) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 162/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.StringWriter
|
|
type rw161 rwState
|
|
|
|
func (w *rw161) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw161) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw161) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw161) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw161) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw161) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw161) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 163/512: http.ResponseWriter, httpFlushError, http.Hijacker, http.Pusher
|
|
type rw162 rwState
|
|
|
|
func (w *rw162) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw162) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw162) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw162) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw162) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw162) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw162) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 164/512: http.ResponseWriter, httpFlushError, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw163 rwState
|
|
|
|
func (w *rw163) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw163) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw163) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw163) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw163) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw163) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw163) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw163) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 165/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler
|
|
type rw164 rwState
|
|
|
|
func (w *rw164) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw164) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw164) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw164) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw164) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw164) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw164) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 166/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw165 rwState
|
|
|
|
func (w *rw165) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw165) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw165) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw165) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw165) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw165) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw165) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw165) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 167/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw166 rwState
|
|
|
|
func (w *rw166) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw166) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw166) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw166) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw166) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw166) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw166) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw166) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 168/512: http.ResponseWriter, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw167 rwState
|
|
|
|
func (w *rw167) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw167) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw167) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw167) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw167) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw167) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw167) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw167) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw167) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 169/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner
|
|
type rw168 rwState
|
|
|
|
func (w *rw168) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw168) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw168) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw168) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw168) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw168) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw168) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw168) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 170/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, io.StringWriter
|
|
type rw169 rwState
|
|
|
|
func (w *rw169) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw169) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw169) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw169) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw169) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw169) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw169) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw169) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw169) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 171/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, http.Pusher
|
|
type rw170 rwState
|
|
|
|
func (w *rw170) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw170) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw170) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw170) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw170) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw170) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw170) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw170) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw170) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 172/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw171 rwState
|
|
|
|
func (w *rw171) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw171) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw171) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw171) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw171) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw171) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw171) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw171) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw171) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw171) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 173/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw172 rwState
|
|
|
|
func (w *rw172) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw172) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw172) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw172) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw172) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw172) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw172) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw172) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw172) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 174/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw173 rwState
|
|
|
|
func (w *rw173) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw173) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw173) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw173) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw173) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw173) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw173) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw173) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw173) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw173) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 175/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw174 rwState
|
|
|
|
func (w *rw174) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw174) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw174) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw174) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw174) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw174) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw174) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw174) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw174) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw174) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 176/512: http.ResponseWriter, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw175 rwState
|
|
|
|
func (w *rw175) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw175) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw175) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw175) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw175) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw175) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw175) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw175) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw175) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw175) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw175) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 177/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom
|
|
type rw176 rwState
|
|
|
|
func (w *rw176) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw176) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw176) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw176) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw176) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw176) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw176) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 178/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw177 rwState
|
|
|
|
func (w *rw177) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw177) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw177) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw177) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw177) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw177) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw177) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw177) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 179/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw178 rwState
|
|
|
|
func (w *rw178) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw178) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw178) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw178) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw178) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw178) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw178) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw178) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 180/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw179 rwState
|
|
|
|
func (w *rw179) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw179) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw179) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw179) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw179) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw179) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw179) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw179) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw179) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 181/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw180 rwState
|
|
|
|
func (w *rw180) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw180) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw180) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw180) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw180) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw180) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw180) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw180) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 182/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw181 rwState
|
|
|
|
func (w *rw181) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw181) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw181) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw181) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw181) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw181) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw181) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw181) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw181) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 183/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw182 rwState
|
|
|
|
func (w *rw182) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw182) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw182) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw182) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw182) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw182) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw182) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw182) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw182) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 184/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw183 rwState
|
|
|
|
func (w *rw183) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw183) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw183) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw183) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw183) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw183) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw183) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw183) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw183) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw183) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 185/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw184 rwState
|
|
|
|
func (w *rw184) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw184) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw184) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw184) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw184) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw184) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw184) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw184) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw184) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 186/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw185 rwState
|
|
|
|
func (w *rw185) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw185) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw185) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw185) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw185) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw185) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw185) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw185) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw185) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw185) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 187/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw186 rwState
|
|
|
|
func (w *rw186) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw186) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw186) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw186) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw186) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw186) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw186) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw186) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw186) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw186) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 188/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw187 rwState
|
|
|
|
func (w *rw187) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw187) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw187) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw187) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw187) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw187) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw187) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw187) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw187) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw187) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw187) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 189/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw188 rwState
|
|
|
|
func (w *rw188) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw188) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw188) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw188) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw188) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw188) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw188) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw188) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw188) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw188) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 190/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw189 rwState
|
|
|
|
func (w *rw189) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw189) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw189) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw189) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw189) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw189) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw189) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw189) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw189) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw189) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw189) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 191/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw190 rwState
|
|
|
|
func (w *rw190) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw190) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw190) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw190) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw190) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw190) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw190) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw190) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw190) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw190) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw190) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 192/512: http.ResponseWriter, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw191 rwState
|
|
|
|
func (w *rw191) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw191) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw191) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw191) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw191) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw191) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw191) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw191) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw191) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw191) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw191) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw191) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 193/512: http.ResponseWriter, httpFlushError, http.CloseNotifier
|
|
type rw192 rwState
|
|
|
|
func (w *rw192) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw192) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw192) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw192) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw192) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw192) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
|
|
// combination 194/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.StringWriter
|
|
type rw193 rwState
|
|
|
|
func (w *rw193) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw193) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw193) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw193) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw193) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw193) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw193) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 195/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Pusher
|
|
type rw194 rwState
|
|
|
|
func (w *rw194) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw194) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw194) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw194) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw194) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw194) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw194) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 196/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Pusher, io.StringWriter
|
|
type rw195 rwState
|
|
|
|
func (w *rw195) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw195) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw195) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw195) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw195) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw195) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw195) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw195) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 197/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler
|
|
type rw196 rwState
|
|
|
|
func (w *rw196) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw196) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw196) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw196) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw196) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw196) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw196) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 198/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
|
|
type rw197 rwState
|
|
|
|
func (w *rw197) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw197) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw197) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw197) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw197) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw197) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw197) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw197) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 199/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher
|
|
type rw198 rwState
|
|
|
|
func (w *rw198) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw198) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw198) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw198) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw198) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw198) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw198) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw198) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 200/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw199 rwState
|
|
|
|
func (w *rw199) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw199) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw199) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw199) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw199) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw199) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw199) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw199) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw199) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 201/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner
|
|
type rw200 rwState
|
|
|
|
func (w *rw200) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw200) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw200) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw200) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw200) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw200) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw200) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw200) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 202/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, io.StringWriter
|
|
type rw201 rwState
|
|
|
|
func (w *rw201) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw201) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw201) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw201) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw201) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw201) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw201) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw201) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw201) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 203/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, http.Pusher
|
|
type rw202 rwState
|
|
|
|
func (w *rw202) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw202) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw202) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw202) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw202) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw202) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw202) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw202) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw202) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 204/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
|
|
type rw203 rwState
|
|
|
|
func (w *rw203) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw203) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw203) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw203) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw203) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw203) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw203) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw203) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw203) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw203) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 205/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler
|
|
type rw204 rwState
|
|
|
|
func (w *rw204) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw204) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw204) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw204) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw204) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw204) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw204) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw204) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw204) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 206/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw205 rwState
|
|
|
|
func (w *rw205) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw205) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw205) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw205) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw205) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw205) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw205) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw205) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw205) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw205) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 207/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw206 rwState
|
|
|
|
func (w *rw206) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw206) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw206) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw206) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw206) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw206) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw206) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw206) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw206) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw206) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 208/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw207 rwState
|
|
|
|
func (w *rw207) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw207) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw207) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw207) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw207) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw207) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw207) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw207) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw207) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw207) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw207) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 209/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom
|
|
type rw208 rwState
|
|
|
|
func (w *rw208) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw208) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw208) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw208) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw208) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw208) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw208) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 210/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, io.StringWriter
|
|
type rw209 rwState
|
|
|
|
func (w *rw209) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw209) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw209) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw209) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw209) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw209) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw209) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw209) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 211/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher
|
|
type rw210 rwState
|
|
|
|
func (w *rw210) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw210) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw210) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw210) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw210) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw210) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw210) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw210) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 212/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw211 rwState
|
|
|
|
func (w *rw211) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw211) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw211) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw211) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw211) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw211) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw211) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw211) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw211) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 213/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
|
|
type rw212 rwState
|
|
|
|
func (w *rw212) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw212) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw212) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw212) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw212) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw212) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw212) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw212) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 214/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw213 rwState
|
|
|
|
func (w *rw213) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw213) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw213) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw213) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw213) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw213) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw213) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw213) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw213) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 215/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw214 rwState
|
|
|
|
func (w *rw214) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw214) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw214) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw214) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw214) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw214) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw214) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw214) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw214) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 216/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw215 rwState
|
|
|
|
func (w *rw215) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw215) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw215) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw215) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw215) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw215) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw215) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw215) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw215) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw215) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 217/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner
|
|
type rw216 rwState
|
|
|
|
func (w *rw216) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw216) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw216) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw216) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw216) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw216) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw216) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw216) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw216) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 218/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw217 rwState
|
|
|
|
func (w *rw217) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw217) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw217) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw217) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw217) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw217) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw217) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw217) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw217) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw217) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 219/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw218 rwState
|
|
|
|
func (w *rw218) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw218) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw218) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw218) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw218) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw218) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw218) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw218) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw218) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw218) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 220/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw219 rwState
|
|
|
|
func (w *rw219) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw219) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw219) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw219) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw219) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw219) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw219) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw219) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw219) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw219) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw219) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 221/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw220 rwState
|
|
|
|
func (w *rw220) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw220) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw220) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw220) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw220) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw220) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw220) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw220) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw220) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw220) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 222/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw221 rwState
|
|
|
|
func (w *rw221) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw221) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw221) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw221) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw221) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw221) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw221) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw221) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw221) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw221) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw221) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 223/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw222 rwState
|
|
|
|
func (w *rw222) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw222) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw222) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw222) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw222) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw222) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw222) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw222) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw222) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw222) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw222) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 224/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw223 rwState
|
|
|
|
func (w *rw223) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw223) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw223) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw223) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw223) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw223) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw223) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw223) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw223) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw223) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw223) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw223) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 225/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker
|
|
type rw224 rwState
|
|
|
|
func (w *rw224) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw224) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw224) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw224) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw224) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw224) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw224) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 226/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.StringWriter
|
|
type rw225 rwState
|
|
|
|
func (w *rw225) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw225) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw225) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw225) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw225) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw225) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw225) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw225) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 227/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher
|
|
type rw226 rwState
|
|
|
|
func (w *rw226) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw226) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw226) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw226) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw226) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw226) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw226) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw226) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 228/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw227 rwState
|
|
|
|
func (w *rw227) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw227) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw227) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw227) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw227) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw227) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw227) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw227) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw227) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 229/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
|
|
type rw228 rwState
|
|
|
|
func (w *rw228) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw228) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw228) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw228) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw228) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw228) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw228) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw228) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 230/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw229 rwState
|
|
|
|
func (w *rw229) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw229) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw229) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw229) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw229) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw229) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw229) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw229) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw229) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 231/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw230 rwState
|
|
|
|
func (w *rw230) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw230) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw230) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw230) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw230) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw230) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw230) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw230) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw230) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 232/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw231 rwState
|
|
|
|
func (w *rw231) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw231) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw231) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw231) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw231) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw231) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw231) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw231) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw231) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw231) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 233/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner
|
|
type rw232 rwState
|
|
|
|
func (w *rw232) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw232) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw232) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw232) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw232) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw232) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw232) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw232) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw232) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 234/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
|
|
type rw233 rwState
|
|
|
|
func (w *rw233) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw233) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw233) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw233) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw233) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw233) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw233) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw233) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw233) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw233) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 235/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
|
|
type rw234 rwState
|
|
|
|
func (w *rw234) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw234) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw234) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw234) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw234) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw234) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw234) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw234) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw234) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw234) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 236/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw235 rwState
|
|
|
|
func (w *rw235) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw235) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw235) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw235) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw235) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw235) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw235) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw235) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw235) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw235) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw235) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 237/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw236 rwState
|
|
|
|
func (w *rw236) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw236) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw236) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw236) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw236) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw236) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw236) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw236) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw236) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw236) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 238/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw237 rwState
|
|
|
|
func (w *rw237) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw237) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw237) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw237) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw237) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw237) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw237) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw237) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw237) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw237) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw237) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 239/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw238 rwState
|
|
|
|
func (w *rw238) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw238) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw238) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw238) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw238) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw238) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw238) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw238) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw238) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw238) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw238) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 240/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw239 rwState
|
|
|
|
func (w *rw239) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw239) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw239) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw239) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw239) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw239) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw239) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw239) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw239) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw239) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw239) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw239) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 241/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom
|
|
type rw240 rwState
|
|
|
|
func (w *rw240) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw240) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw240) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw240) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw240) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw240) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw240) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw240) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 242/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw241 rwState
|
|
|
|
func (w *rw241) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw241) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw241) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw241) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw241) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw241) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw241) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw241) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw241) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 243/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw242 rwState
|
|
|
|
func (w *rw242) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw242) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw242) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw242) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw242) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw242) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw242) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw242) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw242) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 244/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw243 rwState
|
|
|
|
func (w *rw243) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw243) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw243) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw243) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw243) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw243) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw243) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw243) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw243) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw243) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 245/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw244 rwState
|
|
|
|
func (w *rw244) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw244) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw244) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw244) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw244) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw244) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw244) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw244) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw244) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 246/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw245 rwState
|
|
|
|
func (w *rw245) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw245) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw245) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw245) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw245) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw245) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw245) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw245) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw245) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw245) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 247/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw246 rwState
|
|
|
|
func (w *rw246) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw246) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw246) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw246) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw246) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw246) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw246) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw246) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw246) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw246) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 248/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw247 rwState
|
|
|
|
func (w *rw247) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw247) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw247) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw247) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw247) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw247) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw247) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw247) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw247) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw247) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw247) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 249/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw248 rwState
|
|
|
|
func (w *rw248) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw248) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw248) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw248) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw248) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw248) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw248) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw248) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw248) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw248) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 250/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw249 rwState
|
|
|
|
func (w *rw249) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw249) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw249) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw249) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw249) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw249) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw249) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw249) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw249) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw249) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw249) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 251/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw250 rwState
|
|
|
|
func (w *rw250) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw250) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw250) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw250) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw250) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw250) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw250) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw250) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw250) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw250) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw250) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 252/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw251 rwState
|
|
|
|
func (w *rw251) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw251) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw251) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw251) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw251) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw251) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw251) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw251) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw251) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw251) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw251) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw251) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 253/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw252 rwState
|
|
|
|
func (w *rw252) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw252) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw252) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw252) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw252) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw252) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw252) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw252) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw252) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw252) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw252) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 254/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw253 rwState
|
|
|
|
func (w *rw253) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw253) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw253) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw253) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw253) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw253) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw253) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw253) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw253) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw253) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw253) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw253) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 255/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw254 rwState
|
|
|
|
func (w *rw254) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw254) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw254) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw254) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw254) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw254) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw254) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw254) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw254) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw254) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw254) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw254) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 256/512: http.ResponseWriter, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw255 rwState
|
|
|
|
func (w *rw255) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw255) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw255) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw255) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw255) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw255) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw255) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw255) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw255) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw255) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw255) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw255) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw255) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 257/512: http.ResponseWriter, http.Flusher
|
|
type rw256 rwState
|
|
|
|
func (w *rw256) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw256) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw256) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw256) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw256) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
|
|
// combination 258/512: http.ResponseWriter, http.Flusher, io.StringWriter
|
|
type rw257 rwState
|
|
|
|
func (w *rw257) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw257) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw257) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw257) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw257) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw257) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 259/512: http.ResponseWriter, http.Flusher, http.Pusher
|
|
type rw258 rwState
|
|
|
|
func (w *rw258) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw258) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw258) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw258) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw258) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw258) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 260/512: http.ResponseWriter, http.Flusher, http.Pusher, io.StringWriter
|
|
type rw259 rwState
|
|
|
|
func (w *rw259) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw259) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw259) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw259) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw259) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw259) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw259) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 261/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler
|
|
type rw260 rwState
|
|
|
|
func (w *rw260) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw260) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw260) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw260) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw260) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw260) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 262/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler, io.StringWriter
|
|
type rw261 rwState
|
|
|
|
func (w *rw261) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw261) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw261) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw261) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw261) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw261) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw261) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 263/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler, http.Pusher
|
|
type rw262 rwState
|
|
|
|
func (w *rw262) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw262) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw262) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw262) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw262) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw262) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw262) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 264/512: http.ResponseWriter, http.Flusher, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw263 rwState
|
|
|
|
func (w *rw263) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw263) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw263) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw263) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw263) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw263) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw263) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw263) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 265/512: http.ResponseWriter, http.Flusher, deadliner
|
|
type rw264 rwState
|
|
|
|
func (w *rw264) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw264) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw264) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw264) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw264) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw264) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw264) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 266/512: http.ResponseWriter, http.Flusher, deadliner, io.StringWriter
|
|
type rw265 rwState
|
|
|
|
func (w *rw265) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw265) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw265) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw265) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw265) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw265) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw265) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw265) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 267/512: http.ResponseWriter, http.Flusher, deadliner, http.Pusher
|
|
type rw266 rwState
|
|
|
|
func (w *rw266) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw266) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw266) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw266) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw266) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw266) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw266) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw266) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 268/512: http.ResponseWriter, http.Flusher, deadliner, http.Pusher, io.StringWriter
|
|
type rw267 rwState
|
|
|
|
func (w *rw267) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw267) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw267) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw267) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw267) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw267) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw267) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw267) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw267) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 269/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler
|
|
type rw268 rwState
|
|
|
|
func (w *rw268) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw268) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw268) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw268) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw268) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw268) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw268) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw268) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 270/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw269 rwState
|
|
|
|
func (w *rw269) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw269) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw269) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw269) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw269) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw269) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw269) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw269) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw269) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 271/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw270 rwState
|
|
|
|
func (w *rw270) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw270) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw270) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw270) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw270) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw270) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw270) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw270) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw270) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 272/512: http.ResponseWriter, http.Flusher, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw271 rwState
|
|
|
|
func (w *rw271) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw271) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw271) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw271) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw271) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw271) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw271) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw271) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw271) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw271) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 273/512: http.ResponseWriter, http.Flusher, io.ReaderFrom
|
|
type rw272 rwState
|
|
|
|
func (w *rw272) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw272) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw272) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw272) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw272) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw272) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 274/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, io.StringWriter
|
|
type rw273 rwState
|
|
|
|
func (w *rw273) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw273) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw273) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw273) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw273) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw273) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw273) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 275/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, http.Pusher
|
|
type rw274 rwState
|
|
|
|
func (w *rw274) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw274) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw274) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw274) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw274) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw274) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw274) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 276/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw275 rwState
|
|
|
|
func (w *rw275) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw275) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw275) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw275) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw275) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw275) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw275) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw275) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 277/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler
|
|
type rw276 rwState
|
|
|
|
func (w *rw276) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw276) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw276) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw276) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw276) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw276) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw276) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 278/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw277 rwState
|
|
|
|
func (w *rw277) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw277) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw277) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw277) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw277) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw277) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw277) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw277) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 279/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw278 rwState
|
|
|
|
func (w *rw278) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw278) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw278) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw278) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw278) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw278) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw278) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw278) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 280/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw279 rwState
|
|
|
|
func (w *rw279) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw279) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw279) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw279) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw279) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw279) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw279) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw279) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw279) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 281/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner
|
|
type rw280 rwState
|
|
|
|
func (w *rw280) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw280) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw280) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw280) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw280) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw280) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw280) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw280) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 282/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw281 rwState
|
|
|
|
func (w *rw281) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw281) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw281) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw281) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw281) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw281) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw281) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw281) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw281) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 283/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw282 rwState
|
|
|
|
func (w *rw282) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw282) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw282) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw282) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw282) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw282) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw282) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw282) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw282) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 284/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw283 rwState
|
|
|
|
func (w *rw283) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw283) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw283) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw283) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw283) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw283) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw283) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw283) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw283) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw283) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 285/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw284 rwState
|
|
|
|
func (w *rw284) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw284) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw284) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw284) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw284) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw284) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw284) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw284) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw284) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 286/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw285 rwState
|
|
|
|
func (w *rw285) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw285) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw285) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw285) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw285) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw285) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw285) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw285) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw285) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw285) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 287/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw286 rwState
|
|
|
|
func (w *rw286) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw286) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw286) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw286) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw286) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw286) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw286) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw286) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw286) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw286) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 288/512: http.ResponseWriter, http.Flusher, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw287 rwState
|
|
|
|
func (w *rw287) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw287) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw287) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw287) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw287) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw287) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw287) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw287) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw287) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw287) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw287) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 289/512: http.ResponseWriter, http.Flusher, http.Hijacker
|
|
type rw288 rwState
|
|
|
|
func (w *rw288) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw288) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw288) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw288) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw288) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw288) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 290/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.StringWriter
|
|
type rw289 rwState
|
|
|
|
func (w *rw289) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw289) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw289) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw289) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw289) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw289) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw289) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 291/512: http.ResponseWriter, http.Flusher, http.Hijacker, http.Pusher
|
|
type rw290 rwState
|
|
|
|
func (w *rw290) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw290) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw290) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw290) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw290) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw290) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw290) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 292/512: http.ResponseWriter, http.Flusher, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw291 rwState
|
|
|
|
func (w *rw291) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw291) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw291) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw291) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw291) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw291) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw291) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw291) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 293/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler
|
|
type rw292 rwState
|
|
|
|
func (w *rw292) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw292) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw292) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw292) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw292) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw292) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw292) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 294/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw293 rwState
|
|
|
|
func (w *rw293) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw293) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw293) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw293) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw293) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw293) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw293) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw293) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 295/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw294 rwState
|
|
|
|
func (w *rw294) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw294) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw294) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw294) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw294) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw294) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw294) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw294) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 296/512: http.ResponseWriter, http.Flusher, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw295 rwState
|
|
|
|
func (w *rw295) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw295) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw295) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw295) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw295) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw295) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw295) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw295) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw295) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 297/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner
|
|
type rw296 rwState
|
|
|
|
func (w *rw296) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw296) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw296) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw296) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw296) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw296) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw296) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw296) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 298/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, io.StringWriter
|
|
type rw297 rwState
|
|
|
|
func (w *rw297) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw297) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw297) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw297) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw297) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw297) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw297) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw297) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw297) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 299/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, http.Pusher
|
|
type rw298 rwState
|
|
|
|
func (w *rw298) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw298) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw298) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw298) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw298) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw298) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw298) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw298) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw298) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 300/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw299 rwState
|
|
|
|
func (w *rw299) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw299) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw299) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw299) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw299) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw299) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw299) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw299) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw299) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw299) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 301/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw300 rwState
|
|
|
|
func (w *rw300) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw300) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw300) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw300) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw300) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw300) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw300) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw300) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw300) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 302/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw301 rwState
|
|
|
|
func (w *rw301) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw301) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw301) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw301) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw301) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw301) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw301) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw301) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw301) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw301) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 303/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw302 rwState
|
|
|
|
func (w *rw302) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw302) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw302) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw302) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw302) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw302) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw302) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw302) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw302) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw302) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 304/512: http.ResponseWriter, http.Flusher, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw303 rwState
|
|
|
|
func (w *rw303) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw303) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw303) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw303) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw303) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw303) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw303) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw303) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw303) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw303) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw303) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 305/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom
|
|
type rw304 rwState
|
|
|
|
func (w *rw304) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw304) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw304) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw304) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw304) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw304) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw304) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 306/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw305 rwState
|
|
|
|
func (w *rw305) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw305) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw305) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw305) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw305) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw305) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw305) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw305) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 307/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw306 rwState
|
|
|
|
func (w *rw306) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw306) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw306) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw306) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw306) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw306) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw306) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw306) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 308/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw307 rwState
|
|
|
|
func (w *rw307) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw307) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw307) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw307) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw307) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw307) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw307) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw307) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw307) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 309/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw308 rwState
|
|
|
|
func (w *rw308) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw308) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw308) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw308) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw308) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw308) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw308) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw308) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 310/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw309 rwState
|
|
|
|
func (w *rw309) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw309) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw309) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw309) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw309) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw309) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw309) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw309) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw309) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 311/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw310 rwState
|
|
|
|
func (w *rw310) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw310) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw310) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw310) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw310) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw310) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw310) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw310) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw310) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 312/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw311 rwState
|
|
|
|
func (w *rw311) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw311) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw311) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw311) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw311) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw311) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw311) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw311) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw311) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw311) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 313/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw312 rwState
|
|
|
|
func (w *rw312) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw312) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw312) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw312) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw312) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw312) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw312) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw312) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw312) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 314/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw313 rwState
|
|
|
|
func (w *rw313) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw313) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw313) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw313) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw313) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw313) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw313) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw313) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw313) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw313) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 315/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw314 rwState
|
|
|
|
func (w *rw314) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw314) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw314) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw314) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw314) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw314) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw314) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw314) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw314) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw314) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 316/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw315 rwState
|
|
|
|
func (w *rw315) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw315) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw315) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw315) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw315) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw315) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw315) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw315) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw315) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw315) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw315) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 317/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw316 rwState
|
|
|
|
func (w *rw316) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw316) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw316) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw316) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw316) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw316) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw316) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw316) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw316) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw316) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 318/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw317 rwState
|
|
|
|
func (w *rw317) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw317) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw317) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw317) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw317) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw317) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw317) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw317) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw317) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw317) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw317) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 319/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw318 rwState
|
|
|
|
func (w *rw318) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw318) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw318) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw318) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw318) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw318) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw318) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw318) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw318) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw318) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw318) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 320/512: http.ResponseWriter, http.Flusher, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw319 rwState
|
|
|
|
func (w *rw319) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw319) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw319) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw319) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw319) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw319) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw319) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw319) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw319) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw319) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw319) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw319) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 321/512: http.ResponseWriter, http.Flusher, http.CloseNotifier
|
|
type rw320 rwState
|
|
|
|
func (w *rw320) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw320) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw320) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw320) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw320) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw320) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
|
|
// combination 322/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.StringWriter
|
|
type rw321 rwState
|
|
|
|
func (w *rw321) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw321) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw321) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw321) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw321) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw321) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw321) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 323/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Pusher
|
|
type rw322 rwState
|
|
|
|
func (w *rw322) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw322) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw322) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw322) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw322) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw322) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw322) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 324/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Pusher, io.StringWriter
|
|
type rw323 rwState
|
|
|
|
func (w *rw323) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw323) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw323) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw323) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw323) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw323) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw323) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw323) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 325/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler
|
|
type rw324 rwState
|
|
|
|
func (w *rw324) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw324) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw324) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw324) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw324) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw324) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw324) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 326/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
|
|
type rw325 rwState
|
|
|
|
func (w *rw325) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw325) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw325) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw325) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw325) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw325) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw325) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw325) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 327/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, http.Pusher
|
|
type rw326 rwState
|
|
|
|
func (w *rw326) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw326) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw326) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw326) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw326) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw326) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw326) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw326) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 328/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw327 rwState
|
|
|
|
func (w *rw327) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw327) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw327) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw327) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw327) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw327) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw327) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw327) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw327) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 329/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner
|
|
type rw328 rwState
|
|
|
|
func (w *rw328) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw328) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw328) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw328) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw328) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw328) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw328) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw328) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 330/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, io.StringWriter
|
|
type rw329 rwState
|
|
|
|
func (w *rw329) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw329) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw329) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw329) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw329) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw329) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw329) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw329) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw329) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 331/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, http.Pusher
|
|
type rw330 rwState
|
|
|
|
func (w *rw330) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw330) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw330) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw330) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw330) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw330) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw330) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw330) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw330) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 332/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
|
|
type rw331 rwState
|
|
|
|
func (w *rw331) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw331) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw331) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw331) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw331) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw331) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw331) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw331) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw331) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw331) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 333/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler
|
|
type rw332 rwState
|
|
|
|
func (w *rw332) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw332) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw332) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw332) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw332) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw332) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw332) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw332) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw332) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 334/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw333 rwState
|
|
|
|
func (w *rw333) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw333) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw333) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw333) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw333) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw333) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw333) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw333) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw333) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw333) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 335/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw334 rwState
|
|
|
|
func (w *rw334) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw334) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw334) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw334) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw334) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw334) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw334) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw334) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw334) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw334) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 336/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw335 rwState
|
|
|
|
func (w *rw335) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw335) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw335) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw335) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw335) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw335) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw335) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw335) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw335) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw335) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw335) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 337/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom
|
|
type rw336 rwState
|
|
|
|
func (w *rw336) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw336) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw336) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw336) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw336) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw336) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw336) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 338/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, io.StringWriter
|
|
type rw337 rwState
|
|
|
|
func (w *rw337) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw337) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw337) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw337) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw337) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw337) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw337) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw337) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 339/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, http.Pusher
|
|
type rw338 rwState
|
|
|
|
func (w *rw338) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw338) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw338) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw338) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw338) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw338) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw338) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw338) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 340/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw339 rwState
|
|
|
|
func (w *rw339) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw339) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw339) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw339) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw339) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw339) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw339) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw339) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw339) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 341/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
|
|
type rw340 rwState
|
|
|
|
func (w *rw340) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw340) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw340) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw340) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw340) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw340) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw340) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw340) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 342/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw341 rwState
|
|
|
|
func (w *rw341) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw341) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw341) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw341) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw341) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw341) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw341) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw341) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw341) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 343/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw342 rwState
|
|
|
|
func (w *rw342) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw342) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw342) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw342) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw342) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw342) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw342) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw342) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw342) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 344/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw343 rwState
|
|
|
|
func (w *rw343) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw343) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw343) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw343) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw343) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw343) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw343) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw343) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw343) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw343) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 345/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner
|
|
type rw344 rwState
|
|
|
|
func (w *rw344) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw344) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw344) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw344) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw344) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw344) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw344) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw344) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw344) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 346/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw345 rwState
|
|
|
|
func (w *rw345) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw345) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw345) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw345) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw345) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw345) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw345) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw345) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw345) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw345) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 347/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw346 rwState
|
|
|
|
func (w *rw346) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw346) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw346) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw346) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw346) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw346) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw346) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw346) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw346) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw346) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 348/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw347 rwState
|
|
|
|
func (w *rw347) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw347) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw347) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw347) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw347) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw347) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw347) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw347) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw347) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw347) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw347) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 349/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw348 rwState
|
|
|
|
func (w *rw348) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw348) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw348) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw348) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw348) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw348) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw348) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw348) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw348) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw348) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 350/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw349 rwState
|
|
|
|
func (w *rw349) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw349) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw349) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw349) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw349) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw349) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw349) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw349) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw349) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw349) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw349) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 351/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw350 rwState
|
|
|
|
func (w *rw350) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw350) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw350) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw350) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw350) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw350) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw350) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw350) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw350) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw350) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw350) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 352/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw351 rwState
|
|
|
|
func (w *rw351) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw351) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw351) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw351) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw351) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw351) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw351) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw351) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw351) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw351) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw351) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw351) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 353/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker
|
|
type rw352 rwState
|
|
|
|
func (w *rw352) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw352) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw352) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw352) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw352) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw352) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw352) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 354/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.StringWriter
|
|
type rw353 rwState
|
|
|
|
func (w *rw353) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw353) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw353) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw353) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw353) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw353) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw353) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw353) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 355/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, http.Pusher
|
|
type rw354 rwState
|
|
|
|
func (w *rw354) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw354) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw354) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw354) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw354) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw354) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw354) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw354) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 356/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw355 rwState
|
|
|
|
func (w *rw355) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw355) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw355) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw355) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw355) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw355) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw355) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw355) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw355) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 357/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
|
|
type rw356 rwState
|
|
|
|
func (w *rw356) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw356) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw356) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw356) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw356) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw356) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw356) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw356) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 358/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw357 rwState
|
|
|
|
func (w *rw357) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw357) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw357) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw357) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw357) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw357) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw357) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw357) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw357) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 359/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw358 rwState
|
|
|
|
func (w *rw358) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw358) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw358) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw358) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw358) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw358) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw358) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw358) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw358) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 360/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw359 rwState
|
|
|
|
func (w *rw359) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw359) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw359) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw359) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw359) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw359) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw359) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw359) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw359) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw359) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 361/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner
|
|
type rw360 rwState
|
|
|
|
func (w *rw360) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw360) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw360) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw360) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw360) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw360) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw360) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw360) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw360) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 362/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
|
|
type rw361 rwState
|
|
|
|
func (w *rw361) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw361) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw361) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw361) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw361) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw361) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw361) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw361) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw361) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw361) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 363/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
|
|
type rw362 rwState
|
|
|
|
func (w *rw362) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw362) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw362) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw362) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw362) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw362) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw362) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw362) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw362) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw362) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 364/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw363 rwState
|
|
|
|
func (w *rw363) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw363) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw363) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw363) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw363) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw363) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw363) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw363) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw363) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw363) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw363) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 365/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw364 rwState
|
|
|
|
func (w *rw364) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw364) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw364) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw364) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw364) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw364) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw364) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw364) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw364) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw364) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 366/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw365 rwState
|
|
|
|
func (w *rw365) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw365) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw365) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw365) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw365) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw365) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw365) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw365) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw365) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw365) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw365) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 367/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw366 rwState
|
|
|
|
func (w *rw366) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw366) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw366) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw366) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw366) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw366) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw366) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw366) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw366) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw366) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw366) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 368/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw367 rwState
|
|
|
|
func (w *rw367) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw367) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw367) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw367) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw367) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw367) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw367) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw367) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw367) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw367) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw367) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw367) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 369/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom
|
|
type rw368 rwState
|
|
|
|
func (w *rw368) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw368) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw368) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw368) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw368) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw368) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw368) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw368) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 370/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw369 rwState
|
|
|
|
func (w *rw369) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw369) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw369) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw369) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw369) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw369) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw369) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw369) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw369) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 371/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw370 rwState
|
|
|
|
func (w *rw370) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw370) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw370) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw370) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw370) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw370) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw370) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw370) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw370) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 372/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw371 rwState
|
|
|
|
func (w *rw371) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw371) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw371) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw371) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw371) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw371) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw371) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw371) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw371) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw371) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 373/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw372 rwState
|
|
|
|
func (w *rw372) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw372) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw372) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw372) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw372) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw372) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw372) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw372) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw372) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 374/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw373 rwState
|
|
|
|
func (w *rw373) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw373) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw373) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw373) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw373) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw373) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw373) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw373) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw373) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw373) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 375/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw374 rwState
|
|
|
|
func (w *rw374) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw374) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw374) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw374) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw374) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw374) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw374) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw374) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw374) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw374) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 376/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw375 rwState
|
|
|
|
func (w *rw375) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw375) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw375) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw375) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw375) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw375) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw375) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw375) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw375) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw375) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw375) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 377/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw376 rwState
|
|
|
|
func (w *rw376) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw376) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw376) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw376) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw376) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw376) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw376) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw376) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw376) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw376) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 378/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw377 rwState
|
|
|
|
func (w *rw377) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw377) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw377) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw377) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw377) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw377) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw377) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw377) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw377) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw377) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw377) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 379/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw378 rwState
|
|
|
|
func (w *rw378) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw378) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw378) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw378) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw378) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw378) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw378) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw378) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw378) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw378) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw378) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 380/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw379 rwState
|
|
|
|
func (w *rw379) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw379) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw379) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw379) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw379) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw379) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw379) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw379) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw379) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw379) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw379) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw379) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 381/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw380 rwState
|
|
|
|
func (w *rw380) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw380) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw380) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw380) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw380) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw380) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw380) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw380) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw380) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw380) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw380) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 382/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw381 rwState
|
|
|
|
func (w *rw381) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw381) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw381) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw381) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw381) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw381) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw381) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw381) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw381) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw381) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw381) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw381) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 383/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw382 rwState
|
|
|
|
func (w *rw382) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw382) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw382) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw382) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw382) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw382) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw382) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw382) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw382) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw382) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw382) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw382) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 384/512: http.ResponseWriter, http.Flusher, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw383 rwState
|
|
|
|
func (w *rw383) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw383) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw383) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw383) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw383) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw383) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw383) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw383) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw383) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw383) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw383) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw383) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw383) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 385/512: http.ResponseWriter, http.Flusher, httpFlushError
|
|
type rw384 rwState
|
|
|
|
func (w *rw384) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw384) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw384) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw384) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw384) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw384) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
|
|
// combination 386/512: http.ResponseWriter, http.Flusher, httpFlushError, io.StringWriter
|
|
type rw385 rwState
|
|
|
|
func (w *rw385) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw385) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw385) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw385) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw385) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw385) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw385) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 387/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Pusher
|
|
type rw386 rwState
|
|
|
|
func (w *rw386) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw386) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw386) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw386) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw386) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw386) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw386) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 388/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Pusher, io.StringWriter
|
|
type rw387 rwState
|
|
|
|
func (w *rw387) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw387) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw387) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw387) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw387) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw387) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw387) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw387) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 389/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler
|
|
type rw388 rwState
|
|
|
|
func (w *rw388) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw388) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw388) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw388) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw388) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw388) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw388) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 390/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, io.StringWriter
|
|
type rw389 rwState
|
|
|
|
func (w *rw389) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw389) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw389) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw389) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw389) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw389) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw389) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw389) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 391/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, http.Pusher
|
|
type rw390 rwState
|
|
|
|
func (w *rw390) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw390) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw390) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw390) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw390) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw390) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw390) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw390) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 392/512: http.ResponseWriter, http.Flusher, httpFlushError, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw391 rwState
|
|
|
|
func (w *rw391) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw391) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw391) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw391) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw391) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw391) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw391) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw391) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw391) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 393/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner
|
|
type rw392 rwState
|
|
|
|
func (w *rw392) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw392) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw392) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw392) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw392) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw392) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw392) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw392) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 394/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, io.StringWriter
|
|
type rw393 rwState
|
|
|
|
func (w *rw393) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw393) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw393) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw393) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw393) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw393) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw393) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw393) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw393) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 395/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, http.Pusher
|
|
type rw394 rwState
|
|
|
|
func (w *rw394) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw394) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw394) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw394) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw394) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw394) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw394) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw394) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw394) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 396/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, http.Pusher, io.StringWriter
|
|
type rw395 rwState
|
|
|
|
func (w *rw395) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw395) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw395) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw395) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw395) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw395) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw395) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw395) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw395) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw395) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 397/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler
|
|
type rw396 rwState
|
|
|
|
func (w *rw396) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw396) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw396) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw396) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw396) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw396) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw396) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw396) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw396) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 398/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw397 rwState
|
|
|
|
func (w *rw397) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw397) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw397) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw397) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw397) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw397) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw397) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw397) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw397) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw397) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 399/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw398 rwState
|
|
|
|
func (w *rw398) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw398) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw398) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw398) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw398) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw398) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw398) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw398) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw398) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw398) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 400/512: http.ResponseWriter, http.Flusher, httpFlushError, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw399 rwState
|
|
|
|
func (w *rw399) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw399) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw399) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw399) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw399) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw399) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw399) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw399) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw399) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw399) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw399) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 401/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom
|
|
type rw400 rwState
|
|
|
|
func (w *rw400) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw400) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw400) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw400) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw400) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw400) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw400) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 402/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, io.StringWriter
|
|
type rw401 rwState
|
|
|
|
func (w *rw401) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw401) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw401) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw401) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw401) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw401) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw401) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw401) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 403/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, http.Pusher
|
|
type rw402 rwState
|
|
|
|
func (w *rw402) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw402) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw402) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw402) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw402) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw402) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw402) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw402) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 404/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw403 rwState
|
|
|
|
func (w *rw403) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw403) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw403) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw403) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw403) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw403) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw403) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw403) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw403) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 405/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler
|
|
type rw404 rwState
|
|
|
|
func (w *rw404) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw404) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw404) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw404) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw404) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw404) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw404) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw404) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 406/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw405 rwState
|
|
|
|
func (w *rw405) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw405) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw405) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw405) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw405) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw405) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw405) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw405) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw405) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 407/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw406 rwState
|
|
|
|
func (w *rw406) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw406) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw406) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw406) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw406) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw406) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw406) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw406) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw406) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 408/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw407 rwState
|
|
|
|
func (w *rw407) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw407) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw407) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw407) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw407) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw407) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw407) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw407) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw407) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw407) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 409/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner
|
|
type rw408 rwState
|
|
|
|
func (w *rw408) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw408) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw408) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw408) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw408) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw408) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw408) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw408) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw408) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 410/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw409 rwState
|
|
|
|
func (w *rw409) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw409) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw409) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw409) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw409) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw409) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw409) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw409) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw409) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw409) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 411/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw410 rwState
|
|
|
|
func (w *rw410) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw410) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw410) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw410) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw410) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw410) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw410) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw410) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw410) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw410) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 412/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw411 rwState
|
|
|
|
func (w *rw411) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw411) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw411) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw411) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw411) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw411) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw411) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw411) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw411) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw411) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw411) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 413/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw412 rwState
|
|
|
|
func (w *rw412) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw412) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw412) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw412) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw412) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw412) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw412) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw412) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw412) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw412) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 414/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw413 rwState
|
|
|
|
func (w *rw413) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw413) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw413) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw413) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw413) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw413) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw413) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw413) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw413) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw413) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw413) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 415/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw414 rwState
|
|
|
|
func (w *rw414) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw414) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw414) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw414) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw414) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw414) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw414) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw414) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw414) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw414) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw414) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 416/512: http.ResponseWriter, http.Flusher, httpFlushError, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw415 rwState
|
|
|
|
func (w *rw415) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw415) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw415) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw415) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw415) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw415) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw415) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw415) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw415) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw415) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw415) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw415) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 417/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker
|
|
type rw416 rwState
|
|
|
|
func (w *rw416) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw416) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw416) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw416) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw416) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw416) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw416) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 418/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.StringWriter
|
|
type rw417 rwState
|
|
|
|
func (w *rw417) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw417) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw417) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw417) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw417) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw417) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw417) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw417) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 419/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, http.Pusher
|
|
type rw418 rwState
|
|
|
|
func (w *rw418) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw418) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw418) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw418) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw418) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw418) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw418) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw418) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 420/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw419 rwState
|
|
|
|
func (w *rw419) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw419) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw419) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw419) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw419) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw419) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw419) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw419) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw419) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 421/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler
|
|
type rw420 rwState
|
|
|
|
func (w *rw420) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw420) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw420) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw420) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw420) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw420) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw420) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw420) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 422/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw421 rwState
|
|
|
|
func (w *rw421) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw421) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw421) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw421) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw421) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw421) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw421) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw421) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw421) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 423/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw422 rwState
|
|
|
|
func (w *rw422) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw422) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw422) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw422) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw422) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw422) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw422) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw422) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw422) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 424/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw423 rwState
|
|
|
|
func (w *rw423) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw423) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw423) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw423) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw423) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw423) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw423) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw423) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw423) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw423) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 425/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner
|
|
type rw424 rwState
|
|
|
|
func (w *rw424) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw424) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw424) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw424) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw424) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw424) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw424) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw424) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw424) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 426/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, io.StringWriter
|
|
type rw425 rwState
|
|
|
|
func (w *rw425) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw425) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw425) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw425) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw425) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw425) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw425) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw425) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw425) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw425) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 427/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, http.Pusher
|
|
type rw426 rwState
|
|
|
|
func (w *rw426) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw426) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw426) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw426) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw426) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw426) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw426) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw426) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw426) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw426) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 428/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw427 rwState
|
|
|
|
func (w *rw427) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw427) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw427) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw427) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw427) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw427) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw427) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw427) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw427) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw427) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw427) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 429/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw428 rwState
|
|
|
|
func (w *rw428) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw428) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw428) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw428) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw428) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw428) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw428) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw428) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw428) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw428) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 430/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw429 rwState
|
|
|
|
func (w *rw429) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw429) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw429) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw429) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw429) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw429) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw429) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw429) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw429) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw429) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw429) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 431/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw430 rwState
|
|
|
|
func (w *rw430) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw430) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw430) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw430) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw430) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw430) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw430) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw430) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw430) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw430) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw430) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 432/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw431 rwState
|
|
|
|
func (w *rw431) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw431) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw431) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw431) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw431) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw431) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw431) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw431) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw431) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw431) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw431) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw431) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 433/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom
|
|
type rw432 rwState
|
|
|
|
func (w *rw432) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw432) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw432) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw432) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw432) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw432) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw432) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw432) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 434/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw433 rwState
|
|
|
|
func (w *rw433) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw433) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw433) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw433) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw433) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw433) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw433) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw433) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw433) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 435/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw434 rwState
|
|
|
|
func (w *rw434) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw434) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw434) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw434) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw434) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw434) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw434) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw434) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw434) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 436/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw435 rwState
|
|
|
|
func (w *rw435) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw435) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw435) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw435) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw435) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw435) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw435) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw435) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw435) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw435) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 437/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw436 rwState
|
|
|
|
func (w *rw436) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw436) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw436) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw436) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw436) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw436) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw436) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw436) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw436) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 438/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw437 rwState
|
|
|
|
func (w *rw437) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw437) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw437) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw437) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw437) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw437) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw437) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw437) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw437) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw437) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 439/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw438 rwState
|
|
|
|
func (w *rw438) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw438) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw438) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw438) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw438) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw438) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw438) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw438) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw438) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw438) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 440/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw439 rwState
|
|
|
|
func (w *rw439) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw439) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw439) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw439) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw439) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw439) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw439) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw439) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw439) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw439) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw439) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 441/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw440 rwState
|
|
|
|
func (w *rw440) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw440) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw440) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw440) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw440) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw440) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw440) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw440) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw440) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw440) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 442/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw441 rwState
|
|
|
|
func (w *rw441) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw441) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw441) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw441) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw441) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw441) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw441) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw441) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw441) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw441) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw441) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 443/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw442 rwState
|
|
|
|
func (w *rw442) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw442) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw442) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw442) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw442) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw442) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw442) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw442) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw442) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw442) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw442) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 444/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw443 rwState
|
|
|
|
func (w *rw443) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw443) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw443) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw443) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw443) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw443) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw443) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw443) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw443) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw443) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw443) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw443) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 445/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw444 rwState
|
|
|
|
func (w *rw444) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw444) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw444) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw444) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw444) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw444) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw444) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw444) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw444) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw444) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw444) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 446/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw445 rwState
|
|
|
|
func (w *rw445) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw445) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw445) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw445) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw445) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw445) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw445) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw445) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw445) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw445) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw445) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw445) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 447/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw446 rwState
|
|
|
|
func (w *rw446) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw446) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw446) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw446) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw446) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw446) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw446) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw446) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw446) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw446) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw446) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw446) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 448/512: http.ResponseWriter, http.Flusher, httpFlushError, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw447 rwState
|
|
|
|
func (w *rw447) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw447) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw447) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw447) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw447) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw447) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw447) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw447) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw447) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw447) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw447) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw447) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw447) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 449/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier
|
|
type rw448 rwState
|
|
|
|
func (w *rw448) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw448) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw448) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw448) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw448) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw448) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw448) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
|
|
// combination 450/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.StringWriter
|
|
type rw449 rwState
|
|
|
|
func (w *rw449) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw449) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw449) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw449) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw449) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw449) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw449) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw449) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 451/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Pusher
|
|
type rw450 rwState
|
|
|
|
func (w *rw450) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw450) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw450) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw450) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw450) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw450) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw450) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw450) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 452/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Pusher, io.StringWriter
|
|
type rw451 rwState
|
|
|
|
func (w *rw451) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw451) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw451) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw451) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw451) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw451) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw451) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw451) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw451) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 453/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler
|
|
type rw452 rwState
|
|
|
|
func (w *rw452) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw452) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw452) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw452) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw452) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw452) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw452) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw452) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 454/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, io.StringWriter
|
|
type rw453 rwState
|
|
|
|
func (w *rw453) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw453) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw453) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw453) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw453) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw453) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw453) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw453) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw453) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 455/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher
|
|
type rw454 rwState
|
|
|
|
func (w *rw454) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw454) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw454) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw454) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw454) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw454) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw454) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw454) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw454) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 456/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw455 rwState
|
|
|
|
func (w *rw455) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw455) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw455) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw455) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw455) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw455) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw455) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw455) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw455) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw455) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 457/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner
|
|
type rw456 rwState
|
|
|
|
func (w *rw456) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw456) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw456) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw456) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw456) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw456) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw456) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw456) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw456) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 458/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, io.StringWriter
|
|
type rw457 rwState
|
|
|
|
func (w *rw457) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw457) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw457) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw457) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw457) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw457) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw457) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw457) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw457) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw457) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 459/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, http.Pusher
|
|
type rw458 rwState
|
|
|
|
func (w *rw458) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw458) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw458) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw458) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw458) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw458) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw458) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw458) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw458) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw458) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 460/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, http.Pusher, io.StringWriter
|
|
type rw459 rwState
|
|
|
|
func (w *rw459) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw459) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw459) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw459) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw459) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw459) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw459) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw459) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw459) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw459) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw459) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 461/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler
|
|
type rw460 rwState
|
|
|
|
func (w *rw460) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw460) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw460) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw460) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw460) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw460) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw460) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw460) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw460) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw460) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 462/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw461 rwState
|
|
|
|
func (w *rw461) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw461) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw461) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw461) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw461) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw461) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw461) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw461) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw461) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw461) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw461) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 463/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw462 rwState
|
|
|
|
func (w *rw462) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw462) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw462) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw462) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw462) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw462) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw462) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw462) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw462) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw462) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw462) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 464/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw463 rwState
|
|
|
|
func (w *rw463) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw463) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw463) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw463) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw463) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw463) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw463) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw463) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw463) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw463) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw463) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw463) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 465/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom
|
|
type rw464 rwState
|
|
|
|
func (w *rw464) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw464) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw464) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw464) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw464) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw464) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw464) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw464) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 466/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, io.StringWriter
|
|
type rw465 rwState
|
|
|
|
func (w *rw465) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw465) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw465) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw465) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw465) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw465) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw465) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw465) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw465) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 467/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher
|
|
type rw466 rwState
|
|
|
|
func (w *rw466) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw466) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw466) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw466) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw466) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw466) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw466) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw466) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw466) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 468/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw467 rwState
|
|
|
|
func (w *rw467) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw467) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw467) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw467) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw467) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw467) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw467) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw467) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw467) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw467) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 469/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler
|
|
type rw468 rwState
|
|
|
|
func (w *rw468) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw468) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw468) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw468) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw468) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw468) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw468) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw468) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw468) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 470/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw469 rwState
|
|
|
|
func (w *rw469) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw469) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw469) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw469) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw469) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw469) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw469) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw469) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw469) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw469) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 471/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw470 rwState
|
|
|
|
func (w *rw470) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw470) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw470) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw470) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw470) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw470) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw470) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw470) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw470) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw470) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 472/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw471 rwState
|
|
|
|
func (w *rw471) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw471) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw471) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw471) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw471) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw471) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw471) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw471) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw471) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw471) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw471) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 473/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner
|
|
type rw472 rwState
|
|
|
|
func (w *rw472) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw472) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw472) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw472) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw472) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw472) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw472) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw472) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw472) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw472) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 474/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw473 rwState
|
|
|
|
func (w *rw473) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw473) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw473) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw473) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw473) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw473) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw473) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw473) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw473) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw473) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw473) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 475/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw474 rwState
|
|
|
|
func (w *rw474) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw474) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw474) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw474) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw474) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw474) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw474) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw474) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw474) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw474) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw474) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 476/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw475 rwState
|
|
|
|
func (w *rw475) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw475) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw475) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw475) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw475) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw475) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw475) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw475) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw475) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw475) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw475) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw475) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 477/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw476 rwState
|
|
|
|
func (w *rw476) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw476) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw476) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw476) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw476) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw476) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw476) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw476) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw476) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw476) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw476) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 478/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw477 rwState
|
|
|
|
func (w *rw477) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw477) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw477) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw477) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw477) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw477) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw477) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw477) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw477) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw477) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw477) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw477) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 479/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw478 rwState
|
|
|
|
func (w *rw478) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw478) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw478) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw478) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw478) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw478) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw478) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw478) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw478) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw478) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw478) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw478) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 480/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw479 rwState
|
|
|
|
func (w *rw479) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw479) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw479) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw479) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw479) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw479) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw479) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw479) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw479) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw479) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw479) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw479) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw479) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 481/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker
|
|
type rw480 rwState
|
|
|
|
func (w *rw480) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw480) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw480) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw480) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw480) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw480) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw480) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw480) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
|
|
// combination 482/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.StringWriter
|
|
type rw481 rwState
|
|
|
|
func (w *rw481) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw481) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw481) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw481) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw481) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw481) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw481) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw481) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw481) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 483/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher
|
|
type rw482 rwState
|
|
|
|
func (w *rw482) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw482) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw482) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw482) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw482) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw482) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw482) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw482) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw482) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 484/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, http.Pusher, io.StringWriter
|
|
type rw483 rwState
|
|
|
|
func (w *rw483) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw483) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw483) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw483) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw483) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw483) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw483) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw483) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw483) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw483) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 485/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler
|
|
type rw484 rwState
|
|
|
|
func (w *rw484) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw484) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw484) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw484) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw484) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw484) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw484) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw484) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw484) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 486/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, io.StringWriter
|
|
type rw485 rwState
|
|
|
|
func (w *rw485) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw485) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw485) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw485) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw485) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw485) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw485) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw485) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw485) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw485) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 487/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher
|
|
type rw486 rwState
|
|
|
|
func (w *rw486) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw486) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw486) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw486) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw486) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw486) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw486) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw486) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw486) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw486) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 488/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw487 rwState
|
|
|
|
func (w *rw487) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw487) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw487) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw487) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw487) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw487) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw487) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw487) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw487) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw487) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw487) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 489/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner
|
|
type rw488 rwState
|
|
|
|
func (w *rw488) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw488) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw488) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw488) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw488) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw488) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw488) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw488) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw488) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw488) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 490/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, io.StringWriter
|
|
type rw489 rwState
|
|
|
|
func (w *rw489) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw489) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw489) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw489) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw489) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw489) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw489) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw489) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw489) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw489) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw489) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 491/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher
|
|
type rw490 rwState
|
|
|
|
func (w *rw490) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw490) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw490) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw490) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw490) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw490) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw490) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw490) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw490) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw490) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw490) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 492/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, http.Pusher, io.StringWriter
|
|
type rw491 rwState
|
|
|
|
func (w *rw491) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw491) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw491) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw491) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw491) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw491) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw491) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw491) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw491) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw491) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw491) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw491) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 493/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler
|
|
type rw492 rwState
|
|
|
|
func (w *rw492) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw492) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw492) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw492) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw492) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw492) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw492) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw492) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw492) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw492) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw492) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 494/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw493 rwState
|
|
|
|
func (w *rw493) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw493) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw493) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw493) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw493) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw493) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw493) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw493) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw493) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw493) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw493) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw493) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 495/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw494 rwState
|
|
|
|
func (w *rw494) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw494) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw494) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw494) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw494) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw494) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw494) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw494) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw494) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw494) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw494) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw494) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 496/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw495 rwState
|
|
|
|
func (w *rw495) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw495) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw495) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw495) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw495) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw495) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw495) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw495) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw495) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw495) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw495) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw495) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw495) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 497/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom
|
|
type rw496 rwState
|
|
|
|
func (w *rw496) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw496) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw496) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw496) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw496) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw496) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw496) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw496) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw496) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
|
|
// combination 498/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, io.StringWriter
|
|
type rw497 rwState
|
|
|
|
func (w *rw497) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw497) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw497) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw497) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw497) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw497) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw497) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw497) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw497) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw497) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 499/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher
|
|
type rw498 rwState
|
|
|
|
func (w *rw498) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw498) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw498) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw498) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw498) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw498) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw498) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw498) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw498) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw498) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 500/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, http.Pusher, io.StringWriter
|
|
type rw499 rwState
|
|
|
|
func (w *rw499) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw499) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw499) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw499) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw499) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw499) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw499) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw499) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw499) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw499) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw499) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 501/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler
|
|
type rw500 rwState
|
|
|
|
func (w *rw500) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw500) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw500) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw500) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw500) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw500) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw500) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw500) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw500) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw500) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 502/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, io.StringWriter
|
|
type rw501 rwState
|
|
|
|
func (w *rw501) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw501) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw501) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw501) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw501) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw501) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw501) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw501) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw501) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw501) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw501) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 503/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher
|
|
type rw502 rwState
|
|
|
|
func (w *rw502) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw502) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw502) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw502) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw502) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw502) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw502) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw502) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw502) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw502) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw502) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 504/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw503 rwState
|
|
|
|
func (w *rw503) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw503) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw503) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw503) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw503) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw503) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw503) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw503) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw503) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw503) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw503) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw503) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 505/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner
|
|
type rw504 rwState
|
|
|
|
func (w *rw504) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw504) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw504) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw504) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw504) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw504) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw504) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw504) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw504) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw504) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw504) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
|
|
// combination 506/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, io.StringWriter
|
|
type rw505 rwState
|
|
|
|
func (w *rw505) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw505) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw505) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw505) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw505) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw505) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw505) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw505) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw505) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw505) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw505) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw505) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 507/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher
|
|
type rw506 rwState
|
|
|
|
func (w *rw506) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw506) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw506) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw506) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw506) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw506) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw506) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw506) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw506) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw506) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw506) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw506) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 508/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, http.Pusher, io.StringWriter
|
|
type rw507 rwState
|
|
|
|
func (w *rw507) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw507) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw507) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw507) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw507) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw507) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw507) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw507) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw507) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw507) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw507) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw507) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw507) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 509/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler
|
|
type rw508 rwState
|
|
|
|
func (w *rw508) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw508) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw508) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw508) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw508) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw508) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw508) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw508) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw508) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw508) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw508) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw508) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
|
|
// combination 510/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, io.StringWriter
|
|
type rw509 rwState
|
|
|
|
func (w *rw509) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw509) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw509) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw509) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw509) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw509) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw509) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw509) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw509) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw509) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw509) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw509) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw509) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
// combination 511/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher
|
|
type rw510 rwState
|
|
|
|
func (w *rw510) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw510) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw510) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw510) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw510) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw510) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw510) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw510) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw510) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw510) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw510) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw510) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw510) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
|
|
// combination 512/512: http.ResponseWriter, http.Flusher, httpFlushError, http.CloseNotifier, http.Hijacker, io.ReaderFrom, deadliner, fullDuplexEnabler, http.Pusher, io.StringWriter
|
|
type rw511 rwState
|
|
|
|
func (w *rw511) Unwrap() http.ResponseWriter { return w.w }
|
|
func (w *rw511) Header() http.Header {
|
|
return (*rwState)(w).doHeader()
|
|
}
|
|
func (w *rw511) WriteHeader(code int) {
|
|
(*rwState)(w).doWriteHeader(code)
|
|
}
|
|
func (w *rw511) Write(b []byte) (int, error) {
|
|
return (*rwState)(w).doWrite(b)
|
|
}
|
|
func (w *rw511) Flush() {
|
|
(*rwState)(w).doFlush()
|
|
}
|
|
func (w *rw511) FlushError() error {
|
|
return (*rwState)(w).doFlushError()
|
|
}
|
|
func (w *rw511) CloseNotify() <-chan bool {
|
|
return (*rwState)(w).doCloseNotify()
|
|
}
|
|
func (w *rw511) Hijack() (net.Conn, *bufio.ReadWriter, error) {
|
|
return (*rwState)(w).doHijack()
|
|
}
|
|
func (w *rw511) ReadFrom(src io.Reader) (int64, error) {
|
|
return (*rwState)(w).doReadFrom(src)
|
|
}
|
|
func (w *rw511) SetReadDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetReadDeadline(deadline)
|
|
}
|
|
func (w *rw511) SetWriteDeadline(deadline time.Time) error {
|
|
return (*rwState)(w).doSetWriteDeadline(deadline)
|
|
}
|
|
func (w *rw511) EnableFullDuplex() error {
|
|
return (*rwState)(w).doEnableFullDuplex()
|
|
}
|
|
func (w *rw511) Push(target string, opts *http.PushOptions) error {
|
|
return (*rwState)(w).doPush(target, opts)
|
|
}
|
|
func (w *rw511) WriteString(s string) (int, error) {
|
|
return (*rwState)(w).doWriteString(s)
|
|
}
|
|
|
|
type Unwrapper interface {
|
|
Unwrap() http.ResponseWriter
|
|
}
|
|
|
|
// Unwrap returns the underlying http.ResponseWriter from within zero or more
|
|
// layers of httpsnoop wrappers.
|
|
func Unwrap(w http.ResponseWriter) http.ResponseWriter {
|
|
if rw, ok := w.(Unwrapper); ok {
|
|
// recurse until rw.Unwrap() returns a non-Unwrapper
|
|
return Unwrap(rw.Unwrap())
|
|
}
|
|
return w
|
|
}
|