relValuesMap, _ := schema.GetIdentityFieldValuesMapFromValues(association.DB.Statement.Context, values, rel.FieldSchema.PrimaryFields)

			cleanUpDeletedRelations := func(data reflect.Value) {
				if _, zero := rel.Field.ValueOf(association.DB.Statement.Context, data); !zero {
					fieldValue := reflect.Indirect(rel.Field.ReflectValueOf(association.DB.Statement.Context, data))
					primaryValues := make([]interface{}, len(rel.FieldSchema.PrimaryFields))

# Abhängigkeiten mit yield

FastAPI unterstützt Abhängigkeiten, die nach Abschluss einige <abbr title="Manchmal auch genannt „Exit Code“, „Cleanup Code“, „Teardown Code“, „Closing Code“, „Kontext Manager Exit Code“, usw.">zusätzliche Schritte ausführen</abbr>.

Verwenden Sie dazu `yield` statt `return` und schreiben Sie die zusätzlichen Schritte / den zusätzlichen Code danach.

/// tip | "Tipp"

		return nil
	}
	clnt.SetCustomTransport(globalRemoteTargetTransport)
	return clnt
}

// heartBeat performs liveness check on remote endpoints.
func (sys *BucketTargetSys) heartBeat(ctx context.Context) {
	hcTimer := time.NewTimer(defaultHealthCheckDuration)
	defer hcTimer.Stop()
	for {
		select {
		case <-hcTimer.C:
			sys.hMutex.RLock()
			eps := make([]madmin.ServerProperties, 0, len(sys.hc))

	return nil
}

// DoWithContext is similar to Do except that it accepts a context as an argument to be passed.
func (l *Init) DoWithContext(ctx context.Context, f func(context.Context) error) error {
	if atomic.LoadUint32(&l.done) == 0 {
		return l.doWithContext(ctx, f)
	}
	return nil
}

func (l *Init) doWithContext(ctx context.Context, f func(context.Context) error) error {
	l.m.Lock()
	defer l.m.Unlock()

	bucketStorageCache.InitOnce(10*time.Second,
		cachevalue.Opts{ReturnLastGood: true, NoWait: true},
		func(ctx context.Context) (DataUsageInfo, error) {
			if objAPI == nil {
				return DataUsageInfo{}, errServerNotInitialized
			}
			ctx, done := context.WithTimeout(ctx, 2*time.Second)
			defer done()

			return loadDataUsageFromBackend(ctx, objAPI)
		},
	)
}

	}

	return nsNameList, nil
}

func getNamespaces(ctx context.Context, client kube.CLIClient) ([]corev1.Namespace, error) {
	nslist, err := client.Kube().CoreV1().Namespaces().List(ctx, metav1.ListOptions{})
	if err != nil {
		return []corev1.Namespace{}, err
	}
	return nslist.Items, nil
}

func ValidNamespaceArgs(_ *cobra.Command, ctx cli.Context, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

                              status.get());
  std::unique_ptr<TFE_Context, decltype(&TFE_DeleteContext)> context(
      TFE_NewContext(opts.get(), status.get()), TFE_DeleteContext);
  ASSERT_EQ(TF_GetCode(status.get()), TF_OK) << TF_Message(status.get());
  BasicTestsForTwoDevices(context.get(),
                          "/job:localhost/replica:0/task:0/device:CPU:0",

	for _, resource := range resources {
		_, lockTaken := l.lockMap[resource]
		if lockTaken {
			return false
		}
	}
	return true
}

func (l *localLocker) Lock(ctx context.Context, args dsync.LockArgs) (reply bool, err error) {
	if len(args.Resources) > maxDeleteList {
		return false, fmt.Errorf("internal error: localLocker.Lock called with more than %d resources", maxDeleteList)
	}

import java.util.Properties;

import org.apache.maven.model.Activation;
import org.apache.maven.model.ActivationProperty;
import org.apache.maven.model.Profile;
import org.codehaus.plexus.context.Context;
import org.codehaus.plexus.context.ContextException;
import org.codehaus.plexus.personality.plexus.lifecycle.phase.Contextualizable;

/**
 * SystemPropertyProfileActivator
 */
@Deprecated

                .groupId("GROUPID")
                .artifactId("ARTIFACTID")
                .version("1.0-SNAPSHOT")
                .build());
        Mockito.when(context.getRawModel(pomFile, root.resolve("pom.xml"))).thenReturn(parent);
        Mockito.when(context.locate(root)).thenReturn(root.resolve("pom.xml"));
        Model initial = new Model(org.apache.maven.api.model.Model.newBuilder()