builder_conformance

type AllOfHost ¶

type AllOfHost struct {
	// swagger:allOf
	FmtNamed

	// swagger:allOf
	FmtAlias

	// swagger:allOf
	TypeNamed

	// swagger:allOf
	TypeAlias

	// swagger:allOf
	EnumNamed

	// swagger:allOf
	BytesNamed

	// swagger:allOf
	StampAlias

	// swagger:allOf
	RawAlias

	// swagger:allOf
	Plain

	// swagger:allOf
	Speaker

	// swagger:allOf
	EmailsNamed

	// swagger:allOf
	CodesNamed

	// swagger:allOf
	time.Time

	// swagger:allOf
	json.RawMessage

	// swagger:allOf
	ErrAlias

	// Note is the composing struct's own field, which lands in the trailing member.
	Note string `json:"note"`
}

AllOfHost reaches every EMBEDDABLE subject as an allOf MEMBER, one member per subject, in the same order ModelHost declares them.

A member of an allOf is a full schema describing one type, exactly as a model field is, so the two must agree. It is reached by a different arm than any of the other three positions — `buildNamedAllOf` rather than the field dispatch — and that arm consults its own subset of the classifiers.

One allOf rather than one host per subject, deliberately: members that resolve side by side also witness that no member's classifier leaks into its neighbours, which separate hosts could not show. The composing struct's own field lands in a trailing member, so member i is subject i.

Subjects absent here are the ones Go cannot embed under a usable name: a map, a slice of an inline struct, and the pointer/basic/predeclared arms, whose embedded field name would either collide with another member or be unexported.

swagger:model AllOfHost

type BytesNamed ¶

type BytesNamed []byte

BytesNamed is a byte sequence carrying the whole-schema format.

swagger:strfmt byte

type CodesNamed ¶

type CodesNamed [4]string

CodesNamed is the array flavour of the same divergence.

swagger:strfmt email

type EmailsNamed ¶

type EmailsNamed []string

EmailsNamed is a named STRING slice carrying a NON-special format.

This is the pinned divergence. The element-driven rule (see common.ApplyArrayLikeStrfmt) asks whether the ELEMENT makes the sequence string-like: `byte` and `rune` do, so a format describes the whole value; `string` does not, so the format describes each element. The schema builder applies that rule. The parameters and responses builders short-circuit on a local `strfmtFromDoc` helper that predates it and writes `Typed("string", format)` unconditionally, claiming the value IS one email when the Go type is a list of them.

swagger:strfmt email

type EnumNamed ¶

type EnumNamed uint64

EnumNamed is a named enum.

swagger:enum EnumNamed

const (
	// EnumLow is the low member.
	EnumLow EnumNamed = 1

	// EnumHigh is the high member.
	EnumHigh EnumNamed = 2
)

type ErrAlias ¶

type ErrAlias = error

ErrAlias names the predeclared error through an alias.

The alias's own object is this name, not `error`, so an identity recognizer keyed on the object never fires here — only after the alias dissolves.

type FmtAlias ¶

type FmtAlias = string

FmtAlias carries the same format on an alias.

swagger:strfmt isbn

type FmtNamed ¶

type FmtNamed string

FmtNamed carries a format on a named type.

swagger:strfmt isbn

type ModelHost ¶

type ModelHost struct {
	// Fmt is the named-format subject.
	Fmt FmtNamed `json:"fmt"`

	// FmtAl is the alias-format subject.
	FmtAl FmtAlias `json:"fmtAl"`

	// Typ is the named-override subject.
	Typ TypeNamed `json:"typ"`

	// TypAl is the alias-override subject.
	TypAl TypeAlias `json:"typAl"`

	// Enum is the enum subject.
	Enum EnumNamed `json:"enum"`

	// Bytes is the byte-sequence subject.
	Bytes BytesNamed `json:"bytes"`

	// Stamp is the stdlib-alias subject.
	Stamp StampAlias `json:"stamp"`

	// Raw is the open-schema subject.
	Raw RawAlias `json:"raw"`

	// Struct is the struct-arm subject.
	Struct Plain `json:"struct"`

	// Iface is the interface-arm subject.
	Iface Speaker `json:"iface"`

	// Mapping is the map-arm subject.
	Mapping map[string]Plain `json:"mapping"`

	// Inline is the slice arm with an inline element.
	Inline []struct {
		// Code is the inline element property.
		Code string `json:"code"`
	} `json:"inline"`

	// Ptr is the pointer arm.
	Ptr *Plain `json:"ptr"`

	// Basic is the plain-basic arm.
	Basic int32 `json:"basic"`

	// Emails is the pinned slice+non-special-format divergence.
	Emails EmailsNamed `json:"emails"`

	// Codes is the array flavour of the same.
	Codes CodesNamed `json:"codes"`

	// StampN is the stdlib time reached as the named type.
	StampN time.Time `json:"stampN"`

	// RawN is the open-schema stdlib type reached as the named type.
	RawN json.RawMessage `json:"rawN"`

	// AnyV is the predeclared any.
	AnyV any `json:"anyv"`

	// ErrN is the predeclared error — no package, no declaration.
	ErrN error `json:"errN"`

	// ErrAl names the same through an alias.
	ErrAl ErrAlias `json:"errAl"`
}

ModelHost reaches every subject as a MODEL FIELD — the schema builder's view, and the control for the other two.

swagger:model ModelHost

type ParamsAnyV ¶

type ParamsAnyV struct {
	// in: body
	Body any `json:"body"`
}

ParamsAnyV reaches the predeclared any as a body parameter.

swagger:parameters confAnyV

type ParamsBasic ¶

type ParamsBasic struct {
	// in: body
	Body int32 `json:"body"`
}

ParamsBasic reaches the basic subject as a body parameter.

swagger:parameters confBasic

type ParamsBytes ¶

type ParamsBytes struct {
	// in: body
	Body BytesNamed `json:"body"`
}

ParamsBytes reaches BytesNamed as a body parameter.

swagger:parameters confBytes

type ParamsCodes ¶

type ParamsCodes struct {
	// in: body
	Body CodesNamed `json:"body"`
}

ParamsCodes reaches the codes subject as a body parameter.

swagger:parameters confCodes

type ParamsEmails ¶

type ParamsEmails struct {
	// in: body
	Body EmailsNamed `json:"body"`
}

ParamsEmails reaches the emails subject as a body parameter.

swagger:parameters confEmails

type ParamsEnum ¶

type ParamsEnum struct {
	// in: body
	Body EnumNamed `json:"body"`
}

ParamsEnum reaches EnumNamed as a body parameter.

swagger:parameters confEnum

type ParamsErrAl ¶

type ParamsErrAl struct {
	// Named for the subject, as above.
	//
	// in: body
	Body ErrAlias `json:"errAl"`
}

ParamsErrAl reaches the aliased error as a body parameter.

swagger:parameters confErrAl

type ParamsErrN ¶

type ParamsErrN struct {
	// The name is the subject's, not the usual "body": the diagnostic raised when this parameter is
	// dropped has to be attributable to it.
	//
	// in: body
	Body error `json:"errN"`
}

ParamsErrN reaches the predeclared error as a body parameter.

swagger:parameters confErrN

type ParamsFmt ¶

type ParamsFmt struct {
	// in: body
	Body FmtNamed `json:"body"`
}

ParamsFmt reaches FmtNamed as a body parameter.

swagger:parameters confFmt

type ParamsFmtAl ¶

type ParamsFmtAl struct {
	// in: body
	Body FmtAlias `json:"body"`
}

ParamsFmtAl reaches FmtAlias as a body parameter.

swagger:parameters confFmtAl

type ParamsIface ¶

type ParamsIface struct {
	// in: body
	Body Speaker `json:"body"`
}

ParamsIface reaches the iface subject as a body parameter.

swagger:parameters confIface

type ParamsInline ¶

type ParamsInline struct {
	// in: body
	Body []struct {
		// Code is the inline element property.
		Code string `json:"code"`
	} `json:"body"`
}

ParamsInline reaches the inline-element slice as a body parameter.

swagger:parameters confInline

type ParamsMapping ¶

type ParamsMapping struct {
	// in: body
	Body map[string]Plain `json:"body"`
}

ParamsMapping reaches the mapping subject as a body parameter.

swagger:parameters confMapping

type ParamsPtr ¶

type ParamsPtr struct {
	// in: body
	Body *Plain `json:"body"`
}

ParamsPtr reaches the ptr subject as a body parameter.

swagger:parameters confPtr

type ParamsRaw ¶

type ParamsRaw struct {
	// in: body
	Body RawAlias `json:"body"`
}

ParamsRaw reaches RawAlias as a body parameter.

swagger:parameters confRaw

type ParamsRawN ¶

type ParamsRawN struct {
	// in: body
	Body json.RawMessage `json:"body"`
}

ParamsRawN reaches the named open-schema type as a body parameter.

swagger:parameters confRawN

type ParamsStamp ¶

type ParamsStamp struct {
	// in: body
	Body StampAlias `json:"body"`
}

ParamsStamp reaches StampAlias as a body parameter.

swagger:parameters confStamp

type ParamsStampN ¶

type ParamsStampN struct {
	// in: body
	Body time.Time `json:"body"`
}

ParamsStampN reaches the named stdlib time as a body parameter.

swagger:parameters confStampN

type ParamsStruct ¶

type ParamsStruct struct {
	// in: body
	Body Plain `json:"body"`
}

ParamsStruct reaches the struct subject as a body parameter.

swagger:parameters confStruct

type ParamsTyp ¶

type ParamsTyp struct {
	// in: body
	Body TypeNamed `json:"body"`
}

ParamsTyp reaches TypeNamed as a body parameter.

swagger:parameters confTyp

type ParamsTypAl ¶

type ParamsTypAl struct {
	// in: body
	Body TypeAlias `json:"body"`
}

ParamsTypAl reaches TypeAlias as a body parameter.

swagger:parameters confTypAl

type Plain ¶

type Plain struct {
	// Left is a plain property.
	Left string `json:"left"`
}

Plain is a struct reached directly as a field.

type RawAlias ¶

type RawAlias = json.RawMessage

RawAlias is an alias to the open "any JSON" stdlib type.

type RespAnyV ¶

type RespAnyV struct {
	// in: body
	Body any `json:"body"`
}

RespAnyV reaches the predeclared any as a response body.

swagger:response respAnyV

type RespBasic ¶

type RespBasic struct {
	// in: body
	Body int32 `json:"body"`
}

RespBasic reaches the basic subject as a response body.

swagger:response respBasic

type RespBytes ¶

type RespBytes struct {
	// in: body
	Body BytesNamed `json:"body"`
}

RespBytes reaches BytesNamed as a response body.

swagger:response respBytes

type RespCodes ¶

type RespCodes struct {
	// in: body
	Body CodesNamed `json:"body"`
}

RespCodes reaches the codes subject as a response body.

swagger:response respCodes

type RespEmails ¶

type RespEmails struct {
	// in: body
	Body EmailsNamed `json:"body"`
}

RespEmails reaches the emails subject as a response body.

swagger:response respEmails

type RespEnum ¶

type RespEnum struct {
	// in: body
	Body EnumNamed `json:"body"`
}

RespEnum reaches EnumNamed as a response body.

swagger:response respEnum

type RespErrAl ¶

type RespErrAl struct {
	// in: body
	Body ErrAlias `json:"body"`
}

RespErrAl reaches the aliased error as a response body.

swagger:response respErrAl

type RespErrN ¶

type RespErrN struct {
	// in: body
	Body error `json:"body"`
}

RespErrN reaches the predeclared error as a response body.

swagger:response respErrN

type RespFmt ¶

type RespFmt struct {
	// in: body
	Body FmtNamed `json:"body"`
}

RespFmt reaches FmtNamed as a response body.

swagger:response respFmt

type RespFmtAl ¶

type RespFmtAl struct {
	// in: body
	Body FmtAlias `json:"body"`
}

RespFmtAl reaches FmtAlias as a response body.

swagger:response respFmtAl

type RespIface ¶

type RespIface struct {
	// in: body
	Body Speaker `json:"body"`
}

RespIface reaches the iface subject as a response body.

swagger:response respIface

type RespInline ¶

type RespInline struct {
	// in: body
	Body []struct {
		// Code is the inline element property.
		Code string `json:"code"`
	} `json:"body"`
}

RespInline reaches the inline-element slice as a response body.

swagger:response respInline

type RespMapping ¶

type RespMapping struct {
	// in: body
	Body map[string]Plain `json:"body"`
}

RespMapping reaches the mapping subject as a response body.

swagger:response respMapping

type RespPtr ¶

type RespPtr struct {
	// in: body
	Body *Plain `json:"body"`
}

RespPtr reaches the ptr subject as a response body.

swagger:response respPtr

type RespRaw ¶

type RespRaw struct {
	// in: body
	Body RawAlias `json:"body"`
}

RespRaw reaches RawAlias as a response body.

swagger:response respRaw

type RespRawN ¶

type RespRawN struct {
	// in: body
	Body json.RawMessage `json:"body"`
}

RespRawN reaches the named open-schema type as a response body.

swagger:response respRawN

type RespStamp ¶

type RespStamp struct {
	// in: body
	Body StampAlias `json:"body"`
}

RespStamp reaches StampAlias as a response body.

swagger:response respStamp

type RespStampN ¶

type RespStampN struct {
	// in: body
	Body time.Time `json:"body"`
}

RespStampN reaches the named stdlib time as a response body.

swagger:response respStampN

type RespStruct ¶

type RespStruct struct {
	// in: body
	Body Plain `json:"body"`
}

RespStruct reaches the struct subject as a response body.

swagger:response respStruct

type RespTyp ¶

type RespTyp struct {
	// in: body
	Body TypeNamed `json:"body"`
}

RespTyp reaches TypeNamed as a response body.

swagger:response respTyp

type RespTypAl ¶

type RespTypAl struct {
	// in: body
	Body TypeAlias `json:"body"`
}

RespTypAl reaches TypeAlias as a response body.

swagger:response respTypAl

type Speaker ¶

type Speaker interface {
	// Say returns a word.
	Say() string
}

Speaker is a non-empty interface reached directly as a field.

type StampAlias ¶

type StampAlias = time.Time

StampAlias is an alias to a recognised stdlib type.

type TypeAlias ¶

type TypeAlias = int

TypeAlias carries the same override on an alias. This pair is the one that caught the body-branch gap.

swagger:type string

type TypeNamed ¶

type TypeNamed int

TypeNamed carries a type override on a named type.

swagger:type string