Found 447112 results in 50165 files, showing top 150 files (show more).
github.com/apache/storm:storm-client/src/jvm/org/apache/storm/trident/Stream.java: [ master, ]
98: public class Stream implements IAggregatableStream, ResourceDeclarer<Stream> {
103:     protected Stream(TridentTopology topology, String name, Node node) {
592:     private <T> Stream comparableAggregateStream(String inputFieldName, Aggregator<T> aggregator) {
807:     public Stream toStream() {
85:  * A Stream represents the core data model in Trident, and can be thought of as a "stream" of tuples that are p...(29 bytes skipped)...
115:     public Stream name(String name) {
116:         return new Stream(topology, name, node);
122:     public Stream parallelismHint(int hint) {
131:     public Stream setCPULoad(Number load) {
140:     public Stream setMemoryLoad(Number onHeap) {
149:     public Stream setMemoryLoad(Number onHeap, Number offHeap) {
155:     public Stream addSharedMemory(SharedMemory request) {
161:      * Filters out fields from a stream, resulting in a Stream containing only the fields specified by `keepFields`.
163:      * <p>For example, if you had a Stream `mystream` containing the fields `["a", "b", "c","d"]`, calling"
169:      * @param keepFields The fields in the Stream to keep
171:     public Stream project(Fields keepFields) {
192:     public Stream partitionBy(Fields fields) {
200:     public Stream partition(CustomStreamGrouping partitioner) {
209:     public Stream partition(Grouping grouping) {
222:     public Stream shuffle() {
231:     public Stream localOrShuffle() {
241:     public Stream global() {
252:     public Stream batchGlobal() {
263:     public Stream broadcast() {
270:     public Stream identityPartition() {
275:      * Applies an `Assembly` to this `Stream`.
279:     public Stream applyAssembly(Assembly assembly) {
284:     public Stream each(Fields inputFields, Function function, Fields functionFields) {
294:     public Stream each(Function function, Fields functionFields) {
298:     public Stream each(Fields inputFields, Filter filter) {
304:     public Stream partitionAggregate(Fields inputFields, Aggregator agg, Fields functionFields) {
314:     public Stream partitionAggregate(Aggregator agg, Fields functionFields) {
318:     public Stream partitionAggregate(CombinerAggregator agg, Fields functionFields) {
322:     public Stream partitionAggregate(Fields inputFields, CombinerAggregator agg, Fields functionFields) {
329:     public Stream partitionAggregate(ReducerAggregator agg, Fields functionFields) {
333:     public Stream partitionAggregate(Fields inputFields, ReducerAggregator agg, Fields functionFields) {
340:     public Stream stateQuery(TridentState state, Fields inputFields, QueryFunction function, Fields functionFields) {...(0 bytes skipped)...
352:     public Stream stateQuery(TridentState state, QueryFunction function, Fields functionFields) {
403:     public Stream filter(Filter filter) {
414:     public Stream filter(Fields inputFields, Filter filter) {
424:     public Stream map(MapFunction function) {
442:     public Stream map(MapFunction function, Fields outputFields) {
460:     public Stream flatMap(FlatMapFunction function) {
480:     public Stream flatMap(FlatMapFunction function, Fields outputFields) {
498:     public Stream peek(Consumer action) {
520:     public Stream minBy(String inputFieldName) {
535:     public <T> Stream minBy(String inputFieldName, Comparator<T> comparator) {
547:     public Stream min(Comparator<TridentTuple> comparator) {
560:     public Stream maxBy(String inputFieldName) {
575:     public <T> Stream maxBy(String inputFieldName, Comparator<T> comparator) {
587:     public Stream max(Comparator<TridentTuple> comparator) {
599:     public Stream aggregate(Aggregator agg, Fields functionFields) {
603:     public Stream aggregate(Fields inputFields, Aggregator agg, Fields functionFields) {
610:     public Stream aggregate(CombinerAggregator agg, Fields functionFields) {
614:     public Stream aggregate(Fields inputFields, CombinerAggregator agg, Fields functionFields) {
621:     public Stream aggregate(ReducerAggregator agg, Fields functionFields) {
625:     public Stream aggregate(Fields inputFields, ReducerAggregator agg, Fields functionFields) {
642:     public Stream tumblingWindow(int windowCount, WindowsStoreFactory windowStoreFactory,
657:     public Stream tumblingWindow(BaseWindowedBolt.Duration windowDuration, WindowsStoreFactory windowStoreFactory,
674:     public Stream slidingWindow(int windowCount, int slideCount, WindowsStoreFactory windowStoreFactory,
691:     public Stream slidingWindow(BaseWindowedBolt.Duration windowDuration, BaseWindowedBolt.Duration slidingInterval,
706:     public Stream window(WindowConfig windowConfig, Fields inputFields, Aggregator aggregator, Fields functionFields)...(2 bytes skipped)...
723:     public Stream window(WindowConfig windowConfig, WindowsStoreFactory windowStoreFactory, Fields inputFields,
728:     private Stream window(WindowConfig windowConfig, WindowsStoreFactory windowStoreFactory, Fields inputFields, Aggre...(17 bytes skipped)...
737:         Stream stream = topology.addSourcedNode(this,
748:         Stream effectiveStream = stream.project(functionFields);
830:     static class BatchGlobalAggScheme implements GlobalAggregationScheme<Stream> {
833:         public IAggregatableStream aggPartition(Stream s) {
844:     static class GlobalAggScheme implements GlobalAggregationScheme<Stream> {
847:         public IAggregatableStream aggPartition(Stream s) {
26: import org.apache.storm.trident.fluent.GroupedStream;
27: import org.apache.storm.trident.fluent.IAggregatableStream;
184:     public GroupedStream groupBy(Fields fields) {
186:         return new GroupedStream(this, fields);
522:         return comparableAggregateStream(inputFieldName, min);
537:         return comparableAggregateStream(inputFieldName, min);
549:         return comparableAggregateStream(null, min);
562:         return comparableAggregateStream(inputFieldName, max);
577:         return comparableAggregateStream(inputFieldName, max);
589:         return comparableAggregateStream(null, max);
756:         return effectiveStream;
21: import org.apache.storm.grouping.CustomStreamGrouping;
174:                 new ProcessorNode(topology.getUniqueStreamId(),
207: ...(17 bytes skipped)...thod takes in a custom partitioning function that implements {@link org.apache.storm.grouping.CustomStreamGrouping}
287:                 new ProcessorNode(topology.getUniqueStreamId(),
307:                 new ProcessorNode(topology.getUniqueStreamId(),
343:         Node n = new ProcessorNode(topology.getUniqueStreamId(),
363:         ProcessorNode n = new ProcessorNode(topology.getUniqueStreamId(),
427:                 new ProcessorNode(topology.getUniqueStreamId(),
445:                 new ProcessorNode(topology.getUniqueStreamId(),
463:                 new ProcessorNode(topology.getUniqueStreamId(),
483:                 new ProcessorNode(topology.getUniqueStreamId(),
501:                 new ProcessorNode(topology.getUniqueStreamId(),
738:                 new ProcessorNode(topology.getUniqueStreamId(),
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];
chromium.googlesource.com/native_client/pnacl-llvm:include/llvm/Bitcode/NaCl/NaClObjDumpStream.h: [ master, ]
925:   raw_ostream &Stream;
339:   raw_ostream &BaseStream;
343:   raw_string_ostream TextStream;
761: class ObjDumpStream {
788:   ~ObjDumpStream() { Flush(); }
939:   raw_string_ostream AssemblyStream;
943:   raw_string_ostream MessageStream;
952:   raw_string_ostream RecordStream;
207:   /// Base Stream. The viewing width is defined by LineWidth. The
521: inline raw_ostream &operator<<(raw_ostream &Stream,
526:   assert(&Stream == &Directive.GetFormatter().Tokens());
528:   return Stream;
780:   /// comments and errors into a single (user proved Stream).  When
786:   ObjDumpStream(raw_ostream &Stream, bool DumpRecords, bool DumpAssembly);
1: //===- NaClObjDumpStream.h --------------------------------------*- C++ -*-===//
210:   explicit TextFormatter(raw_ostream &BaseStream,
219:     return TextStream;
664: class ObjDumpStream;
670: /// The formatter used for dumping records in ObjDumpStream.
679:   explicit RecordTextFormatter(ObjDumpStream *ObjDump);
762:   ObjDumpStream(const ObjDumpStream&) = delete;
763:   void operator=(const ObjDumpStream&) = delete;
793:     return AssemblyStream;
799:     return RecordStream;
805:     return MessageStream;
skia.googlesource.com/third_party/poppler:poppler/Stream.cc: [ master, ]
106: Stream::Stream() {
113: Stream::~Stream() {
1270: ASCII85Stream::ASCII85Stream(Stream *strA):
1276: ASCII85Stream::~ASCII85Stream() {
360: OutStream::OutStream ()
364: OutStream::~OutStream ()
371: FileOutStream::FileOutStream (FILE* fa, Goffset startA)
377: FileOutStream::~FileOutStream ()
410: BaseStream::BaseStream(Object &&dictA, Goffset lengthA) {
415: BaseStream::~BaseStream() {
422: FilterStream::FilterStream(Stream *strA) {
426: FilterStream::~FilterStream() {
441: ImageStream::ImageStream(Stream *strA, int widthA, int nCompsA, int nBitsA) {
471: ImageStream::~ImageStream() {
564: StreamPredictor::StreamPredictor(Stream *strA, int predictorA,
762: FileStream::FileStream(GooFile* fileA, Goffset startA, GBool limitedA,
775: FileStream::~FileStream() {
783: Stream *FileStream::makeSubStream(Goffset startA, GBool limitedA,
853: CachedFileStream::CachedFileStream(CachedFile *ccA, Goffset startA,
867: CachedFileStream::~CachedFileStream()
878: Stream *CachedFileStream::makeSubStream(Goffset startA, GBool limitedA,
957: MemStream::MemStream(char *bufA, Goffset startA, Goffset lengthA, Object &&dictA):
967: MemStream::~MemStream() {
977: Stream *MemStream::makeSubStream(Goffset startA, GBool limited,
1040: EmbedStream::EmbedStream(Stream *strA, Object &&dictA,
1057: EmbedStream::~EmbedStream() {
1067: Stream *EmbedStream::makeSubStream(Goffset start, GBool limitedA,
1178: ASCIIHexStream::ASCIIHexStream(Stream *strA):
1184: ASCIIHexStream::~ASCIIHexStream() {
1351: LZWStream::LZWStream(Stream *strA, int predictor, int columns, int colors,
1369: LZWStream::~LZWStream() {
1563: RunLengthStream::RunLengthStream(Stream *strA):
1569: RunLengthStream::~RunLengthStream() {
1647: CCITTFaxStream::CCITTFaxStream(Stream *strA, int encodingA, GBool endOfLineA,
1686: CCITTFaxStream::~CCITTFaxStream() {
2499: DCTStream::DCTStream(Stream *strA, int colorXformA, Dict *dict, int recursion):
2528: DCTStream::~DCTStream() {
4569: FlateStream::FlateStream(Stream *strA, int predictor, int columns,
4586: FlateStream::~FlateStream() {
5036: EOFStream::EOFStream(Stream *strA):
5040: EOFStream::~EOFStream() {
5048: BufStream::BufStream(Stream *strA, int bufSizeA): FilterStream(strA) {
5053: BufStream::~BufStream() {
591: StreamPredictor::~StreamPredictor() {
3: // Stream.cc
65: #include "Stream.h"
67: #include "JBIG2Stream.h"
68: #include "Stream-CCITT.h"
80: #include "JPEG2000Stream.h"
103: // Stream (base class)
119: int Stream::incRef() {
125: int Stream::decRef() {
131: void Stream::close() {
134: int Stream::getRawChar() {
139: int Stream::getChars(int nChars, Guchar *buffer) {
144: void Stream::getRawChars(int nChars, int *buffer) {
148: char *Stream::getLine(char *buf, int size) {
169: GooString *Stream::getPSFilter(int psLevel, const char *indent) {
173: Stream *Stream::addFilters(Dict *dict, int recursion) {
176:   Stream *str;
211: Stream *Stream::makeFilter(char *name, Stream *str, Object *params, int recursion, Dict *dict) {
224:     str = new ASCII85Stream(str);
336:     str = new JBIG2Stream(str, &globals, &obj);
1267: // ASCII85Stream
1280: void ASCII85Stream::reset() {
1286: int ASCII85Stream::lookChar() {
1330: GooString *ASCII85Stream::getPSFilter(int psLevel, const char *indent) {
1343: GBool ASCII85Stream::isBinary(GBool last) {
5094: FixedLengthEncoder::FixedLengthEncoder(Stream *strA, int lengthA):
5131: ASCIIHexEncoder::ASCIIHexEncoder(Stream *strA):
5178: ASCII85Encoder::ASCII85Encoder(Stream *strA):
5270: RunLengthEncoder::RunLengthEncoder(Stream *strA):
5375: LZWEncoder::LZWEncoder(Stream *strA):
5520: CMYKGrayEncoder::CMYKGrayEncoder(Stream *strA):
5563: RGBGrayEncoder::RGBGrayEncoder(Stream *strA):
72: #include "DCTStream.h"
76: #include "FlateStream.h"
82: #include "JPXStream.h"
201: 	str = new EOFStream(str);
222:     str = new ASCIIHexStream(str);
248:     str = new LZWStream(str, pred, columns, colors, bits, early);
250:     str = new RunLengthStream(str);
294:     str = new CCITTFaxStream(str, encoding, endOfLine, byteAlign,
305:     str = new DCTStream(str, colorXform, dict, recursion);
308:     str = new EOFStream(str);
329:     str = new FlateStream(str, pred, columns, colors, bits);
339:     str = new JPXStream(str);
342:     str = new EOFStream(str);
346:       str = str->getBaseStream();
352:     str = new EOFStream(str);
358: // OutStream
369: // FileOutStream
382: void FileOutStream::close ()
387: Goffset FileOutStream::getPos ()
392: void FileOutStream::put (char c)
397: void FileOutStream::printf(const char *format, ...)
407: // BaseStream
419: // FilterStream
429: void FilterStream::close() {
433: void FilterStream::setPos(Goffset pos, int dir) {
434:   error(errInternal, -1, "Internal: called setPos() on FilterStream");
438: // ImageStream
478: void ImageStream::reset() {
482: void ImageStream::close() {
486: GBool ImageStream::getPixel(Guchar *pix) {
501: Guchar *ImageStream::getLine() {
556: void ImageStream::skipLine() {
561: // StreamPredictor
595: int StreamPredictor::lookChar() {
604: int StreamPredictor::getChar() {
613: int StreamPredictor::getChars(int nChars, Guchar *buffer) {
634: GBool StreamPredictor::getNextLine() {
759: // FileStream
764:     BaseStream(std::move(dictA), lengthA) {
779: BaseStream *FileStream::copy() {
780:   return new FileStream(file, start, limited, length, dict.copy());
785:   return new FileStream(file, startA, limitedA, lengthA, std::move(dictA));
788: void FileStream::reset() {
796: void FileStream::close() {
803: GBool FileStream::fillBuf() {
828: void FileStream::setPos(Goffset pos, int dir) {
843: void FileStream::moveStart(Goffset delta) {
850: // CachedFileStream
855:   : BaseStream(std::move(dictA), lengthA)
873: BaseStream *CachedFileStream::copy() {
875:   return new CachedFileStream(cc, start, limited, length, dict.copy());
882:   return new CachedFileStream(cc, startA, limitedA, lengthA, std::move(dictA));
885: void CachedFileStream::reset()
895: void CachedFileStream::close()
903: GBool CachedFileStream::fillBuf()
925: void CachedFileStream::setPos(Goffset pos, int dir)
946: void CachedFileStream::moveStart(Goffset delta)
954: // MemStream
958:     BaseStream(std::move(dictA), lengthA) {
973: BaseStream *MemStream::copy() {
974:   return new MemStream(buf, start, length, dict.copy());
979:   MemStream *subStr;
987:   subStr = new MemStream(buf, startA, newLength, std::move(dictA));
991: void MemStream::reset() {
995: void MemStream::close() {
998: int MemStream::getChars(int nChars, Guchar *buffer) {
1014: void MemStream::setPos(Goffset pos, int dir) {
1030: void MemStream::moveStart(Goffset delta) {
1037: // EmbedStream
1042:     BaseStream(std::move(dictA), lengthA) {
1062: BaseStream *EmbedStream::copy() {
1063:   error(errInternal, -1, "Called copy() on EmbedStream");
1069:   error(errInternal, -1, "Called makeSubStream() on EmbedStream");
1073: void EmbedStream::rewind() {
1079: void EmbedStream::restore() {
1083: Goffset EmbedStream::getPos() {
1090: int EmbedStream::getChar() {
1114: int EmbedStream::lookChar() {
1128: int EmbedStream::getChars(int nChars, Guchar *buffer) {
1161: void EmbedStream::setPos(Goffset pos, int dir) {
1162:   error(errInternal, -1, "Internal: called setPos() on EmbedStream");
1165: Goffset EmbedStream::getStart() {
1166:   error(errInternal, -1, "Internal: called getStart() on EmbedStream");
1170: void EmbedStream::moveStart(Goffset delta) {
1171:   error(errInternal, -1, "Internal: called moveStart() on EmbedStream");
1175: // ASCIIHexStream
1179:     FilterStream(strA) {
1188: void ASCIIHexStream::reset() {
1194: int ASCIIHexStream::lookChar() {
1249: GooString *ASCIIHexStream::getPSFilter(int psLevel, const char *indent) {
1262: GBool ASCIIHexStream::isBinary(GBool last) {
1271:     FilterStream(strA) {
1348: // LZWStream
1353:     FilterStream(strA) {
1355:     pred = new StreamPredictor(this, predictor, columns, colors, bits);
1376: int LZWStream::getChar() {
1391: int LZWStream::lookChar() {
1406: void LZWStream::getRawChars(int nChars, int *buffer) {
1411: int LZWStream::getRawChar() {
1415: int LZWStream::getChars(int nChars, Guchar *buffer) {
1442: void LZWStream::reset() {
1449: GBool LZWStream::processNextCode() {
1516: void LZWStream::clearTable() {
1523: int LZWStream::getCode() {
1538: GooString *LZWStream::getPSFilter(int psLevel, const char *indent) {
1555: GBool LZWStream::isBinary(GBool last) {
1560: // RunLengthStream
1564:     FilterStream(strA) {
1573: void RunLengthStream::reset() {
1579: int RunLengthStream::getChars(int nChars, Guchar *buffer) {
1600: GooString *RunLengthStream::getPSFilter(int psLevel, const char *indent) {
1613: GBool RunLengthStream::isBinary(GBool last) {
1617: GBool RunLengthStream::fillBuf() {
1644: // CCITTFaxStream
1650:     FilterStream(strA) {
1692: void CCITTFaxStream::ccittReset(GBool unfiltered) {
1706: void CCITTFaxStream::unfilteredReset() {
1710: void CCITTFaxStream::reset() {
1737: inline void CCITTFaxStream::addPixels(int a1, int blackPixels) {
1752: inline void CCITTFaxStream::addPixelsNeg(int a1, int blackPixels) {
1777: int CCITTFaxStream::lookChar() {
2223: short CCITTFaxStream::getTwoDimCode() {
2257: short CCITTFaxStream::getWhiteCode() {
2315: short CCITTFaxStream::getBlackCode() {
2391: short CCITTFaxStream::lookBits(int n) {
2411: GooString *CCITTFaxStream::getPSFilter(int psLevel, const char *indent) {
2448: GBool CCITTFaxStream::isBinary(GBool last) {
2455: // DCTStream
2500:     FilterStream(strA) {
2533: void DCTStream::dctReset(GBool unfiltered) {
2550: void DCTStream::unfilteredReset() {
2554: void DCTStream::reset() {
2649: void DCTStream::close() {
2660:   FilterStream::close();
2663: int DCTStream::getChar() {
2704: int DCTStream::lookChar() {
2724: void DCTStream::restart() {
2736: GBool DCTStream::readMCURow() {
2861: void DCTStream::readScan() {
2966: GBool DCTStream::readDataUnit(DCTHuffTable *dcHuffTable,
3016: GBool DCTStream::readProgressiveDataUnit(DCTHuffTable *dcHuffTable,
3142: void DCTStream::decodeImage() {
3284: void DCTStream::transformDataUnit(Gushort *quantTable,
3442: int DCTStream::readHuffSym(DCTHuffTable *table) {
3471: int DCTStream::readAmp(int size) {
3486: int DCTStream::readBit() {
3510: GBool DCTStream::readHeader() {
3588: GBool DCTStream::readBaselineSOF() {
3628: GBool DCTStream::readProgressiveSOF() {
3669: GBool DCTStream::readScanInfo() {
3730: GBool DCTStream::readQuantTables() {
3761: GBool DCTStream::readHuffmanTables() {
3807: GBool DCTStream::readRestartInterval() {
3819: GBool DCTStream::readJFIFMarker() {
3849: GBool DCTStream::readAdobeMarker() {
3881: GBool DCTStream::readTrailer() {
3892: int DCTStream::readMarker() {
3906: int DCTStream::read16() {
3916: GooString *DCTStream::getPSFilter(int psLevel, const char *indent) {
3929: GBool DCTStream::isBinary(GBool last) {
3937: // FlateStream
3940: int FlateStream::codeLenCodeMap[flateMaxCodeLenCodes] = {
3944: FlateDecode FlateStream::lengthDecode[flateMaxLitCodes-257] = {
3978: FlateDecode FlateStream::distDecode[flateMaxDistCodes] = {
4526: FlateHuffmanTab FlateStream::fixedLitCodeTab = {
4565: FlateHuffmanTab FlateStream::fixedDistCodeTab = {
4571:     FilterStream(strA) {
4573:     pred = new StreamPredictor(this, predictor, columns, colors, bits);
4599: void FlateStream::flateReset(GBool unfiltered) {
4614: void FlateStream::unfilteredReset() {
4618: void FlateStream::reset() {
4646: int FlateStream::getChar() {
4653: int FlateStream::getChars(int nChars, Guchar *buffer) {
4666: int FlateStream::lookChar() {
4681: void FlateStream::getRawChars(int nChars, int *buffer) {
4686: int FlateStream::getRawChar() {
4690: GooString *FlateStream::getPSFilter(int psLevel, const char *indent) {
4703: GBool FlateStream::isBinary(GBool last) {
4707: void FlateStream::readSome() {
4772: GBool FlateStream::startBlock() {
4839: void FlateStream::loadFixedCodes() {
4846: GBool FlateStream::readDynamicCodes() {
4948: void FlateStream::compHuffmanCodes(int *lengths, int n, FlateHuffmanTab *tab) {
4996: int FlateStream::getHuffmanCodeWord(FlateHuffmanTab *tab) {
5016: int FlateStream::getCodeWord(int bits) {
5033: // EOFStream
5037:     FilterStream(strA) {
5045: // BufStream
5058: void BufStream::reset() {
5067: int BufStream::getChar() {
5078: int BufStream::lookChar() {
5082: int BufStream::lookChar(int idx) {
5086: GBool BufStream::isBinary(GBool last) {
5095:     FilterStream(strA) {
5132:     FilterStream(strA) {
5179:     FilterStream(strA) {
5271:     FilterStream(strA) {
5376:   FilterStream(strA)
5521:     FilterStream(strA) {
5564:     FilterStream(strA) {
811:   if (limited && bufPos + fileStreamBufSize > start + length) {
814:     n = fileStreamBufSize;
912:   if (limited && bufPos + cachedStreamBufSize > start + length) {
915:     n = cachedStreamBufSize - (bufPos % cachedStreamBufSize);
github.com/apache/incubator-retired-s4:subprojects/s4-core/src/main/java/org/apache/s4/core/Stream.java: [ piper, ]
42: public class Stream<T extends Event> implements Runnable, Streamable {
67:     public Stream(App app) {
35:  * {@link Stream} and {@link ProcessingElement} objects represent the links and nodes in the application graph. A st...(4 bytes skipped)...
44:     private static final Logger logger = LoggerFactory.getLogger(Stream.class);
97:     public Stream<T> setName(String name) {
109:     public Stream<T> setKey(KeyFinder<T> keyFinder) {
118:     Stream<T> setEventType(Class<T> type) {
130:     public Stream<T> setKey(String keyName) {
148:     public Stream<T> setPE(ProcessingElement pe) {
161:     public Stream<T> setPEs(ProcessingElement[] pes) {
322:     public Stream<T> register() {
87:         this.receiver.addStream(this);
149:         app.addStream(this);
315:                 receiver.removeStream(this);
323:         app.addStream(this);
174:             event.setStreamId(getName());
192:                     queue.put(new EventMessage(String.valueOf(event.getAppId()), event.getStreamName(), app
204:                 queue.put(new EventMessage(String.valueOf(event.getAppId()), event.getStreamName(), app.getSerDeser()
github.com/apache/maven-scm:maven-scm-providers/maven-scm-provider-accurev/src/main/java/org/apache/maven/scm/provider/accurev/Stream.java: [ master, ]
27: public class Stream
44:     public Stream( String name, long id, String basis, long basisId, String depot, Date startDate, String streamType ...(1 bytes skipped)...
182:     public String getStreamType()
85:         Stream other = (Stream) obj;
android.googlesource.com/platform/external/lldb:source/Core/Stream.cpp: [ master, ]
22: Stream::Stream (uint32_t flags, uint32_t addr_size, ByteOrder byte_order) :
30: Stream::Stream () :
41: Stream::~Stream ()
1: //===-- Stream.cpp ----------------------------------------------*- C++ -*-===//
10: #include "lldb/Core/Stream.h"
46: Stream::SetByteOrder (ByteOrder byte_order)
58: Stream::Offset (uint32_t uval, const char *format)
68: Stream::PutSLEB128 (int64_t sval)
102: Stream::PutULEB128 (uint64_t uval)
131: Stream::PutCString (const char *cstr)
145: Stream::QuotedCString (const char *cstr, const char *format)
155: Stream::Address (uint64_t addr, uint32_t addr_size, const char *prefix, const char *suffix)
171: Stream::AddressRange(uint64_t lo_addr, uint64_t hi_addr, uint32_t addr_size, const char *prefix, const cha...(10 bytes skipped)...
183: Stream::PutChar (char ch)
193: Stream::Printf (const char *format, ...)
206: Stream::PrintfVarArg (const char *format, va_list args)
248: Stream::EOL()
258: Stream::Indent(const char *s)
264: // Stream a character "ch" out to this stream.
266: Stream&
267: Stream::operator<< (char ch)
274: // Stream the NULL terminated C string out to this stream.
276: Stream&
277: Stream::operator<<  (const char *s)
284: // Stream the pointer value out to this stream.
286: Stream&
287: Stream::operator<< (void *p)
294: // Stream a uint8_t "uval" out to this stream.
296: Stream&
297: Stream::operator<< (uint8_t uval)
304: // Stream a uint16_t "uval" out to this stream.
306: Stream&
307: Stream::operator<< (uint16_t uval)
314: // Stream a uint32_t "uval" out to this stream.
316: Stream&
317: Stream::operator<< (uint32_t uval)
324: // Stream a uint64_t "uval" out to this stream.
326: Stream&
327: Stream::operator<< (uint64_t uval)
334: // Stream a int8_t "sval" out to this stream.
336: Stream&
337: Stream::operator<< (int8_t sval)
344: // Stream a int16_t "sval" out to this stream.
346: Stream&
347: Stream::operator<< (int16_t sval)
354: // Stream a int32_t "sval" out to this stream.
356: Stream&
357: Stream::operator<< (int32_t sval)
364: // Stream a int64_t "sval" out to this stream.
366: Stream&
367: Stream::operator<< (int64_t sval)
377: Stream::GetIndentLevel() const
386: Stream::SetIndentLevel(int indent_level)
395: Stream::IndentMore(int amount)
404: Stream::IndentLess (int amount)
416: Stream::GetAddressByteSize() const
425: Stream::SetAddressByteSize(uint32_t addr_size)
434: Stream::GetVerbose() const
443: Stream::GetDebug() const
452: Stream::GetFlags()
461: Stream::GetFlags() const
471: Stream::GetByteOrder() const
477: Stream::PrintfAsRawHex8 (const char *format, ...)
515: Stream::PutNHex8 (size_t n, uint8_t uvalue)
524: Stream::_PutHex8 (uint8_t uvalue, bool add_prefix)
546: Stream::PutHex8 (uint8_t uvalue)
552: Stream::PutHex16 (uint16_t uvalue, ByteOrder byte_order)
573: Stream::PutHex32(uint32_t uvalue, ByteOrder byte_order)
594: Stream::PutHex64(uint64_t uvalue, ByteOrder byte_order)
615: Stream::PutMaxHex64
633: Stream::PutPointer (void *ptr)
639: Stream::PutFloat(float f, ByteOrder byte_order)
648: Stream::PutDouble(double d, ByteOrder byte_order)
657: Stream::PutLongDouble(long double ld, ByteOrder byte_order)
666: Stream::PutRawBytes (const void *s, size_t src_len, ByteOrder src_byte_order, ByteOrder dst_byte_order)
696: Stream::PutBytesAsRawHex8 (const void *s, size_t src_len, ByteOrder src_byte_order, ByteOrder dst_byte_ord...(3 bytes skipped)...
725: Stream::PutCStringAsRawHex8 (const char *s)
741: Stream::UnitTest(Stream *s)
github.com/apache/sling-samples:slingshot/src/main/java/org/apache/sling/sample/slingshot/model/Stream.java: [ master, ]
23: public class Stream {
32:     public Stream(final Resource resource) {
26:     public static final String RESOURCETYPE = "slingshot/Stream";
30:     private volatile StreamInfo info;
36:     public StreamInfo getInfo() {
38:             info = new StreamInfo(this.resource == null ? null : this.resource.getChild("info"));
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
github.com/sparkfun/Arduino_Boards:sparkfun/samd/cores/LilyMini/Stream.h: [ master, ]
49: class Stream : public Print
64:     Stream() {_timeout=1000;}
23: #define Stream_h
2:   Stream.h - base class for character-based streams.
22: #ifndef Stream_h
115:   // Stream and used parseFloat/Int with a custom ignore character. To keep
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);
android.googlesource.com/platform/frameworks/ex:framesequence/jni/Stream.cpp: [ master, ]
32: Stream::Stream()
38: Stream::~Stream() {
143: jint JavaStream_OnLoad(JNIEnv* env) {
30: } gInputStreamClassInfo;
17: #define LOG_TAG "Stream"
19: #include "Stream.h"
42: size_t Stream::peek(void* buffer, size_t size) {
60: size_t Stream::read(void* buffer, size_t size) {
82: uint8_t* Stream::getRawBufferAddr() {
86: jobject Stream::getRawBuffer() {
90: int Stream::getRawBufferSize() {
94: uint8_t* MemoryStream::getRawBufferAddr() {
98: jobject MemoryStream::getRawBuffer() {
102: int MemoryStream::getRawBufferSize() {
110: size_t MemoryStream::doRead(void* buffer, size_t size) {
118: size_t FileStream::doRead(void* buffer, size_t size) {
122: size_t JavaInputStream::doRead(void* dstBuffer, size_t size) {
128:         jint bytesRead = mEnv->CallIntMethod(mInputStream,
146:     jclass inputStreamClazz = env->FindClass("java/io/InputStream");
129:                 gInputStreamClassInfo.read, mByteArray, 0, requested);
147:     if (!inputStreamClazz) {
150:     gInputStreamClassInfo.read = env->GetMethodID(inputStreamClazz, "read", "([BII)I");
151:     gInputStreamClassInfo.reset = env->GetMethodID(inputStreamClazz, "reset", "()V");
152:     if (!gInputStreamClassInfo.read || !gInputStreamClassInfo.reset) {
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/Arduino_Boards:sparkfun/esp8266/cores/esp8266/Stream.h: [ master, ]
38: class Stream: public Print {
52:         Stream() {
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/incubator-optiq-linq4j:src/main/java/net/hydromatic/lambda/streams/Stream.java: [ master, ]
27: public interface Stream<T> extends SequentialStreamOps<T>, Iterator<T> {
23:  * Stream.
25:  * <p>Based on {@code java.util.streams.Stream}.</p>
35: // End Stream.java
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/vanadium/java:lib/src/main/java/io/v/v23/rpc/Stream.java: [ master, ]
16: public interface Stream {
github.com/kubernetes/kubernetes:vendor/github.com/docker/docker/api/types/client.go: [ master, ]
33: 	Stream     bool
github.com/llvm-mirror/llvm:lib/Support/YAMLParser.cpp: [ master, ]
1762: Stream::Stream(StringRef Input, SourceMgr &SM, bool ShowColors,
1766: Stream::Stream(MemoryBufferRef InputBuffer, SourceMgr &SM, bool ShowColors,
536:   bool IsStartOfStream;
129:     TK_StreamStart,
130:     TK_StreamEnd,
1072: bool Scanner::scanStreamStart() {
1085: bool Scanner::scanStreamEnd() {
600:       OS << "Stream-Start: ";
603:       OS << "Stream-End: ";
1770: Stream::~Stream() = default;
1772: bool Stream::failed() { return scanner->failed(); }
1774: void Stream::printError(Node *N, const Twine &Msg) {
1781: document_iterator Stream::begin() {
1785:   // Skip Stream-Start.
1792: document_iterator Stream::end() {
1796: void Stream::skip() {
2257: Document::Document(Stream &S) : stream(S), Root(nullptr) {
599:     case Token::TK_StreamStart:
602:     case Token::TK_StreamEnd:
669:     if (T.Kind == Token::TK_StreamEnd)
682:     if (T.Kind == Token::TK_StreamEnd)
776:   IsStartOfStream = true;
1073:   IsStartOfStream = false;
1078:   T.Kind = Token::TK_StreamStart;
1097:   T.Kind = Token::TK_StreamEnd;
1671:   if (IsStartOfStream)
2231:     case Token::TK_StreamEnd:
2276:   if (T.Kind == Token::TK_StreamEnd)
2392:   case Token::TK_StreamEnd:
440:   bool scanStreamStart();
443:   bool scanStreamEnd();
1672:     return scanStreamStart();
1677:     return scanStreamEnd();
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) {
github.com/chromium/chromium:third_party/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/apache/incubator-mxnet:3rdparty/mshadow/mshadow/tensor.h: [ master, ]
365: struct Stream {
659: inline Stream<Device> *NewStream(int dev_id) {
428:   Stream<Device> *stream_;
442:                          Stream<Device> *stream)
447:                          index_t stride, Stream<Device> *stream)
453:   inline void set_stream(Stream<Device> *stream) {
556:   Stream<Device> *stream_;
563:   MSHADOW_XINLINE Tensor(DType *dptr, Shape<1> shape, Stream<Device> *stream)
566:                          index_t stride, Stream<Device> *stream)
568:   inline void set_stream(Stream<Device> *stream) {
651: inline Stream<Device> *NewStream(bool create_blas_handle,
667: inline void DeleteStream(Stream<Device> *stream);
728:                                             Stream<Device> *stream = NULL);
740:                  Stream<cpu> *stream = NULL);
752:                  Stream<gpu> *stream = NULL);
764:                  Stream<gpu> *stream = NULL);
776:                  Stream<gpu> *stream = NULL);
660:   return NewStream<Device>(true, false, dev_id);
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/swiftshader/third_party/SPIRV-Headers/include/spirv/unified1/spirv.cs: [ master, ]
419:             Stream = 29,
773:             GeometryStreams = 54,
1070:             OpEmitStreamVertex = 220,
1071:             OpEndStreamPrimitive = 221,
1282:             OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
1283:             OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
1284:             OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
1285:             OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
1334:             OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
1335:             OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
1336:             OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
1337:             OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
1338:             OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
1339:             OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
1341:             OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
1342:             OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
1343:             OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
1344:             OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
1345:             OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
1346:             OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
1347:             OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
1348:             OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
1349:             OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
1350:             OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
github.com/google/swiftshader:third_party/SPIRV-Headers/include/spirv/unified1/spirv.cs: [ master, ] Duplicate result
android.googlesource.com/platform/external/swiftshader:third_party/SPIRV-Headers/include/spirv/unified1/spirv.cs: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:external/shaderc/spirv-headers/include/spirv/unified1/spirv.cs: [ master, ]
419:             Stream = 29,
773:             GeometryStreams = 54,
1069:             OpEmitStreamVertex = 220,
1070:             OpEndStreamPrimitive = 221,
1280:             OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
1281:             OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
1282:             OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
1283:             OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
1332:             OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
1333:             OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
1334:             OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
1335:             OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
1336:             OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
1337:             OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
1339:             OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
1340:             OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
1341:             OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
1342:             OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
1343:             OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
1344:             OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
1345:             OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
1346:             OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
1347:             OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
1348:             OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
android.googlesource.com/platform/superproject:external/swiftshader/third_party/SPIRV-Headers/include/spirv/unified1/spv.d: [ master, ]
422:     Stream = 29,
776:     GeometryStreams = 54,
1073:     OpEmitStreamVertex = 220,
1074:     OpEndStreamPrimitive = 221,
1285:     OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
1286:     OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
1287:     OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
1288:     OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
1337:     OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
1338:     OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
1339:     OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
1340:     OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
1341:     OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
1342:     OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
1344:     OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
1345:     OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
1346:     OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
1347:     OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
1348:     OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
1349:     OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
1350:     OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
1351:     OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
1352:     OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
1353:     OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
swiftshader.googlesource.com/SwiftShader:third_party/SPIRV-Headers/include/spirv/unified1/spirv.cs: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:external/swiftshader/third_party/SPIRV-Headers/include/spirv/unified1/spirv.json: [ master, ]
455:                     "Stream": 29,
776:                     "GeometryStreams": 54,
1076:                     "OpEmitStreamVertex": 220,
1077:                     "OpEndStreamPrimitive": 221,
1288:                     "OpTypeAvcImeResultSingleReferenceStreamoutINTEL": 5707,
1289:                     "OpTypeAvcImeResultDualReferenceStreamoutINTEL": 5708,
1290:                     "OpTypeAvcImeSingleReferenceStreaminINTEL": 5709,
1291:                     "OpTypeAvcImeDualReferenceStreaminINTEL": 5710,
1340:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL": 5759,
1341:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL": 5760,
1342:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL": 5761,
1343:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL": 5762,
1344:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL": 5763,
1345:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL": 5764,
1347:                     "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL": 5766,
1348:                     "OpSubgroupAvcImeGetDualReferenceStreaminINTEL": 5767,
1349:                     "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL": 5768,
1350:                     "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL": 5769,
1351:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL": 5770,
1352:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL": 5771,
1353:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL": 5772,
1354:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL": 5773,
1355:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL": 5774,
1356:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL": 5775,
github.com/google/swiftshader:third_party/SPIRV-Headers/include/spirv/unified1/spv.d: [ master, ] Duplicate result
android.googlesource.com/platform/external/swiftshader:third_party/SPIRV-Headers/include/spirv/unified1/spv.d: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:external/shaderc/spirv-headers/include/spirv/unified1/spv.d: [ master, ]
422:     Stream = 29,
776:     GeometryStreams = 54,
1072:     OpEmitStreamVertex = 220,
1073:     OpEndStreamPrimitive = 221,
1283:     OpTypeAvcImeResultSingleReferenceStreamoutINTEL = 5707,
1284:     OpTypeAvcImeResultDualReferenceStreamoutINTEL = 5708,
1285:     OpTypeAvcImeSingleReferenceStreaminINTEL = 5709,
1286:     OpTypeAvcImeDualReferenceStreaminINTEL = 5710,
1335:     OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL = 5759,
1336:     OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL = 5760,
1337:     OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL = 5761,
1338:     OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL = 5762,
1339:     OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL = 5763,
1340:     OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL = 5764,
1342:     OpSubgroupAvcImeGetSingleReferenceStreaminINTEL = 5766,
1343:     OpSubgroupAvcImeGetDualReferenceStreaminINTEL = 5767,
1344:     OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL = 5768,
1345:     OpSubgroupAvcImeStripDualReferenceStreamoutINTEL = 5769,
1346:     OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL = 5770,
1347:     OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL = 5771,
1348:     OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL = 5772,
1349:     OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL = 5773,
1350:     OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL = 5774,
1351:     OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL = 5775,
swiftshader.googlesource.com/SwiftShader:third_party/SPIRV-Headers/include/spirv/unified1/spv.d: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:external/deqp-deps/SPIRV-Headers/include/spirv/unified1/spirv.cs: [ master, ]
404:             Stream = 29,
737:             GeometryStreams = 54,
1021:             OpEmitStreamVertex = 220,
1022:             OpEndStreamPrimitive = 221,
github.com/google/swiftshader:third_party/SPIRV-Headers/include/spirv/unified1/spirv.json: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:external/mesa3d/include/D3D9/d3d9types.h: [ master, ]
1751:     WORD Stream;
android.googlesource.com/platform/external/swiftshader:third_party/SPIRV-Headers/include/spirv/unified1/spirv.json: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:external/shaderc/spirv-headers/include/spirv/unified1/spirv.json: [ master, ]
455:                     "Stream": 29,
776:                     "GeometryStreams": 54,
1075:                     "OpEmitStreamVertex": 220,
1076:                     "OpEndStreamPrimitive": 221,
1286:                     "OpTypeAvcImeResultSingleReferenceStreamoutINTEL": 5707,
1287:                     "OpTypeAvcImeResultDualReferenceStreamoutINTEL": 5708,
1288:                     "OpTypeAvcImeSingleReferenceStreaminINTEL": 5709,
1289:                     "OpTypeAvcImeDualReferenceStreaminINTEL": 5710,
1338:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL": 5759,
1339:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL": 5760,
1340:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL": 5761,
1341:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL": 5762,
1342:                     "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL": 5763,
1343:                     "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL": 5764,
1345:                     "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL": 5766,
1346:                     "OpSubgroupAvcImeGetDualReferenceStreaminINTEL": 5767,
1347:                     "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL": 5768,
1348:                     "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL": 5769,
1349:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL": 5770,
1350:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL": 5771,
1351:                     "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL": 5772,
1352:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL": 5773,
1353:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL": 5774,
1354:                     "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL": 5775,
swiftshader.googlesource.com/SwiftShader:third_party/SPIRV-Headers/include/spirv/unified1/spirv.json: [ master, ] Duplicate result
android.googlesource.com/platform/superproject:external/deqp-deps/SPIRV-Headers/include/spirv/unified1/spirv.json: [ master, ]
442:                     "Stream": 29,
748:                     "GeometryStreams": 54,
1035:                     "OpEmitStreamVertex": 220,
1036:                     "OpEndStreamPrimitive": 221,
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;
github.com/llvm-mirror/clang:lib/Frontend/SerializedDiagnosticPrinter.cpp: [ master, ]
255:     llvm::BitstreamWriter Stream;
245:         : DiagOpts(Diags), Stream(Buffer), OutputFile(File.str()),
311:                         llvm::BitstreamWriter &Stream,
315:   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record);
326:   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_BLOCKNAME, Record);
331:                          llvm::BitstreamWriter &Stream,
339:   Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETRECORDNAME, Record);
384:   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_FILENAME), Record,
395:   State->Stream.EmitRecordWithAbbrev(State->Abbrevs.get(RECORD_SOURCE_RANGE),
402:   State->Stream.Emit((unsigned)'D', 8);
403:   State->Stream.Emit((unsigned)'I', 8);
404:   State->Stream.Emit((unsigned)'A', 8);
405:   State->Stream.Emit((unsigned)'G', 8);
425:   State->Stream.EnterBlockInfoBlock();
428:   llvm::BitstreamWriter &Stream = State->Stream;
436:   EmitBlockID(BLOCK_META, "Meta", Stream, Record);
437:   EmitRecordID(RECORD_VERSION, "Version", Stream, Record);
441:   Abbrevs.set(RECORD_VERSION, Stream.EmitBlockInfoAbbrev(BLOCK_META, Abbrev));
447:   EmitBlockID(BLOCK_DIAG, "Diag", Stream, Record);
448:   EmitRecordID(RECORD_DIAG, "DiagInfo", Stream, Record);
449:   EmitRecordID(RECORD_SOURCE_RANGE, "SrcRange", Stream, Record);
450:   EmitRecordID(RECORD_CATEGORY, "CatName", Stream, Record);
451:   EmitRecordID(RECORD_DIAG_FLAG, "DiagFlag", Stream, Record);
452:   EmitRecordID(RECORD_FILENAME, "FileName", Stream, Record);
453:   EmitRecordID(RECORD_FIXIT, "FixIt", Stream, Record);
464:   Abbrevs.set(RECORD_DIAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
472:   Abbrevs.set(RECORD_CATEGORY, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
479:               Stream.EmitBlockInfoAbbrev(BLOCK_DIAG, Abbrev));
487:   Abbrevs.set(RECORD_DIAG_FLAG, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
498:   Abbrevs.set(RECORD_FILENAME, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
507:   Abbrevs.set(RECORD_FIXIT, Stream.EmitBlockInfoAbbrev(BLOCK_DIAG,
510:   Stream.ExitBlock();
514:   llvm::BitstreamWriter &Stream = State->Stream;
517:   Stream.EnterSubblock(BLOCK_META, 3);
519:   Stream.EmitRecordWithAbbrev(Abbrevs.get(RECORD_VERSION), Record);
520:   Stream.ExitBlock();
531:   State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_CATEGORY), Record,
561:     State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
631:   llvm::BitstreamWriter &Stream = State->Stream;
653:   Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_DIAG), Record, Message);
664:   State->Stream.EnterSubblock(BLOCK_DIAG, 4);
668:   State->Stream.ExitBlock();
688:   llvm::BitstreamWriter &Stream = State->Stream;
708:     Stream.EmitRecordWithBlob(Abbrevs.get(RECORD_FIXIT), Record,
812:   Writer.State->Stream.EmitRecordWithAbbrev(
825:   Writer.State->Stream.EmitRecordWithBlob(
839:   Writer.State->Stream.EmitRecordWithBlob(
254:     /// The BitStreamWriter for the serialized diagnostics.
chromium.googlesource.com/android_ndk:sources/third_party/shaderc/third_party/spirv-tools/external/spirv-headers/include/spirv/unified1/spirv.json: [ master, ]
434:                     "Stream": 29,
735:                     "GeometryStreams": 54,
1016:                     "OpEmitStreamVertex": 220,
1017:                     "OpEndStreamPrimitive": 221,
chromium.googlesource.com/native_client/pnacl-gcc:gcc/ada/g-socket.ads: [ master, ]
996:    function Stream (Socket : Socket_Type) return Stream_Access;
999:    function Stream
467:    type Mode_Type is (Socket_Stream, Socket_Datagram);
796:    type Stream_Element_Reference is access all Ada.Streams.Stream_Element;
993:    type Stream_Access is access all Ada.Streams.Root_Stream_Type'Class;
107:    --        Channel  : Stream_Access;
152:    --        Channel := Stream (Socket);
230:    --        Channel := Stream (Socket, Address);
265:    --        Channel  : Stream_Access;
292:    --        Channel := Stream (Socket);
339:    --        Channel := Stream (Socket, Address);
468:    --  Stream sockets provide connection-oriented byte streams. Datagram
774:    --  Socket_Stream).
799:       Base   : Stream_Element_Reference;
800:       Length : Ada.Streams.Stream_Element_Count;
808:       Mode   : Mode_Type   := Socket_Stream);
896:       Item   : out Ada.Streams.Stream_Element_Array;
897:       Last   : out Ada.Streams.Stream_Element_Offset;
903:    --  is Stream_Element_Offset'First, in which case Constraint_Error is
909:       Item   : out Ada.Streams.Stream_Element_Array;
910:       Last   : out Ada.Streams.Stream_Element_Offset;
921:       Count  : out Ada.Streams.Stream_Element_Count;
936:       Item   : Ada.Streams.Stream_Element_Array;
937:       Last   : out Ada.Streams.Stream_Element_Offset;
945:    --  closed by the peer (unless Item'First is Stream_Element_Offset'First,
954:       Item   : Ada.Streams.Stream_Element_Array;
955:       Last   : out Ada.Streams.Stream_Element_Offset;
963:       Item   : Ada.Streams.Stream_Element_Array;
964:       Last   : out Ada.Streams.Stream_Element_Offset;
974:       Count  : out Ada.Streams.Stream_Element_Count;
994:    --  Same interface as Ada.Streams.Stream_IO
1001:       Send_To : Sock_Addr_Type) return Stream_Access;
1006:      (Stream : not null Stream_Access) return Sock_Addr_Type;
1010:      (Ada.Streams.Root_Stream_Type'Class, Stream_Access);
1011:    --  Destroy a stream created by one of the Stream functions above, releasing
50: with Ada.Streams;
android.googlesource.com/platform/superproject:external/swiftshader/third_party/llvm-7.0/llvm/lib/Support/YAMLParser.cpp: [ master, ]
1763: Stream::Stream(StringRef Input, SourceMgr &SM, bool ShowColors,
1767: Stream::Stream(MemoryBufferRef InputBuffer, SourceMgr &SM, bool ShowColors,
537:   bool IsStartOfStream;
130:     TK_StreamStart,
131:     TK_StreamEnd,
1073: bool Scanner::scanStreamStart() {
1086: bool Scanner::scanStreamEnd() {
601:       OS << "Stream-Start: ";
604:       OS << "Stream-End: ";
1771: Stream::~Stream() = default;
1773: bool Stream::failed() { return scanner->failed(); }
1775: void Stream::printError(Node *N, const Twine &Msg) {
1782: document_iterator Stream::begin() {
1786:   // Skip Stream-Start.
1793: document_iterator Stream::end() {
1797: void Stream::skip() {
2258: Document::Document(Stream &S) : stream(S), Root(nullptr) {
600:     case Token::TK_StreamStart:
603:     case Token::TK_StreamEnd:
670:     if (T.Kind == Token::TK_StreamEnd)
683:     if (T.Kind == Token::TK_StreamEnd)
777:   IsStartOfStream = true;
1074:   IsStartOfStream = false;
1079:   T.Kind = Token::TK_StreamStart;
1098:   T.Kind = Token::TK_StreamEnd;
1672:   if (IsStartOfStream)
2232:     case Token::TK_StreamEnd:
2277:   if (T.Kind == Token::TK_StreamEnd)
2393:   case Token::TK_StreamEnd:
441:   bool scanStreamStart();
444:   bool scanStreamEnd();
1673:     return scanStreamStart();
1678:     return scanStreamEnd();
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, ] Duplicate result
chromium.googlesource.com/chromium/deps/perl:c/i686-w64-mingw32/include/d3d9types.h: [ master, ]
276:   WORD    Stream;
327: #define D3DVSD_STREAM(StreamNumber) \
328:   (D3DVSD_MAKETOKENTYPE(D3DVSD_TOKEN_STREAM) | (StreamNumber))
android.googlesource.com/platform/external/llvm:lib/Support/YAMLParser.cpp: [ master, ]
1769: Stream::Stream(StringRef Input, SourceMgr &SM, bool ShowColors)
1772: Stream::Stream(MemoryBufferRef InputBuffer, SourceMgr &SM, bool ShowColors)
1775: Stream::~Stream() {}
546:   bool IsStartOfStream;
114:     TK_StreamStart,
115:     TK_StreamEnd,
1079: bool Scanner::scanStreamStart() {
1092: bool Scanner::scanStreamEnd() {
608:       OS << "Stream-Start: ";
611:       OS << "Stream-End: ";
1777: bool Stream::failed() { return scanner->failed(); }
1779: void Stream::printError(Node *N, const Twine &Msg) {
1786: document_iterator Stream::begin() {
1790:   // Skip Stream-Start.
1797: document_iterator Stream::end() {
1801: void Stream::skip() {
2260: Document::Document(Stream &S) : stream(S), Root(nullptr) {
607:     case Token::TK_StreamStart:
610:     case Token::TK_StreamEnd:
677:     if (T.Kind == Token::TK_StreamEnd)
690:     if (T.Kind == Token::TK_StreamEnd)
779:   IsStartOfStream = true;
1080:   IsStartOfStream = false;
1085:   T.Kind = Token::TK_StreamStart;
1104:   T.Kind = Token::TK_StreamEnd;
1678:   if (IsStartOfStream)
2234:     case Token::TK_StreamEnd:
2279:   if (T.Kind == Token::TK_StreamEnd)
2395:   case Token::TK_StreamEnd:
450:   bool scanStreamStart();
453:   bool scanStreamEnd();
1679:     return scanStreamStart();
1684:     return scanStreamEnd();
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();
android.googlesource.com/platform/external/llvm_35a:lib/Support/YAMLParser.cpp: [ master, ]
1524: Stream::Stream(StringRef Input, SourceMgr &SM)
1527: Stream::Stream(MemoryBuffer *InputBuffer, SourceMgr &SM)
1530: Stream::~Stream() {}
493:   bool IsStartOfStream;
112:     TK_StreamStart,
113:     TK_StreamEnd,
1000: bool Scanner::scanStreamStart() {
1013: bool Scanner::scanStreamEnd() {
552:       OS << "Stream-Start: ";
555:       OS << "Stream-End: ";
1532: bool Stream::failed() { return scanner->failed(); }
1534: void Stream::printError(Node *N, const Twine &Msg) {
1543: document_iterator Stream::begin() {
1547:   // Skip Stream-Start.
1554: document_iterator Stream::end() {
1558: void Stream::skip() {
2016: Document::Document(Stream &S) : stream(S), Root(nullptr) {
551:     case Token::TK_StreamStart:
554:     case Token::TK_StreamEnd:
618:     if (T.Kind == Token::TK_StreamEnd)
631:     if (T.Kind == Token::TK_StreamEnd)
708:   , IsStartOfStream(true)
726:   , IsStartOfStream(true)
1001:   IsStartOfStream = false;
1006:   T.Kind = Token::TK_StreamStart;
1025:   T.Kind = Token::TK_StreamEnd;
1433:   if (IsStartOfStream)
1990:     case Token::TK_StreamEnd:
2035:   if (T.Kind == Token::TK_StreamEnd)
2143:   case Token::TK_StreamEnd:
421:   bool scanStreamStart();
424:   bool scanStreamEnd();
1434:     return scanStreamStart();
1439:     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
chromium.googlesource.com/arc/arc:third_party/android/external/llvm/lib/Support/YAMLParser.cpp: [ master, ] Duplicate result
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;
github.com/apache/trafficcontrol:traffic_ops/vendor/github.com/basho/riak-go-client/rpb/riak_ts/riak_ts.pb.go: [ master, ]
113: 	Stream           *bool            `protobuf:"varint,2,opt,name=stream,def=0" json:"stream,omitempty"`
123: const Default_TsQueryReq_Stream bool = false
132: func (m *TsQueryReq) GetStream() bool {
133: 	if m != nil && m.Stream != nil {
134: 		return *m.Stream
136: 	return Default_TsQueryReq_Stream
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/superproject:external/llvm/lib/Support/YAMLParser.cpp: [ master, ] Duplicate result
github.com/apache/hawq:depends/storage/src/storage/format/orc/orc_proto.proto: [ master, ]
105: message Stream {
143:   repeated Stream streams = 1;
107:   // StreamName to ensure it is added to the stripe in the right area
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;
kernel.googlesource.com/pub/scm/linux/kernel/git/torvalds/linux:drivers/media/pci/ngene/ngene.h: [ master, ]
334: 	u8     Stream;             /* Stream number (UVI1, UVI2, TVOUT) */
560: 	u8  Stream;
664: 	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:
chromium.googlesource.com/ios-chromium-mirror:third_party/crashpad/crashpad/third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ] Duplicate result
chromium.googlesource.com/chromium/src:third_party/crashpad/crashpad/third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ] Duplicate result
android.googlesource.com/platform/external/opencv3:modules/core/include/opencv2/core/base.hpp: [ master, ]
636:     class CV_EXPORTS Stream;
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
chromium.googlesource.com/chromium/src/third_party:crashpad/crashpad/third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ] Duplicate result
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
android.googlesource.com/platform/superproject: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;
chromium.googlesource.com/private/55048997-blink2:Source/WebKit2/WebProcess/Plugins/PluginView.cpp: [ master, ]
102: class PluginView::Stream : public RefCounted<PluginView::Stream>, NetscapePlugInStreamLoaderClient {
116:     Stream(PluginView* pluginView, uint64_t streamID, const ResourceRequest& request)
141: PluginView::Stream::~Stream()
1151: void PluginView::addStream(Stream* stream)
1157: void PluginView::removeStream(Stream* stream)
1176: void PluginView::redeliverManualStream()
1164: void PluginView::cancelAllStreams()
1285: void PluginView::cancelStreamLoad(uint64_t streamID)
1298: void PluginView::cancelManualStreamLoad()
104:     static PassRefPtr<Stream> create(PluginView* pluginView, uint64_t streamID, const ResourceRequest& request)
106:         return adoptRef(new Stream(pluginView, streamID, request));
108:     ~Stream();
146: void PluginView::Stream::start()
157: void PluginView::Stream::cancel()
198: void PluginView::Stream::didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse& response)
214: void PluginView::Stream::didReceiveData(NetscapePlugInStreamLoader*, const char* bytes, int length)
219: void PluginView::Stream::didFail(NetscapePlugInStreamLoader*, const ResourceError& error) 
222:     RefPtr<Stream> protect(this);
232: void PluginView::Stream::didFinishLoading(NetscapePlugInStreamLoader*)
235:     RefPtr<Stream> protectStream(this);
1063:     RefPtr<Stream> stream = PluginView::Stream::create(this, request->requestID(), request->request());
1166:     Vector<RefPtr<Stream> > streams;
1287:     // Keep a reference to the stream. Stream::cancel might remove the stream from the map, and thus
1289:     RefPtr<Stream> stream = m_streams.get(streamID).get();
228:     m_pluginView->removeStream(this);
243:     m_pluginView->removeStream(this);
277:     , m_manualStreamState(StreamStateInitial)
345:     m_manualStreamState = StreamStateInitial;
363:         ASSERT(m_manualStreamState == StreamStateInitial);
364:         m_manualStreamState = StreamStateHasReceivedResponse;
390:         ASSERT(m_manualStreamState == StreamStateHasReceivedResponse);
408:         ASSERT(m_manualStreamState == StreamStateHasReceivedResponse);
409:         m_manualStreamState = StreamStateFinished;
423:         m_manualStreamState = StreamStateFinished;
569:     redeliverManualStream();
1064:     addStream(stream.get());
1178:     if (m_manualStreamState == StreamStateInitial) {
1183:     if (m_manualStreamState == StreamStateFailed) {
1204:     if (m_manualStreamState == StreamStateFinished)
54: #include <WebCore/NetscapePlugInStreamLoader.h>
124:     // NetscapePluginStreamLoaderClient
125:     virtual void didReceiveResponse(NetscapePlugInStreamLoader*, const ResourceResponse&);
126:     virtual void didReceiveData(NetscapePlugInStreamLoader*, const char*, int);
127:     virtual void didFail(NetscapePlugInStreamLoader*, const ResourceError&);
128:     virtual void didFinishLoading(NetscapePlugInStreamLoader*);
138:     RefPtr<NetscapePlugInStreamLoader> m_loader;
154:     m_loader = resourceLoadScheduler()->schedulePluginStreamLoad(frame, this, m_request);
328:     cancelAllStreams();
365:         m_manualStreamResponse = response;
380:     m_plugin->manualStreamDidReceiveResponse(responseURL, streamLength, response.lastModifiedDate(), mimeType, headers, respon...(24 bytes skipped)...
391:         if (!m_manualStreamData)
392:             m_manualStreamData = SharedBuffer::create();
394:         m_manualStreamData->append(bytes, length);
398:     m_plugin->manualStreamDidReceiveData(bytes, length);
413:     m_plugin->manualStreamDidFinishLoading();
424:         m_manualStreamError = error;
425:         m_manualStreamData = nullptr;
429:     m_plugin->manualStreamDidFail(error.isCancellation());
1184:         manualLoadDidFail(m_manualStreamError);
1189:     manualLoadDidReceiveResponse(m_manualStreamResponse);
1192:     if (m_manualStreamData) {
1196:         while (unsigned length = m_manualStreamData->getSomeData(data, position)) {
1201:         m_manualStreamData = nullptr;
github.com/tensorflow/haskell:third_party/tensorflow/tensorflow/stream_executor/stream.h: [ master, ]
92: class Stream {
16: // The Stream is used in conjunction with the StreamExecutor "parent" to
97:   explicit Stream(StreamExecutor *parent);
101:   Stream(StreamExecutor *parent, internal::StreamInterface *implementation);
106:   ~Stream();
114:   Stream &Init() LOCKS_EXCLUDED(mu_);
117:   Stream &InitTimer(Timer *t);
120:   Stream &InitWithTimer(Timer *t);
127:   Stream *GetOrCreateSubStream() LOCKS_EXCLUDED(mu_);
133:   void ReturnSubStream(Stream *sub_stream) LOCKS_EXCLUDED(mu_);
160:   Stream &ThenLaunch(ThreadDim thread_dims, BlockDim block_dims,
167:   Stream &ThenStartTimer(Timer *t);
170:   // stream's execution. See also Stream::ThenStartTimer.
171:   Stream &ThenStopTimer(Timer *t);
176:   Stream &ThenWaitFor(Stream *other, Params... more_streams) {
189:   Stream &ThenWaitFor(Stream *other);
195:   Stream &ThenWaitFor(P others) {
207:   Stream &ThenWaitFor(Event *event);
214:   Stream &ThenRecordEvent(Event *event);
221:   Stream &ThenBatchNormalizationForward(
234:   Stream &ThenBatchNormalizationBackward(
242:   Stream &ThenBatchNormalizationForward(
255:   Stream &ThenBatchNormalizationBackward(
266:   Stream &ThenFusedConvolve(
278:   Stream &ThenConvolve(const dnn::BatchDescriptor &input_descriptor,
286:   Stream &ThenConvolveQuantized(
296:   Stream &ThenConvolveQuantized(
306:   Stream &ThenFusedConvolveWithScratch(
318:   Stream &ThenFusedConvolveWithScratch(
331:   Stream &ThenFusedConvolveWithScratch(
343:   Stream &ThenConvolveWithScratch(
352:   Stream &ThenConvolveWithScratch(
361:   Stream &ThenConvolveWithAlgorithm(
372:   Stream &ThenConvolveWithAlgorithm(
383:   Stream &ThenConvolveWithAlgorithm(
394:   Stream &ThenFusedConvolveWithAlgorithm(
408:   Stream &ThenFusedConvolveWithAlgorithm(
422:   Stream &ThenFusedConvolveWithAlgorithm(
437:   Stream &ThenFusedConvolveWithAlgorithm(
451:   Stream &ThenSeparableConvolve(
461:   Stream &ThenConvolveBackwardData(
470:   Stream &ThenConvolveBackwardDataWithScratch(
480:   Stream &ThenConvolveBackwardDataWithScratch(
490:   Stream &ThenConvolveBackwardDataWithAlgorithm(
502:   Stream &ThenConvolveBackwardDataWithAlgorithm(
514:   Stream &ThenConvolveBackwardDataWithAlgorithm(
526:   Stream &ThenConvolveBackwardFilter(
535:   Stream &ThenConvolveBackwardFilterWithScratch(
545:   Stream &ThenConvolveBackwardFilterWithScratch(
555:   Stream &ThenConvolveBackwardFilterWithAlgorithm(
567:   Stream &ThenConvolveBackwardFilterWithAlgorithm(
579:   Stream &ThenConvolveBackwardFilterWithAlgorithm(
591:   Stream &ThenConvolveBackwardBias(const dnn::BatchDescriptor &input_descriptor,
596:   Stream &ThenConvolveBackwardBias(const dnn::BatchDescriptor &input_descriptor,
601:   Stream &ThenConvolveBackwardBias(
607:   Stream &ThenMatMul(const DeviceMemory<float> &input_data,
613:   Stream &ThenMatMulQuantized(const DeviceMemory<float> &input_data,
620:   Stream &ThenMatMulQuantized(const DeviceMemory<float> &input_data,
627:   Stream &ThenBiasAdd(const DeviceMemory<float> &input_data,
632:   Stream &ThenPoolForward(const dnn::PoolingDescriptor &pooling_dimensions,
639:   Stream &ThenPoolForward(const dnn::PoolingDescriptor &pooling_dimensions,
646:   Stream &ThenPoolForward(const dnn::PoolingDescriptor &pooling_dimensions,
653:   Stream &ThenPoolBackward(const dnn::PoolingDescriptor &pooling_dimensions,
662:   Stream &ThenPoolBackward(const dnn::PoolingDescriptor &pooling_dimensions,
671:   Stream &ThenPoolBackward(const dnn::PoolingDescriptor &pooling_dimensions,
680:   Stream &ThenNormalize(const dnn::NormalizeDescriptor &normalize_descriptor,
686:   Stream &ThenNormalizeWithDimensions(
691:   Stream &ThenNormalizeBackwardWithDimensions(
700:   Stream &ThenActivate(dnn::ActivationMode activation_mode,
707:   Stream &ThenActivateWithOptions(dnn::ActivationMode activation_mode,
713:   Stream &ThenDepthConcatenate(
718:   Stream &ThenSpaceConcatenate(
728:   Stream &ThenReshape(const dnn::BatchDescriptor &input_dimensions,
739:   Stream &ThenDepthToSpace(const dnn::BatchDescriptor &input_dimensions,
750:   Stream &ThenSpaceToDepth(const dnn::BatchDescriptor &input_dimensions,
756:   Stream &ThenElementwiseOperate(
763:   Stream &ThenElementwiseOperateScaledQuantized(
771:   Stream &ThenXYPad(const dnn::BatchDescriptor &dimensions,
776:   Stream &ThenXYSlice(const dnn::BatchDescriptor &dimensions,
784:   Stream &ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,
790:   Stream &ThenMemcpyD2HQuantized(const DeviceMemory<float> &gpu_unquantized_src,
798:   Stream &ThenMemcpyD2HQuantized(
807:   Stream &ThenMemcpyH2DQuantized(const void *host_src, uint64 size,
815:   Stream &ThenMemcpyH2DQuantized(port::ArraySlice<ElementType> host_src,
823:   Stream &ThenCopyHostBuffer2Device(HostBuffer *buffer_src,
827:   Stream &ThenCopyDevice2HostBuffer(
834:   Stream &ThenBlasAsum(uint64 elem_count, const DeviceMemory<float> &x,
836:   Stream &ThenBlasAsum(uint64 elem_count, const DeviceMemory<double> &x,
838:   Stream &ThenBlasAsum(uint64 elem_count,
841:   Stream &ThenBlasAsum(uint64 elem_count,
850:   Stream &ThenBlasAxpy(uint64 elem_count, float alpha,
853:   Stream &ThenBlasAxpy(uint64 elem_count, double alpha,
856:   Stream &ThenBlasAxpy(uint64 elem_count, std::complex<float> alpha,
859:   Stream &ThenBlasAxpy(uint64 elem_count, std::complex<double> alpha,
864:   Stream &ThenBlasCopy(uint64 elem_count, const DeviceMemory<float> &x,
866:   Stream &ThenBlasCopy(uint64 elem_count, const DeviceMemory<double> &x,
868:   Stream &ThenBlasCopy(uint64 elem_count,
871:   Stream &ThenBlasCopy(uint64 elem_count,
876:   Stream &ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x, int incx,
879:   Stream &ThenBlasDot(uint64 elem_count, const DeviceMemory<double> &x,
884:   Stream &ThenBlasDotc(uint64 elem_count,
888:   Stream &ThenBlasDotc(uint64 elem_count,
894:   Stream &ThenBlasDotu(uint64 elem_count,
898:   Stream &ThenBlasDotu(uint64 elem_count,
904:   Stream &ThenBlasNrm2(uint64 elem_count, const DeviceMemory<float> &x,
906:   Stream &ThenBlasNrm2(uint64 elem_count, const DeviceMemory<double> &x,
908:   Stream &ThenBlasNrm2(uint64 elem_count,
911:   Stream &ThenBlasNrm2(uint64 elem_count,
916:   Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<float> *x, int incx,
918:   Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<double> *x, int incx,
920:   Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<std::complex<float>> *x,
923:   Stream &ThenBlasRot(uint64 elem_count, DeviceMemory<std::complex<double>> *x,
928:   Stream &ThenBlasRotg(DeviceMemory<float> *a, DeviceMemory<float> *b,
930:   Stream &ThenBlasRotg(DeviceMemory<double> *a, DeviceMemory<double> *b,
932:   Stream &ThenBlasRotg(DeviceMemory<std::complex<float>> *a,
936:   Stream &ThenBlasRotg(DeviceMemory<std::complex<double>> *a,
942:   Stream &ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x, int incx,
945:   Stream &ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x, int incx,
950:   Stream &ThenBlasRotmg(DeviceMemory<float> *d1, DeviceMemory<float> *d2,
953:   Stream &ThenBlasRotmg(DeviceMemory<double> *d1, DeviceMemory<double> *d2,
959:   Stream &ThenBlasScal(uint64 elem_count, float alpha, DeviceMemory<float> *x,
961:   Stream &ThenBlasScal(uint64 elem_count, double alpha, DeviceMemory<double> *x,
963:   Stream &ThenBlasScal(uint64 elem_count, float alpha,
965:   Stream &ThenBlasScal(uint64 elem_count, double alpha,
967:   Stream &ThenBlasScal(uint64 elem_count, std::complex<float> alpha,
969:   Stream &ThenBlasScal(uint64 elem_count, std::complex<double> alpha,
973:   Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<float> *x, int incx,
975:   Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<double> *x, int incx,
977:   Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<std::complex<float>> *x,
980:   Stream &ThenBlasSwap(uint64 elem_count, DeviceMemory<std::complex<double>> *x,
985:   Stream &ThenBlasIamax(uint64 elem_count, const DeviceMemory<float> &x,
987:   Stream &ThenBlasIamax(uint64 elem_count, const DeviceMemory<double> &x,
989:   Stream &ThenBlasIamax(uint64 elem_count,
992:   Stream &ThenBlasIamax(uint64 elem_count,
997:   Stream &ThenBlasIamin(uint64 elem_count, const DeviceMemory<float> &x,
999:   Stream &ThenBlasIamin(uint64 elem_count, const DeviceMemory<double> &x,
1001:   Stream &ThenBlasIamin(uint64 elem_count,
1004:   Stream &ThenBlasIamin(uint64 elem_count,
1009:   Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,
1013:   Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,
1017:   Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,
1023:   Stream &ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n, uint64 kl,
1031:   Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n, float alpha,
1035:   Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n, double alpha,
1039:   Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
1045:   Stream &ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
1052:   Stream &ThenBlasGemvWithProfiling(blas::Transpose trans, uint64 m, uint64 n,
1058:   Stream &ThenBlasGemvWithProfiling(blas::Transpose trans, uint64 m, uint64 n,
1064:   Stream &ThenBlasGemvWithProfiling(
1070:   Stream &ThenBlasGemvWithProfiling(
1078:   Stream &ThenBlasGer(uint64 m, uint64 n, float alpha,
1082:   Stream &ThenBlasGer(uint64 m, uint64 n, double alpha,
1088:   Stream &ThenBlasGerc(uint64 m, uint64 n, std::complex<float> alpha,
1092:   Stream &ThenBlasGerc(uint64 m, uint64 n, std::complex<double> alpha,
1098:   Stream &ThenBlasGeru(uint64 m, uint64 n, std::complex<float> alpha,
1102:   Stream &ThenBlasGeru(uint64 m, uint64 n, std::complex<double> alpha,
1108:   Stream &ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
1114:   Stream &ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
1122:   Stream &ThenBlasHemv(blas::UpperLower uplo, uint64 n,
1128:   Stream &ThenBlasHemv(blas::UpperLower uplo, uint64 n,
1136:   Stream &ThenBlasHer(blas::UpperLower uplo, uint64 n, float alpha,
1139:   Stream &ThenBlasHer(blas::UpperLower uplo, uint64 n, double alpha,
1144:   Stream &ThenBlasHer2(blas::UpperLower uplo, uint64 n,
1149:   Stream &ThenBlasHer2(blas::UpperLower uplo, uint64 n,
1156:   Stream &ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
1162:   Stream &ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
1170:   Stream &ThenBlasHpr(blas::UpperLower uplo, uint64 n, float alpha,
1173:   Stream &ThenBlasHpr(blas::UpperLower uplo, uint64 n, double alpha,
1178:   Stream &ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
1183:   Stream &ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
1190:   Stream &ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k, float alpha,
1194:   Stream &ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k, double alpha,
1200:   Stream &ThenBlasSpmv(blas::UpperLower uplo, uint64 n, float alpha,
1204:   Stream &ThenBlasSpmv(blas::UpperLower uplo, uint64 n, double alpha,
1210:   Stream &ThenBlasSpr(blas::UpperLower uplo, uint64 n, float alpha,
1213:   Stream &ThenBlasSpr(blas::UpperLower uplo, uint64 n, double alpha,
1218:   Stream &ThenBlasSpr2(blas::UpperLower uplo, uint64 n, float alpha,
1222:   Stream &ThenBlasSpr2(blas::UpperLower uplo, uint64 n, double alpha,
1228:   Stream &ThenBlasSymv(blas::UpperLower uplo, uint64 n, float alpha,
1232:   Stream &ThenBlasSymv(blas::UpperLower uplo, uint64 n, double alpha,
1238:   Stream &ThenBlasSyr(blas::UpperLower uplo, uint64 n, float alpha,
1241:   Stream &ThenBlasSyr(blas::UpperLower uplo, uint64 n, double alpha,
1246:   Stream &ThenBlasSyr2(blas::UpperLower uplo, uint64 n, float alpha,
1250:   Stream &ThenBlasSyr2(blas::UpperLower uplo, uint64 n, double alpha,
1256:   Stream &ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
1260:   Stream &ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
1264:   Stream &ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
1268:   Stream &ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
1274:   Stream &ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
1278:   Stream &ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
1282:   Stream &ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
1286:   Stream &ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
1292:   Stream &ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
1296:   Stream &ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
1300:   Stream &ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
1304:   Stream &ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
1310:   Stream &ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
1314:   Stream &ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
1318:   Stream &ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
1322:   Stream &ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
1328:   Stream &ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
1332:   Stream &ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
1336:   Stream &ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
1340:   Stream &ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
1346:   Stream &ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
1350:   Stream &ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
1354:   Stream &ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
1358:   Stream &ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
1364:   TF_EXPORT Stream &ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
1370:   TF_EXPORT Stream &ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
1375:   TF_EXPORT Stream &ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
1380:   TF_EXPORT Stream &ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
1388:   TF_EXPORT Stream &ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
1398:   Stream &ThenBlasGemmWithProfiling(blas::Transpose transa,
1406:   Stream &ThenBlasGemmWithProfiling(blas::Transpose transa,
1413:   Stream &ThenBlasGemmWithProfiling(blas::Transpose transa,
1421:   Stream &ThenBlasGemmWithProfiling(
1428:   Stream &ThenBlasGemmWithProfiling(
1437:   Stream &ThenBlasGemmWithAlgorithm(
1446:   Stream &ThenBlasGemmWithAlgorithm(
1454:   Stream &ThenBlasGemmWithAlgorithm(
1462:   Stream &ThenBlasGemmWithAlgorithm(
1470:   Stream &ThenBlasGemmWithAlgorithm(
1479:   Stream &ThenBlasGemmWithAlgorithm(
1490:   Stream &ThenBlasGemmBatched(
1497:   Stream &ThenBlasGemmBatched(blas::Transpose transa, blas::Transpose transb,
1505:   Stream &ThenBlasGemmBatched(blas::Transpose transa, blas::Transpose transb,
1513:   Stream &ThenBlasGemmBatched(
1521:   Stream &ThenBlasGemmBatched(
1529:   Stream &ThenBlasGemmBatchedWithScratch(
1536:   Stream &ThenBlasGemmBatchedWithScratch(
1542:   Stream &ThenBlasGemmBatchedWithScratch(
1548:   Stream &ThenBlasGemmBatchedWithScratch(
1556:   Stream &ThenBlasGemmBatchedWithScratch(
1564:   Stream &ThenBlasGemmStridedBatched(
1570:   Stream &ThenBlasGemmStridedBatched(
1576:   Stream &ThenBlasGemmStridedBatched(
1582:   Stream &ThenBlasGemmStridedBatched(
1589:   Stream &ThenBlasGemmStridedBatched(
1598:   Stream &ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
1604:   Stream &ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
1612:   Stream &ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1617:   Stream &ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1624:   Stream &ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1630:   Stream &ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1638:   Stream &ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
1642:   Stream &ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
1646:   Stream &ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
1652:   Stream &ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
1660:   Stream &ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1663:   Stream &ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1666:   Stream &ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1671:   Stream &ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1678:   Stream &ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1682:   Stream &ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1686:   Stream &ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1692:   Stream &ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans, uint64 n,
1700:   Stream &ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
1704:   Stream &ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
1708:   Stream &ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
1713:   Stream &ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
1720:   Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
1724:   Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
1728:   Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
1733:   Stream &ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
1740:   Stream &ThenFft(fft::Plan *plan,
1743:   Stream &ThenFft(fft::Plan *plan,
1746:   Stream &ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,
1748:   Stream &ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,
1750:   Stream &ThenFft(fft::Plan *plan,
1753:   Stream &ThenFft(fft::Plan *plan,
1774:   Stream &ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes);
1781:   Stream &ThenPopulateRandUniform(DeviceMemory<float> *values);
1782:   Stream &ThenPopulateRandUniform(DeviceMemory<double> *values);
1783:   Stream &ThenPopulateRandUniform(DeviceMemory<std::complex<float>> *values);
1784:   Stream &ThenPopulateRandUniform(DeviceMemory<std::complex<double>> *values);
1785:   Stream &ThenPopulateRandGaussian(float mean, float stddev,
1787:   Stream &ThenPopulateRandGaussian(double mean, double stddev,
1794:   Stream &ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,
1801:   Stream &ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,
1808:   Stream &ThenMemcpyD2H(const DeviceMemory<T> &gpu_src,
1819:   Stream &ThenMemcpyH2D(port::ArraySlice<T> host_src,
1829:   Stream &ThenMemcpy(DeviceMemoryBase *gpu_dst, const DeviceMemoryBase &gpu_src,
1835:   Stream &ThenMemcpyD2D(DeviceMemoryBase *gpu_dst,
1842:   Stream &ThenMemZero(DeviceMemoryBase *location, uint64 size);
1847:   Stream &ThenMemset32(DeviceMemoryBase *location, uint32 pattern, uint64 size);
1851:   Stream &ThenRnnForward(const dnn::RnnDescriptor &rnn_desc,
1870:   Stream &ThenRnnForward(const dnn::RnnDescriptor &rnn_desc,
1888:   Stream &ThenRnnForward(const dnn::RnnDescriptor &rnn_desc,
1908:   Stream &ThenRnnBackward(
1934:   Stream &ThenRnnBackward(const dnn::RnnDescriptor &rnn_desc,
1959:   Stream &ThenRnnBackward(const dnn::RnnDescriptor &rnn_desc,
1986:   Stream &ThenTransformTensor(const dnn::BatchDescriptor &input_desc,
1996:   Stream &ThenTransformTensor(const dnn::BatchDescriptor &input_desc,
2027:   // parameter will still be valid - this Stream may not be!
2029:   Stream &ThenEnqueueOnBackgroundThread(
2043:   Stream &ThenDoHostCallback(std::function<void()> callback);
2057:   Stream &ThenDoHostCallbackWithStatus(std::function<port::Status()> callback);
2126:   std::vector<std::pair<std::unique_ptr<Stream>, bool>> sub_streams_
2137:   Stream &ThenConvolveBackwardBiasImpl(
2143:   SE_DISALLOW_COPY_AND_ASSIGN(Stream);
2151: Stream::AllocateTemporaryArray(uint64 element_count) {
2155: inline internal::TemporaryMemoryManager *Stream::temporary_memory_manager() {
18: // be created between Streams to do task management (i.e. limit which tasks
57: class StreamInterface;
74: class StreamExecutor;
96:   // StreamExecutor's platform.
103:   // Deallocates any stream resources that the parent StreamExecutor has
116:   // Initializes timer t via the StreamExecutor.
165:   // items in the stream's execution). Streams may be started/stopped multiple
1792:   // allocated by StreamExecutor::HostMemoryAllocate or otherwise allocated and
1793:   // then registered with StreamExecutor::HostMemoryRegister.
1799:   // allocated by StreamExecutor::HostMemoryAllocate or otherwise allocated and
1800:   // then registered with StreamExecutor::HostMemoryRegister.
1828:   // peer access must be enabled between their owning StreamExecutors.
2026:   // The ONLY lifetime guarantee in these calls is that the StreamExecutor
2030:       std::function<void(StreamExecutor *)> task);
2034:   internal::StreamInterface *implementation() { return implementation_.get(); }
2059:   // Returns the StreamExecutor (parent object) associated with this stream.
2060:   StreamExecutor *parent() const {
2099:     LOG(WARNING) << "attempting to perform DNN operation using StreamExecutor "
2103:   // The StreamExecutor that supports the operation of this stream.
2104:   StreamExecutor *parent_;
2106:   // The platform-dependent implementation that the StreamExecutor interface
2108:   std::unique_ptr<internal::StreamInterface> implementation_;
2116:   // See StreamExecutor::AllocateStream.
2129:   // Streams can allocate temporary memories to help with work they enqueue
2070:   string DebugStreamPointers() const;
github.com/apache/orc:proto/orc_proto.proto: [ master, ]
118: message Stream {
162:   repeated Stream streams = 1;
176:   repeated Stream streams = 1;
315:   repeated Stream stripeStatistics = 4;
120:   // StreamName to ensure it is added to the stripe in the right area
android.googlesource.com/platform/external/llvm_35a:include/llvm/Support/YAMLParser.h: [ master, ]
77: class Stream {
20: //  The most important class here is Stream. This represents a YAML stream with
25: //  yaml::Stream stream(input, sm);
80:   Stream(StringRef Input, SourceMgr &);
83:   Stream(MemoryBuffer *InputBuffer, SourceMgr &);
84:   ~Stream();
460: /// \brief A YAML Stream is a sequence of Documents. A document contains a root
467:   Document(Stream &ParentStream);
486:   /// \brief Stream to read tokens from.
487:   Stream &stream;
518: /// \brief Iterator abstraction for Documents over a Stream.
537:       Stream &S = (*Doc)->stream;
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) {
github.com/apache/netbeans:nb/o.n.upgrader/src/org/netbeans/upgrade/systemoptions/SerParser.java: [ master, ]
252:     public static final class Stream /*extends Thing*/ {
93:     public Stream parse() throws IOException, CorruptException {
94:         Stream s = new Stream();
257:             return "Stream[contents=" + contents + "]"; // NOI18N
69:     private final InputStream is;
73:     public SerParser(InputStream is) {
65: public final class SerParser implements ObjectStreamConstants {
android.googlesource.com/platform/external/jetbrains/jdk8u_jdk:src/share/transport/shmem/shmemBase.c: [ master, ]
122: typedef struct Stream {
128: } Stream;
98: typedef struct SharedStream {
106: } SharedStream;
360: closeStream(Stream *stream, jboolean linger)
400: createStream(char *name, Stream *stream)
440: openStream(Stream *stream)
131:  * Values for Stream.state field above.
138:  * This catches a freed Stream as long as the memory page is still
149:     Stream incoming;
150:     Stream outgoing;
278: leaveMutex(Stream *stream)
285: enterMutex(Stream *stream, sys_event_t event)
307: waitForSpace(SharedMemoryConnection *connection, Stream *stream)
325: signalSpace(Stream *stream)
335: waitForData(SharedMemoryConnection *connection, Stream *stream)
353: signalData(Stream *stream)
940:     Stream *stream = &connection->outgoing;
965:     Stream *stream = &connection->incoming;
990:     Stream *stream = &connection->outgoing;
1062:     Stream *stream = &connection->incoming;
113:     SharedStream toClient;
114:     SharedStream toServer;
126:     SharedStream *shared;
416:         (void)closeStream(stream, JNI_FALSE);
424:         (void)closeStream(stream, JNI_FALSE);
450:         (void)closeStream(stream, JNI_FALSE);
458:         (void)closeStream(stream, JNI_FALSE);
500:     (void)closeStream(&connection->outgoing, JNI_TRUE);
501:     (void)closeStream(&connection->incoming, JNI_FALSE);
552:     error = openStream(&connection->incoming);
558:     error = openStream(&connection->outgoing);
620:     error = createStream(streamPrefix, &connection->incoming);
628:     error = createStream(streamPrefix, &connection->outgoing);
941:     SharedStream *shared = stream->shared;
966:     SharedStream *shared = stream->shared;
991:     SharedStream *shared = stream->shared;
1063:     SharedStream *shared = stream->shared;
android.googlesource.com/platform/packages/apps/TV:tuner/src/com/android/tv/tuner/ts/TsParser.java: [ master, ]
98:     private abstract static class Stream {
118:     private class SectionStream extends Stream {
122:         public SectionStream(int pid) {
61:     private final SparseArray<Stream> mStreamMap = new SparseArray<>();
484:         Stream stream = mStreamMap.get(pid);
538:             Stream stream = mStreamMap.get(eitPid);
461:         mStreamMap.put(pid, new SectionStream(pid));
54:      * Using a SparseArray removes the need to auto box the int key for mStreamMap
59:      * mStreamMap is the only one called at such a high rate.
210:                             if (mStreamMap.get(i.getTableTypePid()) != null) {
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
github.com/GoogleCloudPlatform/professional-services:examples/ml-audio-content-profiling/app/angular/node_modules/xml2js/node_modules/sax/lib/sax.js: [ master, ]
161:   var Stream
165:     Stream = function () {}
262:     return Stream.prototype.on.call(me, ev, handler)
172:   function createStream (strict, opt) {
163:     Stream = require('stream').Stream
181:     Stream.apply(this)
222:   SAXStream.prototype = Object.create(Stream.prototype, {
4:   sax.SAXStream = SAXStream
5:   sax.createStream = createStream
173:     return new SAXStream(strict, opt)
176:   function SAXStream (strict, opt) {
177:     if (!(this instanceof SAXStream)) {
178:       return new SAXStream(strict, opt)
224:       value: SAXStream
228:   SAXStream.prototype.write = function (data) {
244:   SAXStream.prototype.end = function (chunk) {
252:   SAXStream.prototype.on = function (ev, handler) {
github.com/GoogleCloudPlatform/professional-services:examples/ml-audio-content-profiling/app/angular/node_modules/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) {
github.com/grpc/grpc-go:internal/transport/transport.go: [ master, ]
233: type Stream struct {
139: 	closeStream func(error) // Closes the client transport stream with the given error and nil trailer metadata.
638: 	NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)
644: 	CloseStream(stream *Stream, err error)
516: 	MaxStreams            uint32
678: 	HandleStreams(func(*Stream), func(context.Context, string) context.Context)
752: 	errStreamDrain = status.Error(codes.Unavailable, "the connection is draining")
755: 	errStreamDone = errors.New("the stream is done")
792: 	lastStreamCreatedTime int64
232: // Stream represents an RPC in the transport layer.
235: 	st           ServerTransport    // nil for client side Stream
236: 	ct           *http2Client       // nil for server side Stream
238: 	cancel       context.CancelFunc // always nil for client side Stream
289: func (s *Stream) isHeaderSent() bool {
295: func (s *Stream) updateHeaderSent() bool {