// ScoresRepo mocks base method
18364
func (m *MockService) ScoresRepo() repo.Scores {
	ret := m.ctrl.Call(m, "ScoresRepo")
	ret0, _ := ret[0].(repo.Scores)
	return ret0
}
385408
func ScoreNodes(keys []string, services []*registry.Service) (possibleNodes []*registry.Node, scores []uint64) {
	// Generate a base hashing key based off the supplied keys values.
	key := highwayhash.Sum([]byte(strings.Join(keys, ":")), zeroKey[:])

	// Get all the possible nodes for the services, and assign a hash-based score to each of them.
	for _, s := range services {
		for _, n := range s.Nodes {
			// Use the base key from above to calculate a derivative 64 bit hash number based off the instance ID.
			score := highwayhash.Sum64([]byte(n.Id), key[:])
			scores = append(scores, score)
			possibleNodes = append(possibleNodes, n)
		}
	}
	return
}
502134
func (m *MockFacadeCaller) RawAPICaller() base.APICaller {
	ret := m.ctrl.Call(m, "RawAPICaller")
	ret0, _ := ret[0].(base.APICaller)
	return ret0
}
1044608
func (stub *MockStub) MockInvokeWithSignedProposal(uuid string, args [][]byte, sp *pb.SignedProposal) pb.Response {
	stub.args = args
	stub.MockTransactionStart(uuid)
	stub.signedProposal = sp
	res := stub.cc.Invoke(stub)
	stub.MockTransactionEnd(uuid)
	return res
}
1272255
func NewReplayXHRArgs(requestID RequestID) *ReplayXHRArgs {
	args := new(ReplayXHRArgs)
	args.RequestID = requestID
	return args
}
854799
func (a *AllocMetric) ScoreNode(node *Node, name string, score float64) {
	// Create nodeScoreMeta lazily if its the first time or if its a new node
	if a.nodeScoreMeta == nil || a.nodeScoreMeta.NodeID != node.ID {
		a.nodeScoreMeta = &NodeScoreMeta{
			NodeID: node.ID,
			Scores: make(map[string]float64),
		}
	}
	if name == NormScorerName {
		a.nodeScoreMeta.NormScore = score
		// Once we have the normalized score we can push to the heap
		// that tracks top K by normalized score

		// Create the heap if its not there already
		if a.topScores == nil {
			a.topScores = kheap.NewScoreHeap(MaxRetainedNodeScores)
		}
		heap.Push(a.topScores, a.nodeScoreMeta)

		// Clear out this entry because its now in the heap
		a.nodeScoreMeta = nil
	} else {
		a.nodeScoreMeta.Scores[name] = score
	}
}
1126480
func (m *MockExtensionsV1beta1Interface) Scales(arg0 string) v1beta10.ScaleInterface {
	ret := m.ctrl.Call(m, "Scales", arg0)
	ret0, _ := ret[0].(v1beta10.ScaleInterface)
	return ret0
}
572843
func (r *ReleaseGroupSearchResponse) ResultsWithScore(score int) []*ReleaseGroup {
	var res []*ReleaseGroup
	for _, v := range r.ReleaseGroups {
		if r.Scores[v] >= score {
			res = append(res, v)
		}
	}
	return res
}
880446
func (m *MockMetricsCollector) PingFailureCount(arg0 string) prometheus.Counter {
	ret := m.ctrl.Call(m, "PingFailureCount", arg0)
	ret0, _ := ret[0].(prometheus.Counter)
	return ret0
}
653632
func (r *AreaSearchResponse) ResultsWithScore(score int) []*Area {
	var res []*Area
	for _, v := range r.Areas {
		if r.Scores[v] >= score {
			res = append(res, v)
		}
	}
	return res
}
32925
func (m *symbol) penaltyScore() int {
	return m.penalty1() + m.penalty2() + m.penalty3() + m.penalty4()
}
865413
func NewMockisBatchResponse_Response_Response(ctrl *gomock.Controller) *MockisBatchResponse_Response_Response {
	mock := &MockisBatchResponse_Response_Response{ctrl: ctrl}
	mock.recorder = &MockisBatchResponse_Response_ResponseMockRecorder{mock}
	return mock
}
766980
func (s *Score) WriteJSON(w io.Writer) {
	// check if calling func paniced before calling this
	if r := recover(); r != nil {
		// reset score for paniced functions
		s.Score = 0
	}
	b, err := json.Marshal(s)
	if err != nil {
		fmt.Fprintf(w, "json.Marshal error: \n%v\n", err)
	}
	fmt.Fprintf(w, "\n%s\n", b)
}
284441
func (mr *MockServiceMockRecorder) ThumbnailRepo() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ThumbnailRepo", reflect.TypeOf((*MockService)(nil).ThumbnailRepo))
}
1221699
func (db *DB) ZRangeByScore(key []byte, min int64, max int64,
	offset int, count int) ([]ScorePair, error) {
	return db.ZRangeByScoreGeneric(key, min, max, offset, count, false)
}
228422
func (m *MockID) Equal(arg0 ID) bool {
	ret := m.ctrl.Call(m, "Equal", arg0)
	ret0, _ := ret[0].(bool)
	return ret0
}
1349777
func (db *DB) ZRevRange(key []byte, start int, stop int) ([]ScorePair, error) {
	return db.ZRangeGeneric(key, start, stop, true)
}