// Exclude 除外する項目
489283
func (api *SwitchAPI) Exclude(key string) *SwitchAPI {
	api.exclude(key)
	return api
}
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
}
596464
func (p *Prefix) Exclude(q *Prefix) []Prefix {
	if !p.IPNet.Contains(q.IP) {
		return nil
	}
	if p.Equal(q) {
		return []Prefix{*q}
	}
	subsFn := subnetsIPv6
	if p.IP.To4() != nil {
		subsFn = subnetsIPv4
	}
	var ps []Prefix
	l, r := subsFn(p, false)
	for !l.Equal(q) && !r.Equal(q) {
		if l.IPNet.Contains(q.IP) {
			ps = append(ps, *r)
			l, r = subsFn(l, true)
		} else if r.IPNet.Contains(q.IP) {
			ps = append(ps, *l)
			l, r = subsFn(r, true)
		}
	}
	if l.Equal(q) {
		ps = append(ps, *r)
	} else if r.Equal(q) {
		ps = append(ps, *l)
	}
	return ps
}
774147
func excludeExecutable(goFiles []string) []string {
	var s []string
	for _, f := range goFiles {
		if strings.HasPrefix(f, "executable_") {
			continue
		}
		s = append(s, f)
	}
	return s
}
488406
func (s *IndicesUnfreezeService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesUnfreezeService {
	s.ignoreUnavailable = &ignoreUnavailable
	return s
}
1158555
func (api *MobileGatewayAPI) Exclude(key string) *MobileGatewayAPI {
	api.exclude(key)
	return api
}
173812
func (b *DockerIgnorer) Ignore(config *api.Config) error {
	/*
		 so, to duplicate the .dockerignore capabilities (https://docs.docker.com/reference/builder/#dockerignore-file)
		 we have a flow that follows:
		0) First note, .dockerignore rules are NOT recursive (unlike .gitignore) .. you have to list subdir explicitly
		1) Read in the exclusion patterns
		2) Skip over comments (noted by #)
		3) note overrides (via exclamation sign i.e. !) and reinstate files (don't remove) as needed
		4) leverage Glob matching to build list, as .dockerignore is documented as following filepath.Match / filepath.Glob
		5) del files
		 1 to 4 is in getListOfFilesToIgnore
	*/
	filesToDel, lerr := getListOfFilesToIgnore(config.WorkingSourceDir)
	if lerr != nil {
		return lerr
	}

	if filesToDel == nil {
		return nil
	}

	// delete compiled list of files
	for _, fileToDel := range filesToDel {
		glog.V(5).Infof("attempting to remove file %s \n", fileToDel)
		rerr := os.RemoveAll(fileToDel)
		if rerr != nil {
			glog.Errorf("error removing file %s because of %v \n", fileToDel, rerr)
			return rerr
		}
	}

	return nil
}
579012
func Not(r ReqCondition) ReqConditionFunc {
	return func(req *http.Request, ctx *ProxyCtx) bool {
		return !r.HandleReq(req, ctx)
	}
}
647813
func (s *IndicesFreezeService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesFreezeService {
	s.ignoreUnavailable = &ignoreUnavailable
	return s
}
585330
func (c *GroupsListCall) ExcludeMembers(excludeMembers bool) *GroupsListCall {
	c.excludeMembers = excludeMembers
	return c
}
1282886
func (api *ProductInternetAPI) Exclude(key string) *ProductInternetAPI {
	api.exclude(key)
	return api
}
1105120
func (v *Value) ExcludeSpaces() []string {
	if v.Spaces == nil {
		return nil
	}
	return v.extractItems(*v.Spaces, false)
}
109640
func (s *IndicesOpenService) IgnoreUnavailable(ignoreUnavailable bool) *IndicesOpenService {
	s.ignoreUnavailable = &ignoreUnavailable
	return s
}
275902
func (api *CDROMAPI) Exclude(key string) *CDROMAPI {
	api.exclude(key)
	return api
}
15536
func (s rwsetKeys) exclude(exists func(key rwSetKey) bool) {
	for k := range s {
		if exists(k) {
			delete(s, k)
		}
	}
}
958823
func (a *TimestampArray) Exclude(min, max int64) {
	rmin, rmax := a.FindRange(min, max)
	if rmin == -1 && rmax == -1 {
		return
	}

	// a.Timestamps[rmin] ≥ min
	// a.Timestamps[rmax] ≥ max

	if rmax < a.Len() {
		if a.Timestamps[rmax] == max {
			rmax++
		}
		rest := a.Len() - rmax
		if rest > 0 {
			ts := a.Timestamps[:rmin+rest]
			copy(ts[rmin:], a.Timestamps[rmax:])
			a.Timestamps = ts
			return
		}
	}

	a.Timestamps = a.Timestamps[:rmin]
}
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]
}