// ExcludeArchived sets the value for optional excludeArchived parameter
4495
func (c *GroupsListCall) ExcludeArchived(excludeArchived bool) *GroupsListCall {
	c.excludeArchived = excludeArchived
	return c
}
704112
func (api *PublicPriceAPI) Exclude(key string) *PublicPriceAPI {
	api.exclude(key)
	return api
}
1295929
func (p *PartitionedMemoryIdx) UpdateArchive(archive idx.Archive) {
	p.Partition[archive.Partition].UpdateArchive(archive)
}
740507
func batchArchive(ctx context.Context, client *isolatedclient.Client, al archiveLogger, dumpJSONPath string, concurrentChecks, concurrentUploads int, genJSONPaths []string, blacklistStrings []string) error {
	// Set up a checker and uploader. We limit the uploader to one concurrent
	// upload, since the uploads are all coming from disk (with the exception of
	// the isolated JSON itself) and we only want a single goroutine reading from
	// disk at once.
	checker := archiver.NewChecker(ctx, client, concurrentChecks)
	uploader := archiver.NewUploader(ctx, client, concurrentUploads)
	a := archiver.NewTarringArchiver(checker, uploader)

	var errArchive error
	var isolSummaries []archiver.IsolatedSummary
	for _, genJSONPath := range genJSONPaths {
		opts, err := processGenJSON(genJSONPath)
		if err != nil {
			return err
		}
		// Parse the incoming isolate file.
		deps, rootDir, isol, err := isolate.ProcessIsolate(opts)
		if err != nil {
			return fmt.Errorf("isolate %s: failed to process: %v", opts.Isolate, err)
		}
		log.Printf("Isolate %s referenced %d deps", opts.Isolate, len(deps))

		// Use the explicit blacklist if it's provided.
		if len(blacklistStrings) > 0 {
			opts.Blacklist = blacklistStrings
		}
		isolSummary, err := a.Archive(deps, rootDir, isol, opts.Blacklist, opts.Isolated)
		if err != nil && errArchive == nil {
			errArchive = fmt.Errorf("isolate %s: %v", opts.Isolate, err)
		} else {
			printSummary(al, isolSummary)
			isolSummaries = append(isolSummaries, isolSummary)
		}
	}
	if errArchive != nil {
		return errArchive
	}
	// Make sure that all pending items have been checked.
	if err := checker.Close(); err != nil {
		return err
	}

	// Make sure that all the uploads have completed successfully.
	if err := uploader.Close(); err != nil {
		return err
	}

	if err := dumpSummaryJSON(dumpJSONPath, isolSummaries...); err != nil {
		return err
	}

	al.LogSummary(ctx, int64(checker.Hit.Count()), int64(checker.Miss.Count()), units.Size(checker.Hit.Bytes()), units.Size(checker.Miss.Bytes()), digests(isolSummaries))
	return nil
}
275902
func (api *CDROMAPI) Exclude(key string) *CDROMAPI {
	api.exclude(key)
	return api
}
25763
func (api *ProductDiskAPI) Exclude(key string) *ProductDiskAPI {
	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)
		}
	}
}
1318210
func (s *Service) SetArchived(v bool) *Service {
	s.Archived = &v
	return s
}
1110470
func (api *BridgeAPI) Exclude(key string) *BridgeAPI {
	api.exclude(key)
	return api
}
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]
}
942921
func (api *SubnetAPI) Exclude(key string) *SubnetAPI {
	api.exclude(key)
	return api
}
1101596
func (api *PrivateHostAPI) Exclude(key string) *PrivateHostAPI {
	api.exclude(key)
	return api
}
340152
func (s *OpenIndexService) IgnoreUnavailable(ignoreUnavailable bool) *OpenIndexService {
	s.ignoreUnavailable = &ignoreUnavailable
	return s
}
515739
func ExcludeHosts(endpoints ...string) ExclusionFilter {
	m := make(map[string]struct{})
	for _, endpoint := range endpoints {
		m[endpoint] = struct{}{}
	}
	return ExcludeByHost(func(host string) bool {
		_, excluded := m[host]
		return excluded
	})
}
60305
func (t *Tar) shouldBeExcluded(name string, isDir bool) bool {
	name = filepath.ToSlash(filepath.Clean(name))
	var exclude bool
	for _, re := range t.ignorePaths {
		if re.regexp.MatchString(name) || re.regexp.MatchString(filepath.Base(name)) {
			if !re.dirOnly || (re.dirOnly && isDir) {
				exclude = re.exclude
			}
		}
	}

	return exclude
}
257347
func (ta *TarringArchiver) Archive(deps []string, rootDir string, isol *isolated.Isolated, blacklist []string, isolated string) (IsolatedSummary, error) {
	parts, err := partitionDeps(deps, rootDir, blacklist)
	if err != nil {
		return IsolatedSummary{}, fmt.Errorf("partitioning deps: %v", err)
	}
	log.Printf("Expanded to the following items to be isolated:\n%s", parts)

	tracker := newUploadTracker(ta.checker, ta.uploader, isol)
	if err := tracker.UploadDeps(parts); err != nil {
		return IsolatedSummary{}, err
	}
	return tracker.Finalize(isolated)
}
1357139
func (api *ProductPrivateHostAPI) Exclude(key string) *ProductPrivateHostAPI {
	api.exclude(key)
	return api
}