httpentity

type Encoder interface {
	Locales() []locale.Spec
	Write(io.Writer, locale.Spec) locale.Error
	IsText() bool
}

type EncoderJSON struct {
	Data interface{}
}

type EncoderJSONStr struct {
	Data locale.Stringer
}

type EncoderTXT struct {
	Data locale.Stringer
}

type Entity interface {
	// Methods() returns a map of HTTP request methods to Handlers
	// that handle requests for this Entity.
	Methods() map[string]func(Request) Response
}

type EntityExtra interface {
	Entity
	MethodNotAllowed(request Request) Response
}

type EntityGroup interface {
	Entity

	// Subentity(name, request) returns the child of this entity
	// with the name `name`, or nil if a child with that name
	// doesn't exist.
	//
	// The Request is included in the function call so that it can
	// be determined if the user has permission to access that
	// child.
	Subentity(name string, request Request) Entity

	// SubentityNotFound is called if Subentity returns nil.  If
	// the name contains a slash; it indicates that the child was
	// found, but a grandchild was requested, and the child wasn't
	// an EntityGroup.
	SubentityNotFound(name string, request Request) Response
}

type Logger interface {
	Printf(format string, v ...interface{})
	Println(v ...interface{})
}

type Middleware struct {
	// Outside is able to affect the entity that is looked up
	Outside func(Request, func(Request) Response) Response
	// Inside cannot affect the entity that is looked up, but it
	// gets to inspect the entity.
	Inside func(Request, Entity, func(Request, Entity) Response) Response
}

type NetEntity interface {
	// Encoders() returns a map of MIME-types to encoders that
	// serialize the NetEntity to that type.
	Encoders() map[string]Encoder
}

type NetJSON struct {
	Data interface{}
}

type NetLocations []*url.URL

type NetStringer struct {
	locale.Stringer
}

type Request struct {
	Method  string
	URL     *url.URL
	Headers http.Header
	Entity  interface{}
	Things  map[string]interface{} // Objects added by middlewares
	// contains filtered or unexported fields
}

type Response struct {
	Status                 int16
	Headers                http.Header
	Entity                 NetEntity
	InhibitNotAcceptable   bool
	InhibitMultipleChoices bool
	// contains filtered or unexported fields
}

type RootEntity interface {
	Entity
	Subentity(name string, request Request) Entity
	SubentityNotFound(name string, request Request) Response
	MethodNotAllowed(request Request) Response
}

type Router struct {
	Prefix      string
	Root        RootEntity
	Decoders    map[string]func(io.Reader, map[string]string) (interface{}, locale.Error)
	Middlewares []Middleware

	// Whether to include stacktraces in HTTP 500 responses
	Stacktrace bool

	Log Logger

	// Whether to trust `X-Forwarded-Scheme:` and RFC 7239
	// `Forwarded: proto=`
	TrustForwarded bool

	MethodNotAllowed func(entity Entity, request Request) Response
	// contains filtered or unexported fields
}