Search some code: Max results:

Found 64879 results in 10904 files (1522680 ngram matches, 123266 docs considered, 21200 docs (323MB) loaded, 102020 docs skipped): for
(and (not substr:"Path file") case_substr:"Stream") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 2.332888204s (queued: 2.446µs)

android.googlesource.com/platform/frameworks/ex:framesequence/jni/Stream.cpp:[master, ]

32: Stream::Stream()
38: Stream::~Stream() {
143: jint JavaStream_OnLoad(JNIEnv* env) {
30: } gInputStreamClassInfo;
17: #define LOG_TAG "Stream"
19: #include "Stream.h"
42: size_t Stream::peek(void* buffer, size_t size) {
60: size_t Stream::read(void* buffer, size_t size) {
82: uint8_t* Stream::getRawBufferAddr() {
86: jobject Stream::getRawBuffer() {
90: int Stream::getRawBufferSize() {
94: uint8_t* MemoryStream::getRawBufferAddr() {
98: jobject MemoryStream::getRawBuffer() {
102: int MemoryStream::getRawBufferSize() {
110: size_t MemoryStream::doRead(void* buffer, size_t size) {
118: size_t FileStream::doRead(void* buffer, size_t size) {
122: size_t JavaInputStream::doRead(void* dstBuffer, size_t size) {
128:         jint bytesRead = mEnv->CallIntMethod(mInputStream,
146:     jclass inputStreamClazz = env->FindClass("java/io/InputStream");
129:                 gInputStreamClassInfo.read, mByteArray, 0, requested);
147:     if (!inputStreamClazz) {
150:     gInputStreamClassInfo.read = env->GetMethodID(inputStreamClazz, "read", "([BII)I");
151:     gInputStreamClassInfo.reset = env->GetMethodID(inputStreamClazz, "reset", "()V");
152:     if (!gInputStreamClassInfo.read || !gInputStreamClassInfo.reset) {
github.com/GoogleCloudPlatform/todomvc-mongodb:node_modules/angular/node_modules/jsdom/node_modules/htmlparser2/lib/WritableStream.js:[master, ]
6: function Stream(cbs, options){
4:     WritableStream = require("stream").Writable || require("readable-stream").Writable;
18: WritableStream.prototype._write = function(chunk, encoding, cb){
1: module.exports = Stream;
16: require("util").inherits(Stream, WritableStream);
9: 	WritableStream.call(this, {decodeStrings: false});
github.com/GoogleCloudPlatform/todomvc-mongodb:node_modules/angular/node_modules/jsdom/node_modules/htmlparser2/lib/Stream.js:[master, ]
5: function Stream(options){
11: Stream.prototype.readable = true;
1: module.exports = Stream;
9: require("util").inherits(Stream, Parser);
3: var Parser = require("./WritableStream.js");
android.googlesource.com/platform/external/arduino:hardware/arduino/cores/arduino/Stream.h:[master, ]
26: class Stream : public Print
21: #define Stream_h
2:   Stream.h - base class for character-based streams.
20: #ifndef Stream_h
github.com/google/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();
android.googlesource.com/platform/external/cherry:third_party/sax/lib/sax.js:[master, ]
159:   var Stream = function () {}
167: function createStream (strict, opt) {
171: function SAXStream (strict, opt) {
157:   var Stream = require("stream").Stream
174:   Stream.apply(this)
213: SAXStream.prototype = Object.create(Stream.prototype,
249:   return Stream.prototype.on.call(me, ev, handler)
6: sax.SAXStream = SAXStream
7: sax.createStream = createStream
168:   return new 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/kubernetes/helm:pkg/releasetesting/environment.go:[master, ]
36: 	Stream     services.ReleaseService_RunReleaseTestServer
111: 	return env.Stream.Send(resp)
github.com/google/rspirv:rspirv/sr/decoration.rs:[master, ]
50:     Stream(u32),
github.com/GoogleChrome/net-chromeify:index.js:[master, ]
20: var Stream = require('stream');
180: util.inherits(net.Socket, Stream);
github.com/openconfig/reference:telemetry/client/fake/fake.go:[master, ]
21: type Stream struct {
29: func NewStream(e []Event) *Stream {
141: type StreamError struct {
33: 	s := &Stream{
58: func (s *Stream) Next() (*pathtree.PathVal, error) {
79: func (s *Stream) Close() {
91: 	s  *Stream
108: func (c *Client) Subscribe(p pathtree.Path) (*Stream, error) {
71: 		return nil, StreamError{Msg: fmt.Sprintf("invalid Event type: %T", e)}
96: 		s: NewStream(e),
145: func (e StreamError) Error() string {
github.com/google/barista:modules/reformat/reformat.go:[master, ]
50: func (m *module) Stream() <-chan *bar.Output {
49: // Stream sets up the formatting pipeline and returns a channel for the bar.
52: 	go format(m.Module.Stream(), m.Formatter, reformatted)
github.com/openconfig/reference:telemetry/client/client.go:[master, ]
11: type Stream interface {
10: // Stream provides an iterator for the events being streamed from the client.
27: 	Subscribe(pathtree.Path) (Stream, error)
go.googlesource.com/arch:vendor/rsc.io/pdf/read.go:[master, ]
471: 	Stream
95: 	inStream bool
210: func readXrefStream(r *Reader, b *buffer) ([]xref, objptr, dict, error) {
1046: func decryptStream(key []byte, useAES bool, ptr objptr, rd io.Reader) io.Reader {
270: func readXrefStreamData(r *Reader, strm stream, table []xref, size int64) ([]xref, error) {
31: //	Stream, for an opaque data stream and associated header dictionary.
252: 		if prev.Kind() != Stream {
494: 		return Stream
658: // If v.Kind() != Dict and v.Kind() != Stream, Key returns a null Value.
673: // If v.Kind() != Dict and v.Kind() != Stream, Keys returns nil.
726: 				if strm.Kind() != Stream {
749: 				if ext.Kind() != Stream {
795: // If v.Kind() != Stream, Reader returns a ReadCloser that
205: 		return readXrefStream(r, b)
333: 				table[x] = xref{ptr: objptr{uint32(x), 0}, inStream: true, stream: objptr{uint32(v2), 0}, offset: int64(v3)}
718: 		if xref.ptr != ptr || !xref.inStream && xref.offset == 0 {
722: 		if xref.inStream {
805: 		rd = decryptStream(v.r.key, v.r.useAES, x.ptr, rd)
963: 		c.XORKeyStream(u, u)
969: 		c.XORKeyStream(u, u)
978: 			c.XORKeyStream(u, u)
1040: 		c.XORKeyStream(data, data)
1059: 		rd = &cipher.StreamReader{c, rd}
230: 	table, err := readXrefStreamData(r, strm, table, size)
262: 		if table, err = readXrefStreamData(r, prev.data.(stream), table, psize); err != nil {
github.com/kubernetes/test-infra:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: 	return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: 	return newStream(ƒ)
70: 	return newStream(ƒ)
96: 	return newStream(ƒ)
github.com/google/highwayhash:highwayhash/scalar.h:[master, ]
315: HH_INLINE void Stream(const Scalar<T>& v, T* const HH_RESTRICT to) {
go.googlesource.com/talks:2014/readability/close-cond-good.go:[master, ]
4: type Stream struct {
9: func (s *Stream) Wait() error {
13: func (s *Stream) Close() {
17: func (s *Stream) IsClosed() bool {
github.com/llvm-mirror/lnt:lnt/testing/profile/cPerf.cpp:[master, ]
328:   FILE *Stream;
466: void PerfReader::readDataStream() {
115:   FILE *Stream = fdopen(P[0], "r");
125:   return Stream;
268:     auto Stream = ForkAndExec(Cmd);
273:       ssize_t Len = getline(&Line, &LineLen, Stream);
309:     fclose(Stream);
336:     : Objdump(Objdump), Stream(nullptr), Line(NULL), LineLen(0) {}
338:     if (Stream) {
339:       fclose(Stream);
348:     if (Stream) {
349:       fclose(Stream);
361:     Stream = ForkAndExec(Cmd);
375:       ssize_t Len = getline(&Line, &LineLen, Stream);
409:   void readDataStream();
752:     P.readDataStream();
781:   P.readDataStream();
go.googlesource.com/talks:2014/readability/close-cond-bad.go:[master, ]
4: type Stream struct {
11: func (s *Stream) Wait() error {
19: func (s *Stream) Close() {
26: func (s *Stream) IsClosed() bool {
github.com/google/skia-buildbot:go/metrics2/events/events.go:[master, ]
48: 	Stream    string
194: func (m *EventMetrics) GetEventStream(name string) *EventStream {
193: // GetEventStream returns an EventStream instance.
197: 	return &EventStream{
github.com/kubernetes/client-go:rest/request.go:[master, ]
719: func (r *Request) Stream() (io.ReadCloser, error) {
71: 	Stream() (io.ReadCloser, error)
715: // Stream formats and executes the request, and offers streaming of the response.
693: 	decoder := streaming.NewDecoder(framer, r.serializers.StreamingSerializer)
694: 	return watch.NewStreamWatcher(restclientwatch.NewDecoder(decoder, r.serializers.Decoder)), nil
github.com/google/gemmlowp:meta/base.h:[master, ]
78: class Stream {
39:   typedef OutputStream_ OutputStream;
51:   typedef LeftStream_ LeftStream;
52:   typedef RightStream_ RightStream;
54:   typedef OutputStream_ OutputStream;
92: class StreamUtil {
35: template <typename Kernel_, typename OutputStream_>
42:   OutputStream output_stream;
45: template <typename InType_, typename OutType_, typename LeftStream_,
46:           typename RightStream_, typename Kernel_, typename OutputStream_>
56:   typedef FusedKernelParams<Kernel, OutputStream> FusedKernel;
71:   LeftStream left_stream;
72:   RightStream right_stream;
77:           typename StreamParams>
80:   static void Pack(const InType* in, const StreamParams& params, InType* out);
82:   static int UnpackedAdvance(const StreamParams& params);
84:   static int PackedAdvance(const StreamParams& params);
86:   static int UnpackedStride(const StreamParams& params);
88:   static int PackedStride(const StreamParams& params);
91: template <typename InType, typename StreamType>
94:   static const InType* Offset(const StreamType& params, const InType* source,
97:   static int Scratch(const StreamType& params, int lanes);
101:           typename OutputStream, int kernel_m, int kernel_n, int pack_size>
105:                        const FusedKernelParams<Kernel, OutputStream>& params,
github.com/google/io-captions-gadget:includes/js/jquery-effects.js:[master, ]
135: Stream = {
12: 		Stream.scrolled = true;
13: 		Stream.container.scrollTop(Stream.container.scrollTop() - 20);
16: 		Stream.container.scrollTop(Stream.container.scrollTop() + 20);
17: 		if(Stream.container.scrollTop() + Stream.container.height() < Stream.container.get(0).scrollHeight) {
18: 			Stream.scrolled = false;
25: 	Stream.container = $('#captions');
26: 	Stream.fetch();
66: 			Stream.setLang(lang);
109: 				Stream.run = false;
110: 				if(Stream.currentFetch) {
111: 					Stream.currentFetch.abort();
113: 				Stream.container.html('');
121: 				Stream.run = true;
122: 				Stream.container.html('');
123: 				Stream.fetch();
149: 		if(!Stream.run || Stream.running) { return;}
150: 		Stream.running = true;
151: 		var last = Stream.lasts[Stream.eventId];
152: 		var url = "/update?last=" + last + '&lang=' + Stream.lang + '&event=' + Stream.eventId;
153: 		Stream.currentFetch = $.getJSON(url, function(response, status) {
157: 				var delay = Math.max(response.delay_ms || 0, Stream.displayDelay - Stream.fetchDelay);
158: 				Stream.displayDelay = delay;
160: 					Stream.container.html(Stream.runDeletes(Stream.container.html() + response.output));
162: 				if(!Stream.scrolled) {
163: 					Stream.fixScroll();
166: 	   				Stream.messageAdd("No event currently in progress.")
175: 	   				Stream.emptyFetches++;
176: 	   				if(Stream.emptyFetches > 1) {
177: 	   					Stream.fetchDelay = Stream.fetchDelay * 2;
178: 	   					Stream.fetchDelay = Math.min(Stream.maxDelay, Stream.fetchDelay * 2);
182: 	   				Stream.emptyFetches = 0;
184: 	   			if(Stream.emptyFetches > Stream.emptyLimit) {
185: 	   				Stream.messageAdd("There hasn't been any new content for a while...");
189: 	   					Stream.messageClear();
191: 	   				Stream.lasts[Stream.eventId] = response.last;
194: 			Stream.running = false;
196: 				Stream.fetch();
197: 			}, Stream.fetchDelay);
199:    			Stream.errors++;
200:    			Stream.fetchDelay = Math.min(Stream.maxDelay, Stream.fetchDelay * 2);
201:    			Stream.running = false;
202:    			if(Stream.errors <= Stream.maxRetries) {
204:    					Stream.fetch();
205:    				}, Stream.fetchDelay);
208:    				Stream.messageAdd("There seems to be a problem, try reloading");
213:    			Stream.fetchDelay = Stream.baseDelay;
218: 		Stream.container.animate({scrollTop:Stream.container.get(0).scrollHeight}, 'slow');
219: //		var current = Stream.container.scrollTop() + Stream.container.height();
220: //		var full = Stream.container.get(0).scrollHeight;
222: //			Stream.container.animate({scrollTop: Stream.container.scrollTop()+20}, 'slow')
223: //			setTimeout(Stream.fixScroll, 500);
228: 		if(l != Stream.lang) {
229: 			Stream.lang = l;
230: 			Stream.scrolled = false;
231: 			Stream.messageAdd("Machine translation loading&hellip;", "<span class='poweredBy'>Powered by Google Translate</span>");
232: 			Stream.currentFetch.abort();
233: 			if($.inArray(l, Stream.rtl_langs) != -1) {
234: 				Stream.container.css('direction', 'rtl');
237: 				Stream.container.css('direction', 'ltr');
243: 		if(e != Stream.eventId) {
244: 			Stream.eventId = e;
245: 			Stream.container.html('');
246: 			Stream.currentFetch.abort();
262: 		Stream.container.html('');
github.com/google/barista:modules/base/base.go:[master, ]
43: func (b *Base) Stream() <-chan *bar.Output {
37: 	Stream() <-chan *bar.Output
42: // Stream starts up the worker goroutine, and channels its output to the bar.
github.com/vanadium/third_party:csrc/node-v0.10.24/deps/npm/lib/utils/lifecycle.js:[master, ]
11:   , Stream = require("stream").Stream
313:     if (value instanceof Stream || Array.isArray(value)) return
github.com/GoogleChrome/erlnmyr:core/types.js:[master, ]
111: function Stream(tags) {
115: function isStream(type) {
202: module.exports.Stream = Stream;
145:   if (isStream(left) && isStream(right)) {
github.com/GoogleChrome/erlnmyr:core/stream.js:[master, ]
24: function Stream() {
20: function newStreamID() {
29: Stream.prototype = {
49: module.exports.Stream = Stream;
26:   this.id = newStreamID();
github.com/kubernetes/heapster:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: 	return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: 	return newStream(ƒ)
70: 	return newStream(ƒ)
96: 	return newStream(ƒ)
github.com/google/closure-compiler-js:closure-compiler/contrib/nodejs/stream.js:[master, ]
33: stream.Stream = function(options) {};
40: stream.Stream.prototype.pipe;
113: stream.ReadableStream = function() {};
118: stream.ReadableStream.prototype.readable;
173: stream.WritableStream = function() {};
178: stream.WritableStream.prototype.drain;
45:  * @extends stream.Stream
104:  * @param {stream.Stream} stream
134:  * @extends stream.Stream
124: stream.ReadableStream.prototype.setEncoding;
129: stream.ReadableStream.prototype.destroy;
183: stream.WritableStream.prototype.writable;
190: stream.WritableStream.prototype.write;
198: stream.WritableStream.prototype.end;
203: stream.WritableStream.prototype.destroy;
208: stream.WritableStream.prototype.destroySoon;
github.com/google/closure-compiler-npm:compiler/contrib/nodejs/stream.js:[master, ]
33: stream.Stream = function(options) {};
40: stream.Stream.prototype.pipe;
113: stream.ReadableStream = function() {};
118: stream.ReadableStream.prototype.readable;
173: stream.WritableStream = function() {};
178: stream.WritableStream.prototype.drain;
45:  * @extends stream.Stream
104:  * @param {stream.Stream} stream
134:  * @extends stream.Stream
124: stream.ReadableStream.prototype.setEncoding;
129: stream.ReadableStream.prototype.destroy;
183: stream.WritableStream.prototype.writable;
190: stream.WritableStream.prototype.write;
198: stream.WritableStream.prototype.end;
203: stream.WritableStream.prototype.destroy;
208: stream.WritableStream.prototype.destroySoon;
github.com/google/closure-compiler:contrib/nodejs/stream.js:[master, ]
33: stream.Stream = function(options) {};
40: stream.Stream.prototype.pipe;
113: stream.ReadableStream = function() {};
118: stream.ReadableStream.prototype.readable;
173: stream.WritableStream = function() {};
178: stream.WritableStream.prototype.drain;
45:  * @extends stream.Stream
104:  * @param {stream.Stream} stream
134:  * @extends stream.Stream
124: stream.ReadableStream.prototype.setEncoding;
129: stream.ReadableStream.prototype.destroy;
183: stream.WritableStream.prototype.writable;
190: stream.WritableStream.prototype.write;
198: stream.WritableStream.prototype.end;
203: stream.WritableStream.prototype.destroy;
208: stream.WritableStream.prototype.destroySoon;
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));
github.com/kubernetes/kube-aggregator:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: 	return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: 	return newStream(ƒ)
70: 	return newStream(ƒ)
96: 	return newStream(ƒ)
github.com/google/qpp:http/node_modules/express/node_modules/connect/node_modules/formidable/lib/incoming_form.js:[master, ]
11:     Stream = require('stream').Stream;
275:     part = new Stream();
github.com/kubernetes/dns:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: 	return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: 	return newStream(ƒ)
70: 	return newStream(ƒ)
96: 	return newStream(ƒ)
github.com/vanadium/java:android-lib/src/main/java/io/v/android/impl/google/rpc/protocols/bt/BluetoothWithSdp.java:[master, ]
270:     public static class Stream {
275:         private Stream(BluetoothSocket socket, String localAddress, String remoteAddress) {
155:     static Stream dial(VContext ctx, String address, Duration timeout) throws Exception {
199:         return new Stream(socket, localAddress, remoteAddress);
229:         public Stream accept() throws IOException {
239:                 return new Stream(socket, mLocalAddress, remoteAddress);
269:     // Stream provides I/O primitives to read and write over a Bluetooth socket.
17: import java.io.InputStream;
19: import java.io.OutputStream;
283:                 InputStream in = mSocket.getInputStream();
303:                 OutputStream out = mSocket.getOutputStream();
github.com/vanadium/java:android-lib/src/main/java/io/v/android/impl/google/rpc/protocols/bt/BluetoothWithPort.java:[master, ]
222:     static class Stream {
227:         Stream(BluetoothSocket socket, String localAddress, String remoteAddress) {
51:     static Stream dial(VContext ctx, String btAddr, Duration timeout) throws Exception {
93:         return new Stream(socket, localAddr, remoteAddr);
199:         Stream accept() throws IOException {
206:                 return new Stream(socket, localAddress, remoteAddress);
17: import java.io.InputStream;
19: import java.io.OutputStream;
235:                 InputStream in = socket.getInputStream();
254:                 OutputStream out = socket.getOutputStream();
github.com/google/martian:marbl/marbl.go:[master, ]
76: type Stream struct {
85: func NewStream(w io.Writer) *Stream {
75: // Stream writes logs of requests and responses to a writer.
82: // NewStream initializes a Stream with an io.Writer to log requests and
86: 	s := &Stream{
97: func (s *Stream) loop() {
111: // Close signals Stream to stop listening for frames in the log loop and stop writing logs.
112: func (s *Stream) Close() error {
127: func (s *Stream) sendHeader(id string, mt MessageType, key, value string) {
140: func (s *Stream) sendData(id string, mt MessageType, i uint32, terminal bool, b []byte) {
157: // LogRequest writes an http.Request to Stream with an id unique for the request / response pair.
158: func (s *Stream) LogRequest(id string, req *http.Request) error {
192: // LogResponse writes an http.Response to Stream with an id unique for the request / response pair.
193: func (s *Stream) LogResponse(id string, res *http.Response) error {
225: 	s     *Stream
github.com/kubernetes/kube-state-metrics:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: 	return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: 	return newStream(ƒ)
70: 	return newStream(ƒ)
96: 	return newStream(ƒ)
github.com/kubernetes/sample-apiserver:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: 	return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: 	return newStream(ƒ)
70: 	return newStream(ƒ)
96: 	return newStream(ƒ)
github.com/google/gae-secure-scaffold-python:closure-compiler/contrib/nodejs/stream.js:[master, ]
33: stream.Stream = function(options) {};
40: stream.Stream.prototype.pipe;
113: stream.ReadableStream = function() {};
118: stream.ReadableStream.prototype.readable;
173: stream.WritableStream = function() {};
178: stream.WritableStream.prototype.drain;
45:  * @extends stream.Stream
104:  * @param {stream.Stream} stream
134:  * @extends stream.Stream
124: stream.ReadableStream.prototype.setEncoding;
129: stream.ReadableStream.prototype.destroy;
183: stream.WritableStream.prototype.writable;
190: stream.WritableStream.prototype.write;
198: stream.WritableStream.prototype.end;
203: stream.WritableStream.prototype.destroy;
208: stream.WritableStream.prototype.destroySoon;
github.com/google/csp-evaluator:closure-compiler/contrib/nodejs/stream.js:[master, ]
33: stream.Stream = function(options) {};
40: stream.Stream.prototype.pipe;
113: stream.ReadableStream = function() {};
118: stream.ReadableStream.prototype.readable;
173: stream.WritableStream = function() {};
178: stream.WritableStream.prototype.drain;
45:  * @extends stream.Stream
104:  * @param {stream.Stream} stream
134:  * @extends stream.Stream
124: stream.ReadableStream.prototype.setEncoding;
129: stream.ReadableStream.prototype.destroy;
183: stream.WritableStream.prototype.writable;
190: stream.WritableStream.prototype.write;
198: stream.WritableStream.prototype.end;
203: stream.WritableStream.prototype.destroy;
208: stream.WritableStream.prototype.destroySoon;
android.googlesource.com/platform/external/qt:Mac-4.7.4/src/qt3support/network/q3socketdevice.h:[master, ]
61:     enum Type { Stream, Datagram };
64:     Q3SocketDevice( Type type = Stream );
go.googlesource.com/gofrontend:go/export.h:[master, ]
73:   class Stream
237: class Stream_to_section : public Export::Stream
70:   // The Stream class is an interface used to output the exported
76:     Stream();
77:     virtual ~Stream();
117:   Export(Stream*);
226:   Stream* stream_;
240:   Stream_to_section(Backend*);
go.googlesource.com/gofrontend:go/export.cc:[master, ]
697: Export::Stream::Stream()
703: Export::Stream::~Stream()
737: Stream_to_section::Stream_to_section(Backend* backend)
42: Export::Export(Stream* stream)
695: // Class Export::Stream.
711: Export::Stream::write_and_sum_bytes(const char* bytes, size_t length)
720: Export::Stream::checksum()
730: Export::Stream::write_checksum(const std::string& s)
735: // Class Stream_to_section.
745: Stream_to_section::do_write(const char* bytes, size_t length)
github.com/kubernetes/contrib:404-server/vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
101: type Stream struct {
107: func newStream(ƒ invariant) *Stream {
39: // NewLowBiased returns an initialized Stream for low-biased quantiles
49: func NewLowBiased(epsilon float64) *Stream {
56: // NewHighBiased returns an initialized Stream for high-biased quantiles
66: func NewHighBiased(epsilon float64) *Stream {
73: // NewTargeted returns an initialized Stream concerned with a particular set of
80: func NewTargeted(targets map[float64]float64) *Stream {
99: // Stream computes quantiles for a stream of float64s. It is not thread-safe by
109: 	return &Stream{x, make(Samples, 0, 500), true}
113: func (s *Stream) Insert(v float64) {
117: func (s *Stream) insert(sample Sample) {
128: func (s *Stream) Query(q float64) float64 {
152: func (s *Stream) Merge(samples Samples) {
158: func (s *Stream) Reset() {
164: func (s *Stream) Samples() Samples {
174: func (s *Stream) Count() int {
178: func (s *Stream) flush() {
184: func (s *Stream) maybeSort() {
191: func (s *Stream) flushed() bool {
12: // Effective Computation of Biased Quantiles over Data Streams
53: 	return newStream(ƒ)
70: 	return newStream(ƒ)
96: 	return newStream(ƒ)
github.com/android-pay/s2ap-quickstart-php:google-api-client/src/Google/IO/Stream.php:[master, ]
26: class Google_IO_Stream extends Google_IO_Abstract
19:  * Http Streams based implementation of Google_IO.
android.googlesource.com/platform/external/mpg123:ports/MSVC++/CMP3Stream/SOURCE/SourceFilter_MP3Stream.CPP:[master, ]
50: IIEP::CMP3Stream::CMP3Stream(void)
76: IIEP::CMP3Stream::~CMP3Stream(void)
12: // name: CMP3Stream()
20:     IIEP::CMP3Stream *pcoStream = (IIEP::CMP3Stream *) fd;
29: // name: CMP3Stream()
37:     IIEP::CMP3Stream *pcoStream = (IIEP::CMP3Stream *) fd;
46: // name: CMP3Stream()
72: // name: ~CMP3Stream()
86: void IIEP::CMP3Stream::SetSeekFlag(void)
96: bool IIEP::CMP3Stream::Open(const WORD *pcwsFileName, CMediaType &coMT, DWORD dwKBPerSec)
197:   coMT.majortype = MEDIATYPE_Stream;
218: void IIEP::CMP3Stream::Close(void)
249: HRESULT IIEP::CMP3Stream::SetPointer(LONGLONG llPos)
284: HRESULT IIEP::CMP3Stream::Read(PBYTE   pucBuffer,
382: LONGLONG IIEP::CMP3Stream::Size(LONGLONG *pSizeAvailable)
401: DWORD IIEP::CMP3Stream::Alignment(void)
411: void IIEP::CMP3Stream::Lock(void)
421: void IIEP::CMP3Stream::Unlock(void)
431: bool IIEP::CMP3Stream::DecodeFrame(void)
457: bool IIEP::CMP3Stream::OpenFile(const WORD *pcwsFileName)
549: DWORD IIEP::CMP3Stream::ReadFile(PVOID pBuf, DWORD dwLen)
559: long IIEP::CMP3Stream::SeekFile(long nOffset, int iOrigin)
22:     return pcoStream -> ReadFile(pBuf, nSize);
39:     return pcoStream -> SeekFile(nOffset, iOrigin);
android.googlesource.com/platform/external/mpg123:ports/MSVC++/CMP3Stream/INCLUDE/CORE/SourceFilter_MP3.H:[master, ]
38:   class CMP3Stream : public CAsyncStream
42:     CMP3Stream(void);
43:     ~CMP3Stream(void);
126:     CMP3Reader(CMP3Stream *pcoStream,
131:                    pcoStream,
github.com/llvm-mirror/llvm:docs/PDB/DbiStream.rst:[master, ]
2: The PDB DBI (Debug Info) Stream
25: Stream Header
393: Optional Debug Header Stream
13: The PDB DBI Stream (Index 3) is one of the largest and most important streams
27: At offset 0 of the DBI Stream is a header with the following layout:
69: Similar to the :doc:`PDB Stream <PdbStream>`, this value always appears to be
73:   field from the :ref:`PDB Stream header <pdb_stream_header>`.
75: - **GlobalStreamIndex** - The index of the :doc:`Global Symbol Stream <GlobalStream>`,
94: - **PublicStreamIndex** - The index of the :doc:`Public Symbol Stream <PublicStream>`,
129: Immediately after the fixed-size DBI Stream header are ``7`` variable-length
130: `substreams`.  The following ``7`` fields of the DBI Stream header specify the
133: DBI Stream should equal ``64`` (the length of the header above) plus the value
40:     uint16_t SymRecordStream;
101: - **SymRecordStream** - The stream containing all CodeView symbol records used
190:     uint16_t ModuleSymStream;
216: - **ModuleSymStream** - The index of the stream that contains symbol information
221:   ``ModuleSymStream`` that represent CodeView symbol records.
224:   ``ModuleSymStream`` that represent C11-style CodeView line information.
227:   ``ModuleSymStream`` that represent C13-style CodeView line information.  At
32:   struct DbiStreamHeader {
36:     uint16_t GlobalStreamIndex;
38:     uint16_t PublicStreamIndex;
61:   enum class DbiStreamVersion : uint32_t {
406: **FPO Data** - ``DbgStreamArray[0]``.  The data in the referenced stream is a
409: **Exception Data** - ``DbgStreamArray[1]``.  The data in the referenced stream
412: **Fixup Data** - ``DbgStreamArray[2]``.  The data in the referenced stream is a
415: **Omap To Src Data** - ``DbgStreamArray[3]``.  The data in the referenced stream
419: **Omap From Src Data** - ``DbgStreamArray[4]``.  The data in the referenced stream
423: **Section Header Data** - ``DbgStreamArray[5]``.  A dump of all section headers from
426: **Token / RID Map** - ``DbgStreamArray[6]``.  The layout of this stream is not
431: **Xdata** - ``DbgStreamArray[7]``.  A copy of the ``.xdata`` section from the
434: **Pdata** - ``DbgStreamArray[8]``. This is assumed to be a copy of the ``.pdata``
436: ``DbgStreamArray[1]``.  The difference between these two indices is not well
439: **New FPO Data** - ``DbgStreamArray[9]``.  The data in the referenced stream is a
441: differs from ``DbgStreamArray[0]``, but in practice all observed PDB files have
444: **Original Section Header Data** - ``DbgStreamArray[10]``.  Assumed to be similar
445: to ``DbgStreamArray[5]``, but has not been observed in practice.
github.com/fuchsia-mirror/third_party-llvm:docs/PDB/DbiStream.rst:[master, ]
2: The PDB DBI (Debug Info) Stream
25: Stream Header
393: Optional Debug Header Stream
13: The PDB DBI Stream (Index 3) is one of the largest and most important streams
27: At offset 0 of the DBI Stream is a header with the following layout:
69: Similar to the :doc:`PDB Stream <PdbStream>`, this value always appears to be
73:   field from the :ref:`PDB Stream header <pdb_stream_header>`.
75: - **GlobalStreamIndex** - The index of the :doc:`Global Symbol Stream <GlobalStream>`,
94: - **PublicStreamIndex** - The index of the :doc:`Public Symbol Stream <PublicStream>`,
129: Immediately after the fixed-size DBI Stream header are ``7`` variable-length
130: `substreams`.  The following ``7`` fields of the DBI Stream header specify the
133: DBI Stream should equal ``64`` (the length of the header above) plus the value
40:     uint16_t SymRecordStream;
101: - **SymRecordStream** - The stream containing all CodeView symbol records used
190:     uint16_t ModuleSymStream;
216: - **ModuleSymStream** - The index of the stream that contains symbol information
221:   ``ModuleSymStream`` that represent CodeView symbol records.
224:   ``ModuleSymStream`` that represent C11-style CodeView line information.
227:   ``ModuleSymStream`` that represent C13-style CodeView line information.  At
32:   struct DbiStreamHeader {
36:     uint16_t GlobalStreamIndex;
38:     uint16_t PublicStreamIndex;
61:   enum class DbiStreamVersion : uint32_t {
406: **FPO Data** - ``DbgStreamArray[0]``.  The data in the referenced stream is a
409: **Exception Data** - ``DbgStreamArray[1]``.  The data in the referenced stream
412: **Fixup Data** - ``DbgStreamArray[2]``.  The data in the referenced stream is a
415: **Omap To Src Data** - ``DbgStreamArray[3]``.  The data in the referenced stream
419: **Omap From Src Data** - ``DbgStreamArray[4]``.  The data in the referenced stream
423: **Section Header Data** - ``DbgStreamArray[5]``.  A dump of all section headers from
426: **Token / RID Map** - ``DbgStreamArray[6]``.  The layout of this stream is not
431: **Xdata** - ``DbgStreamArray[7]``.  A copy of the ``.xdata`` section from the
434: **Pdata** - ``DbgStreamArray[8]``. This is assumed to be a copy of the ``.pdata``
436: ``DbgStreamArray[1]``.  The difference between these two indices is not well
439: **New FPO Data** - ``DbgStreamArray[9]``.  The data in the referenced stream is a
441: differs from ``DbgStreamArray[0]``, but in practice all observed PDB files have
444: **Original Section Header Data** - ``DbgStreamArray[10]``.  Assumed to be similar
445: to ``DbgStreamArray[5]``, but has not been observed in practice.