*/
package jcifs;

import java.net.URLStreamHandler;

/**
 * Encapsulation of client context
 *
 *
 * A context holds the client configuration, shared services as well as the active credentials.
 *
 * Usually you will want to create one context per client configuration and then
 * multiple sub-contexts using different credentials (if necessary).
 *

        // Session starts with usage count > 0
        assertTrue(session.isInUse(), "Session should be in use initially");

        // Create and release trees
        SmbTreeImpl tree = session.getSmbTree("share1", null);
        assertNotNull(tree, "Tree should be created");
        tree.release();

        // Release the session (back to initial state)
        session.release();

All source code in Gradle is written to target one or more of these runtimes.
Most source code targets the daemon and the remaining code either targets a single runtime, for example the Gradle client, or is shared across multiple runtimes.

## Composition by architecture modules

Each [architecture module and platform](platforms.md) can contribute code to any of the runtimes.
Not every module contributes to every runtime.

	shardSize := int64(1024 * 1024)
	shard := make([]byte, shardSize)
	w := newStreamingBitrotWriter(storage, "", volName, fileName, size, algo, shardSize)
	reader := bytes.NewReader(data)
	for {
		// Using io.Copy instead of this loop will not work for us as io.Copy
		// will use bytes.Reader.WriteTo() which will not do shardSize'ed writes
		// causing error.
		n, err := reader.Read(shard)
		w.Write(shard[:n])

    </dependencySet>
  </dependencySets>
  <fileSets>
    <fileSet>
      <includes>
        <include>README*</include>
      </includes>
    </fileSet>
    <fileSet>
      <directory>target/maven-shared-archive-resources/META-INF</directory>
      <outputDirectory>./</outputDirectory>
      <includes>
        <include>LICENSE</include>
        <include>NOTICE</include>
      </includes>
    </fileSet>
    <fileSet>

    # A local firewall rule for the container is added in
    # ci/official/utilities/setup_docker.sh.
  fi
else
  # The volume mapping flag below shares the user's gcloud credentials, if any,
  # with the container, in case the user has credentials stored there.
  # This would allow Bazel to authenticate for RBE.
  # Note: TF's CI does not have any credentials stored there.

and furthermore provides reuse of the structs used for the request and response.

Note that Responses sent for serialization are automatically reused for similar requests.
If the response contains shared data it will cause issues, since each unique response is reused.
To disable this behavior, use `(SingleHandler).WithSharedResponse()` to disable it.

## Streaming Requests

 * limitations under the License.
 */

package com.google.common.graph;

import java.util.Set;

/**
 * A non-public interface for the methods shared between {@link Graph} and {@link ValueGraph}.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 */
interface BaseGraph<N> extends ArchetypeGraph<N> {
  //
  // Graph-level accessors
  //

            }
            return resp.getAvailable();
        } catch (final SmbException se) {
            throw seToIoe(se);
        }
    }

    @Override
    public void close() {
        // ignore, the shared file descriptor is closed by the pipe handle
    }

* They can't be declared in Pydantic validation and require additional logic
* The logic depends on external resources or could block in any other way
* Other dependencies need their results (it's a sub-dependency)
* The logic can be shared by multiple endpoints to do things like error early, authentication, etc.
* They need to handle cleanup (e.g., DB sessions, file handles), using dependencies with `yield`