for (i in 0 until COUNT) {
      if (!other.isSet(i)) continue
      set(i, other[i])
    }
  }

  companion object {
    /**
     * From the HTTP/2 specs, the default initial window size for all streams is 64 KiB. (Chrome 25
     * uses 10 MiB).
     */
    const val DEFAULT_INITIAL_WINDOW_SIZE = 65535

    /** HTTP/2: Size in bytes of the table used to decode the sender's header blocks. */

//
// Calling Multistream(false) disables this behavior; disabling the behavior
// can be useful when reading file formats that distinguish individual gzip
// data streams or mix gzip data streams with other data streams.
// In this mode, when the [Reader] reaches the end of the data stream,
// [Reader.Read] returns [io.EOF]. The underlying reader must implement [io.ByteReader]
// in order to be left positioned just after the gzip stream.

    iter->Unref();
  }
  // The XlaDeviceContext keeps a reference count to the streams, and the
  // XlaDeviceContext remains live for the duration of a Executor run. This
  // ensures that the streams remain live for the duration of a run, even if
  // an error is encountered and the streams are replaced with new ones.
  for (const auto& iter : shape_determination_fns_) {

     */
    ExecHandleBuilder setDaemon(boolean daemon);

    /**
     * Sets a handler for the output streams of the process.
     */
    ExecHandleBuilder streamsHandler(StreamsHandler streamsHandler);

    /**
     * Sets the start-up timeout, when spawning a process. Not used when forking a process (the default).
     */

 private:
  bool UseMultipleStreams() const { return stream_ != host_to_device_stream_; }

  // The main compute stream of the device, used to synchronize the transfer
  // streams if they are set.
  std::shared_ptr<se::Stream> stream_;
  // The stream to use for transferring data from host to device. Can be
  // idential to stream_, but must not be nullptr.

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.cc.impl.cacheentry

import org.gradle.cache.internal.streams.BlockAddress
import org.gradle.util.Path
import java.io.File


/**
 * Data stored in the "entry details" file. Provides some metadata about the cache entry.
 */
internal
class EntryDetails(

        def matches = projects.findAll { it.name == name }
        assert matches.size() == 1
        return matches[0]
    }

    void assertHasLibs(String... jarNames) {
        assert libs*.jarName == jarNames as List
    }

    EclipseLibrary lib(String jarName) {
        def matches = libs.findAll { it.jarName.contains(jarName) } + vars.findAll { it.jarName == jarName }
        assert matches.size() == 1

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.cache.internal.streams;

/**
 * An opaque (outside this package) pointer to a block in a file.
 */
public class BlockAddress {
    final int fileId;
    final long pos;
    final long length;

 * limitations under the License.
 */

package org.gradle.tooling.events.test;

import java.io.Serializable;

/**
 * Enumerates possible output streams for {@link TestOutputEvent}.
 *
 * @since 6.0
 */
public enum Destination implements Serializable {

    StdOut(0),
    StdErr(1);

    private final int code;

     Destination(int code) {

	// Close resets all streams and closes the connection.
	Close() error
	// CloseChan returns a channel that is closed when the underlying connection is closed.
	CloseChan() <-chan bool
	// SetIdleTimeout sets the amount of time the connection may remain idle before
	// it is automatically closed.
	SetIdleTimeout(timeout time.Duration)
	// RemoveStreams can be used to remove a set of streams from the Connection.