Found 181404 results in 22364 files, showing top 50 files (show more).
skia.googlesource.com/third_party/poppler:poppler/Stream.h: [ master, ]
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];
github.com/sparkfun/Arduino_Boards:sparkfun/samd/cores/arduino/Stream.h: [ master, ]
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
github.com/sparkfun/Arduino_Boards:sparkfun/samd/cores/arduino51/Stream.h: [ master, ] Duplicate result
android.googlesource.com/platform/frameworks/ex:framesequence/jni/Stream.h: [ master, ]
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);
github.com/sparkfun/BadgerStick:badgerstick/avr/cores/arduino/Stream.h: [ master, ]
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
github.com/sparkfun/PSoC_Arduino_Support:Hardware/SparkFun/psoc/cores/arduino/Stream.h: [ master, ]
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
github.com/google/gulava:java/gulava/Stream.java: [ master, ]
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();
github.com/sparkfun/Arduino_Apollo3:cores/arduino/ard_sup/ard_supers/Stream.h: [ master, ] Duplicate result
github.com/apache/accumulo-testing:src/main/java/org/apache/accumulo/testing/stress/Stream.java: [ master, ]
26: public abstract class Stream<T> implements Iterator<T> {
github.com/sparkfun/MaKeyMaKey:firmware/Arduino/hardware/MaKeyMaKey/cores/arduino/Stream.h: [ master, ]
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
android.googlesource.com/platform/external/arduino:hardware/arduino/cores/arduino/Stream.h: [ master, ]
26: class Stream : public Print
21: #define Stream_h
2:   Stream.h - base class for character-based streams.
20: #ifndef Stream_h
github.com/google/highwayhash:highwayhash/vector256.h: [ master, ]
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) {
android.googlesource.com/platform/frameworks/compile/libbcc:bcinfo/BitReader_2_7/BitcodeReader.cpp: [ master, ]
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));
go.googlesource.com/grpc-review:transport/transport.go: [ master, ]
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.
android.googlesource.com/platform/superproject:external/mesa3d/include/D3D9/d3d9types.h: [ master, ]
1751:     WORD Stream;
android.googlesource.com/platform/external/mesa3d:include/D3D9/d3d9types.h: [ master, ] Duplicate result
chromium.googlesource.com/native_client/pnacl-gcc:gcc/ada/g-socket.adb: [ master, ]
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;
android.googlesource.com/platform/external/swiftshader:third_party/llvm-subzero/include/llvm/Support/YAMLParser.h: [ master, ]
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;
chromium.googlesource.com/crashpad/crashpad:third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ]
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() {
github.com/playgameservices/play-games-plugin-for-unity:source/PluginDev/Assets/GooglePlayGames/BasicApi/CommonTypes.cs: [ master, ]
143:         Stream = 1 // Not currently supported in the Unity Plugin.
android.googlesource.com/platform/external/cherry:third_party/sax/lib/sax.js: [ master, ]
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) {
chromium.googlesource.com/native_client/pnacl-llvm:lib/Support/YAMLParser.cpp: [ master, ]
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();
github.com/apache/trafficcontrol:traffic_ops/vendor/github.com/basho/riak-go-client/rpb/riak_kv/riak_kv.pb.go: [ master, ]
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
github.com/llvm-mirror/clang-tools-extra:clang-doc/BitcodeWriter.h: [ master, ]
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;
android.googlesource.com/platform/external/clang_35a:include/clang/Serialization/ASTWriter.h: [ master, ]
101:   llvm::BitstreamWriter &Stream;
789:   llvm::BitstreamWriter Stream;
517:   ASTWriter(llvm::BitstreamWriter &Stream);
android.googlesource.com/platform/external/jetbrains/JetBrainsRuntime:src/jdk.jdi/share/native/libdt_shmem/shmemBase.c: [ master, ]
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;
android.googlesource.com/platform/superproject:external/syzkaller/vendor/google.golang.org/grpc/transport/transport.go: [ master, ]
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
github.com/google/highwayhash:highwayhash/vector128.h: [ master, ]
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) {
go.googlesource.com/perf:vendor/google.golang.org/grpc/transport/transport.go: [ master, ]
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
github.com/apache/falcon:falcon-ui/app/js/lib/dust-full-2.0.0.min.js: [ master, ]
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) {
android.googlesource.com/platform/external/clang:lib/Frontend/SerializedDiagnosticPrinter.cpp: [ master, ]
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.
github.com/google/shipshape:third_party/node/lib/node_modules/npm/node_modules/npmconf/config-defs.js: [ master, ]
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
go.googlesource.com/gofrontend:go/import.h: [ master, ]
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&);
github.com/llvm-mirror/polly:include/polly/ScopInfo.h: [ master, ]
2867:   raw_ostream &Stream;
2863:   ScopInfoPrinterPass(raw_ostream &OS) : Stream(OS) {}
android.googlesource.com/platform/external/jmonkeyengine:engine/src/core/com/jme3/scene/VertexBuffer.java: [ master, ]
218:         Stream,
android.googlesource.com/platform/external/drrickorang:LoopbackApp/app/src/main/cpp/lb2/sound_system_aaudio.cpp: [ master, ]
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);
github.com/google/capsicum-linux:drivers/media/pci/ngene/ngene.h: [ capsicum, ]
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:
chromium.googlesource.com/devtools/devtools-frontend:node_modules/readable-stream/lib/_stream_readable.js: [ master, ]
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);
github.com/apache/cordova-blackberry:node_modules/xml2js/node_modules/sax/lib/sax.js: [ master, ] Duplicate result
github.com/google/ktsan:drivers/media/pci/ngene/ngene.h: [ tsan, ]
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:
github.com/chromium/crashpad:third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ] Duplicate result
github.com/googlearchive/todomvc-mongodb:node_modules/angular/node_modules/jsdom/lib/jsdom/level3/xpath.js: [ master, ]
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);
github.com/googleapis/google-cloud-ruby:google-cloud-pubsub/lib/google/cloud/pubsub/subscriber/stream.rb: [ master, ]
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|
github.com/apache/incubator-retired-s4:subprojects/s4-tools/src/main/java/org/apache/s4/tools/Status.java: [ piper, ]
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();
github.com/apache/cordova-blackberry:node_modules/elementtree/node_modules/sax/lib/sax.js: [ master, ]
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) {
github.com/apache/cordova-wp8:node_modules/nopt/lib/nopt.js: [ master, ]
9:   , Stream = require("stream").Stream
21:   , Stream  : { type: Stream,  validate: validateStream  }
169: function validateStream (data, k, val) {
170:   if (!(val instanceof Stream)) return false
skia.googlesource.com/buildbot:go/metrics2/events/events.go: [ master, ]
68: 	Stream    string
349: func (m *EventMetrics) GetEventStream(name string) *EventStream {
348: // GetEventStream returns an EventStream instance.
352: 	return &EventStream{
github.com/apache/cordova-ubuntu:node_modules/elementtree/node_modules/sax/lib/sax.js: [ master, ] Duplicate result
github.com/google/martian:marbl/marbl.go: [ master, ]
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
android.googlesource.com/platform/bionic:libc/upstream-netbsd/lib/libc/isc/eventlib_p.h: [ master, ]
169: 	enum {  Accept, File, Stream, Timer, Wait, Free, Null  } type;
126: typedef struct evStream {
143: } evStream;
141: 	struct evStream	*prevDone, *nextDone;
142: 	struct evStream	*prev, *next;
173: 		struct {  evStream *this;  }			stream;
250: 	/* Streams. */
251: 	evStream	*streams;
252: 	evStream	*strDone, *strLast;
127: 	evStreamFunc	func;