@GwtIncompatible
  @J2ktIncompatible
    private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();
    Serialization.writeMultimap(this, stream);
  }

  @GwtIncompatible
  @J2ktIncompatible
    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();
    expectedValuesPerKey = DEFAULT_VALUES_PER_KEY;

    return Multisets.iteratorImpl(this);
  }

  @GwtIncompatible // java.io.ObjectOutputStream
  private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();
    stream.writeObject(type);
    Serialization.writeMultiset(this, stream);
  }

  /**
   * @serialData the {@code Class<E>} for the enum type, the number of distinct elements, the first

        byte[] data = new byte[0];
        ContentCache cache = new ContentCache(data);

        try (InputStream stream = cache.getInputStream()) {
            assertNotNull(stream);
            assertEquals(-1, stream.read()); // Should indicate end of stream
        }
    }

    @Test
    public void testFileBasedCacheWithEmptyFile() throws IOException {

            context.addFieldLog(field, text);
            stream(texts).of(stream -> stream.forEach(t -> context.addHighlightedQuery(t)));
            return buildDefaultQueryBuilder(fessConfig, context, (f, b) -> buildMatchPhraseQuery(f, text).boost(b * boost));
        }

        if (isSearchField(field)) {
            context.addFieldLog(field, text);
            stream(texts).of(stream -> stream.forEach(t -> context.addHighlightedQuery(t)));

import java.nio.file.Files;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TreeMap;
import java.util.stream.Collectors;

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.groupingBy;

/**
 * Generates the page that lists the breaking changes and deprecations for a minor version release.
 */
public class BreakingChangesGenerator {

import org.gradle.process.ExecOperations;

import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * This class wraps certain {@code git} operations. This is partly for convenience, and partly so that these
 * operations can be easily mocked in testing.
 */
public class GitWrapper {

   *     values for that key, and the key's values
   */
  @GwtIncompatible
  @J2ktIncompatible
    private void writeObject(ObjectOutputStream stream) throws IOException {
    stream.defaultWriteObject();
    stream.writeObject(valueComparator());
    Serialization.writeMultimap(this, stream);
  }

  private @Nullable Comparator<? super V> valueComparator() {
    return emptySet instanceof ImmutableSortedSet

/// tip

If you want to stream binary data, for example video or audio, check the advanced guide: [Stream Data](../advanced/stream-data.md).

///

## Stream SSE with FastAPI { #stream-sse-with-fastapi }

To stream SSE with FastAPI, use `yield` in your *path operation function* and set `response_class=EventSourceResponse`.

class Item(BaseModel):
    name: str
    price: float


app = FastAPI()


@app.get("/items/stream-invalid")
async def stream_items_invalid() -> AsyncIterable[Item]:
    yield {"name": "valid", "price": 1.0}
    yield {"name": "invalid", "price": "not-a-number"}


@app.get("/items/stream-invalid-sync")
def stream_items_invalid_sync() -> Iterable[Item]:
    yield {"name": "valid", "price": 1.0}

	})
	if err != nil {
		return nil, err
	}
	stream, err := metadata.Algorithm.Stream(key)
	if err != nil {
		return nil, err
	}
	if stream.NonceSize() != len(metadata.Nonce) {
		return nil, sio.NotAuthentic
	}
	return stream.DecryptReader(ciphertext, metadata.Nonce, nil), nil
}

type encryptedObject struct {
	KeyID  string `json:"keyid"`
	KMSKey []byte `json:"kmskey"`