// containsBoundary reports whether this polygon contains the entire boundary of B.
974513
func (p *Polygon) containsBoundary(o *Polygon) bool {
	for _, l := range o.loops {
		if p.compareBoundary(l) <= 0 {
			return false
		}
	}
	return true
}
742843
func (ps ProtocolSet) ContainsAny(p ...Protocol) bool {
	for _, x := range ps {
		for _, y := range p {
			if x == y {
				return true
			}
		}
	}
	return false
}
903021
func (d *Diet) Contains(x, y uint64) bool {
	x, y = sortBoundaries(x, y)
	return intersection(x, y, d.root) == y-x+1
}
174913
func (c *BundlingChecker) contains(items []checkerItem) ([]*isolatedclient.PushState, error) {
	var digests []*service.HandlersEndpointsV1Digest
	for _, item := range items {
		digests = append(digests, &service.HandlersEndpointsV1Digest{
			Digest:     string(item.item.Digest),
			Size:       item.item.Size,
			IsIsolated: item.isolated,
		})
	}
	pushStates, err := c.svc.Contains(c.ctx, digests)
	if err != nil {
		return nil, fmt.Errorf("isolate Contains call failed: %v", err)
	}
	return pushStates, nil
}
397290
func (a Nodes) Contains(n *Node) bool {
	for i := range a {
		if a[i] == n {
			return true
		}
	}
	return false
}
85748
func (r *PortAllocator) contains(port int) (bool, int) {
	if !r.portRange.Contains(port) {
		return false, 0
	}

	offset := port - r.portRange.Base
	return true, offset
}
227698
func (r *Range) Contains(other Version) bool {
	return other.Compare(&r.Begin) >= 0 && other.Compare(&r.End) < 0
}
1269593
func clippedEdgeBound(a, b r2.Point, clip r2.Rect) r2.Rect {
	bound := r2.RectFromPoints(a, b)
	if b1, intersects := clipEdgeBound(a, b, clip, bound); intersects {
		return b1
	}
	return r2.EmptyRect()
}
414934
func (body Body) Contains(x *Expr) bool {
	for _, e := range body {
		if e.Equal(x) {
			return true
		}
	}
	return false
}
965596
func Contains(a [][]byte, x []byte) bool {
	n := SearchBytes(a, x)
	return n < len(a) && bytes.Equal(a[n], x)
}
1036364
func (b LocationBounds) Contains(loc Location) bool {
	if b.SpansDateLine() {
		return loc.Longitude >= b.West || loc.Longitude <= b.East
	}
	return loc.Longitude >= b.West && loc.Longitude <= b.East
}
1023071
func containsCenterMatches(a *clippedShape, target crossingTarget) bool {
	return (!a.containsCenter && target == crossingTargetDontCross) ||
		(a.containsCenter && target == crossingTargetCross)
}
1060688
func (r Rect) ContainsCell(c Cell) bool {
	// A latitude-longitude rectangle contains a cell if and only if it contains
	// the cell's bounding rectangle. This test is exact from a mathematical
	// point of view, assuming that the bounds returned by Cell.RectBound()
	// are tight. However, note that there can be a loss of precision when
	// converting between representations -- for example, if an s2.Cell is
	// converted to a polygon, the polygon's bounding rectangle may not contain
	// the cell's bounding rectangle. This has some slightly unexpected side
	// effects; for instance, if one creates an s2.Polygon from an s2.Cell, the
	// polygon will contain the cell, but the polygon's bounding box will not.
	return r.Contains(c.RectBound())
}
1176029
func (c Cap) Contains(other Cap) bool {
	// In a set containment sense, every cap contains the empty cap.
	if c.IsFull() || other.IsEmpty() {
		return true
	}
	return c.radius >= ChordAngleBetweenPoints(c.center, other.center).Add(other.radius)
}
202642
func (c Cap) ContainsPoint(p Point) bool {
	return ChordAngleBetweenPoints(c.center, p) <= c.radius
}
762951
func (h HTTPCodeRanges) Contains(statusCode int) bool {
	for _, block := range h {
		if statusCode >= block[0] && statusCode <= block[1] {
			return true
		}
	}
	return false
}
853131
func MultiPolygonContains(mp orb.MultiPolygon, point orb.Point) bool {
	for _, p := range mp {
		if PolygonContains(p, point) {
			return true
		}
	}

	return false
}