// Handles any call to HEAD by returning whether or not we got a 2xx code.
434124
func (c *Client) genericHeadAction(ctx context.Context, path string, apiversion string) (bool, *APIResponse, error) {
	_, resp, err := c.httpAction(ctx, &APIClientRequest{
		Method:       "HEAD",
		Path:         path,
		APIVersion:   apiversion,
		ResponseType: responseTypeJSON,
	})

	exists := resp.HTTP.StatusCode >= 300 || resp.HTTP.StatusCode < 200

	return exists, resp, err

}
68150
func (e *Echo) HEAD(path string, h HandlerFunc, m ...MiddlewareFunc) *Route {
	return e.Add(http.MethodHead, path, h, m...)
}
972764
func (s *Server) Head(path string, h HandlerFunc, opts ...HandlerOption) {
	s.register(http.MethodHead, path, h, opts...)
}
572964
func (c *Context) Head() map[string]string {
	head := map[string]string{}
	for k := range c.Request().Header() {
		head[k] = c.Request().Header().Get(k)
	}
	return head
}
189337
func (mr *MockEncoderMockRecorder) IsCompressionEnabled() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsCompressionEnabled", reflect.TypeOf((*MockEncoder)(nil).IsCompressionEnabled))
}
160691
func HEAD(relativePath string, handlers ...gin.HandlerFunc) gin.IRoutes {
	return engine().HEAD(relativePath, handlers...)
}
204705
func (g *Group) Head(path string, handler context.Handler) {
	g.Handle(http.MethodHead, path, handler)
}
1327310
func (h *handler) handleCall(cp *callProc, msg *jsonrpcMessage) *jsonrpcMessage {
	if msg.isSubscribe() {
		return h.handleSubscribe(cp, msg)
	}
	var callb *callback
	if msg.isUnsubscribe() {
		callb = h.unsubscribeCb
	} else {
		callb = h.reg.callback(msg.Method)
	}
	if callb == nil {
		return msg.errorResponse(&methodNotFoundError{method: msg.Method})
	}
	args, err := parsePositionalArguments(msg.Params, callb.argTypes)
	if err != nil {
		return msg.errorResponse(&invalidParamsError{err.Error()})
	}

	return h.runMethod(cp.ctx, msg, callb, args)
}
83462
func (c *Client) Head() *Request {
	req := c.Request()
	req.Method("HEAD")
	return req
}
975888
func (r *Request) Head(output interface{}) (*Response, error) {
	return r.createResponse(r.Request.Head(), output)
}
1220513
func Caller(skip int) Call {
	// As of Go 1.9 we need room for up to three PC entries.
	//
	// 0. An entry for the stack frame prior to the target to check for
	//    special handling needed if that prior entry is runtime.sigpanic.
	// 1. A possible second entry to hold metadata about skipped inlined
	//    functions. If inline functions were not skipped the target frame
	//    PC will be here.
	// 2. A third entry for the target frame PC when the second entry
	//    is used for skipped inline functions.
	var pcs [3]uintptr
	n := runtime.Callers(skip+1, pcs[:])
	frames := runtime.CallersFrames(pcs[:n])
	frame, _ := frames.Next()
	frame, _ = frames.Next()

	return Call{
		frame: frame,
	}
}
671151
func (c *CheckSuite) GetHeadBranch() string {
	if c == nil || c.HeadBranch == nil {
		return ""
	}
	return *c.HeadBranch
}
661482
func Head(url string, ro *RequestOptions) (*Response, error) {
	return DoRegularRequest("HEAD", url, ro)
}
1141276
func (g *Group) HEAD(path string, handler HandlerFunc) {
	g.Handle("HEAD", path, handler)
}
1102475
func (service *Service) handlePhoneValidation(w http.ResponseWriter, request *http.Request, registration bool) {
	err := request.ParseForm()
	if err != nil {
		log.Debug(err)
		http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
		return
	}

	values := request.Form
	key := values.Get("k")
	smscode := values.Get("c")
	langKey := values.Get("l")

	translationValues := tools.TranslationValues{
		"invalidlink":      nil,
		"error":            nil,
		"smsconfirmed":     nil,
		"return_to_window": nil,
	}

	translations, err := tools.ParseTranslations(langKey, translationValues)
	if err != nil {
		log.Error("Failed to parse translations: ", err)
		return
	}

	if registration {
		err = service.phonenumberValidationService.ConfirmRegistrationValidation(request, key, smscode)
	} else {
		err = service.phonenumberValidationService.ConfirmValidation(request, key, smscode)
	}
	if err == validation.ErrInvalidCode || err == validation.ErrInvalidOrExpiredKey {
		service.renderSMSConfirmationPage(w, request, translations["invalidlink"], "")
		return
	}
	if err != nil {
		log.Error(err)
		service.renderSMSConfirmationPage(w, request, translations["error"], "")
		return
	}

	service.renderSMSConfirmationPage(w, request, translations["smsconfirmed"], translations["return_to_window"])
}
304890
func (c *Context) Code(code int) (err error) {
	c.response.WriteHeader(code)
	return
}
1194829
func Head(url string, v ...interface{}) (*Resp, error) {
	return std.Head(url, v...)
}