Search some code: Max results:

Found 58124 results in 9917 files (4928496 ngram matches, 123266 docs considered, 19850 docs (285MB) loaded, 100594 docs skipped): for
(and (not (and case_substr:"Path" case_substr:"File")) case_substr:"Stream") with options &zoekt.SearchOptions{EstimateDocCount:false, Whole:false, ShardMaxMatchCount:250, TotalMaxMatchCount:1000000, ShardMaxImportantMatch:2, TotalMaxImportantMatch:100, MaxWallTime:10000000000}
in 3.212052724s (queued: 3.127µ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/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/kubernetes/kubernetes:pkg/client/unversioned/remotecommand/remotecommand.go:[master, ]
155: func (e *streamExecutor) Stream(options StreamOptions) error {
38: type StreamOptions struct {
58: type StreamExecutor interface {
100: func NewStreamExecutor(upgrader httpstream.UpgradeRoundTripper, fn func(http.RoundTripper) http.RoundTripper, method string, url *url.URL) (StreamExecutor, error) {
49: 	// Stream initiates the transport of the standard shell streams. It will transport any
53: 	Stream(options StreamOptions) error
146: 	CreateStream(headers http.Header) (httpstream.Stream, error)
153: // Stream opens a protocol streamer to the server and streams until a client closes
35: // StreamOptions holds information pertaining to the current streaming session: supported stream
56: // StreamExecutor supports the ability to dial an httpstream connection and the ability to
76: func NewExecutor(config *restclient.Config, method string, url *url.URL) (StreamExecutor, error) {
165: 	case remotecommand.StreamProtocolV4Name:
167: 	case remotecommand.StreamProtocolV3Name:
169: 	case remotecommand.StreamProtocolV2Name:
172: 		glog.V(4).Infof("The server did not negotiate a streaming protocol version. Falling back to %s", remotecommand.StreamProtocolV1Name)
174: 	case remotecommand.StreamProtocolV1Name:
96: // NewStreamExecutor upgrades the request so that it supports multiplexed bidirectional
166: 		streamer = newStreamProtocolV4(options)
168: 		streamer = newStreamProtocolV3(options)
170: 		streamer = newStreamProtocolV2(options)
175: 		streamer = newStreamProtocolV1(options)
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/kubernetes/ingress:vendor/github.com/docker/engine-api/types/client.go:[master, ]
15: 	Stream     bool
github.com/kubernetes/ingress: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/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/kubernetes/minikube: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/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,