// ForceReply ...
502473
func (sp *SendSticker) ForceReply(fr ForceReply) *SendSticker {
	var rmi ReplyMarkupInt = fr
	sp.ReplyMarkup = &rmi
	return sp
}
284454
func (tr Row) ForceInt64(nn int) (val int64) {
	val, _ = tr.Int64Err(nn)
	return
}
1186191
func (c *Client) Forcemerge(indices ...string) *IndicesForcemergeService {
	return NewIndicesForcemergeService(c).Index(indices...)
}
563492
func (fw *Framework) NewReplyFromSecureReply(sr protocol.SecureReply) (reply protocol.Reply, err error) {
	switch sr.Version() {
	case protocol.SecureReplyV1:
		reply, err = v1.NewReplyFromSecureReply(sr)
	default:
		err = fmt.Errorf("Do not know how to create a Reply version %s", sr.Version())
	}

	return
}
67467
func (j *Jobs) ForceEvaluate(jobID string, q *WriteOptions) (string, *WriteMeta, error) {
	var resp JobRegisterResponse
	wm, err := j.client.write("/v1/job/"+jobID+"/evaluate", nil, &resp, q)
	if err != nil {
		return "", nil, err
	}
	return resp.EvalID, wm, nil
}
704856
func (db *DB) ForceUse(name string) *Col {
	db.schemaLock.RLock()
	defer db.schemaLock.RUnlock()
	if db.cols[name] == nil {
		if err := db.create(name); err != nil {
			tdlog.Panicf("ForceUse: failed to create collection - %v", err)
		}
	}
	return db.cols[name]
}
956122
func (cli *OpsGenieClient) buildPutRequest(uri string, request interface{}) goreq.Request {
	req := cli.buildPostRequest(uri, request)
	req.Method = "PUT"
	return req
}
264248
func (s *Service) ForceInstances(instances []ServiceInstance) {
	atomic.StoreInt64(&s.ignoreUpdates, 1)
	s.watchLock.Lock()
	defer s.watchLock.Unlock()
	s.services.Store(instances)
	for _, watch := range s.watches {
		watch()
	}
}
155875
func (buffer *Buffer) awaitGenReply() error {
	var done osc.Message
	select {
	case done = <-buffer.client.doneChan:
	case err := <-buffer.client.errChan:
		return err
	}
	if len(done.Arguments) != 2 {
		return errors.New("expected two arguments to /done message")
	}
	addr, err := done.Arguments[0].ReadString()
	if err != nil {
		return err
	}
	// If reply address is not /b_gen, requeue the done event.
	if addr != bufferGenAddress {
		buffer.client.doneChan <- done
		return nil
	}
	bufnum, err := done.Arguments[1].ReadInt32()
	if err != nil {
		return err
	}

	// TODO: Don't error if we get a done message for a different buffer.
	// We should probably requeue this particular done message on doneChan.
	if bufnum != buffer.Num {
		buffer.client.doneChan <- done
	}
	return nil
}
1253566
func ForceUnmount(target string) (err error) {
	// Simple retry logic for unmount
	for i := 0; i < 10; i++ {
		if err = unmount(target, 0); err == nil {
			return nil
		}
		time.Sleep(100 * time.Millisecond)
	}
	return nil
}
649265
func (tr Row) ForceFloat(nn int) (val float64) {
	val, _ = tr.FloatErr(nn)
	return
}
346173
func (sub *Subscription) ensureProtocol() error {
	if sub.resp == nil {
		p, err := sub.database.pool.pull(forcedPull)
		if err != nil {
			return err
		}
		sub.resp = p
	}
	return nil
}
293225
func (cli *Client) ProxyGet(appname string) (*pb.ProxyReply, error) {
	req := &pb.ProxyRequest{Appname: appname}
	ctx, cancel := context.WithTimeout(context.Background(), cli.timeout)
	defer cancel()
	rpl, err := cli.proxyClient.Get(ctx, req)
	return rpl, err
}
544966
func (bot TgBot) SendDocumentWithForceReply(cid int, document string, rmi *int, rm ForceReply) ResultWithMessage {
	var rkm ReplyMarkupInt = rm
	return bot.SendDocument(cid, document, rmi, &rkm)
}
1366761
func (dm *DRWMutex) ForceUnlock() {
	{
		dm.m.Lock()
		defer dm.m.Unlock()

		// Clear write locks array
		dm.writeLocks = make([]string, dm.clnt.dNodeCount)
		// Clear read locks array
		dm.readersLocks = nil
	}

	for _, c := range dm.clnt.rpcClnts {
		// broadcast lock release to all nodes that granted the lock
		sendRelease(dm.clnt, c, dm.Name, "", false)
	}
}
1105655
func (r *Request) ReplyFunc(replier func(*Response)) *Response {
	replier(r.Response)
	return r.Response
}
184438
func waitStreamReply(ctx context.Context, replySent <-chan struct{}, notify chan<- struct{}) {
	select {
	case <-replySent:
		notify <- struct{}{}
	case <-ctx.Done():
	}
}