Found 356033 results in 37204 files, showing top 50 files (show more).
github.com/GoogleCloudPlatform/appengine-php-sdk:src/Api/UrlFetch/UrlFetchStream.php: [ master, ]
25: use GuzzleHttp\Stream\Stream;
26: use GuzzleHttp\Stream\CachingStream;
32: class UrlFetchStream implements IteratorAggregate, ArrayAccess 
259:      * Opens URL Stream.
302:             $this->stream = new CachingStream(Stream::factory($resp->getContent()));
315:      * Closes URL Stream.
263:      * @param int $optionsStream UNUSED in the context of URLs.
270:     public function stream_open(string $url, string $mode, int $optionsStream, &$openedPath): bool
android.googlesource.com/platform/frameworks/ex:framesequence/jni/Stream.h: [ master, ]
24: class Stream {
44: class MemoryStream : public Stream {
46:     MemoryStream(void* buffer, size_t size, jobject buf) :
63: class FileStream : public Stream {
65:     FileStream(FILE* fd) : mFd(fd) {}
74: class JavaInputStream : public Stream {
76:     JavaInputStream(JNIEnv* env, jobject inputStream, jbyteArray byteArray) :
87:     const jobject mInputStream;
26:     Stream();
27:     virtual ~Stream();
78:             mInputStream(inputStream),
92: jint JavaStream_OnLoad(JNIEnv* env);
github.com/sparkfun/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/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/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/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/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/apache/superset:superset/translations/pt_BR/LC_MESSAGES/messages.json: [ master, ]
4590:       "Stream": ["Fluxo"],
github.com/apache/superset:superset/translations/de/LC_MESSAGES/messages.json: [ master, ]
4585:       "Stream": ["Stream"],
6564:       "stream": ["Stream"],
github.com/llvm-mirror/llvm:tools/llvm-pdbutil/llvm-pdbutil.cpp: [ master, ]
731:     Stream("stream", cl::Required,
641: cl::opt<bool> StreamMetadata(
645: cl::opt<bool> StreamDirectory(
649: cl::opt<bool> PdbStream("pdb-stream",
656: cl::opt<bool> DbiStream("dbi-stream",
660: cl::opt<bool> TpiStream("tpi-stream",
664: cl::opt<bool> IpiStream("ipi-stream",
668: cl::opt<bool> PublicsStream("publics-stream",
1356: static void exportStream() {
387:     DumpStreamData("stream-data", cl::CommaSeparated, cl::ZeroOrMore,
454: cl::opt<bool> DumpStreams("streams",
457: cl::opt<bool> DumpStreamBlocks(
591: cl::opt<bool> DumpNamedStreams("named-streams",
368: cl::OptionCategory DbiBytes("Dbi Stream Options");
369: cl::OptionCategory PdbBytes("PDB Stream Options");
650:                         cl::desc("Dump the PDB Stream (Stream 1)"),
657:                         cl::desc("Dump the DBI Stream Headers (Stream 2)"),
661:                         cl::desc("Dump the TPI Stream (Stream 3)"),
665:                         cl::desc("Dump the IPI Stream (Stream 5)"),
669:                             cl::desc("Dump the Publics Stream"),
1064:   auto &Stream = outs();
1066:                             ? Stream.has_colors()
1068:   LinePrinter Printer(2, UseColor, Stream);
1368:     if (to_integer(opts::exportstream::Stream, Index)) {
1381:     Index = ExitOnErr(IS.getNamedStreamIndex(opts::exportstream::Stream));
1382:     outs() << "Dumping contents of stream '" << opts::exportstream::Stream
53: #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
61: #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
75: #include "llvm/Support/BinaryByteStream.h"
713:                clEnumValN(InputFileType::PDBStream, "pdb-stream",
715:                clEnumValN(InputFileType::DBIStream, "dbi-stream",
719:                clEnumValN(InputFileType::ModuleStream, "mod-stream",
773:     ExitOnErr(Builder.getMsfBuilder().addStream(0));
783:   pdb::yaml::PdbInfoStream DefaultInfoStream;
784:   pdb::yaml::PdbDbiStream DefaultDbiStream;
785:   pdb::yaml::PdbTpiStream DefaultTpiStream;
786:   pdb::yaml::PdbTpiStream DefaultIpiStream;
788:   const auto &Info = YamlObj.PdbStream.getValueOr(DefaultInfoStream);
798:   const auto &Dbi = YamlObj.DbiStream.getValueOr(DefaultDbiStream);
814:       const auto &ModiStream = *MI.Modi;
815:       for (auto Symbol : ModiStream.Symbols) {
833:   const auto &Tpi = YamlObj.TpiStream.getValueOr(DefaultTpiStream);
841:   const auto &Ipi = YamlObj.IpiStream.getValueOr(DefaultIpiStream);
1304:     if (File.hasPDBTpiStream()) {
1305:       auto &Tpi = ExitOnErr(File.getPDBTpiStream());
1309:     if (File.hasPDBIpiStream()) {
1310:       auto &Ipi = ExitOnErr(File.getPDBIpiStream());
1322:     ExitOnErr(Builder.getMsfBuilder().addStream(0));
1360:   std::unique_ptr<MappedBlockStream> SourceStream;
1380:     InfoStream &IS = cantFail(File.getPDBInfoStream());
1386:   SourceStream = File.createIndexedStream(Index);
1388:       FileOutputBuffer::create(OutFileName, SourceStream->getLength()));
1389:   FileBufferByteStream DestStream(std::move(OutFile), llvm::support::little);
1390:   BinaryStreamWriter Writer(DestStream);
1391:   ExitOnErr(Writer.writeStreamRef(*SourceStream));
1392:   ExitOnErr(DestStream.commit());
1479:       opts::pdb2yaml::StreamMetadata = true;
1480:       opts::pdb2yaml::StreamDirectory = true;
1481:       opts::pdb2yaml::PdbStream = true;
1483:       opts::pdb2yaml::DbiStream = true;
1484:       opts::pdb2yaml::TpiStream = true;
1485:       opts::pdb2yaml::IpiStream = true;
1486:       opts::pdb2yaml::PublicsStream = true;
1499:       opts::pdb2yaml::DbiStream = true;
1566:     exportStream();
45: #include "llvm/DebugInfo/CodeView/TypeStreamMerger.h"
52: #include "llvm/DebugInfo/PDB/Native/DbiStreamBuilder.h"
54: #include "llvm/DebugInfo/PDB/Native/InfoStreamBuilder.h"
62: #include "llvm/DebugInfo/PDB/Native/TpiStreamBuilder.h"
772:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)
1321:   for (uint32_t I = 0; I < kSpecialStreamCount; ++I)
1369:       if (Index >= File.getNumStreams()) {
1463:       opts::dump::DumpStreams = true;
1464:       opts::dump::DumpStreamBlocks = true;
github.com/tensorflow/fold:tensorflow/tensorflow/stream_executor/stream.cc: [ master, ]
236: Stream::Stream(StreamExecutor *parent)
245: Stream::Stream(StreamExecutor *parent,
255: Stream::~Stream() {
1793: Stream *Stream::GetOrCreateSubStream() {
1810: void Stream::ReturnSubStream(Stream *sub_stream) {
195: // there are on Stream and how many parameters they each have.
196: string CallStr(const char *function_name, Stream *stream,
202:   string str = port::StrCat("Called Stream::", function_name, "(");
265: Stream &Stream::Init() {
284: Stream &Stream::InitTimer(Timer *timer) {
295: Stream &Stream::InitWithTimer(Timer *timer) {
301: Stream &Stream::ThenRecordEvent(Event *event) {
314: Stream &Stream::ThenBatchNormalizationForward(
342: Stream &Stream::ThenBatchNormalizationBackward(
364: Stream &Stream::ThenBatchNormalizationForward(
392: Stream &Stream::ThenBatchNormalizationBackward(
415: Stream &Stream::ThenFusedConvolveWithScratch(
448: Stream &Stream::ThenFusedConvolveWithScratch(
482: Stream &Stream::ThenFusedConvolveWithScratch(
515: Stream &Stream::ThenConvolveWithScratch(
542: Stream &Stream::ThenConvolveWithScratch(
569: Stream &Stream::ThenFusedConvolveWithAlgorithm(
607: Stream &Stream::ThenFusedConvolveWithAlgorithm(
646: Stream &Stream::ThenFusedConvolveWithAlgorithm(
684: Stream &Stream::ThenConvolveWithAlgorithm(
715: Stream &Stream::ThenConvolveWithAlgorithm(
746: Stream &Stream::ThenFusedConvolve(
764: Stream &Stream::ThenConvolve(
778: Stream &Stream::ThenConvolveQuantized(
808: Stream &Stream::ThenConvolveQuantized(
838: Stream &Stream::ThenSeparableConvolve(
865: Stream &Stream::ThenConvolveBackwardDataWithScratch(
893: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
926: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
959: Stream &Stream::ThenConvolveBackwardDataWithScratch(
987: Stream &Stream::ThenConvolveBackwardData(
1001: Stream &Stream::ThenConvolveBackwardFilterWithScratch(
1029: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
1062: Stream &Stream::ThenConvolveBackwardFilterWithScratch(
1090: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
1123: Stream &Stream::ThenConvolveBackwardFilter(
1138: Stream &Stream::ThenConvolveBackwardBiasImpl(
1158: Stream &Stream::ThenConvolveBackwardBias(
1167: Stream &Stream::ThenConvolveBackwardBias(
1176: Stream &Stream::ThenConvolveBackwardBias(
1185: Stream &Stream::ThenMatMul(const DeviceMemory<float> &input_data,
1204: Stream &Stream::ThenMatMulQuantized(
1226: Stream &Stream::ThenMatMulQuantized(
1248: Stream &Stream::ThenBiasAdd(const DeviceMemory<float> &input_data,
1266: Stream &Stream::ThenPoolForward(
1290: Stream &Stream::ThenPoolForward(
1311: Stream &Stream::ThenPoolForward(
1332: Stream &Stream::ThenPoolBackward(
1359: Stream &Stream::ThenPoolBackward(
1383: Stream &Stream::ThenPoolBackward(
1407: Stream &Stream::ThenNormalize(
1423: Stream &Stream::ThenNormalizeWithDimensions(
1441: Stream &Stream::ThenNormalizeBackwardWithDimensions(
1463: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,
1471: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,
1490: Stream &Stream::ThenDepthConcatenate(
1520: Stream &Stream::ThenSpaceConcatenate(
1567: Stream &Stream::ThenReshape(const dnn::BatchDescriptor &input_dimensions,
1585: Stream &Stream::ThenDepthToSpace(
1606: Stream &Stream::ThenSpaceToDepth(
1627: Stream &Stream::ThenElementwiseOperate(
1648: Stream &Stream::ThenElementwiseOperateScaledQuantized(
1671: Stream &Stream::ThenXYPad(const dnn::BatchDescriptor &dimensions,
1690: Stream &Stream::ThenXYSlice(const dnn::BatchDescriptor &dimensions,
1711: Stream &Stream::ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,
1729: Stream &Stream::ThenMemcpyD2HQuantized(
1746: Stream &Stream::ThenMemcpyH2DQuantized(
1763: Stream &Stream::ThenCopyHostBuffer2Device(
1778: Stream &Stream::ThenCopyDevice2HostBuffer(
1801:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},
1803:   Stream *sub_stream = sub_streams_.back().first.get();
1821: Stream &Stream::ThenStartTimer(Timer *t) {
1832: Stream &Stream::ThenStopTimer(Timer *t) {
1843: Stream &Stream::ThenWaitFor(Stream *other) {
1856: Stream &Stream::ThenWaitFor(Event *event) {
1878:   // arguments except the first one of Stream* type.
1879:   Stream &operator()(Stream *stream,
1880:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1887:   Stream &Run(Stream *stream,
1888:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1893: Stream &ThenBlasImpl<Args...>::Run(
1894:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1913: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<float> &x,
1923: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<double> &x,
1933: Stream &Stream::ThenBlasAsum(uint64 elem_count,
1944: Stream &Stream::ThenBlasAsum(uint64 elem_count,
1955: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,
1967: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,
1979: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<float> alpha,
1993: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<double> alpha,
2007: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<float> &x,
2017: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<double> &x,
2027: Stream &Stream::ThenBlasCopy(uint64 elem_count,
2039: Stream &Stream::ThenBlasCopy(uint64 elem_count,
2051: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,
2063: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<double> &x,
2075: Stream &Stream::ThenBlasDotc(uint64 elem_count,
2091: Stream &Stream::ThenBlasDotc(uint64 elem_count,
2107: Stream &Stream::ThenBlasDotu(uint64 elem_count,
2123: Stream &Stream::ThenBlasDotu(uint64 elem_count,
2139: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<float> &x,
2149: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<double> &x,
2159: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
2170: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
2181: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<float> *x, int incx,
2193: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<double> *x,
2205: Stream &Stream::ThenBlasRot(uint64 elem_count,
2218: Stream &Stream::ThenBlasRot(uint64 elem_count,
2231: Stream &Stream::ThenBlasRotg(DeviceMemory<float> *a, DeviceMemory<float> *b,
2240: Stream &Stream::ThenBlasRotg(DeviceMemory<double> *a, DeviceMemory<double> *b,
2249: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<float>> *a,
2261: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<double>> *a,
2273: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,
2285: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,
2297: Stream &Stream::ThenBlasRotmg(DeviceMemory<float> *d1, DeviceMemory<float> *d2,
2309: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,
2322: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
2330: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
2338: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
2346: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
2354: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<float> alpha,
2363: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<double> alpha,
2372: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<float> *x,
2382: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<double> *x,
2392: Stream &Stream::ThenBlasSwap(uint64 elem_count,
2403: Stream &Stream::ThenBlasSwap(uint64 elem_count,
2414: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<float> &x,
2424: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<double> &x,
2434: Stream &Stream::ThenBlasIamax(uint64 elem_count,
2445: Stream &Stream::ThenBlasIamax(uint64 elem_count,
2456: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<float> &x,
2466: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<double> &x,
2476: Stream &Stream::ThenBlasIamin(uint64 elem_count,
2487: Stream &Stream::ThenBlasIamin(uint64 elem_count,
2498: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2514: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2530: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2550: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2570: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2585: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2600: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2620: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2640: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, float alpha,
2654: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, double alpha,
2668: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<float> alpha,
2685: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<double> alpha,
2702: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<float> alpha,
2719: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<double> alpha,
2736: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2755: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2774: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
2793: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
2812: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, float alpha,
2826: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, double alpha,
2840: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
2858: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
2876: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
2894: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
2912: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, float alpha,
2924: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, double alpha,
2936: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
2953: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
2970: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2984: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2998: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, float alpha,
3012: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, double alpha,
3026: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, float alpha,
3037: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, double alpha,
3048: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, float alpha,
3062: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, double alpha,
3076: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, float alpha,
3090: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, double alpha,
3104: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, float alpha,
3116: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, double alpha,
3128: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, float alpha,
3142: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, double alpha,
3156: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3170: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3184: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3199: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3214: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3228: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3242: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3257: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3272: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3285: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3298: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3312: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3326: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3339: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3352: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3366: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3380: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3394: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3408: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3423: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3438: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3452: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3466: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3481: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3496: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3514: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3530: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3546: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3567: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3595:   Stream &operator()(Stream *stream,
3597:                          Stream *, Args..., blas::ProfileResult *),
3606: Stream &Stream::ThenBlasGemvWithProfiling(
3623: Stream &Stream::ThenBlasGemvWithProfiling(
3641: Stream &Stream::ThenBlasGemvWithProfiling(
3661: Stream &Stream::ThenBlasGemvWithProfiling(
3681: Stream &Stream::ThenBlasGemmWithProfiling(
3701: Stream &Stream::ThenBlasGemmWithProfiling(
3720: Stream &Stream::ThenBlasGemmWithProfiling(
3740: Stream &Stream::ThenBlasGemmWithProfiling(
3762: Stream &Stream::ThenBlasGemmWithProfiling(
3784: Stream &Stream::ThenBlasGemmWithAlgorithm(
3808: Stream &Stream::ThenBlasGemmWithAlgorithm(
3829: Stream &Stream::ThenBlasGemmWithAlgorithm(
3850: Stream &Stream::ThenBlasGemmWithAlgorithm(
3872: Stream &Stream::ThenBlasGemmWithAlgorithm(
3897: Stream &Stream::ThenBlasGemmWithAlgorithm(
3922: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
3942: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
3962: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
3977: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
3992: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
4011: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
4030: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4046: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4062: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4082: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4102: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4116: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4130: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4146: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4162: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4178: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4194: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4214: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4234: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4249: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4264: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4281: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4298: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4313: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4328: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4345: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4362: Stream &Stream::ThenBlasGemmBatched(
4373: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4394: Stream &Stream::ThenBlasGemmBatched(
4405: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4426: Stream &Stream::ThenBlasGemmBatched(
4439: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4465: Stream &Stream::ThenBlasGemmBatched(
4478: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4504: Stream &Stream::ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes) {
4522: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<float> *values) {
4537: Stream &Stream::ThenPopulateRandGaussian(float mean, float sd,
4553: Stream &Stream::ThenPopulateRandGaussian(double mean, double sd,
4569: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<double> *values) {
4584: Stream &Stream::ThenPopulateRandUniform(
4600: Stream &Stream::ThenPopulateRandUniform(
4617: Stream &Stream::ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,
4630: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,
4643: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst,
4656: Stream &Stream::ThenMemZero(DeviceMemoryBase *location, uint64 size) {
4668: Stream &Stream::ThenMemset32(DeviceMemoryBase *location, uint32 pattern,
4682: Stream &Stream::ThenRnnForward(
4714: Stream &Stream::ThenRnnForward(
4747: Stream &Stream::ThenRnnBackward(
4788: Stream &Stream::ThenRnnBackward(
4830: Stream &Stream::ThenTransformTensor(const dnn::BatchDescriptor &input_desc,
4851: Stream &Stream::ThenDoHostCallbackForTest(std::function<void()> callback) {
4857: Stream &Stream::ThenDoHostCallback(std::function<void()> callback) {
4869: Stream &Stream::ThenFft(fft::Plan *plan,
4886: Stream &Stream::ThenFft(fft::Plan *plan,
4903: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,
4919: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,
4935: Stream &Stream::ThenFft(fft::Plan *plan,
4952: Stream &Stream::ThenFft(fft::Plan *plan,
4971: Stream &Stream::ThenEnqueueOnBackgroundThread(
4983: bool Stream::BlockHostUntilDone() {
246:                internal::StreamInterface *implementation)
261:     parent_->DeallocateStream(this);
273:   if (parent_->AllocateStream(this)) {
801:           << "attempting to perform DNN operation using StreamExecutor "
831:           << "attempting to perform DNN operation using StreamExecutor "
1283:           << "attempting to perform DNN operation using StreamExecutor "
1352:           << "attempting to perform DNN operation using StreamExecutor "
1902:           << "attempting to perform BLAS operation using StreamExecutor "
4530:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4546:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4562:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4577:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4593:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4610:                 << " attempting to perform RNG operation using StreamExecutor "
4879:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4896:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4912:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4928:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4945:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4962:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4972:     std::function<void(StreamExecutor *)> task) {
4975:   StreamExecutor *stream_executor = this->parent_;
238:       implementation_(parent->implementation()->GetStreamImplementation()),
1848:     CheckError(parent_->CreateStreamDependency(this, other));
github.com/kubernetes/client-go:rest/request.go: [ master, ]
71: 	Stream(context.Context) (io.ReadCloser, error)
830: func (r *Request) Stream(ctx context.Context) (io.ReadCloser, error) {
770: func (r *Request) newStreamWatcher(resp *http.Response) (watch.Interface, error) {
826: // Stream formats and executes the request, and offers streaming of the response.
1086: 			klog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err)
776: 	objectDecoder, streamingSerializer, framer, err := r.c.content.Negotiator.StreamDecoder(mediaType, params)
1078: 		case http2.StreamError:
737: 			return r.newStreamWatcher(resp)
786: 	return watch.NewStreamWatcher(
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/tensorflow/deepmath:tensorflow/tensorflow/stream_executor/stream.cc: [ master, ]
249: Stream::Stream(StreamExecutor *parent)
258: Stream::Stream(StreamExecutor *parent,
268: Stream::~Stream() {
1738: Stream *Stream::GetOrCreateSubStream() {
1785: void Stream::ReturnSubStream(Stream *sub_stream) {
5277: string Stream::DebugStreamPointers() const {
207: // there are on Stream and how many parameters they each have.
208: string CallStr(const char *function_name, Stream *stream,
215:                             " Called Stream::", function_name, "(");
284: port::Status Stream::RefreshStatus() {
290: Stream &Stream::Init() {
309: Stream &Stream::InitTimer(Timer *timer) {
320: Stream &Stream::InitWithTimer(Timer *timer) {
326: Stream &Stream::ThenRecordEvent(Event *event) {
339: Stream &Stream::ThenBatchNormalizationForward(
367: Stream &Stream::ThenBatchNormalizationBackward(
389: Stream &Stream::ThenBatchNormalizationForward(
417: Stream &Stream::ThenBatchNormalizationBackward(
440: Stream &Stream::ThenFusedConvolveWithAlgorithm(
478: Stream &Stream::ThenFusedConvolveWithAlgorithm(
516: Stream &Stream::ThenFusedConvolveWithAlgorithm(
555: Stream &Stream::ThenFusedConvolveWithAlgorithm(
593: Stream &Stream::ThenConvolveWithAlgorithm(
635: Stream &Stream::ThenConvolveWithAlgorithm(
677: Stream &Stream::ThenConvolveWithAlgorithm(
719: Stream &Stream::ThenConvolve(
734: Stream &Stream::ThenConvolveQuantized(
764: Stream &Stream::ThenConvolveQuantized(
794: Stream &Stream::ThenSeparableConvolve(
821: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
866: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
911: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
956: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
1001: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
1046: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
1092: Stream &Stream::ThenConvolveBackwardBiasImpl(
1112: Stream &Stream::ThenConvolveBackwardBias(
1121: Stream &Stream::ThenConvolveBackwardBias(
1130: Stream &Stream::ThenConvolveBackwardBias(
1139: Stream &Stream::ThenMatMul(const DeviceMemory<float> &input_data,
1158: Stream &Stream::ThenMatMulQuantized(
1180: Stream &Stream::ThenMatMulQuantized(
1202: Stream &Stream::ThenBiasAdd(const DeviceMemory<float> &input_data,
1220: Stream &Stream::ThenPoolForward(
1245: Stream &Stream::ThenPoolForward(
1267: Stream &Stream::ThenPoolForward(
1290: Stream &Stream::ThenPoolForward(
1312: Stream &Stream::ThenPoolBackward(
1342: Stream &Stream::ThenPoolBackward(
1369: Stream &Stream::ThenPoolBackward(
1396: Stream &Stream::ThenNormalizeWithDimensions(
1414: Stream &Stream::ThenNormalizeBackwardWithDimensions(
1438: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,
1446: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,
1465: Stream &Stream::ThenDepthConcatenate(
1495: Stream &Stream::ThenSpaceConcatenate(
1542: Stream &Stream::ThenReshape(const dnn::BatchDescriptor &input_dimensions,
1560: Stream &Stream::ThenDepthToSpace(
1581: Stream &Stream::ThenSpaceToDepth(
1602: Stream &Stream::ThenElementwiseOperate(
1623: Stream &Stream::ThenElementwiseOperateScaledQuantized(
1646: Stream &Stream::ThenXYPad(const dnn::BatchDescriptor &dimensions,
1665: Stream &Stream::ThenXYSlice(const dnn::BatchDescriptor &dimensions,
1686: Stream &Stream::ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,
1704: Stream &Stream::ThenMemcpyD2HQuantized(
1721: Stream &Stream::ThenMemcpyH2DQuantized(
1744:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];
1747:       Stream *sub_stream = pair.first.get();
1772:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},
1774:   Stream *sub_stream = sub_streams_.back().first.get();
1790:     std::pair<std::unique_ptr<Stream>, bool> &pair = sub_streams_[index];
1820: Stream &Stream::ThenStartTimer(Timer *t) {
1832: Stream &Stream::ThenStopTimer(Timer *t) {
1844: Stream &Stream::ThenWaitFor(Stream *other) {
1858: Stream &Stream::ThenWaitFor(Event *event) {
1880:   // arguments except the first one of Stream* type.
1881:   Stream &operator()(Stream *stream,
1882:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1889:   Stream &Run(Stream *stream,
1890:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1895: Stream &ThenBlasImpl<Args...>::Run(
1896:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1915: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<float> &x,
1925: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<double> &x,
1935: Stream &Stream::ThenBlasAsum(uint64 elem_count,
1946: Stream &Stream::ThenBlasAsum(uint64 elem_count,
1957: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,
1969: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,
1981: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<float> alpha,
1995: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<double> alpha,
2009: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<float> &x,
2019: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<double> &x,
2029: Stream &Stream::ThenBlasCopy(uint64 elem_count,
2041: Stream &Stream::ThenBlasCopy(uint64 elem_count,
2053: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,
2065: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<double> &x,
2077: Stream &Stream::ThenBlasDotc(uint64 elem_count,
2093: Stream &Stream::ThenBlasDotc(uint64 elem_count,
2109: Stream &Stream::ThenBlasDotu(uint64 elem_count,
2125: Stream &Stream::ThenBlasDotu(uint64 elem_count,
2141: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<float> &x,
2151: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<double> &x,
2161: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
2172: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
2183: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<float> *x, int incx,
2195: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<double> *x,
2207: Stream &Stream::ThenBlasRot(uint64 elem_count,
2220: Stream &Stream::ThenBlasRot(uint64 elem_count,
2233: Stream &Stream::ThenBlasRotg(DeviceMemory<float> *a, DeviceMemory<float> *b,
2242: Stream &Stream::ThenBlasRotg(DeviceMemory<double> *a, DeviceMemory<double> *b,
2251: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<float>> *a,
2263: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<double>> *a,
2275: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,
2287: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,
2299: Stream &Stream::ThenBlasRotmg(DeviceMemory<float> *d1, DeviceMemory<float> *d2,
2311: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,
2324: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
2332: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
2340: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
2348: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
2356: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<float> alpha,
2365: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<double> alpha,
2374: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<float> *x,
2384: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<double> *x,
2394: Stream &Stream::ThenBlasSwap(uint64 elem_count,
2405: Stream &Stream::ThenBlasSwap(uint64 elem_count,
2416: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<float> &x,
2426: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<double> &x,
2436: Stream &Stream::ThenBlasIamax(uint64 elem_count,
2447: Stream &Stream::ThenBlasIamax(uint64 elem_count,
2458: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<float> &x,
2468: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<double> &x,
2478: Stream &Stream::ThenBlasIamin(uint64 elem_count,
2489: Stream &Stream::ThenBlasIamin(uint64 elem_count,
2500: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2516: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2532: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2552: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2572: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2587: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2602: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2622: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2642: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, float alpha,
2656: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, double alpha,
2670: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<float> alpha,
2687: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<double> alpha,
2704: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<float> alpha,
2721: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<double> alpha,
2738: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2757: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2776: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
2795: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
2814: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, float alpha,
2828: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, double alpha,
2842: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
2860: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
2878: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
2896: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
2914: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, float alpha,
2926: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, double alpha,
2938: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
2955: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
2972: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2986: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
3000: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, float alpha,
3014: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, double alpha,
3028: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, float alpha,
3039: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, double alpha,
3050: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, float alpha,
3064: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, double alpha,
3078: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, float alpha,
3092: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, double alpha,
3106: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, float alpha,
3118: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, double alpha,
3130: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, float alpha,
3144: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, double alpha,
3158: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3172: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3186: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3201: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
3216: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3230: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3244: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3259: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
3274: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3287: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3300: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3314: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
3328: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3341: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3354: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3368: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3382: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3396: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3410: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3425: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3440: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3454: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3468: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3483: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3498: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3516: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3532: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3548: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3569: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3597:   Stream &operator()(Stream *stream,
3599:                          Stream *, Args..., blas::ProfileResult *),
3608: Stream &Stream::ThenBlasGemvWithProfiling(
3625: Stream &Stream::ThenBlasGemvWithProfiling(
3643: Stream &Stream::ThenBlasGemvWithProfiling(
3663: Stream &Stream::ThenBlasGemvWithProfiling(
3683: Stream &Stream::ThenBlasGemmWithProfiling(
3703: Stream &Stream::ThenBlasGemmWithProfiling(
3722: Stream &Stream::ThenBlasGemmWithProfiling(
3742: Stream &Stream::ThenBlasGemmWithProfiling(
3764: Stream &Stream::ThenBlasGemmWithProfiling(
3786: Stream &Stream::ThenBlasGemmWithAlgorithm(
3811: Stream &Stream::ThenBlasGemmWithAlgorithm(
3834: Stream &Stream::ThenBlasGemmWithAlgorithm(
3857: Stream &Stream::ThenBlasGemmWithAlgorithm(
3881: Stream &Stream::ThenBlasGemmWithAlgorithm(
3909: Stream &Stream::ThenBlasGemmWithAlgorithm(
3937: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
3957: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
3977: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
3992: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
4007: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
4026: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
4045: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4061: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4077: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4097: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
4117: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4131: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4145: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4161: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
4177: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4193: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4209: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4229: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
4249: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4264: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4279: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4296: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
4313: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4328: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4343: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4360: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
4377: Stream &Stream::ThenBlasGemmBatched(
4389: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4411: Stream &Stream::ThenBlasGemmBatched(
4422: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4443: Stream &Stream::ThenBlasGemmBatched(
4454: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4475: Stream &Stream::ThenBlasGemmBatched(
4488: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4514: Stream &Stream::ThenBlasGemmBatched(
4527: Stream &Stream::ThenBlasGemmBatchedWithScratch(
4553: Stream &Stream::ThenBlasGemmStridedBatched(
4574: Stream &Stream::ThenBlasGemmStridedBatched(
4595: Stream &Stream::ThenBlasGemmStridedBatched(
4616: Stream &Stream::ThenBlasGemmStridedBatched(
4639: Stream &Stream::ThenBlasGemmStridedBatched(
4662: Stream &Stream::ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes) {
4680: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<float> *values) {
4696: Stream &Stream::ThenPopulateRandGaussian(float mean, float sd,
4713: Stream &Stream::ThenPopulateRandGaussian(double mean, double sd,
4730: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<double> *values) {
4746: Stream &Stream::ThenPopulateRandUniform(
4763: Stream &Stream::ThenPopulateRandUniform(
4780: Stream &Stream::ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,
4793: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,
4806: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst,
4819: Stream &Stream::ThenMemZero(DeviceMemoryBase *location, uint64 size) {
4831: Stream &Stream::ThenMemset32(DeviceMemoryBase *location, uint32 pattern,
4845: Stream &Stream::ThenRnnForward(
4882: Stream &Stream::ThenRnnForward(
4918: Stream &Stream::ThenRnnForward(
4955: Stream &Stream::ThenRnnBackward(
5002: Stream &Stream::ThenRnnBackward(
5048: Stream &Stream::ThenRnnBackward(
5095: Stream &Stream::ThenTransformTensor(const dnn::BatchDescriptor &input_desc,
5116: Stream &Stream::ThenDoHostCallback(std::function<void()> callback) {
5127: Stream &Stream::ThenDoHostCallbackWithStatus(
5139: Stream &Stream::ThenFft(fft::Plan *plan,
5157: Stream &Stream::ThenFft(fft::Plan *plan,
5175: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,
5192: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,
5209: Stream &Stream::ThenFft(fft::Plan *plan,
5227: Stream &Stream::ThenFft(fft::Plan *plan,
5247: Stream &Stream::ThenEnqueueOnBackgroundThread(
5259: port::Status Stream::BlockHostUntilDone() {
5283: void Stream::CheckStatus(port::Status status) {
259:                internal::StreamInterface *implementation)
280:     parent_->DeallocateStream(this);
298:   if (parent_->AllocateStream(this)) {
757:           << "attempting to perform DNN operation using StreamExecutor "
787:           << "attempting to perform DNN operation using StreamExecutor "
1238:           << "attempting to perform DNN operation using StreamExecutor "
1335:           << "attempting to perform DNN operation using StreamExecutor "
1755:       // The stream is reusable and not ok. Streams have a monotonic state
1801:       // The returned stream is not ok. Streams have a monotonic state
1904:           << "attempting to perform BLAS operation using StreamExecutor "
4689:                 << " attempting to perform RNG operation using StreamExecutor"
4706:                 << " attempting to perform RNG operation using StreamExecutor"
4723:                 << " attempting to perform RNG operation using StreamExecutor"
4739:                 << " attempting to perform RNG operation using StreamExecutor"
4756:                 << " attempting to perform RNG operation using StreamExecutor"
4773:                 << " attempting to perform RNG operation using StreamExecutor"
5150:                 << " attempting to perform FFT operation using StreamExecutor"
5168:                 << " attempting to perform FFT operation using StreamExecutor"
5185:                 << " attempting to perform FFT operation using StreamExecutor"
5202:                 << " attempting to perform FFT operation using StreamExecutor"
5220:                 << " attempting to perform FFT operation using StreamExecutor"
5238:                 << " attempting to perform FFT operation using StreamExecutor"
5248:     std::function<void(StreamExecutor *)> task) {
5251:   StreamExecutor *stream_executor = this->parent_;
214:   string str = absl::StrCat(stream->DebugStreamPointers(),
251:       implementation_(parent->implementation()->GetStreamImplementation()),
1749:         VLOG(1) << DebugStreamPointers() << " reusing sub_stream "
1750:                 << sub_stream->DebugStreamPointers();
1763:       VLOG(1) << DebugStreamPointers() << " dropped !ok sub_stream "
1764:               << sub_stream->DebugStreamPointers();
1779:   VLOG(1) << DebugStreamPointers() << " created new sub_stream "
1780:           << sub_stream->DebugStreamPointers();
1797:       VLOG(1) << DebugStreamPointers() << " returned ok sub_stream "
1798:               << sub_stream->DebugStreamPointers();
1804:       VLOG(1) << DebugStreamPointers() << " returned !ok sub_stream "
1805:               << sub_stream->DebugStreamPointers();
1815:   LOG(FATAL) << DebugStreamPointers()
1817:              << sub_stream->DebugStreamPointers();
1826:     LOG(INFO) << DebugStreamPointers()
1838:     LOG(INFO) << DebugStreamPointers()
1849:     CheckError(parent_->CreateStreamDependency(this, other));
1852:     LOG(INFO) << DebugStreamPointers() << " did not wait for "
1853:               << other->DebugStreamPointers();
1870:     LOG(INFO) << DebugStreamPointers() << " did not wait for an event.";
4670:       LOG(INFO) << DebugStreamPointers() << " unable to initialize RNG";
4673:     LOG(INFO) << DebugStreamPointers()
4688:       LOG(INFO) << DebugStreamPointers()
4705:       LOG(INFO) << DebugStreamPointers()
4722:       LOG(INFO) << DebugStreamPointers()
4738:       LOG(INFO) << DebugStreamPointers()
4755:       LOG(INFO) << DebugStreamPointers()
4772:       LOG(INFO) << DebugStreamPointers()
4787:     LOG(INFO) << DebugStreamPointers()
4800:     LOG(INFO) << DebugStreamPointers()
4813:     LOG(INFO) << DebugStreamPointers()
4825:     LOG(INFO) << DebugStreamPointers()
4838:     LOG(INFO) << DebugStreamPointers()
5120:     LOG(INFO) << DebugStreamPointers()
5132:     LOG(INFO) << DebugStreamPointers()
5149:       LOG(INFO) << DebugStreamPointers()
5167:       LOG(INFO) << DebugStreamPointers()
5184:       LOG(INFO) << DebugStreamPointers()
5201:       LOG(INFO) << DebugStreamPointers()
5219:       LOG(INFO) << DebugStreamPointers()
5237:       LOG(INFO) << DebugStreamPointers()
5266:     LOG(INFO) << DebugStreamPointers() << " " << status;
github.com/tensorflow/deepmath:fold/tensorflow/tensorflow/stream_executor/stream.cc: [ master, ]
219: Stream::Stream(StreamExecutor *parent)
228: Stream::Stream(StreamExecutor *parent,
238: Stream::~Stream() {
1442: Stream *Stream::GetOrCreateSubStream() {
1459: void Stream::ReturnSubStream(Stream *sub_stream) {
178: // there are on Stream and how many parameters they each have.
179: string CallStr(const char *function_name, Stream *stream,
185:   string str = port::StrCat("Called Stream::", function_name, "(");
248: Stream &Stream::Init() {
267: Stream &Stream::InitTimer(Timer *timer) {
278: Stream &Stream::InitWithTimer(Timer *timer) {
284: Stream &Stream::ThenRecordEvent(Event *event) {
297: Stream &Stream::ThenBatchNormalizationForward(
325: Stream &Stream::ThenBatchNormalizationBackward(
347: Stream &Stream::ThenConvolveWithScratch(
375: Stream &Stream::ThenConvolveWithScratch(
402: Stream &Stream::ThenConvolveWithAlgorithm(
433: Stream &Stream::ThenConvolveWithAlgorithm(
464: Stream &Stream::ThenConvolve(
478: Stream &Stream::ThenConvolveQuantized(
508: Stream &Stream::ThenConvolveQuantized(
538: Stream &Stream::ThenSeparableConvolve(
565: Stream &Stream::ThenConvolveBackwardDataWithScratch(
593: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
626: Stream &Stream::ThenConvolveBackwardDataWithAlgorithm(
659: Stream &Stream::ThenConvolveBackwardDataWithScratch(
687: Stream &Stream::ThenConvolveBackwardData(
701: Stream &Stream::ThenConvolveBackwardFilterWithScratch(
729: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
762: Stream &Stream::ThenConvolveBackwardFilterWithScratch(
790: Stream &Stream::ThenConvolveBackwardFilterWithAlgorithm(
823: Stream &Stream::ThenConvolveBackwardFilter(
838: Stream &Stream::ThenConvolveBackwardBiasImpl(
858: Stream &Stream::ThenConvolveBackwardBias(
867: Stream &Stream::ThenConvolveBackwardBias(
876: Stream &Stream::ThenConvolveBackwardBias(
885: Stream &Stream::ThenMatMul(const DeviceMemory<float> &input_data,
904: Stream &Stream::ThenMatMulQuantized(
926: Stream &Stream::ThenMatMulQuantized(
948: Stream &Stream::ThenBiasAdd(const DeviceMemory<float> &input_data,
966: Stream &Stream::ThenPoolForward(
987: Stream &Stream::ThenPoolForward(
1008: Stream &Stream::ThenPoolBackward(
1032: Stream &Stream::ThenPoolBackward(
1056: Stream &Stream::ThenNormalize(
1072: Stream &Stream::ThenNormalizeWithDimensions(
1090: Stream &Stream::ThenNormalizeBackwardWithDimensions(
1112: Stream &Stream::ThenActivate(dnn::ActivationMode activation_mode,
1120: Stream &Stream::ThenActivateWithOptions(dnn::ActivationMode activation_mode,
1139: Stream &Stream::ThenDepthConcatenate(
1169: Stream &Stream::ThenSpaceConcatenate(
1216: Stream &Stream::ThenReshape(const dnn::BatchDescriptor &input_dimensions,
1234: Stream &Stream::ThenDepthToSpace(
1255: Stream &Stream::ThenSpaceToDepth(
1276: Stream &Stream::ThenElementwiseOperate(
1297: Stream &Stream::ThenElementwiseOperateScaledQuantized(
1320: Stream &Stream::ThenXYPad(const dnn::BatchDescriptor &dimensions,
1339: Stream &Stream::ThenXYSlice(const dnn::BatchDescriptor &dimensions,
1360: Stream &Stream::ThenXYBroadcast(const dnn::BatchDescriptor &dimensions,
1378: Stream &Stream::ThenMemcpyD2HQuantized(
1395: Stream &Stream::ThenMemcpyH2DQuantized(
1412: Stream &Stream::ThenCopyHostBuffer2Device(
1427: Stream &Stream::ThenCopyDevice2HostBuffer(
1450:   sub_streams_.emplace_back(std::unique_ptr<Stream>{new Stream{parent_}},
1452:   Stream *sub_stream = sub_streams_.back().first.get();
1470: Stream &Stream::ThenStartTimer(Timer *t) {
1481: Stream &Stream::ThenStopTimer(Timer *t) {
1492: Stream &Stream::ThenWaitFor(Stream *other) {
1505: Stream &Stream::ThenWaitFor(Event *event) {
1527:   // arguments except the first one of Stream* type.
1528:   Stream &operator()(Stream *stream,
1529:                      bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1536:   Stream &Run(Stream *stream,
1537:               bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1542: Stream &ThenBlasImpl<Args...>::Run(
1543:     Stream *stream, bool (blas::BlasSupport::*blas_func)(Stream *, Args...),
1562: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<float> &x,
1572: Stream &Stream::ThenBlasAsum(uint64 elem_count, const DeviceMemory<double> &x,
1582: Stream &Stream::ThenBlasAsum(uint64 elem_count,
1593: Stream &Stream::ThenBlasAsum(uint64 elem_count,
1604: Stream &Stream::ThenBlasAxpy(uint64 elem_count, float alpha,
1616: Stream &Stream::ThenBlasAxpy(uint64 elem_count, double alpha,
1628: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<float> alpha,
1642: Stream &Stream::ThenBlasAxpy(uint64 elem_count, std::complex<double> alpha,
1656: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<float> &x,
1666: Stream &Stream::ThenBlasCopy(uint64 elem_count, const DeviceMemory<double> &x,
1676: Stream &Stream::ThenBlasCopy(uint64 elem_count,
1688: Stream &Stream::ThenBlasCopy(uint64 elem_count,
1700: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<float> &x,
1712: Stream &Stream::ThenBlasDot(uint64 elem_count, const DeviceMemory<double> &x,
1724: Stream &Stream::ThenBlasDotc(uint64 elem_count,
1740: Stream &Stream::ThenBlasDotc(uint64 elem_count,
1756: Stream &Stream::ThenBlasDotu(uint64 elem_count,
1772: Stream &Stream::ThenBlasDotu(uint64 elem_count,
1788: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<float> &x,
1798: Stream &Stream::ThenBlasNrm2(uint64 elem_count, const DeviceMemory<double> &x,
1808: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
1819: Stream &Stream::ThenBlasNrm2(uint64 elem_count,
1830: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<float> *x, int incx,
1842: Stream &Stream::ThenBlasRot(uint64 elem_count, DeviceMemory<double> *x,
1854: Stream &Stream::ThenBlasRot(uint64 elem_count,
1867: Stream &Stream::ThenBlasRot(uint64 elem_count,
1880: Stream &Stream::ThenBlasRotg(DeviceMemory<float> *a, DeviceMemory<float> *b,
1889: Stream &Stream::ThenBlasRotg(DeviceMemory<double> *a, DeviceMemory<double> *b,
1898: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<float>> *a,
1910: Stream &Stream::ThenBlasRotg(DeviceMemory<std::complex<double>> *a,
1922: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<float> *x,
1934: Stream &Stream::ThenBlasRotm(uint64 elem_count, DeviceMemory<double> *x,
1946: Stream &Stream::ThenBlasRotmg(DeviceMemory<float> *d1, DeviceMemory<float> *d2,
1958: Stream &Stream::ThenBlasRotmg(DeviceMemory<double> *d1,
1971: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
1979: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
1987: Stream &Stream::ThenBlasScal(uint64 elem_count, float alpha,
1995: Stream &Stream::ThenBlasScal(uint64 elem_count, double alpha,
2003: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<float> alpha,
2012: Stream &Stream::ThenBlasScal(uint64 elem_count, std::complex<double> alpha,
2021: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<float> *x,
2031: Stream &Stream::ThenBlasSwap(uint64 elem_count, DeviceMemory<double> *x,
2041: Stream &Stream::ThenBlasSwap(uint64 elem_count,
2052: Stream &Stream::ThenBlasSwap(uint64 elem_count,
2063: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<float> &x,
2073: Stream &Stream::ThenBlasIamax(uint64 elem_count, const DeviceMemory<double> &x,
2083: Stream &Stream::ThenBlasIamax(uint64 elem_count,
2094: Stream &Stream::ThenBlasIamax(uint64 elem_count,
2105: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<float> &x,
2115: Stream &Stream::ThenBlasIamin(uint64 elem_count, const DeviceMemory<double> &x,
2125: Stream &Stream::ThenBlasIamin(uint64 elem_count,
2136: Stream &Stream::ThenBlasIamin(uint64 elem_count,
2147: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2163: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2179: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2199: Stream &Stream::ThenBlasGbmv(blas::Transpose trans, uint64 m, uint64 n,
2219: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2234: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2249: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2269: Stream &Stream::ThenBlasGemv(blas::Transpose trans, uint64 m, uint64 n,
2289: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, float alpha,
2303: Stream &Stream::ThenBlasGer(uint64 m, uint64 n, double alpha,
2317: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<float> alpha,
2334: Stream &Stream::ThenBlasGerc(uint64 m, uint64 n, std::complex<double> alpha,
2351: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<float> alpha,
2368: Stream &Stream::ThenBlasGeru(uint64 m, uint64 n, std::complex<double> alpha,
2385: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2404: Stream &Stream::ThenBlasHbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2423: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
2442: Stream &Stream::ThenBlasHemv(blas::UpperLower uplo, uint64 n,
2461: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, float alpha,
2475: Stream &Stream::ThenBlasHer(blas::UpperLower uplo, uint64 n, double alpha,
2489: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
2507: Stream &Stream::ThenBlasHer2(blas::UpperLower uplo, uint64 n,
2525: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
2543: Stream &Stream::ThenBlasHpmv(blas::UpperLower uplo, uint64 n,
2561: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, float alpha,
2573: Stream &Stream::ThenBlasHpr(blas::UpperLower uplo, uint64 n, double alpha,
2585: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
2602: Stream &Stream::ThenBlasHpr2(blas::UpperLower uplo, uint64 n,
2619: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2633: Stream &Stream::ThenBlasSbmv(blas::UpperLower uplo, uint64 n, uint64 k,
2647: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, float alpha,
2661: Stream &Stream::ThenBlasSpmv(blas::UpperLower uplo, uint64 n, double alpha,
2675: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, float alpha,
2686: Stream &Stream::ThenBlasSpr(blas::UpperLower uplo, uint64 n, double alpha,
2697: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, float alpha,
2711: Stream &Stream::ThenBlasSpr2(blas::UpperLower uplo, uint64 n, double alpha,
2725: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, float alpha,
2739: Stream &Stream::ThenBlasSymv(blas::UpperLower uplo, uint64 n, double alpha,
2753: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, float alpha,
2765: Stream &Stream::ThenBlasSyr(blas::UpperLower uplo, uint64 n, double alpha,
2777: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, float alpha,
2791: Stream &Stream::ThenBlasSyr2(blas::UpperLower uplo, uint64 n, double alpha,
2805: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
2819: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
2833: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
2848: Stream &Stream::ThenBlasTbmv(blas::UpperLower uplo, blas::Transpose trans,
2863: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
2877: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
2891: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
2906: Stream &Stream::ThenBlasTbsv(blas::UpperLower uplo, blas::Transpose trans,
2921: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
2934: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
2947: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
2961: Stream &Stream::ThenBlasTpmv(blas::UpperLower uplo, blas::Transpose trans,
2975: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
2988: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3001: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3015: Stream &Stream::ThenBlasTpsv(blas::UpperLower uplo, blas::Transpose trans,
3029: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3043: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3057: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3072: Stream &Stream::ThenBlasTrmv(blas::UpperLower uplo, blas::Transpose trans,
3087: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3101: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3115: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3130: Stream &Stream::ThenBlasTrsv(blas::UpperLower uplo, blas::Transpose trans,
3145: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3163: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3179: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3195: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3216: Stream &Stream::ThenBlasGemm(blas::Transpose transa, blas::Transpose transb,
3244:   Stream &operator()(Stream *stream,
3246:                          Stream *, Args..., blas::ProfileResult *),
3255: Stream &Stream::ThenBlasGemmWithAlgorithm(
3279: Stream &Stream::ThenBlasGemmWithAlgorithm(
3300: Stream &Stream::ThenBlasGemmWithAlgorithm(
3322: Stream &Stream::ThenBlasGemmWithAlgorithm(
3347: Stream &Stream::ThenBlasGemmWithAlgorithm(
3372: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
3392: Stream &Stream::ThenBlasHemm(blas::Side side, blas::UpperLower uplo, uint64 m,
3412: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
3427: Stream &Stream::ThenBlasHerk(blas::UpperLower uplo, blas::Transpose trans,
3442: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
3461: Stream &Stream::ThenBlasHer2k(blas::UpperLower uplo, blas::Transpose trans,
3480: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
3496: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
3512: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
3532: Stream &Stream::ThenBlasSymm(blas::Side side, blas::UpperLower uplo, uint64 m,
3552: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
3566: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
3580: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
3596: Stream &Stream::ThenBlasSyrk(blas::UpperLower uplo, blas::Transpose trans,
3612: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
3628: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
3644: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
3664: Stream &Stream::ThenBlasSyr2k(blas::UpperLower uplo, blas::Transpose trans,
3684: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
3699: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
3714: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
3731: Stream &Stream::ThenBlasTrmm(blas::Side side, blas::UpperLower uplo,
3748: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
3763: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
3778: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
3795: Stream &Stream::ThenBlasTrsm(blas::Side side, blas::UpperLower uplo,
3812: Stream &Stream::ThenBlasGemmBatched(
3823: Stream &Stream::ThenBlasGemmBatchedWithScratch(
3844: Stream &Stream::ThenBlasGemmBatched(
3855: Stream &Stream::ThenBlasGemmBatchedWithScratch(
3876: Stream &Stream::ThenBlasGemmBatched(
3889: Stream &Stream::ThenBlasGemmBatchedWithScratch(
3915: Stream &Stream::ThenBlasGemmBatched(
3928: Stream &Stream::ThenBlasGemmBatchedWithScratch(
3954: Stream &Stream::ThenSetRngSeed(const uint8 *seed, uint64 seed_bytes) {
3972: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<float> *values) {
3987: Stream &Stream::ThenPopulateRandGaussian(float mean, float sd,
4003: Stream &Stream::ThenPopulateRandGaussian(double mean, double sd,
4019: Stream &Stream::ThenPopulateRandUniform(DeviceMemory<double> *values) {
4034: Stream &Stream::ThenPopulateRandUniform(
4050: Stream &Stream::ThenPopulateRandUniform(
4067: Stream &Stream::ThenMemcpy(void *host_dst, const DeviceMemoryBase &gpu_src,
4080: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst, const void *host_src,
4093: Stream &Stream::ThenMemcpy(DeviceMemoryBase *gpu_dst,
4106: Stream &Stream::ThenMemZero(DeviceMemoryBase *location, uint64 size) {
4118: Stream &Stream::ThenMemset32(DeviceMemoryBase *location, const uint32 &pattern,
4132: Stream &Stream::ThenRnnForward(
4164: Stream &Stream::ThenRnnBackward(
4205: Stream &Stream::ThenDoHostCallbackForTest(std::function<void()> callback) {
4211: Stream &Stream::ThenDoHostCallback(std::function<void()> callback) {
4223: Stream &Stream::ThenFft(fft::Plan *plan,
4240: Stream &Stream::ThenFft(fft::Plan *plan,
4257: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<float> &input,
4273: Stream &Stream::ThenFft(fft::Plan *plan, const DeviceMemory<double> &input,
4289: Stream &Stream::ThenFft(fft::Plan *plan,
4306: Stream &Stream::ThenFft(fft::Plan *plan,
4325: Stream &Stream::ThenEnqueueOnBackgroundThread(
4337: bool Stream::BlockHostUntilDone() {
229:                internal::StreamInterface *implementation)
244:     parent_->DeallocateStream(this);
256:   if (parent_->AllocateStream(this)) {
501:           << "attempting to perform DNN operation using StreamExecutor "
531:           << "attempting to perform DNN operation using StreamExecutor "
1551:           << "attempting to perform BLAS operation using StreamExecutor "
3980:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
3996:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4012:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4027:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4043:       LOG(INFO) << "attempting to perform RNG operation using StreamExecutor "
4060:                 << " attempting to perform RNG operation using StreamExecutor "
4233:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4250:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4266:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4282:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4299:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4316:       LOG(INFO) << "attempting to perform FFT operation using StreamExecutor "
4326:     std::function<void(StreamExecutor *)> task) {
4329:   StreamExecutor *stream_executor = this->parent_;
221:       implementation_(parent->implementation()->GetStreamImplementation()),
1497:     CheckError(parent_->CreateStreamDependency(this, other));
github.com/firebase/firebase-android-sdk:firebase-crashlytics-ndk/src/third_party/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/googledatalab/datalab:third_party/externs/ts/node/node.d.ts: [ master, ]
1131:     export interface Stream extends events.EventEmitter {
99:     export interface ReadableStream extends EventEmitter {
112:     export interface WritableStream extends EventEmitter {
123:     export interface ReadWriteStream extends ReadableStream, WritableStream {}
830:     export interface ReadStream extends stream.Readable {}
831:     export interface WriteStream extends stream.Writable {}
937:     export function createReadStream(path: string, options?: {
1027:     export interface ClearTextStream extends stream.Duplex {
1301:     export interface WriteStream extends net.Socket {
105:         pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
106:         unpipe<T extends WritableStream>(destination?: T): void;
109:         wrap(oldStream: ReadableStream): ReadableStream;
126:         stdout: WritableStream;
127:         stderr: WritableStream;
128:         stdin: ReadableStream;
561:         input?: NodeJS.ReadableStream;
562:         output?: NodeJS.WritableStream;
587:         input: NodeJS.ReadableStream;
588:         output: NodeJS.WritableStream;
930:     export function createReadStream(path: string, options?: {
936:     }): ReadStream;
943:     }): ReadStream;
944:     export function createWriteStream(path: string, options?: {
948:     }): WriteStream;
1049:     export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server;
1050:     export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
1051: ...(32 bytes skipped)...: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
1052: ...(17 bytes skipped)...on connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
1132:         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
1141:     export class Readable extends events.EventEmitter implements NodeJS.ReadableStream {
1149:         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
1150:         unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
1153:         wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
1162:     export class Writable extends events.EventEmitter implements NodeJS.WritableStream {
1181:     export class Duplex extends Readable implements NodeJS.ReadWriteStream {
1198:     export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream {
1209:         pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
1210:         unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
1213:         wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
1297:     export interface ReadStream extends net.Socket {
android.googlesource.com/platform/external/rust/crates/futures-core:src/stream.rs: [ master, ]
27: pub trait Stream {
10: pub type BoxStream<'a, T> = Pin<alloc::boxed::Box<dyn Stream<Item = T> + Send + 'a>>;
14: pub type LocalBoxStream<'a, T> = Pin<alloc::boxed::Box<dyn Stream<Item = T> + 'a>>;
136: pub trait FusedStream: Stream {
167: pub trait TryStream: Stream + private_try_stream::Sealed {
7: /// An owned dynamically typed [`Stream`] for use in cases where you can't
18: /// If `Future<Output = T>` is an asynchronous version of `T`, then `Stream<Item
55:     /// problems; the `Stream` trait places no requirements on the effects of
100: impl<S: ?Sized + Stream + Unpin> Stream for &mut S {
112: impl<P> Stream for Pin<P>
115:     P::Target: Stream,
117:     type Item = <P::Target as Stream>::Item;
158:     use super::Stream;
162:     impl<S, T, E> Sealed for S where S: ?Sized + Stream<Item = Result<T, E>> {}
174:     /// Poll this `TryStream` as if it were a `Stream`.
177:     /// directly inheriting from the `Stream` trait; in the future it won't be
187:     S: ?Sized + Stream<Item = Result<T, E>>,
205:     impl<S: ?Sized + Stream + Unpin> Stream for Box<S> {
218:     impl<S: Stream> Stream for std::panic::AssertUnwindSafe<S> {
12: /// `BoxStream`, but without the `Send` requirement.
65:     /// [`fuse`]: https://docs.rs/futures/0.3/futures/stream/trait.StreamExt.html#method.fuse
141: impl<F: ?Sized + FusedStream + Unpin> FusedStream for &mut F {
143:         <F as FusedStream>::is_terminated(&**self)
147: impl<P> FusedStream for Pin<P>
150:     P::Target: FusedStream,
153:         <P::Target as FusedStream>::is_terminated(&**self)
185: impl<S, T, E> TryStream for S
230:     impl<S: ?Sized + FusedStream + Unpin> FusedStream for Box<S> {
232:             <S as FusedStream>::is_terminated(&**self)
android.googlesource.com/platform/external/mesa3d:src/mesa/main/mtypes.h: [ master, ]
1809:    uint32_t Stream;
3268:    GLuint Stream;      /**< The stream */
1779:    uint32_t StreamId;
3053:       unsigned ActiveStreamMask;
3951:    GLuint MaxVertexStreams;
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));
android.googlesource.com/platform/external/rust/crates/combine:src/stream/mod.rs: [ master, ]
163: pub trait Stream: StreamOnce + ResetStream + Positioned {}
109: pub type StreamErrorFor<Input> = <<Input as StreamOnce>::Error as ParseError<
116: pub trait StreamOnce {
143: pub trait ResetStream: StreamOnce {
242: pub trait RangeStream: Stream + RangeStreamOnce {}
757: pub struct PartialStream<S>(pub S);
759: impl<S> From<S> for PartialStream<S> {
765: impl<S> Positioned for PartialStream<S>
775: impl<S> ResetStream for PartialStream<S>
792: impl<S> StreamOnce for PartialStream<S>
811: impl<S> RangeStreamOnce for PartialStream<S>
852: pub struct CompleteStream<S>(pub S);
854: impl<S> From<S> for CompleteStream<S> {
860: impl<'s, S> From<&'s mut S> for &'s mut CompleteStream<S> {
867: impl<S> Positioned for CompleteStream<S>
877: impl<S> ResetStream for CompleteStream<S>
894: impl<S> StreamOnce for CompleteStream<S>
913: impl<S> RangeStreamOnce for CompleteStream<S>
949: pub struct MaybePartialStream<S>(pub S, pub bool);
951: impl<S> Positioned for MaybePartialStream<S>
961: impl<S> ResetStream for MaybePartialStream<S>
978: impl<S> StreamOnce for MaybePartialStream<S>
997: impl<S> RangeStreamOnce for MaybePartialStream<S>
1034: pub struct SliceStream<'a, T>(pub &'a [T]);
1036: impl<'a, T> Clone for SliceStream<'a, T> {
1042: impl<'a, T> Positioned for SliceStream<'a, T>
1052: impl<'a, T> StreamOnce for SliceStream<'a, T>
1119: impl<'a, T> RangeStreamOnce for SliceStream<'a, T>
1172: pub struct IteratorStream<Input>(Input);
1174: impl<Input> IteratorStream<Input>
1190: impl<Input> Iterator for IteratorStream<Input>
1200: impl<Input: Iterator> StreamOnce for IteratorStream<Input>
184: pub trait RangeStreamOnce: StreamOnce + ResetStream {
5: //! which can be retrieved one by one. Where `Stream`s differ is that they are allowed to return
9: //! In addition to he functionality above, a proper `Stream` usable by a `Parser` must also have a
53: /// Stream wrapper which provides a `ResetStream` impl for `StreamOnce` impls which do not have
61: /// Stream wrapper which provides more detailed position information.
63: /// Stream wrapper allowing `std::io::Read` to be used
68: /// Stream wrapper allowing custom state to be used.
86: /// use combine::{easy, Parser, Stream, many1};
93: ///     where [ Input: Stream<Token = char>, ]
161: /// traits. If you need a custom `Stream` object then implement those traits and `Stream` is
165: impl<Input> Stream for Input
175:     Input: ?Sized + Stream,
241: /// A `RangeStream` is an extension of `Stream` which allows for zero copy parsing.
244: impl<Input> RangeStream for Input where Input: RangeStreamOnce + Stream {}
285:     Input: ?Sized + Stream,
755: /// Stream type which indicates that the stream is partial if end of input is reached
846: /// Stream type which indicates that the stream is complete if end of input is reached
1181:     ///     such as `BufferedStreamRef` and `State` to become a `Stream` which can be parsed
1402: ///         |input, _position| combine::easy::Stream::from(input),
1498: ///             |input, _position| combine::easy::Stream::from(input),
1592: ///             |input, _position| combine::easy::Stream::from(input),
1688: ///             |input, _position| combine::easy::Stream::from(input),
1784: ///             |input, _position| combine::easy::Stream::from(input),
4: //! Streams are similar to the `Iterator` trait in that they represent some sequential set of items
11: //! `ResetStream` trait). The former is used to ensure that errors at different points in the stream
21:         StreamError, StringStreamError, Tracked, UnexpectedParse,
33:         impl<$($params)*> ResetStream for $ty
34:             where Self: StreamOnce
76: pub trait Positioned: StreamOnce {
81: /// Convenience alias over the `StreamError` for the input stream `Input`
88: /// use combine::stream::StreamErrorFor;
89: /// use combine::error::{ParseError, StreamError};
99: ///                 // The alias makes it easy to refer to the `StreamError` type of `Input`
100: ///                 Err(StreamErrorFor::<Input>::expected_static_message("combine"))
110:     <Input as StreamOnce>::Token,
111:     <Input as StreamOnce>::Range,
112:     <Input as StreamOnce>::Position,
113: >>::StreamError;
115: /// `StreamOnce` represents a sequence of items that can be extracted one by one.
132:     fn uncons(&mut self) -> Result<Self::Token, StreamErrorFor<Self>>;
136:     /// See `PartialStream`.
142: /// A `StreamOnce` which can create checkpoints which the stream can be reset to
155: clone_resetable! {('a, T) SliceStream<'a, T> }
156: clone_resetable! {(T: Clone) IteratorStream<T>}
160: /// This is a trait over types which implement the `StreamOnce`, `ResetStream` and `Positioned`
167:     Input: StreamOnce + Positioned + ResetStream,
183: /// A `RangeStream` is an extension of `StreamOnce` which allows for zero copy parsing.
187:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>>;
191:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
202:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
220:             PeekErr(Tracked::from(StreamErrorFor::<Self>::end_of_input()))
223:                 StreamErrorFor::<Self>::unexpected_static_message(""),
249:     err: <Input::Error as ParseError<Input::Token, Input::Range, Input::Position>>::StreamError,
250: ) -> ParseResult<T, <Input as StreamOnce>::Error>
252:     Input: ?Sized + StreamOnce + Positioned,
266: ) -> ParseResult<Input::Range, <Input as StreamOnce>::Error>
268:     Input: ?Sized + RangeStream,
303:     Input: ?Sized + RangeStream,
314:                     StreamError::end_of_input(),
338:     Input: ?Sized + RangeStream,
347:                     StreamError::end_of_input(),
359:                     StreamError::end_of_input(),
371:                     StreamError::end_of_input(),
393: impl<'a, I> StreamOnce for &'a mut I
395:     I: StreamOnce + ?Sized,
404:     fn uncons(&mut self) -> Result<Self::Token, StreamErrorFor<Self>> {
423: impl<'a, I> ResetStream for &'a mut I
425:     I: ResetStream + ?Sized,
443:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
451:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
459:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
482: impl<'a> StreamOnce for &'a str {
489:     fn uncons(&mut self) -> Result<char, StreamErrorFor<Self>> {
546:     fn uncons_while<F>(&mut self, f: F) -> Result<&'a str, StreamErrorFor<Self>>
554:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
572:     fn uncons_range(&mut self, size: usize) -> Result<&'a str, StreamErrorFor<Self>> {
677:     fn uncons_range(&mut self, size: usize) -> Result<&'a [T], StreamErrorFor<Self>> {
688:     fn uncons_while<F>(&mut self, f: F) -> Result<&'a [T], StreamErrorFor<Self>>
696:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
734: impl<'a, T> StreamOnce for &'a [T]
744:     fn uncons(&mut self) -> Result<T, StreamErrorFor<Self>> {
761:         PartialStream(t)
777:     S: ResetStream,
794:     S: StreamOnce,
802:     fn uncons(&mut self) -> Result<S::Token, StreamErrorFor<Self>> {
816:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
821:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
828:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
849: /// `PartialStream`
856:         CompleteStream(t)
862:         // SAFETY repr(transparent) is specified on CompleteStream
863:         unsafe { &mut *(t as *mut S as *mut CompleteStream<S>) }
879:     S: ResetStream,
896:     S: StreamOnce,
904:     fn uncons(&mut self) -> Result<S::Token, StreamErrorFor<Self>> {
918:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
923:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
930:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
963:     S: ResetStream,
980:     S: StreamOnce,
988:     fn uncons(&mut self) -> Result<S::Token, StreamErrorFor<Self>> {
1002:     fn uncons_range(&mut self, size: usize) -> Result<Self::Range, StreamErrorFor<Self>> {
1007:     fn uncons_while<F>(&mut self, f: F) -> Result<Self::Range, StreamErrorFor<Self>>
1014:     fn uncons_while1<F>(&mut self, f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
1037:     fn clone(&self) -> SliceStream<'a, T> {
1038:         SliceStream(self.0)
1062:     fn uncons(&mut self) -> Result<&'a T, StreamErrorFor<Self>> {
1124:     fn uncons_range(&mut self, size: usize) -> Result<&'a [T], StreamErrorFor<Self>> {
1135:     fn uncons_while<F>(&mut self, f: F) -> Result<&'a [T], StreamErrorFor<Self>>
1143:     fn uncons_while1<F>(&mut self, mut f: F) -> ParseResult<Self::Range, StreamErrorFor<Self>>
1170: /// Returned by [`IteratorStream::new`].
1182:     pub fn new<T>(iter: T) -> IteratorStream<Input>
1186:         IteratorStream(iter.into_iter())
1210:     fn uncons(&mut self) -> Result<Self::Token, StreamErrorFor<Self>> {
1311: ) -> Result<(Option<P::Output>, usize), <Input as StreamOnce>::Error>
1314:     Input: RangeStream,
1350: ) -> Result<(Option<P::Output>, usize), <Input as StreamOnce>::Error>
1353:     Input: RangeStream,
1429:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
1527:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
1619:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
1715:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
1811:                             $crate::stream::MaybePartialStream(buffer, !end_of_input),
1878:         assert_eq!(SliceStream(s).uncons_range(0), Ok(&[][..]));
6: //! errors instead of just `None` and if they implement the `RangeStreamOnce` trait they are also
438: impl<'a, I> RangeStreamOnce for &'a mut I
440:     I: RangeStreamOnce + ?Sized,
486:     type Error = StringStreamError;
496:             None => Err(StringStreamError::Eoi),
545: impl<'a> RangeStreamOnce for &'a str {
562:                     return PeekErr(Tracked::from(StringStreamError::UnexpectedParse));
565:             None => return PeekErr(Tracked::from(StringStreamError::Eoi)),
588:                 Err(StringStreamError::CharacterBoundary)
591:             Err(StringStreamError::Eoi)
672: impl<'a, T> RangeStreamOnce for &'a [T]
813:     S: RangeStreamOnce,
915:     S: RangeStreamOnce,
999:     S: RangeStreamOnce,
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/external/rust/crates/atty:src/lib.rs: [ master, ]
32: pub enum Stream {
7: //! if atty::is(atty::Stream::Stdout) {
13: //! if atty::isnt(atty::Stream::Stdout) {
40: pub fn is(stream: Stream) -> bool {
44:         Stream::Stdout => libc::STDOUT_FILENO,
45:         Stream::Stderr => libc::STDERR_FILENO,
46:         Stream::Stdin => libc::STDIN_FILENO,
53: pub fn is(stream: Stream) -> bool {
57:         Stream::Stdout => hermit_abi::STDOUT_FILENO,
58:         Stream::Stderr => hermit_abi::STDERR_FILENO,
59:         Stream::Stdin => hermit_abi::STDIN_FILENO,
66: pub fn is(stream: Stream) -> bool {
73:         Stream::Stdin => (STD_INPUT, [STD_ERROR, STD_OUTPUT]),
74:         Stream::Stderr => (STD_ERROR, [STD_INPUT, STD_OUTPUT]),
75:         Stream::Stdout => (STD_OUTPUT, [STD_INPUT, STD_ERROR]),
97: pub fn isnt(stream: Stream) -> bool {
158: pub fn is(_stream: Stream) -> bool {
164:     use super::{is, Stream};
170:         assert!(!is(Stream::Stderr))
177:         assert!(!is(Stream::Stdout))
183:         assert!(is(Stream::Stdin))
189:         assert!(is(Stream::Stderr))
195:         assert!(is(Stream::Stdout))
202:         assert!(is(Stream::Stdin))
208:         assert!(is(Stream::Stdin))
android.googlesource.com/platform/external/webrtc:webrtc/modules/audio_processing/debug.pb.h: [ master, ]
551: class Stream final :
554:   inline Stream() : Stream(nullptr) {}
559:   Stream(Stream&& from) noexcept
381: class ReverseStream final :
384:   inline ReverseStream() : ReverseStream(nullptr) {}
389:   ReverseStream(ReverseStream&& from) noexcept
1774:     kReverseStreamFieldNumber = 3,
1775:     kStreamFieldNumber = 4,
65: class Stream;
67: extern StreamDefaultTypeInternal _Stream_default_instance_;
77: template<> ::webrtc::audioproc::Stream* Arena::CreateMaybeMessage<::webrtc::audioproc::Stream>(Arena*);
552: ...(10 bytes skipped)... ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.Stream) */ {
555:   ~Stream() override;
556:   explicit PROTOBUF_CONSTEXPR Stream(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
558:   Stream(const Stream& from);
560:     : Stream() {
564:   inline Stream& operator=(const Stream& from) {
568:   inline Stream& operator=(Stream&& from) noexcept {
589:   static const Stream& default_instance() {
592:   static inline const Stream* internal_default_instance() {
593:     return reinterpret_cast<const Stream*>(
594:                &_Stream_default_instance_);
599:   friend void swap(Stream& a, Stream& b) {
602:   PROTOBUF_NOINLINE void Swap(Stream* other) {
615:   void UnsafeArenaSwap(Stream* other) {
623:   Stream* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
624:     return CreateMaybeMessage<Stream>(arena);
627:   void CopyFrom(const Stream& from);
628:   void MergeFrom(const Stream& from);
642:   void InternalSwap(Stream* other);
647:     return "webrtc.audioproc.Stream";
650:   explicit Stream(::PROTOBUF_NAMESPACE_ID::Arena* arena,
806:   // @@protoc_insertion_point(class_scope:webrtc.audioproc.Stream)
1816:   // optional .webrtc.audioproc.Stream stream = 4;
1822:   const ::webrtc::audioproc::Stream& stream() const;
1823:   PROTOBUF_NODISCARD ::webrtc::audioproc::Stream* release_stream();
1824:   ::webrtc::audioproc::Stream* mutable_stream();
1825:   void set_allocated_stream(::webrtc::audioproc::Stream* stream);
1827:   const ::webrtc::audioproc::Stream& _internal_stream() const;
1828:   ::webrtc::audioproc::Stream* _internal_mutable_stream();
1831:       ::webrtc::audioproc::Stream* stream);
1832:   ::webrtc::audioproc::Stream* unsafe_arena_release_stream();
1894:   ::webrtc::audioproc::Stream* stream_;
2340: // Stream
2343: inline bool Stream::_internal_has_input_data() const {
2347: inline bool Stream::has_input_data() const {
2350: inline void Stream::clear_input_data() {
2354: inline const std::string& Stream::input_data() const {
2355:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.input_data)
2360: void Stream::set_input_data(ArgT0&& arg0, ArgT... args) {
2363:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_data)
2365: inline std::string* Stream::mutable_input_data() {
2367:   // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.input_data)
2370: inline const std::string& Stream::_internal_input_data() const {
2373: inline void Stream::_internal_set_input_data(const std::string& value) {
2377: inline std::string* Stream::_internal_mutable_input_data() {
2381: inline std::string* Stream::release_input_data() {
2382:   // @@protoc_insertion_point(field_release:webrtc.audioproc.Stream.input_data)
2395: inline void Stream::set_allocated_input_data(std::string* input_data) {
2407:   // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Stream.input_data)
2411: inline bool Stream::_internal_has_output_data() const {
2415: inline bool Stream::has_output_data() const {
2418: inline void Stream::clear_output_data() {
2422: inline const std::string& Stream::output_data() const {
2423:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.output_data)
2428: void Stream::set_output_data(ArgT0&& arg0, ArgT... args) {
2431:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_data)
2433: inline std::string* Stream::mutable_output_data() {
2435:   // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.output_data)
2438: inline const std::string& Stream::_internal_output_data() const {
2441: inline void Stream::_internal_set_output_data(const std::string& value) {
2445: inline std::string* Stream::_internal_mutable_output_data() {
2449: inline std::string* Stream::release_output_data() {
2450:   // @@protoc_insertion_point(field_release:webrtc.audioproc.Stream.output_data)
2463: inline void Stream::set_allocated_output_data(std::string* output_data) {
2475:   // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.Stream.output_data)
2479: inline bool Stream::_internal_has_delay() const {
2483: inline bool Stream::has_delay() const {
2486: inline void Stream::clear_delay() {
2490: inline int32_t Stream::_internal_delay() const {
2493: inline int32_t Stream::delay() const {
2494:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.delay)
2497: inline void Stream::_internal_set_delay(int32_t value) {
2501: inline void Stream::set_delay(int32_t value) {
2503:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.delay)
2507: inline bool Stream::_internal_has_drift() const {
2511: inline bool Stream::has_drift() const {
2514: inline void Stream::clear_drift() {
2518: inline int32_t Stream::_internal_drift() const {
2521: inline int32_t Stream::drift() const {
2522:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.drift)
2525: inline void Stream::_internal_set_drift(int32_t value) {
2529: inline void Stream::set_drift(int32_t value) {
2531:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.drift)
2535: inline bool Stream::_internal_has_applied_input_volume() const {
2539: inline bool Stream::has_applied_input_volume() const {
2542: inline void Stream::clear_applied_input_volume() {
2546: inline int32_t Stream::_internal_applied_input_volume() const {
2549: inline int32_t Stream::applied_input_volume() const {
2550:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.applied_input_volume)
2553: inline void Stream::_internal_set_applied_input_volume(int32_t value) {
2557: inline void Stream::set_applied_input_volume(int32_t value) {
2559:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.applied_input_volume)
2563: inline bool Stream::_internal_has_keypress() const {
2567: inline bool Stream::has_keypress() const {
2570: inline void Stream::clear_keypress() {
2574: inline bool Stream::_internal_keypress() const {
2577: inline bool Stream::keypress() const {
2578:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.keypress)
2581: inline void Stream::_internal_set_keypress(bool value) {
2585: inline void Stream::set_keypress(bool value) {
2587:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.keypress)
2591: inline int Stream::_internal_input_channel_size() const {
2594: inline int Stream::input_channel_size() const {
2597: inline void Stream::clear_input_channel() {
2600: inline std::string* Stream::add_input_channel() {
2602:   // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.Stream.input_channel)
2605: inline const std::string& Stream::_internal_input_channel(int index) const {
2608: inline const std::string& Stream::input_channel(int index) const {
2609:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.input_channel)
2612: inline std::string* Stream::mutable_input_channel(int index) {
2613:   // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.input_channel)
2616: inline void Stream::set_input_channel(int index, const std::string& value) {
2618:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_channel)
2620: inline void Stream::set_input_channel(int index, std::string&& value) {
2622:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.input_channel)
2624: inline void Stream::set_input_channel(int index, const char* value) {
2627:   // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.input_channel)
2629: inline void Stream::set_input_channel(int index, const void* value, size_t size) {
2632:   // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.input_channel)
2634: inline std::string* Stream::_internal_add_input_channel() {
2637: inline void Stream::add_input_channel(const std::string& value) {
2639:   // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.input_channel)
2641: inline void Stream::add_input_channel(std::string&& value) {
2643:   // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.input_channel)
2645: inline void Stream::add_input_channel(const char* value) {
2648:   // @@protoc_insertion_point(field_add_char:webrtc.audioproc.Stream.input_channel)
2650: inline void Stream::add_input_channel(const void* value, size_t size) {
2652:   // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.Stream.input_channel)
2655: Stream::input_channel() const {
2656:   // @@protoc_insertion_point(field_list:webrtc.audioproc.Stream.input_channel)
2660: Stream::mutable_input_channel() {
2661:   // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.Stream.input_channel)
2666: inline int Stream::_internal_output_channel_size() const {
2669: inline int Stream::output_channel_size() const {
2672: inline void Stream::clear_output_channel() {
2675: inline std::string* Stream::add_output_channel() {
2677:   // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.Stream.output_channel)
2680: inline const std::string& Stream::_internal_output_channel(int index) const {
2683: inline const std::string& Stream::output_channel(int index) const {
2684:   // @@protoc_insertion_point(field_get:webrtc.audioproc.Stream.output_channel)
2687: inline std::string* Stream::mutable_output_channel(int index) {
2688:   // @@protoc_insertion_point(field_mutable:webrtc.audioproc.Stream.output_channel)
2691: inline void Stream::set_output_channel(int index, const std::string& value) {
2693:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_channel)
2695: inline void Stream::set_output_channel(int index, std::string&& value) {
2697:   // @@protoc_insertion_point(field_set:webrtc.audioproc.Stream.output_channel)
2699: inline void Stream::set_output_channel(int index, const char* value) {
2702:   // @@protoc_insertion_point(field_set_char:webrtc.audioproc.Stream.output_channel)
2704: inline void Stream::set_output_channel(int index, const void* value, size_t size) {
2707:   // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.Stream.output_channel)
2709: inline std::string* Stream::_internal_add_output_channel() {
2712: inline void Stream::add_output_channel(const std::string& value) {
2714:   // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.output_channel)
2716: inline void Stream::add_output_channel(std::string&& value) {
2718:   // @@protoc_insertion_point(field_add:webrtc.audioproc.Stream.output_channel)
2720: inline void Stream::add_output_channel(const char* value) {
2723:   // @@protoc_insertion_point(field_add_char:webrtc.audioproc.Stream.output_channel)
2725: inline void Stream::add_output_channel(const void* value, size_t size) {
2727:   // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.Stream.output_channel)
2730: Stream::output_channel() const {
2731:   // @@protoc_insertion_point(field_list:webrtc.audioproc.Stream.output_channel)
2735: Stream::mutable_output_channel() {
2736:   // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.Stream.output_channel)
3851: // optional .webrtc.audioproc.Stream stream = 4;
3864: inline const ::webrtc::audioproc::Stream& Event::_internal_stream() const {
3865:   const ::webrtc::audioproc::Stream* p = stream_;
3866:   return p != nullptr ? *p : reinterpret_cast<const ::webrtc::audioproc::Stream&>(
3867:       ::webrtc::audioproc::_Stream_default_instance_);
3869: inline const ::webrtc::audioproc::Stream& Event::stream() const {
3874:     ::webrtc::audioproc::Stream* stream) {
3886: inline ::webrtc::audioproc::Stream* Event::release_stream() {
3888:   ::webrtc::audioproc::Stream* temp = stream_;
3901: inline ::webrtc::audioproc::Stream* Event::unsafe_arena_release_stream() {
3904:   ::webrtc::audioproc::Stream* temp = stream_;
3908: inline ::webrtc::audioproc::Stream* Event::_internal_mutable_stream() {
3911:     auto* p = CreateMaybeMessage<::webrtc::audioproc::Stream>(GetArenaForAllocation());
3916: inline ::webrtc::audioproc::Stream* Event::mutable_stream() {
3917:   ::webrtc::audioproc::Stream* _msg = _internal_mutable_stream();
3921: inline void Event::set_allocated_stream(::webrtc::audioproc::Stream* stream) {
59: class ReverseStream;
61: extern ReverseStreamDefaultTypeInternal _ReverseStream_default_instance_;
66: struct StreamDefaultTypeInternal;
75: template<> ::webrtc::audioproc::ReverseStream* Arena::CreateMaybeMessage<::webrtc::audioproc::ReverseStream>(Arena*);
191:       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
382: ...(17 bytes skipped)...OBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:webrtc.audioproc.ReverseStream) */ {
385:   ~ReverseStream() override;
386:   explicit PROTOBUF_CONSTEXPR ReverseStream(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
388:   ReverseStream(const ReverseStream& from);
390:     : ReverseStream() {
394:   inline ReverseStream& operator=(const ReverseStream& from) {
398:   inline ReverseStream& operator=(ReverseStream&& from) noexcept {
419:   static const ReverseStream& default_instance() {
422:   static inline const ReverseStream* internal_default_instance() {
423:     return reinterpret_cast<const ReverseStream*>(
424:                &_ReverseStream_default_instance_);
429:   friend void swap(ReverseStream& a, ReverseStream& b) {
432:   PROTOBUF_NOINLINE void Swap(ReverseStream* other) {
445:   void UnsafeArenaSwap(ReverseStream* other) {
453:   ReverseStream* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
454:     return CreateMaybeMessage<ReverseStream>(arena);
457:   void CopyFrom(const ReverseStream& from);
458:   void MergeFrom(const ReverseStream& from);
465:       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
472:   void InternalSwap(ReverseStream* other);
477:     return "webrtc.audioproc.ReverseStream";
480:   explicit ReverseStream(::PROTOBUF_NAMESPACE_ID::Arena* arena,
536:   // @@protoc_insertion_point(class_scope:webrtc.audioproc.ReverseStream)
635:       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
911:       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1325:       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1479:       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1713:       uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
1798:   // optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
1804:   const ::webrtc::audioproc::ReverseStream& reverse_stream() const;
1805:   PROTOBUF_NODISCARD ::webrtc::audioproc::ReverseStream* release_reverse_stream();
1806:   ::webrtc::audioproc::ReverseStream* mutable_reverse_stream();
1807:   void set_allocated_reverse_stream(::webrtc::audioproc::ReverseStream* reverse_stream);
1809:   const ::webrtc::audioproc::ReverseStream& _internal_reverse_stream() const;
1810:   ::webrtc::audioproc::ReverseStream* _internal_mutable_reverse_stream();
1813:       ::webrtc::audioproc::ReverseStream* reverse_stream);
1814:   ::webrtc::audioproc::ReverseStream* unsafe_arena_release_reverse_stream();
1893:   ::webrtc::audioproc::ReverseStream* reverse_stream_;
2193: // ReverseStream
2196: inline bool ReverseStream::_internal_has_data() const {
2200: inline bool ReverseStream::has_data() const {
2203: inline void ReverseStream::clear_data() {
2207: inline const std::string& ReverseStream::data() const {
2208:   // @@protoc_insertion_point(field_get:webrtc.audioproc.ReverseStream.data)
2213: void ReverseStream::set_data(ArgT0&& arg0, ArgT... args) {
2216:   // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.data)
2218: inline std::string* ReverseStream::mutable_data() {
2220:   // @@protoc_insertion_point(field_mutable:webrtc.audioproc.ReverseStream.data)
2223: inline const std::string& ReverseStream::_internal_data() const {
2226: inline void ReverseStream::_internal_set_data(const std::string& value) {
2230: inline std::string* ReverseStream::_internal_mutable_data() {
2234: inline std::string* ReverseStream::release_data() {
2235:   // @@protoc_insertion_point(field_release:webrtc.audioproc.ReverseStream.data)
2248: inline void ReverseStream::set_allocated_data(std::string* data) {
2260:   // @@protoc_insertion_point(field_set_allocated:webrtc.audioproc.ReverseStream.data)
2264: inline int ReverseStream::_internal_channel_size() const {
2267: inline int ReverseStream::channel_size() const {
2270: inline void ReverseStream::clear_channel() {
2273: inline std::string* ReverseStream::add_channel() {
2275:   // @@protoc_insertion_point(field_add_mutable:webrtc.audioproc.ReverseStream.channel)
2278: inline const std::string& ReverseStream::_internal_channel(int index) const {
2281: inline const std::string& ReverseStream::channel(int index) const {
2282:   // @@protoc_insertion_point(field_get:webrtc.audioproc.ReverseStream.channel)
2285: inline std::string* ReverseStream::mutable_channel(int index) {
2286:   // @@protoc_insertion_point(field_mutable:webrtc.audioproc.ReverseStream.channel)
2289: inline void ReverseStream::set_channel(int index, const std::string& value) {
2291:   // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.channel)
2293: inline void ReverseStream::set_channel(int index, std::string&& value) {
2295:   // @@protoc_insertion_point(field_set:webrtc.audioproc.ReverseStream.channel)
2297: inline void ReverseStream::set_channel(int index, const char* value) {
2300:   // @@protoc_insertion_point(field_set_char:webrtc.audioproc.ReverseStream.channel)
2302: inline void ReverseStream::set_channel(int index, const void* value, size_t size) {
2305:   // @@protoc_insertion_point(field_set_pointer:webrtc.audioproc.ReverseStream.channel)
2307: inline std::string* ReverseStream::_internal_add_channel() {
2310: inline void ReverseStream::add_channel(const std::string& value) {
2312:   // @@protoc_insertion_point(field_add:webrtc.audioproc.ReverseStream.channel)
2314: inline void ReverseStream::add_channel(std::string&& value) {
2316:   // @@protoc_insertion_point(field_add:webrtc.audioproc.ReverseStream.channel)
2318: inline void ReverseStream::add_channel(const char* value) {
2321:   // @@protoc_insertion_point(field_add_char:webrtc.audioproc.ReverseStream.channel)
2323: inline void ReverseStream::add_channel(const void* value, size_t size) {
2325:   // @@protoc_insertion_point(field_add_pointer:webrtc.audioproc.ReverseStream.channel)
2328: ReverseStream::channel() const {
2329:   // @@protoc_insertion_point(field_list:webrtc.audioproc.ReverseStream.channel)
2333: ReverseStream::mutable_channel() {
2334:   // @@protoc_insertion_point(field_mutable_list:webrtc.audioproc.ReverseStream.channel)
3761: // optional .webrtc.audioproc.ReverseStream reverse_stream = 3;
3774: inline const ::webrtc::audioproc::ReverseStream& Event::_internal_reverse_stream() const {
3775:   const ::webrtc::audioproc::ReverseStream* p = reverse_stream_;
3776:   return p != nullptr ? *p : reinterpret_cast<const ::webrtc::audioproc::ReverseStream&>(
3777:       ::webrtc::audioproc::_ReverseStream_default_instance_);
3779: inline const ::webrtc::audioproc::ReverseStream& Event::reverse_stream() const {
3784:     ::webrtc::audioproc::ReverseStream* reverse_stream) {
3796: inline ::webrtc::audioproc::ReverseStream* Event::release_reverse_stream() {
3798:   ::webrtc::audioproc::ReverseStream* temp = reverse_stream_;
3811: inline ::webrtc::audioproc::ReverseStream* Event::unsafe_arena_release_reverse_stream() {
3814:   ::webrtc::audioproc::ReverseStream* temp = reverse_stream_;
3818: inline ::webrtc::audioproc::ReverseStream* Event::_internal_mutable_reverse_stream() {
3821:     auto* p = CreateMaybeMessage<::webrtc::audioproc::ReverseStream>(GetArenaForAllocation());
3826: inline ::webrtc::audioproc::ReverseStream* Event::mutable_reverse_stream() {
3827:   ::webrtc::audioproc::ReverseStream* _msg = _internal_mutable_reverse_stream();
3831: inline void Event::set_allocated_reverse_stream(::webrtc::audioproc::ReverseStream* reverse_stream) {
60: struct ReverseStreamDefaultTypeInternal;
chromium.googlesource.com/native_client/nacl-llvm-project-v10:polly/include/polly/ScopInfo.h: [ master, ]
2867:   raw_ostream &Stream;
2863:   ScopInfoPrinterPass(raw_ostream &OS) : Stream(OS) {}
github.com/google/mediapipe:mediapipe/framework/api2/builder.h: [ master, ]
286: using Stream = Source<T>;
272: //   Stream<Image> Resize(Stream<Image> image, const Size& size, Graph& graph) {
283: //   Stream<Image> input_image = graph.In("INPUT_IMAGE").Cast<Image>();
284: //   Stream<Image> resized_image = Resize(input_image, {64, 64}, graph);
chromium.googlesource.com/crashpad/crashpad:third_party/cpp-httplib/cpp-httplib/httplib.h: [ master, ] Duplicate result
android.googlesource.com/platform/external/mesa3d:include/D3D9/d3d9types.h: [ master, ]
1751:     WORD Stream;
pdfium.googlesource.com/pdfium:third_party/lcms/src/cmscgats.c: [ master, ]
136:         FILE*          Stream;                   // File stream or NULL if holded in memory
488:     if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {
490:         it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);
492:         if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream))  {
496:                 fclose(it8 ->FileStack[it8->IncludeSP--]->Stream);
936:                 FileNest->Stream = fopen(FileNest->FileName, "rt");
937:                 if (FileNest->Stream == NULL) {
2364:      it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");
2366:      if (!it8 ->FileStack[0]->Stream) {
2377:             fclose(it8 ->FileStack[0]->Stream);
2385:     if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
android.googlesource.com/platform/external/pigweed:pw_stream/public/pw_stream/stream.h: [ master, ]
35: class Stream {
242:   constexpr Stream(bool readable, bool writable, Seekability seekability)
30: // return Status::Unimplemented(). Stream serves as the base for the Reader,
33: // Stream should NOT be used or extended directly. Instead, work with one of the
61:   virtual ~Stream() = default;
171:   // Stream::kUnknownPosition if the position is unknown.
208:   // The Stream class should not be extended directly, so its constructor is
209:   // private. To implement a new Stream, extend one of its derived classes.
267: // A Stream that supports reading but not writing. The Write() method is hidden.
280: class Reader : public Stream {
286:       : Stream(true, false, seekability) {}
288:   using Stream::Write;
352: // A Stream that supports writing but not reading. The Read() method is hidden.
365: class Writer : public Stream {
371:       : Stream(false, true, seekability) {}
373:   using Stream::Read;
439: // A Stream that supports both reading and writing.
453: class ReaderWriter : public Stream {
457:     return static_cast<Reader&>(static_cast<Stream&>(*this));
460:     return static_cast<const Reader&>(static_cast<const Stream&>(*this));
468:     return static_cast<Writer&>(static_cast<Stream&>(*this));
471:     return static_cast<const Writer&>(static_cast<const Stream&>(*this));
482:       : Stream(true, true, seekability) {}
505:     return static_cast<RelativeSeekableReader&>(static_cast<Stream&>(*this));
509:         static_cast<const Stream&>(*this));
512:     return static_cast<RelativeSeekableWriter&>(static_cast<Stream&>(*this));
516:         static_cast<const Stream&>(*this));
543:     return static_cast<SeekableReader&>(static_cast<Stream&>(*this));
547:         static_cast<const Stream&>(*this));
557:     return static_cast<SeekableWriter&>(static_cast<Stream&>(*this));
561:         static_cast<const Stream&>(*this));
589:     return static_cast<NonSeekableReader&>(static_cast<Stream&>(*this));
593:         static_cast<const Stream&>(*this));
596:     return static_cast<NonSeekableWriter&>(static_cast<Stream&>(*this));
600:         static_cast<const Stream&>(*this));
173:   // Streams that support seeking from the beginning always support Tell().
android.googlesource.com/platform/external/pdfium:third_party/lcms/src/cmscgats.c: [ master, ]
136:         FILE*          Stream;                   // File stream or NULL if holded in memory
488:     if (it8 -> FileStack[it8 ->IncludeSP]->Stream) {
490:         it8 ->ch = fgetc(it8 ->FileStack[it8 ->IncludeSP]->Stream);
492:         if (feof(it8 -> FileStack[it8 ->IncludeSP]->Stream))  {
496:                 fclose(it8 ->FileStack[it8->IncludeSP--]->Stream);
936:                 FileNest->Stream = fopen(FileNest->FileName, "rt");
937:                 if (FileNest->Stream == NULL) {
2368:      it8 ->FileStack[0]->Stream = fopen(cFileName, "rt");
2370:      if (!it8 ->FileStack[0]->Stream) {
2381:             fclose(it8 ->FileStack[0]->Stream);
2389:     if (fclose(it8 ->FileStack[0]->Stream)!= 0) {
github.com/apache/rocketmq-externals:rocketmq-knative/source/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.pb.go: [ master, ]
2188: type Stream struct {
316: type StreamStatus int32
319: 	StreamStatus_STREAM_ENABLING StreamStatus = 1
320: 	StreamStatus_STREAM_ACTIVE   StreamStatus = 2
323: var StreamStatus_name = map[int32]string{
327: var StreamStatus_value = map[string]int32{
790: type StreamSpecification struct {
791: 	EnableStream     *bool  `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"`
801: func (m *StreamSpecification) GetEnableStream() bool {
815: type StreamDetails struct {
816: 	EnableStream     *bool   `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"`
817: 	StreamId         *string `protobuf:"bytes,2,opt,name=stream_id" json:"stream_id,omitempty"`
828: func (m *StreamDetails) GetEnableStream() bool {
871: 	StreamSpec         *StreamSpecification `protobuf:"bytes,5,opt,name=stream_spec" json:"stream_spec,omitempty"`
937: 	StreamSpec         *StreamSpecification `protobuf:"bytes,4,opt,name=stream_spec" json:"stream_spec,omitempty"`
977: 	StreamDetails             *StreamDetails             `protobuf:"bytes,3,opt,name=stream_details" json:"stream_details,omitempty"`
1030: 	StreamDetails             *StreamDetails             `protobuf:"bytes,5,opt,name=stream_details" json:"stream_details,omitempty"`
2189: 	StreamId         *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`
2222: 	Streams          []*Stream `protobuf:"bytes,1,rep,name=streams" json:"streams,omitempty"`
2238: type StreamShard struct {
2272: 	StreamId              *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`
2305: 	StreamId         *string        `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`
2309: 	StreamStatus     *StreamStatus  `protobuf:"varint,5,req,name=stream_status,enum=otsprotocol.StreamStatus" json:"stream_status,omitempty"`
2370: 	StreamId         *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"`
2461: 	StreamRecords     []*GetStreamRecordResponse_StreamRecord `protobuf:"bytes,1,rep,name=stream_records" json:"stream_records,omitempty"`
2485: type GetStreamRecordResponse_StreamRecord struct {
835: func (m *StreamDetails) GetStreamId() string {
909: func (m *CreateTableRequest) GetStreamSpec() *StreamSpecification {
967: func (m *UpdateTableRequest) GetStreamSpec() *StreamSpecification {
1000: func (m *UpdateTableResponse) GetStreamDetails() *StreamDetails {
1069: func (m *DescribeTableResponse) GetStreamDetails() *StreamDetails {
2171: type ListStreamRequest struct {
2200: func (m *Stream) GetStreamId() string {
2221: type ListStreamResponse struct {
2231: func (m *ListStreamResponse) GetStreams() []*Stream {
2271: type DescribeStreamRequest struct {
2283: func (m *DescribeStreamRequest) GetStreamId() string {
2304: type DescribeStreamResponse struct {
2320: func (m *DescribeStreamResponse) GetStreamId() string {
2348: func (m *DescribeStreamResponse) GetStreamStatus() StreamStatus {
2382: func (m *GetShardIteratorRequest) GetStreamId() string {
2435: type GetStreamRecordRequest struct {
2460: type GetStreamRecordResponse struct {
2471: func (m *GetStreamRecordResponse) GetStreamRecords() []*GetStreamRecordResponse_StreamRecord {
2195: func (m *Stream) Reset()                    { *m = Stream{} }
2196: func (m *Stream) String() string            { return proto.CompactTextString(m) }
2197: func (*Stream) ProtoMessage()               {}
2198: func (*Stream) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{50} }
2207: func (m *Stream) GetTableName() string {
2214: func (m *Stream) GetCreationTime() int64 {
2993: 	proto.RegisterType((*Stream)(nil), "otsprotocol.Stream")
332: func (x StreamStatus) Enum() *StreamStatus {
333: 	p := new(StreamStatus)
337: func (x StreamStatus) String() string {
338: 	return proto.EnumName(StreamStatus_name, int32(x))
340: func (x *StreamStatus) UnmarshalJSON(data []byte) error {
341: 	value, err := proto.UnmarshalJSONEnum(StreamStatus_value, data, "StreamStatus")
345: 	*x = StreamStatus(value)
348: func (StreamStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{8} }
796: func (m *StreamSpecification) Reset()                    { *m = StreamSpecification{} }
797: func (m *StreamSpecification) String() string            { return proto.CompactTextString(m) }
798: func (*StreamSpecification) ProtoMessage()               {}
799: func (*StreamSpecification) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} }
802: 	if m != nil && m.EnableStream != nil {
803: 		return *m.EnableStream
808: func (m *StreamSpecification) GetExpirationTime() int32 {
823: func (m *StreamDetails) Reset()                    { *m = StreamDetails{} }
824: func (m *StreamDetails) String() string            { return proto.CompactTextString(m) }
825: func (*StreamDetails) ProtoMessage()               {}
826: func (*StreamDetails) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} }
829: 	if m != nil && m.EnableStream != nil {
830: 		return *m.EnableStream
836: 	if m != nil && m.StreamId != nil {
837: 		return *m.StreamId
842: func (m *StreamDetails) GetExpirationTime() int32 {
849: func (m *StreamDetails) GetLastEnableTime() int64 {
911: 		return m.StreamSpec
969: 		return m.StreamSpec
1002: 		return m.StreamDetails
1071: 		return m.StreamDetails
2201: 	if m != nil && m.StreamId != nil {
2202: 		return *m.StreamId
2233: 		return m.Streams
2245: func (m *StreamShard) Reset()                    { *m = StreamShard{} }
2246: func (m *StreamShard) String() string            { return proto.CompactTextString(m) }
2247: func (*StreamShard) ProtoMessage()               {}
2248: func (*StreamShard) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{52} }
2250: func (m *StreamShard) GetShardId() string {
2257: func (m *StreamShard) GetParentId() string {
2264: func (m *StreamShard) GetParentSiblingId() string {
2284: 	if m != nil && m.StreamId != nil {
2285: 		return *m.StreamId
2310: 	Shards           []*StreamShard `protobuf:"bytes,6,rep,name=shards" json:"shards,omitempty"`
2321: 	if m != nil && m.StreamId != nil {
2322: 		return *m.StreamId
2349: 	if m != nil && m.StreamStatus != nil {
2350: 		return *m.StreamStatus
2352: 	return StreamStatus_STREAM_ENABLING
2355: func (m *DescribeStreamResponse) GetShards() []*StreamShard {
2383: 	if m != nil && m.StreamId != nil {
2384: 		return *m.StreamId
2473: 		return m.StreamRecords
2491: func (m *GetStreamRecordResponse_StreamRecord) Reset()         { *m = GetStreamRecordResponse_StreamRecord{} }
2492: func (m *GetStreamRecordResponse_StreamRecord) String() string { return proto.CompactTextString(m) }
2493: func (*GetStreamRecordResponse_StreamRecord) ProtoMessage()    {}
2494: func (*GetStreamRecordResponse_StreamRecord) Descriptor() ([]byte, []int) {
2498: func (m *GetStreamRecordResponse_StreamRecord) GetActionType() ActionType {
2505: func (m *GetStreamRecordResponse_StreamRecord) GetRecord() []byte {
2953: 	proto.RegisterType((*StreamSpecification)(nil), "otsprotocol.StreamSpecification")
2954: 	proto.RegisterType((*StreamDetails)(nil), "otsprotocol.StreamDetails")
2995: 	proto.RegisterType((*StreamShard)(nil), "otsprotocol.StreamShard")
3002: 	proto.RegisterType((*GetStreamRecordResponse_StreamRecord)(nil), "otsprotocol.GetStreamRecordResponse.StreamRecord")
3030: 	proto.RegisterEnum("otsprotocol.StreamStatus", StreamStatus_name, StreamStatus_value)
2176: func (m *ListStreamRequest) Reset()                    { *m = ListStreamRequest{} }
2177: func (m *ListStreamRequest) String() string            { return proto.CompactTextString(m) }
2178: func (*ListStreamRequest) ProtoMessage()               {}
2179: func (*ListStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{49} }
2181: func (m *ListStreamRequest) GetTableName() string {
2226: func (m *ListStreamResponse) Reset()                    { *m = ListStreamResponse{} }
2227: func (m *ListStreamResponse) String() string            { return proto.CompactTextString(m) }
2228: func (*ListStreamResponse) ProtoMessage()               {}
2229: func (*ListStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{51} }
2278: func (m *DescribeStreamRequest) Reset()                    { *m = DescribeStreamRequest{} }
2279: func (m *DescribeStreamRequest) String() string            { return proto.CompactTextString(m) }
2280: func (*DescribeStreamRequest) ProtoMessage()               {}
2281: func (*DescribeStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{53} }
2290: func (m *DescribeStreamRequest) GetInclusiveStartShardId() string {
2297: func (m *DescribeStreamRequest) GetShardLimit() int32 {
2315: func (m *DescribeStreamResponse) Reset()                    { *m = DescribeStreamResponse{} }
2316: func (m *DescribeStreamResponse) String() string            { return proto.CompactTextString(m) }
2317: func (*DescribeStreamResponse) ProtoMessage()               {}
2318: func (*DescribeStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{54} }
2327: func (m *DescribeStreamResponse) GetExpirationTime() int32 {
2334: func (m *DescribeStreamResponse) GetTableName() string {
2341: func (m *DescribeStreamResponse) GetCreationTime() int64 {
2362: func (m *DescribeStreamResponse) GetNextShardId() string {
2441: func (m *GetStreamRecordRequest) Reset()                    { *m = GetStreamRecordRequest{} }
2442: func (m *GetStreamRecordRequest) String() string            { return proto.CompactTextString(m) }
2443: func (*GetStreamRecordRequest) ProtoMessage()               {}
2444: func (*GetStreamRecordRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{57} }
2446: func (m *GetStreamRecordRequest) GetShardIterator() string {
2453: func (m *GetStreamRecordRequest) GetLimit() int32 {
2466: func (m *GetStreamRecordResponse) Reset()                    { *m = GetStreamRecordResponse{} }
2467: func (m *GetStreamRecordResponse) String() string            { return proto.CompactTextString(m) }
2468: func (*GetStreamRecordResponse) ProtoMessage()               {}
2469: func (*GetStreamRecordResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{58} }
2478: func (m *GetStreamRecordResponse) GetNextShardIterator() string {
2992: 	proto.RegisterType((*ListStreamRequest)(nil), "otsprotocol.ListStreamRequest")
2994: 	proto.RegisterType((*ListStreamResponse)(nil), "otsprotocol.ListStreamResponse")
2996: 	proto.RegisterType((*DescribeStreamRequest)(nil), "otsprotocol.DescribeStreamRequest")
2997: 	proto.RegisterType((*DescribeStreamResponse)(nil), "otsprotocol.DescribeStreamResponse")
3000: 	proto.RegisterType((*GetStreamRecordRequest)(nil), "otsprotocol.GetStreamRecordRequest")
3001: 	proto.RegisterType((*GetStreamRecordResponse)(nil), "otsprotocol.GetStreamRecordResponse")
github.com/apache/trafficcontrol:vendor/github.com/basho/riak-go-client/rpb/riak_kv/riak_kv.pb.go: [ master, ]
585: 	Stream           *bool   `protobuf:"varint,2,opt,name=stream" json:"stream,omitempty"`
775: 	Stream       *bool                       `protobuf:"varint,8,opt,name=stream" json:"stream,omitempty"`
602: func (m *RpbListBucketsReq) GetStream() bool {
843: func (m *RpbIndexReq) GetStream() bool {
603: 	if m != nil && m.Stream != nil {
604: 		return *m.Stream
844: 	if m != nil && m.Stream != nil {
845: 		return *m.Stream
github.com/llvm-mirror/clang-tools-extra:clang-doc/BitcodeWriter.h: [ master, ]
175:     llvm::BitstreamWriter &Stream;
215:   llvm::BitstreamWriter &Stream;
174:   class StreamSubBlockGuard {
178:     StreamSubBlockGuard(llvm::BitstreamWriter &Stream_, BlockId ID)
188:     ~StreamSubBlockGuard() { Stream.ExitBlock(); }
142:   ClangDocBitcodeWriter(llvm::BitstreamWriter &Stream) : Stream(Stream) {
179:         : Stream(Stream_) {
182:       Stream.EnterSubblock(ID, BitCodeConstants::SubblockIDSize);
185:     StreamSubBlockGuard(const StreamSubBlockGuard &) = delete;
186:     StreamSubBlockGuard &operator=(const StreamSubBlockGuard &) = delete;
android.googlesource.com/platform/frameworks/compile/libbcc:bcinfo/BitReader_3_0/BitcodeReader.cpp: [ master, ]
433:   BitstreamCursor Stream;
432:   std::unique_ptr<BitstreamReader> StreamFile;
3758: std::error_code BitcodeReader::InitStream() {
3783: std::error_code BitcodeReader::InitLazyStream() {
434:   std::unique_ptr<DataStreamer> LazyStreamer;
3764: std::error_code BitcodeReader::InitStreamFromBuffer() {
1113:   if (Stream.EnterSubBlock(bitc::PARAMATTR_BLOCK_ID))
1125:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1140:     switch (Stream.readRecord(Entry.ID, Record)) {
1172:   if (Stream.EnterSubBlock(bitc::TYPE_BLOCK_ID_NEW))
1189:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1207:     switch (Stream.readRecord(Entry.ID, Record)) {
1400:   if (Stream.EnterSubBlock(TYPE_BLOCK_ID_OLD_3_0))
1410:   BitstreamCursor StartOfTypeBlockCursor(Stream);
1421:     unsigned Code = Stream.ReadCode();
1433:         Stream = StartOfTypeBlockCursor;
1437:       if (Stream.ReadBlockEnd())
1444:       Stream.ReadSubBlockID();
1445:       if (Stream.SkipBlock())
1451:       Stream.ReadAbbrevRecord();
1458:     switch (Stream.readRecord(Code, Record)) {
1606:   if (Stream.EnterSubBlock(TYPE_SYMTAB_BLOCK_ID_OLD_3_0))
1614:     unsigned Code = Stream.ReadCode();
1616:       if (Stream.ReadBlockEnd())
1623:       Stream.ReadSubBlockID();
1624:       if (Stream.SkipBlock())
1630:       Stream.ReadAbbrevRecord();
1636:     switch (Stream.readRecord(Code, Record)) {
1657:   if (Stream.EnterSubBlock(bitc::VALUE_SYMTAB_BLOCK_ID))
1665:     unsigned Code = Stream.ReadCode();
1667:       if (Stream.ReadBlockEnd())
1673:       Stream.ReadSubBlockID();
1674:       if (Stream.SkipBlock())
1680:       Stream.ReadAbbrevRecord();
1686:     switch (Stream.readRecord(Code, Record)) {
1719:   if (Stream.EnterSubBlock(bitc::METADATA_BLOCK_ID))
1726:     unsigned Code = Stream.ReadCode();
1728:       if (Stream.ReadBlockEnd())
1735:       Stream.ReadSubBlockID();
1736:       if (Stream.SkipBlock())
1742:       Stream.ReadAbbrevRecord();
1749:     Code = Stream.readRecord(Code, Record);
1757:       Code = Stream.ReadCode();
1760:       unsigned NextBitCode = Stream.readRecord(Code, Record);
1919:   if (Stream.EnterSubBlock(bitc::CONSTANTS_BLOCK_ID))
1928:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
1950:     unsigned BitCode = Stream.readRecord(Entry.ID, Record);
2254:   if (Stream.ReadBlockEnd())
2281:   uint64_t CurBit = Stream.GetCurrentBitNo();
2285:   if (Stream.SkipBlock())
2321:     Stream.JumpToBit(NextUnreadBit);
2322:   else if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
2331:     BitstreamEntry Entry = Stream.advance();
2342:         if (Stream.SkipBlock())
2346:         if (Stream.ReadBlockInfoBlock())
2399:           NextUnreadBit = Stream.GetCurrentBitNo();
2414:     switch (Stream.readRecord(Entry.ID, Record)) {
2612:   if (Stream.Read(8) != 'B' ||
2613:       Stream.Read(8) != 'C' ||
2614:       Stream.Read(4) != 0x0 ||
2615:       Stream.Read(4) != 0xC ||
2616:       Stream.Read(4) != 0xE ||
2617:       Stream.Read(4) != 0xD)
2623:     if (Stream.AtEndOfStream())
2627:       Stream.advance(BitstreamCursor::AF_DontAutoprocessAbbrevs);
2638:         if (Stream.ReadBlockInfoBlock())
2652:         if (Stream.SkipBlock())
2663:       if (Stream.getAbbrevIDWidth() == 2 && Entry.ID == 2 &&
2664:           Stream.Read(6) == 2 && Stream.Read(24) == 0xa0a0a &&
2665:           Stream.AtEndOfStream())
2674:   if (Stream.EnterSubBlock(bitc::MODULE_BLOCK_ID))
2682:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
2696:     switch (Stream.readRecord(Entry.ID, Record)) {
2724:   if (Stream.Read(8) != 'B' ||
2725:       Stream.Read(8) != 'C' ||
2726:       Stream.Read(4) != 0x0 ||
2727:       Stream.Read(4) != 0xC ||
2728:       Stream.Read(4) != 0xE ||
2729:       Stream.Read(4) != 0xD)
2735:     BitstreamEntry Entry = Stream.advance();
2748:       if (Stream.SkipBlock())
2753:       Stream.skipRecord(Entry.ID);
2761:   if (Stream.EnterSubBlock(bitc::METADATA_ATTACHMENT_ID))
2766:     BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
2781:     switch (Stream.readRecord(Entry.ID, Record)) {
2806:   if (Stream.EnterSubBlock(bitc::FUNCTION_BLOCK_ID))
2826:     unsigned Code = Stream.ReadCode();
2828:       if (Stream.ReadBlockEnd())
2834:       switch (Stream.ReadSubBlockID()) {
2836:         if (Stream.SkipBlock())
2861:       Stream.ReadAbbrevRecord();
2868:     unsigned BitCode = Stream.readRecord(Code, Record);
3671:   Stream.JumpToBit(DFII->second);
3778:   Stream.init(&*StreamFile);
3790:   Stream.init(&*StreamFile);
591:   std::error_code InitStream();
593:   std::error_code InitLazyStream();
2608:   if (std::error_code EC = InitStream())
2720:   if (std::error_code EC = InitStream())
3760:     return InitLazyStream();
3777:   StreamFile.reset(new BitstreamReader(BufPtr, BufEnd));
3786:   auto OwnedBytes = llvm::make_unique<StreamingMemoryObject>(
3788:   StreamingMemoryObject &Bytes = *OwnedBytes;
3789:   StreamFile = llvm::make_unique<BitstreamReader>(std::move(OwnedBytes));
592:   std::error_code InitStreamFromBuffer();
633:       TheModule(nullptr), Buffer(buffer), LazyStreamer(nullptr),
2398:         if (LazyStreamer && SeenValueSymbolTable) {
2566:         if (LazyStreamer)
2648:         if (LazyStreamer)
3759:   if (LazyStreamer)
3761:   return InitStreamFromBuffer();
3787:       std::move(LazyStreamer));
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) */
562: 	u8  Stream;
629: 	u8                    Stream;
450: 		struct FW_STREAM_CONTROL         StreamControl;
540: 	StreamMode_NONE   = 0, /* Stream not used */
541: 	StreamMode_ANALOG = 1, /* Analog: Stream 0,1 = Video, 2,3 = Audio */
542: 	StreamMode_TSIN   = 2, /* Transport stream input (all) */
543: 	StreamMode_HDTV   = 4, /* HDTV: Maximum 1920x1080p30,1920x1080i60
545: 	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/native_client/pnacl-gcc:gcc/go/gofrontend/import.h: [ master, ]
26:   class Stream
261: class Stream_from_string : public Import::Stream
264:   Stream_from_string(const std::string& str)
291: class Stream_from_buffer : public Import::Stream
294:   Stream_from_buffer(char* buf, size_t length)
326: class Stream_from_file : public Import::Stream
298:   ~Stream_from_buffer()
24:   // The Stream class is an interface used to read the data.  The
29:     Stream();
30:     virtual ~Stream();
124:   // returns a pointer to a Stream object to read the data that it
126:   static Stream*
130:   Import(Stream*, source_location);
192:   static Stream*
198:   static Stream*
201:   static Stream*
210:   static Stream*
245:   Stream* stream_;
329:   Stream_from_file(int fd);
331:   ~Stream_from_file();
342:   Stream_from_file(const Stream_from_file&);
343:   Stream_from_file& operator=(const Stream_from_file&);
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) {
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) {
github.com/google/highway:hwy/ops/arm_neon-inl.h: [ master, ]
3498: HWY_API void Stream(const VFromD<D> v, D d, TFromD<D>* HWY_RESTRICT aligned) {
github.com/google/google-drive-shell-extension:google-drive-proxy/DriveProxy/API/Interfaces/IDriveService.cs: [ master, ]
2743:     protected class Stream : IStream
2749:       internal Stream()
2754:       internal Stream(DriveProxy.API.DriveService.Stream stream)
585:     IStream Stream { get; }
3167:       public IStream Stream
2760:       internal DriveProxy.API.DriveService.Stream _Stream
3160:       protected IStream _Stream = null;
66:     event IStreamEventHandler OnQueueStartedStream;
71:     event IStreamEventHandler OnQueueFinishedStream;
591:   public interface IStream
902:     private static void State_QueuedStream(DriveProxy.API.DriveService.State sender,
918:     private static void State_FinishedStream(DriveProxy.API.DriveService.State sender,
953:     public static IStream CreateStream()
1256:       public event IStreamEventHandler OnQueueStartedStream = null;
1257:       public event IStreamEventHandler OnQueueFinishedStream = null;
2293:       public void InvokeQueueStartedStream(object sender, IStreamEventArgs e)
2307:       public void InvokeQueueFinishedStream(object sender, IStreamEventArgs e)
3158:     protected class StreamEventArgs : IStreamEventArgs
3162:       public StreamEventArgs(IStream stream)
578:   public delegate void IStreamEventHandler(object sender, IStreamEventArgs e);
583:   public interface IStreamEventArgs
574:   ///   A delegate handler for Stream Events.
581:   ///   Arguments supplied for Stream Events.
903:                                            DriveProxy.API.DriveService.Stream stream)
909:           _DriveService.InvokeQueueStartedStream(sender, new StreamEventArgs(new Stream(stream)));
919:                                              DriveProxy.API.DriveService.Stream stream)
925:           _DriveService.InvokeQueueFinishedStream(sender, new StreamEventArgs(new Stream(stream)));
957:         return new Stream();
1755:           var tempStream = stream as Stream;
1775:           tempStream._Stream = copyStream;
1813:           var tempStream = stream as Stream;
1836:           tempStream._Stream = downloadStream;
1850:           var tempStream = stream as Stream;
1869:           tempStream._Stream = insertStream;
1924:           var tempStream = stream as Stream;
1944:           tempStream._Stream = moveStream;
1982:           var tempStream = stream as Stream;
2003:           tempStream._Stream = renameStream;
2041:           var tempStream = stream as Stream;
2064:           tempStream._Stream = uploadStream;
2102:           var tempStream = stream as Stream;
2121:           tempStream._Stream = trashStream;
2159:           var tempStream = stream as Stream;
2178:           tempStream._Stream = untrashStream;