import common.Os
import jetbrains.buildServer.configs.kotlin.BuildType
import model.Stage

open class BaseGradleBuildType(
    open val stage: Stage? = null,
    open val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {},
) : BuildType() {
    init {
        this.init()
    }
}

open class OsAwareBaseGradleBuildType(
    val os: Os,
    override val stage: Stage? = null,

{* ../../docs_src/events/tutorial003_py310.py hl[1,13] *}

Un **gestionnaire de contexte** en Python est quelque chose que vous pouvez utiliser dans une instruction `with`. Par exemple, `open()` peut être utilisé comme gestionnaire de contexte :

```Python
with open("file.txt") as file:
    file.read()
```

Dans les versions récentes de Python, il existe aussi un **gestionnaire de contexte asynchrone**. Vous l'utiliseriez avec `async with` :

      for (int aHigh = 0; aHigh < 6; aHigh++) {
        for (BoundType aLowType : BoundType.values()) {
          for (BoundType aHighType : BoundType.values()) {
            if ((aLow == aHigh && aLowType == OPEN && aHighType == OPEN) || aLow > aHigh) {
              continue;
            }
            for (int bLow = 0; bLow < 6; bLow++) {
              for (int bHigh = 0; bHigh < 6; bHigh++) {

            this.retval = _src.dec_ndr_long();
        }
    }

    /**
     * SAMR Connect2 operation for establishing a connection to the SAM database.
     * This operation opens the SAM database on a remote server.
     */
    public static class SamrConnect2 extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x39;
        }

            retval = _src.dec_ndr_long();
        }
    }

    /**
     * SAMR Connect2 operation for establishing a connection to the SAM database.
     * This operation opens the SAM database on a remote server.
     */
    public static class SamrConnect2 extends DcerpcMessage {

        @Override
        public int getOpnum() {
            return 0x39;
        }

			results:   []string{"c5", "c1", "c2", "c3", "c4"},
		},
	}

	for idx, data := range datas {
		db, err := gorm.Open(nil, nil)
		if err != nil {
			t.Fatal(err)
		}
		callbacks := db.Callback()

		for _, c := range data.callbacks {
			var v interface{} = callbacks.Create()

    } else {
      eventsForMatching.forEach loop@{
        when (e.closes(it)) {
          null -> return

          // no open event
          true -> return

          // found open event
          false -> return@loop // this is not the open event so continue
        }
      }
      fail<Any>("event $e without matching start event")
    }
  }

    private static final Logger log = LoggerFactory.getLogger(SmbFileHandleImpl.class);

    private final Configuration cfg;
    private final int fid;
    private final byte[] fileId;
    private boolean open = true;
    private final long tree_num; // for checking whether the tree changed
    private SmbTreeHandleImpl tree;

    private final AtomicLong usageCount = new AtomicLong(1);
    private final int flags;

import java.net.InetAddress
import java.net.Socket
import javax.net.SocketFactory

/**
 * A [SocketFactory] that delegates calls. Sockets can be configured after creation by
 * overriding [.configureSocket].
 */
open class DelegatingSocketFactory(
  private val delegate: SocketFactory,
) : SocketFactory() {
  @Throws(IOException::class)
  override fun createSocket(): Socket {
    val socket = delegate.createSocket()

     */
    int TYPE_COMM = 0x40;

    /* open flags */

    /**
     * Open for reading only.
     */
    int O_RDONLY = 0x01;
    /**
     * Open for writing only.
     */
    int O_WRONLY = 0x02;
    /**
     * Open for reading and writing.
     */
    int O_RDWR = 0x03;
    /**
     * Open in append mode.
     */
    int O_APPEND = 0x04;