/**
 * Represents a maven plugin runtime
 *
 * @since 4.0.0
 */
@Experimental
public interface Plugin {

    @Nonnull
    org.apache.maven.api.model.Plugin getModel();

    @Nonnull
    PluginDescriptor getDescriptor();

    @Nonnull
    List<Lifecycle> getLifecycles();

    @Nonnull
    ClassLoader getClassLoader();

    @Nonnull
    Artifact getArtifact();

        this.model = model;
        this.request = request;
        this.problems = problems;
    }

    @Override
    public Model getModel() {
        return model;
    }

    @Override
    public ModelBuildingRequest getRequest() {
        return request;
    }

    @Override
    public ModelProblemCollector getProblems() {

    }

    /**
     * getter
     */
    public MetadataGraphNode getEntry() {
        return entry;
    }

    /**
     * getter
     */
    public Collection<MetadataGraphNode> getNodes() {
        return nodes;
    }

func checkPutObjectLockAllowed(ctx context.Context, rq *http.Request, bucket, object string, getObjectInfoFn GetObjectInfoFn, retentionPermErr, legalHoldPermErr APIErrorCode) (objectlock.RetMode, objectlock.RetentionDate, objectlock.ObjectLegalHold, APIErrorCode) {
	var mode objectlock.RetMode
	var retainDate objectlock.RetentionDate
	var legalHold objectlock.ObjectLegalHold

	retentionRequested := objectlock.IsObjectLockRetentionRequested(rq.Header)

    private List<String> fatals = new ArrayList<>();

    public SimpleProblemCollector() {}

    public SimpleProblemCollector(Model model) {
        this.model = model;
    }

    public Model getModel() {
        return model;
    }

    public List<String> getWarnings() {
        return warnings;
    }

    public List<String> getErrors() {
        return errors;
    }

				LabelSelector: "app=sidecar-injector",
			})
			if err != nil {
				return err
			}
			hooks := hooksList.Items
			pods, err := getPods(context.Background(), client)
			if err != nil {
				return err
			}
			err = printNS(cmd.OutOrStdout(), nsList, hooks, pods)
			if err != nil {
				return err
			}
			fmt.Fprintln(cmd.OutOrStdout())

 * the License.
 */

package com.google.common.util.concurrent;

import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.util.concurrent.Futures.getDone;
import static com.google.common.util.concurrent.MoreExecutors.rejectionPropagatingExecutor;
import static com.google.common.util.concurrent.Platform.restoreInterruptIfIsInterruptedException;

        return result;
    }

    /**
     * Gets the model that could not be built properly.
     *
     * @return The erroneous model or {@code null} if not available.
     */
    public Model getModel() {
        if (result == null) {
            return null;
        }
        if (result.getEffectiveModel() != null) {
            return result.getEffectiveModel();
        }
        return result.getRawModel();

     *            the fid to set
     */
    public void setFid ( int fid ) {
        this.fid = fid;
    }


    /**
     * @param mode
     *            the mode to set
     */
    public final void setMode ( int mode ) {
        this.mode = mode;
    }


    /**
     * @param offset
     *            the offset to set
     */
    public final void setOffset ( long offset ) {
        this.offset = offset;

In Python gibt es eine Möglichkeit, eine Instanz einer Klasse „aufrufbar“ („callable“) zu machen.

Nicht die Klasse selbst (die bereits aufrufbar ist), sondern eine Instanz dieser Klasse.

Dazu deklarieren wir eine Methode `__call__`:

//// tab | Python 3.9+

```Python hl_lines="12"
{!> ../../docs_src/dependencies/tutorial011_an_py39.py!}
```

////

//// tab | Python 3.8+

```Python hl_lines="11"