// Exact returns all the exact component matches
512683
func (m ScoredComponentMatches) Exact() []*ComponentMatch {
	out := []*ComponentMatch{}
	for _, match := range m {
		if match.Score == 0.0 {
			out = append(out, match)
		}
	}
	return out
}
1126287
func (s Selector) MatchAll(n *html.Node) []*html.Node {
	return s.matchAllInto(n, nil)
}
526390
func (c Cell) ExactArea() float64 {
	v0, v1, v2, v3 := c.Vertex(0), c.Vertex(1), c.Vertex(2), c.Vertex(3)
	return PointArea(v0, v1, v2) + PointArea(v0, v2, v3)
}
883803
func Equal(t Tester, actual, expected interface{}, noun string) {
	actualEqualer, actualEqualerOK := actual.(Equaler)
	expectedEqualer, expectedEqualerOK := expected.(Equaler)
	equals := false
	if actualEqualerOK && expectedEqualerOK {
		equals = actualEqualer.Equal(expectedEqualer)
	} else {
		equals = reflect.DeepEqual(actual, expected)
	}
	if !equals {
		t.Fatalf(callerStrf(WithFrameWrapper(t), "actual %s [%+v] != expected %s [%+v]", noun, actual, noun, expected))
	}
}
596036
func Any(platforms ...specs.Platform) MatchComparer {
	matchers := make([]Matcher, len(platforms))
	for i := range platforms {
		matchers[i] = NewMatcher(platforms[i])
	}
	return anyPlatformComparer{
		matchers: matchers,
	}
}
980277
func (matcher *EqualImageMatcher) Match(actual interface{}) (success bool, err error) {
	if actual == nil && matcher.Expected == nil {
		return false, fmt.Errorf("Refusing to compare <nil> to <nil>.\nBe explicit and use BeNil() instead.  This is to avoid mistakes where both sides of an assertion are erroneously uninitialized.")
	}

	a, ok := actual.(image.Image)
	if !ok {
		return false, fmt.Errorf("actual must be of type image.Image")
	}

	e, ok := matcher.Expected.(image.Image)
	if !ok {
		return false, fmt.Errorf("expected must be of type image.Image")
	}

	if a.Bounds().Dx() != e.Bounds().Dx() {
		return false, fmt.Errorf("Different width values %d != %d", a.Bounds().Dx(), e.Bounds().Dx())
	}

	if a.Bounds().Dy() != e.Bounds().Dy() {
		return false, fmt.Errorf("Different height values %d != %d", a.Bounds().Dy(), e.Bounds().Dy())
	}

	for x := 0; x < a.Bounds().Dx(); x++ {
		for y := 0; y < a.Bounds().Dy(); y++ {
			if a.At(x, y) != e.At(x, y) {
				return false, fmt.Errorf("pixels don't match at %d %d. %d != %d", x, y, a.At(x, y), e.At(x, y))
			}
		}
	}

	return true, nil
}
387087
func (claims *Claims) ComponentRight(componentID string, right types.Right) bool {
	return claims.ComponentAccess(componentID) && containsRight(claims.Components[componentID], right)
}
1163791
func AllEqual(values ...string) bool {
	if len(values) < 2 {
		return true
	}
	compare := values[0]
	for _, v := range values[1:] {
		if v != compare {
			return false
		}
	}
	return true
}
715964
func (t *docMatchTree) matches(cp *contentProvider, cost int, known map[matchTree]bool) (bool, bool) {
	return len(t.current) > 0, true
}
209685
func (s MultiWeightedSearcher) Search(precise bool, terms ...string) (ComponentMatches, []error) {
	componentMatches := ComponentMatches{}
	var errs []error
	for _, searcher := range s {
		matches, err := searcher.Search(precise, terms...)
		if len(err) > 0 {
			errs = append(errs, err...)
			continue
		}
		for _, match := range matches {
			match.Score += searcher.Weight
			componentMatches = append(componentMatches, match)
		}
	}
	sort.Sort(ScoredComponentMatches(componentMatches))
	return componentMatches, errs
}
1162700
func (v *TypeReference) Equals(rhs *TypeReference) bool {
	if v == nil {
		return rhs == nil
	} else if rhs == nil {
		return false
	}
	if !(v.Name == rhs.Name) {
		return false
	}
	if !(v.ImportPath == rhs.ImportPath) {
		return false
	}
	if !((v.Annotations == nil && rhs.Annotations == nil) || (v.Annotations != nil && rhs.Annotations != nil && _Map_String_String_Equals(v.Annotations, rhs.Annotations))) {
		return false
	}

	return true
}
1154694
func ExactScopeMatch(addr Address, addrScopes ...Scope) bool {
	for _, scope := range addrScopes {
		if addr.Scope == scope {
			return true
		}
	}
	return false
}
924032
func (e *ComplexExplanation) IsMatch() bool {
	return e.match != nil && e.match.(bool) || e.match == nil && e.ExplanationImpl.IsMatch()
}
690224
func (o *SeparatorsToIndexOption) Equal(o2 *SeparatorsToIndexOption) bool {
	if o2 == nil {
		return o.value == ""
	}
	return o.value == o2.value
}
1354444
func (m Material) Equal(a *Material) (isEqual bool, err error) {
	if m.Type != a.Type {
		return
	}

	return m.Attributes.equal(a.Attributes)
}
365677
func (self *todo) Equal(e s5.Equaler) bool {
	if e == nil {
		return false
	}
	other := e.(*todo)
	return self.Id() == other.Id()
}
474964
func (ltype LineType) Equals(other core.DxfElement) bool {
	if otherLtype, ok := other.(*LineType); ok {
		if ltype.Name != otherLtype.Name ||
			ltype.Description != otherLtype.Description ||
			!core.FloatEquals(ltype.Length, otherLtype.Length) ||
			len(ltype.Pattern) != len(otherLtype.Pattern) {

			return false
		}

		for i, pattern1 := range ltype.Pattern {
			pattern2 := otherLtype.Pattern[i]

			if !pattern1.Equals(*pattern2) {
				return false
			}
		}
		return true
	}
	return false
}