// Exclude 除外する項目
544760
func (api *IconAPI) Exclude(key string) *IconAPI {
	api.exclude(key)
	return api
}
1078842
func (api *IPv6NetAPI) Exclude(key string) *IPv6NetAPI {
	api.exclude(key)
	return api
}
489283
func (api *SwitchAPI) Exclude(key string) *SwitchAPI {
	api.exclude(key)
	return api
}
759863
func excludeEntries(e []IndexEntry, tr TimeRange) []IndexEntry {
	for i := range e {
		if e[i].OverlapsTimeRange(tr.Min, tr.Max) {
			e = e[i:]
			break
		}
	}

	for i := range e {
		if !e[i].OverlapsTimeRange(tr.Min, tr.Max) {
			e = e[:i]
			break
		}
	}

	return e
}
343517
func getExcludedChecks(r *http.Request) sets.String {
	checks, found := r.URL.Query()["exclude"]
	if found {
		return sets.NewString(checks...)
	}
	return sets.NewString()
}
883141
func (s *IndicesPutMappingService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesPutMappingService {
	s.ignoreUnavailable = &ignoreUnavailable
	return s
}
535311
func (p *Polygon) excludesNonCrossingShells(o *Polygon) bool {
	for _, l := range o.loops {
		if l.IsHole() {
			continue
		}
		if p.containsNonCrossingBoundary(l, false) {
			return false
		}
	}
	return true
}
906860
func (a UnsignedValues) Exclude(min, max int64) UnsignedValues {
	rmin, rmax := a.FindRange(min, max)
	if rmin == -1 && rmax == -1 {
		return a
	}

	// a[rmin].UnixNano() ≥ min
	// a[rmax].UnixNano() ≥ max

	if rmax < len(a) {
		if a[rmax].UnixNano() == max {
			rmax++
		}
		rest := len(a) - rmax
		if rest > 0 {
			b := a[:rmin+rest]
			copy(b[rmin:], a[rmax:])
			return b
		}
	}

	return a[:rmin]
}
1363879
func (q *ModelQuery) Exclude(attrs ...string) *ModelQuery {
	q.exclude = attrs
	return q
}
867304
func (api *SIMAPI) Exclude(key string) *SIMAPI {
	api.exclude(key)
	return api
}
1357139
func (api *ProductPrivateHostAPI) Exclude(key string) *ProductPrivateHostAPI {
	api.exclude(key)
	return api
}
1337776
func (c *adminClient) Excludes(excludes []string) AdminClient {
	c.excludes = excludes
	return c
}
1036998
func (api *IPAddressAPI) Exclude(key string) *IPAddressAPI {
	api.exclude(key)
	return api
}
334909
func (s *GetMappingService) IgnoreUnavailable(ignoreUnavailable bool) *GetMappingService {
	s.ignoreUnavailable = &ignoreUnavailable
	return s
}
236872
func excludeInternal(input, rules reflect.Value) {
	// restore original value by Elm()
	if input.Type().Kind() == reflect.Interface {
		input = input.Elem()
	}
	if rules.Type().Kind() == reflect.Interface {
		rules = rules.Elem()
	}
	if rules.MapIndex(reflect.ValueOf("*")).IsValid() {
		for _, key := range input.MapKeys() {
			excludeInternal(input.MapIndex(key), rules.MapIndex(reflect.ValueOf("*")))
		}
	} else {
		for _, key := range input.MapKeys() {
			value := input.MapIndex(key)
			rule := rules.MapIndex(key)

			if rule.IsValid() {
				// restore original value by Elm()
				if value.Type().Kind() == reflect.Interface {
					value = value.Elem()
				}
				if rule.Type().Kind() == reflect.Interface {
					rule = rule.Elem()
				}

				switch rule.Type().Kind() {
				case reflect.Slice:
					for i := 0; i < rule.Len(); i++ {
						input.SetMapIndex(key, remove(value, find(value, rule.Index(i))))
					}
				case reflect.String:
					if rule.Interface() == "*" {
						input.SetMapIndex(key, reflect.Value{})
					}
				case reflect.Map:
					excludeInternal(value, rule)
				}
			}
		}
	}
}
422495
func excludeByIsolation(container *container.Snapshot, ctx *listContext) iterationAction {
	i := strings.ToLower(string(container.HostConfig.Isolation))
	if i == "" {
		i = "default"
	}
	if !ctx.filters.Match("isolation", i) {
		return excludeContainer
	}
	return includeContainer
}
1125155
func (cps ComparablePrincipalSets) ExcludeIndices(mapping map[int][]int) ComparablePrincipalSets {
	var res ComparablePrincipalSets
	for i, set := range cps {
		if _, exists := mapping[i]; exists {
			continue
		}
		res = append(res, set)
	}
	return res
}