Function subjectFilterIntersection

internal/engines/subject_filter.go:735–811

subjectFilterIntersection function is used to find the intersection of subjects returned by executing multiple lookup subject functions concurrently.

(ctx context.Context, functions []SubjectFilterFunction, limit int)

// subjectFilterIntersection function is used to find the intersection of subjects
// returned by executing multiple lookup subject functions concurrently.
func subjectFilterIntersection(ctx context.Context, functions []SubjectFilterFunction, limit int) ([]string, error) {
	// If there are no functions to be executed, return an empty response
	if len(functions) == 0 {
		return subjectFilterEmpty(), nil
	}

	// Create channels to handle asynchronous responses from lookup functions.
	decisionChan := make(chan SubjectFilterResponse, len(functions))

	// Create a cancellable context
	cancelCtx, cancel := context.WithCancel(ctx)

	// Run the functions concurrently
	clean := subjectFiltersRun(cancelCtx, functions, decisionChan, limit)

	// Ensure resources are cleaned up correctly after functions are done executing
	defer func() {
		cancel()
		clean()
		close(decisionChan)
	}()

	var commonIds []string
	initialized := false
	encounteredWildcard := false
	var excludedIds []string

	// For each function, collect results
	for i := 0; i < len(functions); i++ {
		select {
		case d := <-decisionChan:
			// If an error occurred in the function, return the error
			if d.err != nil {
				return subjectFilterEmpty(), d.err
			}
			// If "<>" is encountered, handle any exclusions that come with it
			if containsWildcard(d.resp) {
				encounteredWildcard = true
				for _, id := range d.resp {
					if id != ALL && !slices.Contains(excludedIds, id) {
						excludedIds = append(excludedIds, id)
					}
				}
				continue
			}
			// If it's the first function, initialize the common IDs list
			if !initialized {
				commonIds = append(commonIds, d.resp...)
				initialized = true
			} else {
				// Intersect the current common IDs with the new set of IDs
				commonIds = intersect(commonIds, d.resp)
			}
		case <-ctx.Done():
			return subjectFilterEmpty(), errors.New(base.ErrorCode_ERROR_CODE_CANCELLED.String())
		}
	}