99: class Stream {

686: class ASCII85Stream: public FilterStream {

54: enum StreamKind {

70: enum StreamColorSpaceMode {

225:   virtual Stream *getNextStream() { return NULL; }

255: class OutStream {

281: class FileOutStream : public OutStream {

307: class BaseStream: public Stream {

318:   BaseStream *getBaseStream() override { return this; }

319:   Stream *getUndecodedStream() override { return this; }

341: class FilterStream: public Stream {

349:   BaseStream *getBaseStream() override { return str->getBaseStream(); }

350:   Stream *getUndecodedStream() override { return str->getUndecodedStream(); }

353:   Stream *getNextStream() override { return str; }

367: class ImageStream {

414: class StreamPredictor {

456: class FileStream: public BaseStream {

526: class CachedFileStream: public BaseStream {

570: class MemStream: public BaseStream {

619: class EmbedStream: public BaseStream {

663: class ASCIIHexStream: public FilterStream {

711: class LZWStream: public FilterStream {

771: class RunLengthStream: public FilterStream {

804: class CCITTFaxStream: public FilterStream {

892: class DCTStream: public FilterStream {

999: class FlateStream: public FilterStream {

1074: class EOFStream: public FilterStream {

1091: class BufStream: public FilterStream {

454: #define fileStreamBufSize 256

524: #define cachedStreamBufSize 1024

3: // Stream.h

79: // This is in Stream.h instead of Decrypt.h to avoid really annoying

96: // Stream (base class)

103:   Stream();

106:   virtual ~Stream();

108:   Stream(const Stream &) = delete;

109:   Stream& operator=(const Stream &other) = delete;

211:   virtual Stream *getUndecodedStream() = 0;

229:   Stream *addFilters(Dict *dict, int recursion = 0);

241:   Stream *makeFilter(char *name, Stream *str, Object *params, int recursion = 0, Dict *dict = nullptr);

314:   virtual Stream *makeSubStream(Goffset start, GBool limited,

344:   FilterStream(Stream *strA);

360:   Stream *str;

373:   ImageStream(Stream *strA, int widthA, int nCompsA, int nBitsA);

399:   Stream *str;			// base stream

419:   StreamPredictor(Stream *strA, int predictorA,

437:   Stream *str;			// base stream

463:   Stream *makeSubStream(Goffset startA, GBool limitedA,

533:   Stream *makeSubStream(Goffset startA, GBool limitedA,

576:   Stream *makeSubStream(Goffset start, GBool limited,

622:   EmbedStream(Stream *strA, Object &&dictA, GBool limitedA, Goffset lengthA, GBool reusableA = gFalse);

625:   Stream *makeSubStream(Goffset start, GBool limitedA,

647:   Stream *str;

666:   ASCIIHexStream(Stream *strA);

683: // ASCII85Stream

689:   ASCII85Stream(Stream *strA);

690:   ~ASCII85Stream();

714:   LZWStream(Stream *strA, int predictor, int columns, int colors,

774:   RunLengthStream(Stream *strA);

807:   CCITTFaxStream(Stream *strA, int encodingA, GBool endOfLineA,

895:   DCTStream(Stream *strA, int colorXformA, Dict *dict, int recursion);

1002:   FlateStream(Stream *strA, int predictor, int columns,

1077:   EOFStream(Stream *strA);

1094:   BufStream(Stream *strA, int bufSizeA);

1119:   FixedLengthEncoder(Stream *strA, int lengthA);

1142:   ASCIIHexEncoder(Stream *strA);

1172:   ASCII85Encoder(Stream *strA);

1202:   RunLengthEncoder(Stream *strA);

1238:   LZWEncoder(Stream *strA);

1270:   CMYKGrayEncoder(Stream *strA);

1299:   RGBGrayEncoder(Stream *strA);

49: class BaseStream;

112:   virtual StreamKind getKind() = 0;

177:   // This is only used by StreamPredictor.

206:   // Get the BaseStream of this stream.

207:   virtual BaseStream *getBaseStream() = 0;

209:   // Get the stream after the last decoder (this may be a BaseStream

210:   // or a DecryptStream).

222: 			      StreamColorSpaceMode * /*csMode*/) {}

251: // OutStream

258:   OutStream ();

261:   virtual ~OutStream ();

263:   OutStream(const OutStream &) = delete;

264:   OutStream& operator=(const OutStream &other) = delete;

279: // FileOutStream

283:   FileOutStream (FILE* fa, Goffset startA);

285:   ~FileOutStream ();

302: // BaseStream

311:   BaseStream(Object &&dictA, Goffset lengthA);

312:   ~BaseStream();

313:   virtual BaseStream *copy() = 0;

336: // FilterStream

345:   ~FilterStream();

364: // ImageStream

375:   ~ImageStream();

377:   ImageStream(const ImageStream &) = delete;

378:   ImageStream& operator=(const ImageStream &other) = delete;

411: // StreamPredictor

422:   ~StreamPredictor();

424:   StreamPredictor(const StreamPredictor &) = delete;

425:   StreamPredictor& operator=(const StreamPredictor &) = delete;

451: // FileStream

459:   FileStream(GooFile* fileA, Goffset startA, GBool limitedA,

461:   ~FileStream();

462:   BaseStream *copy() override;

465:   StreamKind getKind() override { return strFile; }

521: // CachedFileStream

529:   CachedFileStream(CachedFile *ccA, Goffset startA, GBool limitedA,

531:   ~CachedFileStream();

532:   BaseStream *copy() override;

535:   StreamKind getKind() override { return strCachedFile; }

567: // MemStream

573:   MemStream(char *bufA, Goffset startA, Goffset lengthA, Object &&dictA);

574:   ~MemStream();

575:   BaseStream *copy() override;

578:   StreamKind getKind() override { return strWeird; }

610: // EmbedStream

614: // EmbedStream is deleted, reads from the base stream will proceed where

615: // the BaseStream left off.  Note that this is very different behavior

616: // that creating a new FileStream (using makeSubStream).

623:   ~EmbedStream();

624:   BaseStream *copy() override;

627:   StreamKind getKind() override { return str->getKind(); }

660: // ASCIIHexStream

667:   ~ASCIIHexStream();

668:   StreamKind getKind() override { return strASCIIHex; }

691:   StreamKind getKind() override { return strASCII85; }

708: // LZWStream

716:   ~LZWStream();

717:   StreamKind getKind() override { return strLZW; }

743:   StreamPredictor *pred;	// predictor

768: // RunLengthStream

775:   ~RunLengthStream();

776:   StreamKind getKind() override { return strRunLength; }

799: // CCITTFaxStream

810:   ~CCITTFaxStream();

811:   StreamKind getKind() override { return strCCITTFax; }

863: // DCTStream

896:   virtual ~DCTStream();

897:   StreamKind getKind() override { return strDCT; }

972: // FlateStream

1004:   ~FlateStream();

1005:   StreamKind getKind() override { return strFlate; }

1034:   StreamPredictor *pred;	// predictor

1071: // EOFStream

1078:   ~EOFStream();

1079:   StreamKind getKind() override { return strWeird; }

1088: // BufStream

1095:   ~BufStream();

1096:   StreamKind getKind() override { return strWeird; }

1116: class FixedLengthEncoder: public FilterStream {

1121:   StreamKind getKind() override { return strWeird; }

1139: class ASCIIHexEncoder: public FilterStream {

1144:   StreamKind getKind() override { return strWeird; }

1169: class ASCII85Encoder: public FilterStream {

1174:   StreamKind getKind() override { return strWeird; }

1199: class RunLengthEncoder: public FilterStream {

1204:   StreamKind getKind() override { return strWeird; }

1235: class LZWEncoder: public FilterStream {

1240:   StreamKind getKind() override { return strWeird; }

1267: class CMYKGrayEncoder: public FilterStream {

1272:   StreamKind getKind() override { return strWeird; }

1296: class RGBGrayEncoder: public FilterStream {

1301:   StreamKind getKind() override { return strWeird; }

512:   char buf[fileStreamBufSize];

557:   char buf[cachedStreamBufSize];

49: class Stream : public Print

63:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

114:   // Stream and used parseFloat/Int with a custom ignore character. To keep

24: class Stream {

44: class MemoryStream : public Stream {

46:     MemoryStream(void* buffer, size_t size, jobject buf) :

63: class FileStream : public Stream {

65:     FileStream(FILE* fd) : mFd(fd) {}

74: class JavaInputStream : public Stream {

76:     JavaInputStream(JNIEnv* env, jobject inputStream, jbyteArray byteArray) :

87:     const jobject mInputStream;

26:     Stream();

27:     virtual ~Stream();

78:             mInputStream(inputStream),

92: jint JavaStream_OnLoad(JNIEnv* env);

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

38: class Stream : public Print

54:     Stream() {_timeout=1000;}

23: #define Stream_h

48:     ~Stream(){}

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

31: public interface Stream {

35:    * which the solutions are returned depends on the implementations of {@code Stream} used.

37:   Stream mplus(Stream s2);

44:   Stream bind(Goal goal);

55:   Stream rest();

26: public abstract class Stream<T> implements Iterator<T> {

38: class Stream : public Print

53:     Stream() {_timeout=1000;}

23: #define Stream_h

2:   Stream.h - base class for character-based streams.

22: #ifndef Stream_h

26: class Stream : public Print

21: #define Stream_h

2:   Stream.h - base class for character-based streams.

20: #ifndef Stream_h

671: HH_INLINE void Stream(const V256<T>& v, T* const HH_RESTRICT to) {

674: HH_INLINE void Stream(const V256<float>& v, float* const HH_RESTRICT to) {

677: HH_INLINE void Stream(const V256<double>& v, double* const HH_RESTRICT to) {

191:   BitstreamCursor Stream;

190:   std::unique_ptr<BitstreamReader> StreamFile;

3416: std::error_code BitcodeReader::InitStream() {

3441: std::error_code BitcodeReader::InitLazyStream() {

192:   std::unique_ptr<DataStreamer> LazyStreamer;

3422: std::error_code BitcodeReader::InitStreamFromBuffer() {

838:   if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))

850:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

865:     switch (Stream.readRecord(Entry.ID, Record)) {

896:   if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))

913:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

931:     switch (Stream.readRecord(Entry.ID, Record)) {

1105:   if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0))

1115:   BitstreamCursor StartOfTypeBlockCursor(Stream);

1126:     unsigned Code = Stream.ReadCode();

1138:         Stream = StartOfTypeBlockCursor;

1142:       if (Stream.ReadBlockEnd())

1149:       Stream.ReadSubBlockID();

1150:       if (Stream.SkipBlock())

1156:       Stream.ReadAbbrevRecord();

1163:     switch (Stream.readRecord(Code, Record)) {

1294:   if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0))

1302:     unsigned Code = Stream.ReadCode();

1304:       if (Stream.ReadBlockEnd())

1311:       Stream.ReadSubBlockID();

1312:       if (Stream.SkipBlock())

1318:       Stream.ReadAbbrevRecord();

1324:     switch (Stream.readRecord(Code, Record)) {

1345:   if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))

1353:     unsigned Code = Stream.ReadCode();

1355:       if (Stream.ReadBlockEnd())

1361:       Stream.ReadSubBlockID();

1362:       if (Stream.SkipBlock())

1368:       Stream.ReadAbbrevRecord();

1374:     switch (Stream.readRecord(Code, Record)) {

1407:   if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))

1414:     unsigned Code = Stream.ReadCode();

1416:       if (Stream.ReadBlockEnd())

1423:       Stream.ReadSubBlockID();

1424:       if (Stream.SkipBlock())

1430:       Stream.ReadAbbrevRecord();

1437:     Code = Stream.readRecord(Code, Record);

1449:       Code = Stream.ReadCode();

1452:       unsigned NextBitCode = Stream.readRecord(Code, Record);

1626:   if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))

1635:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

1657:     unsigned BitCode = Stream.readRecord(Entry.ID, Record);

1961:   if (Stream.ReadBlockEnd())

1988:   uint64_t CurBit = Stream.GetCurrentBitNo();

1992:   if (Stream.SkipBlock())

2028:     Stream.JumpToBit(NextUnreadBit);

2029:   else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

2037:   while (!Stream.AtEndOfStream()) {

2038:     unsigned Code = Stream.ReadCode();

2040:       if (Stream.ReadBlockEnd())

2073:       switch (Stream.ReadSubBlockID()) {

2075:         if (Stream.SkipBlock())

2079:         if (Stream.ReadBlockInfoBlock())

2132:           NextUnreadBit = Stream.GetCurrentBitNo();

2142:       Stream.ReadAbbrevRecord();

2147:     switch (Stream.readRecord(Code, Record)) {

2347:   if (Stream.Read(8) != 'B' ||

2348:       Stream.Read(8) != 'C' ||

2349:       Stream.Read(4) != 0x0 ||

2350:       Stream.Read(4) != 0xC ||

2351:       Stream.Read(4) != 0xE ||

2352:       Stream.Read(4) != 0xD)

2358:     if (Stream.AtEndOfStream())

2362:       Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);

2373:         if (Stream.ReadBlockInfoBlock())

2387:         if (Stream.SkipBlock())

2398:       if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 &&

2399:           Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&

2400:           Stream.AtEndOfStream())

2409:   if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))

2417:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

2431:     switch (Stream.readRecord(Entry.ID, Record)) {

2459:   if (Stream.Read(8) != 'B' ||

2460:       Stream.Read(8) != 'C' ||

2461:       Stream.Read(4) != 0x0 ||

2462:       Stream.Read(4) != 0xC ||

2463:       Stream.Read(4) != 0xE ||

2464:       Stream.Read(4) != 0xD)

2470:     BitstreamEntry Entry = Stream.advance();

2483:       if (Stream.SkipBlock())

2488:       Stream.skipRecord(Entry.ID);

2496:   if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))

2501:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();

2516:     switch (Stream.readRecord(Entry.ID, Record)) {

2543:   if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))

2563:     unsigned Code = Stream.ReadCode();

2565:       if (Stream.ReadBlockEnd())

2571:       switch (Stream.ReadSubBlockID()) {

2573:         if (Stream.SkipBlock())

2598:       Stream.ReadAbbrevRecord();

2605:     unsigned BitCode = Stream.readRecord(Code, Record);

3332:   Stream.JumpToBit(DFII->second);

3436:   Stream.init(&*StreamFile);

3448:   Stream.init(&*StreamFile);

354:   std::error_code InitStream();

356:   std::error_code InitLazyStream();

2343:   if (std::error_code EC = InitStream())

2455:   if (std::error_code EC = InitStream())

3418:     return InitLazyStream();

3435:   StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));

3444:   auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>(

3446:   StreamingMemoryObject &Bytes = *OwnedBytes;

3447:   StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));

355:   std::error_code InitStreamFromBuffer();

395:       TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),

2131:         if (LazyStreamer && SeenValueSymbolTable) {

2299:         if (LazyStreamer)

2383:         if (LazyStreamer)

3417:   if (LazyStreamer)

3419:   return InitStreamFromBuffer();

3445:       std::move(LazyStreamer));

165: type Stream struct {

309: func newContextWithStream(ctx context.Context, stream *Stream) context.Context {

314: func StreamFromContext(ctx context.Context) (s *Stream, ok bool) {

391: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)

397: 	CloseStream(stream *Stream, err error)

427: func StreamErrorf(c codes.Code, format string, a ...interface{}) StreamError {

455: type StreamError struct {

417: 	HandleStreams(func(*Stream))

164: // Stream represents an RPC in the transport layer.

167: 	// nil for client side Stream.

208: func (s *Stream) RecvCompress() string {

213: func (s *Stream) SetSendCompress(str string) {

220: func (s *Stream) Header() (metadata.MD, error) {

232: func (s *Stream) Trailer() metadata.MD {

240: func (s *Stream) ServerTransport() ServerTransport {

245: func (s *Stream) Context() context.Context {

250: func (s *Stream) TraceContext(tr trace.Trace) {

255: func (s *Stream) Method() string {

260: func (s *Stream) StatusCode() codes.Code {

265: func (s *Stream) StatusDesc() string {

275: func (s *Stream) SetTrailer(md metadata.MD) error {

285: func (s *Stream) write(m recvMsg) {

289: // Read reads all the data available for this Stream from the transport and

293: func (s *Stream) Read(p []byte) (n int, err error) {

304: // The key to save transport.Stream in the context.

315: 	s, ok = ctx.Value(streamKey).(*Stream)

388: 	Write(s *Stream, data []byte, opts *Options) error

390: 	// NewStream creates a Stream for an RPC.

411: 	WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error

413: 	Write(s *Stream, data []byte, opts *Options) error

415: 	WriteHeader(s *Stream, md metadata.MD) error

159: 	streamWriteDone             // EndStream sent

160: 	streamReadDone              // EndStream received

307: // newContextWithStream creates a new context from ctx and attaches stream

313: // StreamFromContext returns the stream saved in ctx.

393: 	// CloseStream clears the footprint of a stream when the stream is

395: 	// CloseStream is called. Must be called when a stream is finished

426: // StreamErrorf creates an StreamError with the specified error code and description.

428: 	return StreamError{

454: // StreamError is an error that only affects one stream within a connection.

460: func (e StreamError) Error() string {

464: // ContextErr converts the error from context package into a StreamError.

465: func ContextErr(err error) StreamError {

468: 		return StreamErrorf(codes.DeadlineExceeded, "%v", err)

470: 		return StreamErrorf(codes.Canceled, "%v", err)

476: // If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err.

161: 	streamDone                  // sendDone and recvDone or RSTStreamFrame is sent or received.

330: func NewServerTransport(protocol string, conn net.Conn, maxStreams uint32, authInfo credentials.AuthInfo) (ServerTransport, error) {

331: 	return newHTTP2Server(conn, maxStreams, authInfo)

416: 	// HandleStreams receives incoming streams using the given handler.

1751:     WORD Stream;

2305:    function Stream

2323:    function Stream (Socket : Socket_Type) return Stream_Access is

225:    type Stream_Socket_Stream_Type is new Root_Stream_Type with record

229:    type Stream_Socket_Stream_Access is

241:    procedure Stream_Write

2335:    procedure Stream_Write

205:    type Datagram_Socket_Stream_Type is new Root_Stream_Type with record

211:    type Datagram_Socket_Stream_Access is

75:              (Socket_Stream   => SOSC.SOCK_STREAM,

203:    --  Types needed for Datagram_Socket_Stream_Type

212:      access all Datagram_Socket_Stream_Type;

215:      (Stream : in out Datagram_Socket_Stream_Type;

216:       Item   : out Ada.Streams.Stream_Element_Array;

217:       Last   : out Ada.Streams.Stream_Element_Offset);

220:      (Stream : in out Datagram_Socket_Stream_Type;

221:       Item   : Ada.Streams.Stream_Element_Array);

223:    --  Types needed for Stream_Socket_Stream_Type

230:      access all Stream_Socket_Stream_Type;

233:      (Stream : in out Stream_Socket_Stream_Type;

234:       Item   : out Ada.Streams.Stream_Element_Array;

235:       Last   : out Ada.Streams.Stream_Element_Offset);

238:      (Stream : in out Stream_Socket_Stream_Type;

239:       Item   : Ada.Streams.Stream_Element_Array);

243:       Item   : Ada.Streams.Stream_Element_Array;

245:    --  Common implementation for the Write operation of Datagram_Socket_Stream_

246:    --  Type and Stream_Socket_Stream_Type.

831:       Mode   : Mode_Type   := Socket_Stream)

919:      (Stream : not null Stream_Access) return Sock_Addr_Type

922:       if Stream.all in Datagram_Socket_Stream_Type then

923:          return Datagram_Socket_Stream_Type (Stream.all).From;

925:          return Get_Peer_Name (Stream_Socket_Stream_Type (Stream.all).Socket);

1672:      (Stream : in out Datagram_Socket_Stream_Type;

1673:       Item   : out Ada.Streams.Stream_Element_Array;

1674:       Last   : out Ada.Streams.Stream_Element_Offset)

1676:       First : Ada.Streams.Stream_Element_Offset          := Item'First;

1677:       Index : Ada.Streams.Stream_Element_Offset          := First - 1;

1678:       Max   : constant Ada.Streams.Stream_Element_Offset := Item'Last;

1683:            (Stream.Socket,

1686:             Stream.From);

1704:      (Stream : in out Stream_Socket_Stream_Type;

1705:       Item   : out Ada.Streams.Stream_Element_Array;

1706:       Last   : out Ada.Streams.Stream_Element_Offset)

1708:       pragma Warnings (Off, Stream);

1710:       First : Ada.Streams.Stream_Element_Offset          := Item'First;

1711:       Index : Ada.Streams.Stream_Element_Offset          := First - 1;

1712:       Max   : constant Ada.Streams.Stream_Element_Offset := Item'Last;

1716:          Receive_Socket (Stream.Socket, Item (First .. Max), Index);

1734:       Item   : out Ada.Streams.Stream_Element_Array;

1735:       Last   : out Ada.Streams.Stream_Element_Offset;

1757:       Item   : out Ada.Streams.Stream_Element_Array;

1758:       Last   : out Ada.Streams.Stream_Element_Offset;

1793:       Count  : out Ada.Streams.Stream_Element_Count;

1825:       Count := Ada.Streams.Stream_Element_Count (Res);

2005:       Item   : Ada.Streams.Stream_Element_Array;

2006:       Last   : out Ada.Streams.Stream_Element_Offset;

2019:       Item   : Ada.Streams.Stream_Element_Array;

2020:       Last   : out Ada.Streams.Stream_Element_Offset;

2035:       Item   : Ada.Streams.Stream_Element_Array;

2036:       Last   : out Ada.Streams.Stream_Element_Offset;

2083:       Count  : out Ada.Streams.Stream_Element_Count;

2129:          Count := Count + Ada.Streams.Stream_Element_Count (Res);

2302:    -- Stream --

2307:       Send_To : Sock_Addr_Type) return Stream_Access

2309:       S : Datagram_Socket_Stream_Access;

2312:       S        := new Datagram_Socket_Stream_Type;

2316:       return Stream_Access (S);

2317:    end Stream;

2320:    -- Stream --

2324:       S : Stream_Socket_Stream_Access;

2326:       S := new Stream_Socket_Stream_Type;

2328:       return Stream_Access (S);

2329:    end Stream;

2332:    -- Stream_Write --

2337:       Item   : Ada.Streams.Stream_Element_Array;

2340:       First : Ada.Streams.Stream_Element_Offset;

2341:       Index : Ada.Streams.Stream_Element_Offset;

2342:       Max   : constant Ada.Streams.Stream_Element_Offset := Item'Last;

2366:    end Stream_Write;

2590:      (Stream : in out Datagram_Socket_Stream_Type;

2591:       Item   : Ada.Streams.Stream_Element_Array)

2594:       Stream_Write (Stream.Socket, Item, To => Stream.To'Unrestricted_Access);

2602:      (Stream : in out Stream_Socket_Stream_Type;

2603:       Item   : Ada.Streams.Stream_Element_Array)

2606:       Stream_Write (Stream.Socket, Item, To => null);

32: with Ada.Streams;              use Ada.Streams;

76: class Stream {

20: //  The most important class here is Stream. This represents a YAML stream with

25: //  yaml::Stream stream(input, sm);

79:   Stream(StringRef Input, SourceMgr &, bool ShowColors = true,

82:   Stream(MemoryBufferRef InputBuffer, SourceMgr &, bool ShowColors = true,

84:   ~Stream();

506: /// \brief A YAML Stream is a sequence of Documents. A document contains a root

513:   Document(Stream &ParentStream);

532:   /// \brief Stream to read tokens from.

533:   Stream &stream;

564: /// \brief Iterator abstraction for Documents over a Stream.

583:       Stream &S = (*Doc)->stream;

161: class Stream {

163:     virtual ~Stream() {}

173: class SocketStream : public Stream {

308: class SSLSocketStream : public Stream {

1388: inline SocketStream::SocketStream(socket_t sock): sock_(sock)

1392: inline SocketStream::~SocketStream()

2221: inline SSLSocketStream::SSLSocketStream(socket_t sock, SSL* ssl)

2226: inline SSLSocketStream::~SSLSocketStream()

221:     bool process_request(Stream& strm, bool last_connection, bool& connection_close);

237:     void write_response(Stream& strm, bool last_connection, const Request& req, Response& res);

292:     bool process_request(Stream& strm, Request& req, Response& res, bool& connection_close);

301:     bool read_response_line(Stream& strm, Response& res);

302:     void write_request(Stream& strm, Request& req);

386:     stream_line_reader(Stream& strm, char* fixed_buffer, size_t fixed_buffer_size)

442:     Stream& strm_;

761: inline bool read_headers(Stream& strm, Headers& headers)

788: inline bool read_content_with_length(Stream& strm, std::string& out, size_t len, Progress progress)

808: inline bool read_content_without_length(Stream& strm, std::string& out)

824: inline bool read_content_chunked(Stream& strm, std::string& out)

870: bool read_content(Stream& strm, T& x, Progress progress = Progress())

890: inline void write_headers(Stream& strm, const T& info)

1358: inline void Stream::write_format(const char* fmt, const Args& ...args)

1539: inline void Server::write_response(Stream& strm, bool last_connection, const Request& req, Response& res)

1750: inline bool Server::process_request(Stream& strm, bool last_connection, bool& connection_close)

1837:         [this](Stream& strm, bool last_connection, bool& connection_close) {

1881: inline bool Client::read_response_line(Stream& strm, Response& res)

1917: inline void Client::write_request(Stream& strm, Request& req)

1964: inline bool Client::process_request(Stream& strm, Request& req, Response& res, bool& connection_close)

2001:         [&](Stream& strm, bool /*last_connection*/, bool& connection_close) {

2292:         [this](Stream& strm, bool last_connection, bool& connection_close) {

2325:         [&](Stream& strm, bool /*last_connection*/, bool& connection_close) {

175:     SocketStream(socket_t sock);

176:     virtual ~SocketStream();

310:     SSLSocketStream(socket_t sock, SSL* ssl);

311:     virtual ~SSLSocketStream();

510:             SocketStream strm(sock);

522:         SocketStream strm(sock);

1396: inline int SocketStream::read(char* ptr, size_t size)

1401: inline int SocketStream::write(const char* ptr, size_t size)

1406: inline int SocketStream::write(const char* ptr)

1411: inline std::string SocketStream::get_remote_addr() {

2179:             SSLSocketStream strm(sock, ssl);

2191:         SSLSocketStream strm(sock, ssl);

2230: inline int SSLSocketStream::read(char* ptr, size_t size)

2235: inline int SSLSocketStream::write(const char* ptr, size_t size)

2240: inline int SSLSocketStream::write(const char* ptr)

2245: inline std::string SSLSocketStream::get_remote_addr() {

143:         Stream = 1 // Not currently supported in the Unity Plugin.

157:   var Stream = require("stream").Stream

159:   var Stream = function () {}

249:   return Stream.prototype.on.call(me, ev, handler)

167: function createStream (strict, opt) {

174:   Stream.apply(this)

213: SAXStream.prototype = Object.create(Stream.prototype,

6: sax.SAXStream = SAXStream

7: sax.createStream = createStream

168:   return new SAXStream(strict, opt)

171: function SAXStream (strict, opt) {

172:   if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)

214:   { constructor: { value: SAXStream } })

216: SAXStream.prototype.write = function (data) {

232: SAXStream.prototype.end = function (chunk) {

238: SAXStream.prototype.on = function (ev, handler) {

1521: Stream::Stream(StringRef Input, SourceMgr &SM)

1524: Stream::Stream(MemoryBufferRef InputBuffer, SourceMgr &SM)

1527: Stream::~Stream() {}

496:   bool IsStartOfStream;

113:     TK_StreamStart,

114:     TK_StreamEnd,

997: bool Scanner::scanStreamStart() {

1010: bool Scanner::scanStreamEnd() {

555:       OS << "Stream-Start: ";

558:       OS << "Stream-End: ";

1529: bool Stream::failed() { return scanner->failed(); }

1531: void Stream::printError(Node *N, const Twine &Msg) {

1538: document_iterator Stream::begin() {

1542:   // Skip Stream-Start.

1549: document_iterator Stream::end() {

1553: void Stream::skip() {

2011: Document::Document(Stream &S) : stream(S), Root(nullptr) {

554:     case Token::TK_StreamStart:

557:     case Token::TK_StreamEnd:

621:     if (T.Kind == Token::TK_StreamEnd)

634:     if (T.Kind == Token::TK_StreamEnd)

721:   IsStartOfStream = true;

998:   IsStartOfStream = false;

1003:   T.Kind = Token::TK_StreamStart;

1022:   T.Kind = Token::TK_StreamEnd;

1430:   if (IsStartOfStream)

1985:     case Token::TK_StreamEnd:

2030:   if (T.Kind == Token::TK_StreamEnd)

2138:   case Token::TK_StreamEnd:

424:   bool scanStreamStart();

427:   bool scanStreamEnd();

1431:     return scanStreamStart();

1436:     return scanStreamEnd();

585: 	Stream           *bool   `protobuf:"varint,2,opt,name=stream" json:"stream,omitempty"`

775: 	Stream       *bool                       `protobuf:"varint,8,opt,name=stream" json:"stream,omitempty"`

602: func (m *RpbListBucketsReq) GetStream() bool {

843: func (m *RpbIndexReq) GetStream() bool {

603: 	if m != nil && m.Stream != nil {

604: 		return *m.Stream

844: 	if m != nil && m.Stream != nil {

845: 		return *m.Stream

175:     llvm::BitstreamWriter &Stream;

215:   llvm::BitstreamWriter &Stream;

174:   class StreamSubBlockGuard {

178:     StreamSubBlockGuard(llvm::BitstreamWriter &Stream_, BlockId ID)

188:     ~StreamSubBlockGuard() { Stream.ExitBlock(); }

142:   ClangDocBitcodeWriter(llvm::BitstreamWriter &Stream) : Stream(Stream) {

179:         : Stream(Stream_) {

182:       Stream.EnterSubblock(ID, BitCodeConstants::SubblockIDSize);

185:     StreamSubBlockGuard(const StreamSubBlockGuard &) = delete;

186:     StreamSubBlockGuard &operator=(const StreamSubBlockGuard &) = delete;

101:   llvm::BitstreamWriter &Stream;

789:   llvm::BitstreamWriter Stream;

517:   ASTWriter(llvm::BitstreamWriter &Stream);

126: typedef struct Stream {

132: } Stream;

102: typedef struct SharedStream {

110: } SharedStream;

364: closeStream(Stream *stream, jboolean linger)

404: createStream(char *name, Stream *stream)

444: openStream(Stream *stream)

135:  * Values for Stream.state field above.

142:  * This catches a freed Stream as long as the memory page is still

153:     Stream incoming;

154:     Stream outgoing;

282: leaveMutex(Stream *stream)

289: enterMutex(Stream *stream, sys_event_t event)

311: waitForSpace(SharedMemoryConnection *connection, Stream *stream)

329: signalSpace(Stream *stream)

339: waitForData(SharedMemoryConnection *connection, Stream *stream)

357: signalData(Stream *stream)

942:     Stream *stream = &connection->outgoing;

967:     Stream *stream = &connection->incoming;

992:     Stream *stream = &connection->outgoing;

1064:     Stream *stream = &connection->incoming;

117:     SharedStream toClient;

118:     SharedStream toServer;

130:     SharedStream *shared;

420:         (void)closeStream(stream, JNI_FALSE);

428:         (void)closeStream(stream, JNI_FALSE);

454:         (void)closeStream(stream, JNI_FALSE);

462:         (void)closeStream(stream, JNI_FALSE);

504:     (void)closeStream(&connection->outgoing, JNI_TRUE);

505:     (void)closeStream(&connection->incoming, JNI_FALSE);

556:     error = openStream(&connection->incoming);

562:     error = openStream(&connection->outgoing);

624:     error = createStream(streamName, &connection->incoming);

632:     error = createStream(streamName, &connection->outgoing);

943:     SharedStream *shared = stream->shared;

968:     SharedStream *shared = stream->shared;

993:     SharedStream *shared = stream->shared;

1065:     SharedStream *shared = stream->shared;

166: type Stream struct {

556: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)

562: 	CloseStream(stream *Stream, err error)

687: type StreamError struct {

431: 	MaxStreams            uint32

593: 	HandleStreams(func(*Stream), func(context.Context, string) context.Context)

675: 	errStreamDrain = streamErrorf(codes.Unavailable, "the connection is draining")

678: 	errStreamDone = errors.New("the stream is done")

165: // Stream represents an RPC in the transport layer.

168: 	st           ServerTransport    // nil for client side Stream

170: 	cancel       context.CancelFunc // always nil for client side Stream

212: func (s *Stream) isHeaderSent() bool {

218: func (s *Stream) updateHeaderSent() bool {

222: func (s *Stream) swapState(st streamState) streamState {

226: func (s *Stream) compareAndSwapState(oldState, newState streamState) bool {

230: func (s *Stream) getState() streamState {

234: func (s *Stream) waitOnHeader() error {

250: func (s *Stream) RecvCompress() string {

258: func (s *Stream) SetSendCompress(str string) {

264: func (s *Stream) Done() <-chan struct{} {

271: func (s *Stream) Header() (metadata.MD, error) {

290: func (s *Stream) Trailer() metadata.MD {

297: func (s *Stream) ServerTransport() ServerTransport {

306: func (s *Stream) ContentSubtype() string {

311: func (s *Stream) Context() context.Context {

316: func (s *Stream) Method() string {

323: func (s *Stream) Status() *status.Status {

330: func (s *Stream) SetHeader(md metadata.MD) error {

346: func (s *Stream) SendHeader(md metadata.MD) error {

354: func (s *Stream) SetTrailer(md metadata.MD) error {

367: func (s *Stream) write(m recvMsg) {

372: func (s *Stream) Read(p []byte) (n int, err error) {

381: // tranportReader reads all the data available for this Stream from the transport and

404: func (s *Stream) BytesReceived() bool {

410: func (s *Stream) Unprocessed() bool {

414: // GoString is implemented by Stream so context.String() won't

416: func (s *Stream) GoString() string {

553: 	Write(s *Stream, hdr []byte, data []byte, opts *Options) error

555: 	// NewStream creates a Stream for an RPC.

590: // Write methods for a given Stream will be called serially.

597: 	WriteHeader(s *Stream, md metadata.MD) error

601: 	Write(s *Stream, hdr []byte, data []byte, opts *Options) error

605: 	WriteStatus(s *Stream, st *status.Status) error

160: 	streamWriteDone             // EndStream sent

161: 	streamReadDone              // EndStream received

558: 	// CloseStream clears the footprint of a stream when the stream is

560: 	// CloseStream is called. Must be called when a stream is finished

625: // streamErrorf creates an StreamError with the specified error code and description.

626: func streamErrorf(c codes.Code, format string, a ...interface{}) StreamError {

627: 	return StreamError{

684: // TODO: See if we can replace StreamError with status package errors.

686: // StreamError is an error that only affects one stream within a connection.

692: func (e StreamError) Error() string {

592: 	// HandleStreams receives incoming streams using the given handler.

672: 	// errStreamDrain indicates that the stream is rejected because the

676: 	// errStreamDone is returned from write at the client side to indiacte application

709: HH_INLINE void Stream(const V128<T>& v, T* const HH_RESTRICT to) {

712: HH_INLINE void Stream(const V128<float>& v, float* const HH_RESTRICT to) {

715: HH_INLINE void Stream(const V128<double>& v, double* const HH_RESTRICT to) {

167: type Stream struct {

339: func newContextWithStream(ctx context.Context, stream *Stream) context.Context {

344: func StreamFromContext(ctx context.Context) (s *Stream, ok bool) {

454: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)

460: 	CloseStream(stream *Stream, err error)

562: type StreamError struct {

361: 	MaxStreams   uint32

482: 	HandleStreams(func(*Stream), func(context.Context, string) context.Context)

558: 	ErrStreamDrain = streamErrorf(codes.Unavailable, "the server stops accepting new RPCs")

166: // Stream represents an RPC in the transport layer.

169: 	// nil for client side Stream.

178: 	// cancel is always nil for client side Stream.

220: func (s *Stream) RecvCompress() string {

225: func (s *Stream) SetSendCompress(str string) {

231: func (s *Stream) Done() <-chan struct{} {

237: func (s *Stream) GoAway() <-chan struct{} {

244: func (s *Stream) Header() (metadata.MD, error) {

258: func (s *Stream) Trailer() metadata.MD {

266: func (s *Stream) ServerTransport() ServerTransport {

271: func (s *Stream) Context() context.Context {

276: func (s *Stream) Method() string {

281: func (s *Stream) StatusCode() codes.Code {

286: func (s *Stream) StatusDesc() string {

292: func (s *Stream) SetHeader(md metadata.MD) error {

307: func (s *Stream) SetTrailer(md metadata.MD) error {

317: func (s *Stream) write(m recvMsg) {

321: // Read reads all the data available for this Stream from the transport and

325: func (s *Stream) Read(p []byte) (n int, err error) {

334: // The key to save transport.Stream in the context.

345: 	s, ok = ctx.Value(streamKey{}).(*Stream)

451: 	Write(s *Stream, data []byte, opts *Options) error

453: 	// NewStream creates a Stream for an RPC.

479: // Write methods for a given Stream will be called serially.

486: 	WriteHeader(s *Stream, md metadata.MD) error

490: 	Write(s *Stream, data []byte, opts *Options) error

495: 	WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error

161: 	streamWriteDone             // EndStream sent

162: 	streamReadDone              // EndStream received

337: // newContextWithStream creates a new context from ctx and attaches stream

343: // StreamFromContext returns the stream saved in ctx.

456: 	// CloseStream clears the footprint of a stream when the stream is

458: 	// CloseStream is called. Must be called when a stream is finished

509: // streamErrorf creates an StreamError with the specified error code and description.

510: func streamErrorf(c codes.Code, format string, a ...interface{}) StreamError {

511: 	return StreamError{

561: // StreamError is an error that only affects one stream within a connection.

567: func (e StreamError) Error() string {

571: // ContextErr converts the error from context package into a StreamError.

572: func ContextErr(err error) StreamError {

583: // If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err.

585: // it return the StreamError for ctx.Err.

145: 		return 0, ErrStreamDrain

249: 		return nil, ErrStreamDrain

481: 	// HandleStreams receives incoming streams using the given handler.

556: 	// ErrStreamDrain indicates that the stream is rejected by the server because

586: // If it receives from goAway, it returns 0, ErrStreamDrain.

602: 		return 0, ErrStreamDrain

229:   function Stream() {

26:     var stream = new Stream();

40:       var master = callback ? new Stub(callback) : new Stream();

233:   Stream.prototype.flush = function() {

252:   Stream.prototype.emit = function(type, data) {

260:   Stream.prototype.on = function(type, callback) {

269:     llvm::BitstreamWriter Stream;

259:         : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),

325:                         llvm::BitstreamWriter &Stream,

329:   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);

340:   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);

345:                          llvm::BitstreamWriter &Stream,

353:   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);

401:   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,

412:   State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),

419:   State->Stream.Emit((unsigned)'D', 8);

420:   State->Stream.Emit((unsigned)'I', 8);

421:   State->Stream.Emit((unsigned)'A', 8);

422:   State->Stream.Emit((unsigned)'G', 8);

442:   State->Stream.EnterBlockInfoBlock(3);

445:   llvm::BitstreamWriter &Stream = State->Stream;

453:   EmitBlockID(BLOCK_META, "Meta", Stream, Record);

454:   EmitRecordID(RECORD_VERSION, "Version", Stream, Record);

458:   Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));

464:   EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);

465:   EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);

466:   EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);

467:   EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);

468:   EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);

469:   EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);

470:   EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);

481:   Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));

489:   Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));

496:               Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));

504:   Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,

515:   Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,

524:   Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,

527:   Stream.ExitBlock();

531:   llvm::BitstreamWriter &Stream = State->Stream;

534:   Stream.EnterSubblock(BLOCK_META, 3);

536:   Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);

537:   Stream.ExitBlock();

548:   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,

578:     State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),

653:   llvm::BitstreamWriter &Stream = State->Stream;

675:   Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);

690:   State->Stream.EnterSubblock(BLOCK_DIAG, 4);

694:   State->Stream.ExitBlock();

714:   llvm::BitstreamWriter &Stream = State->Stream;

734:     Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,

840:   Writer.State->Stream.EmitRecordWithAbbrev(

853:   Writer.State->Stream.EmitRecordWithBlob(

867:   Writer.State->Stream.EmitRecordWithBlob(

268:     /// \brief The BitStreamWriter for the serialized diagnostics.

6:   , Stream = require("stream").Stream

49: nopt.typeDefs.Stream = { type: Stream, validate: validateStream }

42: function validateStream (data, k, val) {

43:   if (!(val instanceof Stream)) return false

72:     case Stream:

73:       log.warn("invalid config", "Must be an instance of the Stream class")

272:   , logstream : Stream

98:   class Stream

457: class Stream_from_string : public Import::Stream

460:   Stream_from_string(const std::string& str)

487: class Stream_from_buffer : public Import::Stream

490:   Stream_from_buffer(char* buf, size_t length)

522: class Stream_from_file : public Import::Stream

551: class Stream_from_string_ref : public Import::Stream

554:   Stream_from_string_ref(const std::string& str, size_t offset, size_t length)

494:   ~Stream_from_buffer()

558:   ~Stream_from_string_ref()

96:   // The Stream class is an interface used to read the data.  The

101:     Stream();

102:     virtual ~Stream();

201:   // returns a pointer to a Stream object to read the data that it

204:   static Stream*

209:   Import(Stream*, Location);

268:   // Stream position, for error reporting.

339:   static Stream*

345:   static Stream*

348:   static Stream*

357:   static Stream*

431:   Stream* stream_;

525:   Stream_from_file(int fd);

527:   ~Stream_from_file();

538:   Stream_from_file(const Stream_from_file&);

539:   Stream_from_file& operator=(const Stream_from_file&);

2867:   raw_ostream &Stream;

2863:   ScopInfoPrinterPass(raw_ostream &OS) : Stream(OS) {}

218:         Stream,

28: class Stream {

50: Stream::Stream(AAudioStream *stream)

59: Stream::~Stream() {

45:     AAudioStream *mAAStream;

109: class StreamBuilder {

147: StreamBuilder::StreamBuilder(AAudioStreamBuilder *builder)

160: std::unique_ptr<Stream> StreamBuilder::makeStream() {

239:     std::unique_ptr<Stream> mStream;

344:     std::unique_ptr<Stream> mStream;

152: StreamBuilder::~StreamBuilder() {

171: std::unique_ptr<StreamBuilder> makeStreamBuilder() {

30:     explicit Stream(AAudioStream *stream);

31:     Stream(const Stream&) = delete;

32:     Stream& operator=(const Stream&) = delete;

33:     ~Stream();

66: int Stream::getSamplingRateHz() {

70: ssize_t Stream::read(AudioBufferView<sample_t> buffer) {

81: bool Stream::setBufferFrameCount(int numFrames) {

90: bool Stream::start() {

99: bool Stream::stop() {

116:     std::unique_ptr<Stream> makeStream();

168:     return std::unique_ptr<Stream>(new Stream(stream));

52:           mAAStream(stream),

60:     aaudio_result_t result = mAAudio->stream_close(mAAStream);

67:     return mAAudio->stream_getSampleRate(mAAStream);

73:             mAAStream, buffer.getData(), buffer.getFrameCount(), 0 /* timeout */);

82:     aaudio_result_t result = mAAudio->stream_setBufferSize(mAAStream, numFrames);

91:     aaudio_result_t result = mAAudio->stream_requestStart(mAAStream);

100:     aaudio_result_t result = mAAudio->stream_requestStop(mAAStream);

111:     explicit StreamBuilder(AAudioStreamBuilder *builder);

112:     StreamBuilder(const StreamBuilder&) = delete;

113:     StreamBuilder& operator=(const StreamBuilder&) = delete;

114:     ~StreamBuilder();

117:     void setCallbacks(AAudioStream_dataCallback dataCb,

118:             AAudioStream_errorCallback errorCb,

161:     AAudioStream *stream = nullptr;

162:     aaudio_result_t result = mAAudio->builder_openStream(mAABuilder, &stream);

179:     return std::unique_ptr<StreamBuilder>(new StreamBuilder(builder));

228:     static aaudio_data_callback_result_t aaudioDataCallback(AAudioStream *stream,

232:     static void aaudioErrorCallback(AAudioStream *stream,

236:     std::unique_ptr<StreamBuilder> createBuilder(PerformanceMode performanceMode);

244: std::unique_ptr<StreamBuilder> Player::createBuilder(PerformanceMode performanceMode) {

245:     std::unique_ptr<StreamBuilder> builder = makeStreamBuilder();

259:     std::unique_ptr<StreamBuilder> builder = createBuilder(performanceMode);

261:     mStream = builder->makeStream();

262:     if (!mStream) return false;

263:     *samplingRate = mStream->getSamplingRateHz();

265:             mStream->getFramesPerBurst(), MINIMUM_STREAM_BUFFER_SIZE_MS, *samplingRate);

273:     std::unique_ptr<StreamBuilder> builder = createBuilder(testCtx->getPerformanceMode());

278:     mStream = builder->makeStream();

279:     if (!mStream) return false;

280:     mStream->setBufferFrameCount(testCtx->getFrameCount());

283:     return mStream->start();

287:     if (mStream) {

288:         mStream->stop();

289:         mStream.reset();

293: aaudio_data_callback_result_t Player::aaudioDataCallback(AAudioStream* /*stream*/,

307:                     numFrames, self->mStream->getChannelCount()));

312: void Player::aaudioErrorCallback(AAudioStream* /*stream*/,

341:     std::unique_ptr<StreamBuilder> createBuilder(PerformanceMode performanceMode);

348: std::unique_ptr<StreamBuilder> Recorder::createBuilder(PerformanceMode performanceMode) {

349:     std::unique_ptr<StreamBuilder> builder = makeStreamBuilder();

362:     std::unique_ptr<StreamBuilder> builder = createBuilder(performanceMode);

364:     mStream = builder->makeStream();

365:     if (!mStream) return false;

366:     *samplingRate = mStream->getSamplingRateHz();

368:             mStream->getFramesPerBurst(), MINIMUM_STREAM_BUFFER_SIZE_MS, *samplingRate);

374:     std::unique_ptr<StreamBuilder> builder = createBuilder(testCtx->getPerformanceMode());

378:     mStream = builder->makeStream();

379:     if (!mStream) return false;

380:     if (mStream->getChannelCount() != mTestCtx->getChannelCount()) {

382:                         mTestCtx->getFrameCount(), mStream->getChannelCount()));

384:     mStream->setBufferFrameCount(testCtx->getFrameCount());

385:     return mStream->start();

390:     AudioBuffer<sample_t> drainBuffer(mStream->getFramesPerBurst(), mStream->getChannelCount());

393:         framesRead = mStream->read(drainBuffer);

401:         return mStream->read(buffer);

403:         ssize_t result = mStream->read(mConversionBuffer->getView(0, buffer.getFrameCount()));

413:     if (mStream) {

414:         mStream->stop();

415:         mStream.reset();

144:     AAudioStreamBuilder *mAABuilder;

172:     AAudioStreamBuilder *builder = nullptr;

173:     aaudio_result_t result = AAudioLoader::getInstance()->createStreamBuilder(&builder);

330: 	u8     Stream;             /* Stream number (UVI1, UVI2, TVOUT) */

556: 	u8  Stream;

658: 	u8                    Stream;

444: 		struct FW_STREAM_CONTROL         StreamControl;

534: 	StreamMode_NONE   = 0, /* Stream not used */

535: 	StreamMode_ANALOG = 1, /* Analog: Stream 0,1 = Video, 2,3 = Audio */

536: 	StreamMode_TSIN   = 2, /* Transport stream input (all) */

537: 	StreamMode_HDTV   = 4, /* HDTV: Maximum 1920x1080p30,1920x1080i60

539: 	StreamMode_TSOUT  = 8, /* Transport stream output (only stream 3) */

165: 	u32 Clock;           /* Stream time in 100ns units */

322: /* Meaning of FW_STREAM_CONTROL::Stream bits:

42: var Stream = require('./internal/streams/stream');

90: var createReadableStreamAsyncIterator;

92: require('inherits')(Readable, Stream);

170:   if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside

183:   Stream.call(this);

786:   var res = Stream.prototype.on.call(this, ev, fn);

816:   var res = Stream.prototype.removeListener.call(this, ev, fn);

832:   var res = Stream.prototype.removeAllListeners.apply(this, arguments);

991:     if (createReadableStreamAsyncIterator === undefined) {

992:       createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');

995:     return createReadableStreamAsyncIterator(this);

334: 	u8     Stream;             /* Stream number (UVI1, UVI2, TVOUT) */

560: 	u8  Stream;

662: 	u8                    Stream;

448: 		struct FW_STREAM_CONTROL         StreamControl;

538: 	StreamMode_NONE   = 0, /* Stream not used */

539: 	StreamMode_ANALOG = 1, /* Analog: Stream 0,1 = Video, 2,3 = Audio */

540: 	StreamMode_TSIN   = 2, /* Transport stream input (all) */

541: 	StreamMode_HDTV   = 4, /* HDTV: Maximum 1920x1080p30,1920x1080i60

543: 	StreamMode_TSOUT  = 8, /* Transport stream output (only stream 3) */

169: 	u32 Clock;           /* Stream time in 100ns units */

326: /* Meaning of FW_STREAM_CONTROL::Stream bits:

54:   var Stream = xpath.Stream = function Stream(str) {

62:   Stream.prototype = {

177:     Stream.prototype.re = re;

178:     Stream.prototype.startsWithNcNameRe = new RegExp('^' + ncNameChars);

179:     Stream.prototype.isQnameRe = new RegExp('^' + qNameChars + '$');

180:     Stream.prototype.isNumberRe = new RegExp('^' + numberChars + '$');

1667:     var stream = new Stream(expr);

1702:     var stream = new Stream(expression);

29:         class Stream

197:           class RestartStream < StandardError; end

41:           # @private Create an empty Subscriber::Stream object.

302:             # A Stream will only ever have one background thread. If the thread

59:                 push Google::Cloud::PubSub::V1::StreamingPullRequest.new

219:             # Call the StreamingPull API to get the response enumerator

264:             raise RestartStream unless synchronize { @stopped }

275:           rescue RestartStream

340:             Google::Cloud::PubSub::V1::StreamingPullRequest.new.tap do |req|

247:     static class Stream {

259:         public Stream(String streamName, ZkClient zkClient) throws Exception {

191:     private static void showStreamsStatus(List<Stream> streams) {

267:         private void readStreamFromZk() throws Exception {

52:         List<Stream> streamStatus = new ArrayList<Stream>();

95:                         Stream stream = new Stream(streamName, zkClient);

192:         System.out.println("Stream Status");

198:         for (Stream stream : streams) {

119:             showStreamsStatus(streamStatus);

264:             readStreamFromZk();

141:   var Stream = require("stream").Stream

143:   var Stream = function () {}

221:   return Stream.prototype.on.call(me, ev, handler)

151: function createStream (strict, opt) {

158:   Stream.apply(me)

195: SAXStream.prototype = Object.create(Stream.prototype,

6: sax.SAXStream = SAXStream

7: sax.createStream = createStream

152:   return new SAXStream(strict, opt)

155: function SAXStream (strict, opt) {

156:   if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)

196:   { constructor: { value: SAXStream } })

198: SAXStream.prototype.write = function (data) {

204: SAXStream.prototype.end = function (chunk) {

210: SAXStream.prototype.on = function (ev, handler) {

9:   , Stream = require("stream").Stream

21:   , Stream  : { type: Stream,  validate: validateStream  }

169: function validateStream (data, k, val) {

170:   if (!(val instanceof Stream)) return false

68: 	Stream    string

349: func (m *EventMetrics) GetEventStream(name string) *EventStream {

348: // GetEventStream returns an EventStream instance.

352: 	return &EventStream{

76: type Stream struct {

85: func NewStream(w io.Writer) *Stream {

75: // Stream writes logs of requests and responses to a writer.

82: // NewStream initializes a Stream with an io.Writer to log requests and

86: 	s := &Stream{

97: func (s *Stream) loop() {

111: // Close signals Stream to stop listening for frames in the log loop and stop writing logs.

112: func (s *Stream) Close() error {

127: func (s *Stream) sendHeader(id string, mt MessageType, key, value string) {

140: func (s *Stream) sendData(id string, mt MessageType, i uint32, terminal bool, b []byte, bl int) {

155: // LogRequest writes an http.Request to Stream with an id unique for the request / response pair.

156: func (s *Stream) LogRequest(id string, req *http.Request) error {

190: // LogResponse writes an http.Response to Stream with an id unique for the request / response pair.

191: func (s *Stream) LogResponse(id string, res *http.Response) error {

223: 	s     *Stream

169: 	enum {  Accept, File, Stream, Timer, Wait, Free, Null  } type;

126: typedef struct evStream {