In that case, they will be applied to all the *path operations* in the application:

{* ../../docs_src/dependencies/tutorial012_an_py39.py hl[17] *}


And all the ideas in the section about [adding `dependencies` to the *path operation decorators*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} still apply, but in this case, to all of the *path operations* in the app.

		enc := json.NewEncoder(&buf)
		for {
			select {
			case <-doneCh:
				return
			case v, ok := <-subChT:
				if !ok {
					return
				}
				buf.Reset()
				err := enc.Encode(v)
				if err != nil {
					return
				}

				select {
				case subCh <- append(GetByteBuffer()[:0], buf.Bytes()...):
					continue
				case <-doneCh:
					return
				}
			}
		}
	}()

	if len(in) == 1 {
		for {
			select {
			case <-ctxDone:
				return ctx.Err()
			case v, ok := <-in[0]:
				if !ok {
					return nil
				}
				select {
				case <-ctxDone:
					return ctx.Err()
				case out <- v:
				}
			}
		}
	}

	selectFrom := func(idx int) error {
		select {
		case <-ctxDone:
			return ctx.Err()
		case entry, ok := <-in[idx]:
			if !ok {

        @Override
        public ModelSource resolveModel(Dependency dependency) throws UnresolvableModelException {
            return switch (dependency.getManagementKey()) {
                case BASE1_ID -> new StringModelSource(BASE1);
                case BASE2_ID -> new StringModelSource(BASE2);
                default -> null;
            };
        }
    }

    static class BaseModelResolver implements ModelResolver {

				dm.startContinuousLockRefresh(lockLossCallback, id, source, quorum)

				return locked
			}

			switch {
			case opts.RetryInterval < 0:
				return false
			case opts.RetryInterval > 0:
				time.Sleep(opts.RetryInterval)
			default:
				attempt++
				time.Sleep(lockRetryBackOff(dm.rng, attempt))
			}
		}
	}
}

                    switch (type) {
                        case INITIATED:
                            delegate.transferInitiated(transferEvent);
                            break;
                        case STARTED:
                            delegate.transferStarted(transferEvent);
                            break;
                        case PROGRESSED:

//   - The object is a multipart object. In this case,
//     Format returns the ETag unmodified.
//   - The object is a SSE-KMS or SSE-C encrypted single-
//     part object. In this case, Format returns the last
//     16 bytes of the encrypted ETag which will be a random
//     value.
//   - The object is a SSE-S3 encrypted single-part object.
//     In this case, the caller has to decrypt the ETag first

)

// Valid - returns if retention mode is valid
func (r RetMode) Valid() bool {
	switch r {
	case RetGovernance, RetCompliance:
		return true
	}
	return false
}

func parseRetMode(modeStr string) (mode RetMode) {
	switch strings.ToUpper(modeStr) {
	case "GOVERNANCE":
		mode = RetGovernance
	case "COMPLIANCE":
		mode = RetCompliance
	}
	return mode
}

// LegalHoldStatus - object legal hold status.

	if reqTimeMinute.After(h.currentMinute.statsTime) {
		// Drop the last full minute now, since we got a request for a time we
		// are not yet tracking.
		h.updateLastFullMinute(reqTimeMinute)
	}
	var entry *serviceRTTMinuteStats
	switch {
	case reqTimeMinute.Equal(h.currentMinute.statsTime):
		entry = &h.currentMinute
	case reqTimeMinute.Equal(h.lastFullMinute.statsTime):
		entry = &h.lastFullMinute
	default:

	srs.Secure = st.Secure
	switch {
	case st.Completed:
		srs.ReplicatedSize += st.TransferSize
		srs.ReplicatedCount++
		if st.TransferDuration > 0 {
			srs.Latency.update(st.TransferSize, st.TransferDuration)
			srs.updateXferRate(st.TransferSize, st.TransferDuration)
		}
	case st.Failed:
		srs.Failed.addsize(st.TransferSize, st.Err)
	case st.Pending:
	}
	sr.M[dID] = srs
}