Search some code: Max results:

Found 81742 results in 13544 files (86MB index data, 11672981 ngram matches, 302271 docs considered, 30006 docs (459MB) loaded, 268475 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 1.58054717s (queued: 3.359µ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/mirror/superproject:platform/external/arduino/hardware/arduino/cores/arduino/Stream.h:[master, ]
duplicate result
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/GoogleChrome/net-chromeify:index.js:[master, ]
20: var Stream = require('stream');
180: util.inherits(net.Socket, Stream);
github.com/google/rspirv:rspirv/sr/decoration.rs:[master, ]
50:     Stream(u32),
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/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) {
github.com/llvm-mirror/lnt:lnt/testing/profile/cPerf.cpp:[master, ]
334:   FILE *Stream;
472: void PerfReader::readDataStream() {
115:   FILE *Stream = fdopen(P[0], "r");
125:   return Stream;
274:     auto Stream = ForkAndExec(Cmd);
279:       ssize_t Len = getline(&Line, &LineLen, Stream);
315:     fclose(Stream);
342:     : Objdump(Objdump), Stream(nullptr), Line(NULL), LineLen(0) {}
344:     if (Stream) {
345:       fclose(Stream);
354:     if (Stream) {
355:       fclose(Stream);
367:     Stream = ForkAndExec(Cmd);
381:       ssize_t Len = getline(&Line, &LineLen, Stream);
415:   void readDataStream();
776:     P.readDataStream();
805:   P.readDataStream();
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 {
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 {
chromium.googlesource.com/apps/libapps:nassh/js/nassh_stream.js:[master, ]
16: nassh.Stream = function(fd, path) {
25: nassh.Stream.ERR_STREAM_CLOSED = 'Stream closed';
26: nassh.Stream.ERR_STREAM_OPENED = 'Stream opened';
27: nassh.Stream.ERR_FD_IN_USE = 'File descriptor in use';
28: nassh.Stream.ERR_NOT_IMPLEMENTED = 'Not implemented';
29: nassh.Stream.ERR_STREAM_CANT_READ = 'Stream has no read permission';
30: nassh.Stream.ERR_STREAM_CANT_WRITE = 'Stream has no write permission';
35: nassh.Stream.prototype.asyncOpen_ = function(path, onOpen) {
42: nassh.Stream.prototype.asyncRead = function(size, onRead) {
43:   throw nassh.Stream.ERR_NOT_IMPLEMENTED;
49: nassh.Stream.prototype.asyncWrite = function(data, onSuccess) {
50:   throw nassh.Stream.ERR_NOT_IMPLEMENTED;
56: nassh.Stream.prototype.close = function(reason) {
64: nassh.Stream.prototype.setIo = function(io) {
73: nassh.Stream.Random = function(fd) {
74:   nassh.Stream.apply(this, [fd]);
77: nassh.Stream.Random.prototype = Object.create(nassh.Stream.prototype);
78: nassh.Stream.Random.constructor = nassh.Stream.Random;
80: nassh.Stream.Random.prototype.asyncOpen_ = function(path, onOpen) {
85: nassh.Stream.Random.prototype.asyncRead = function(size, onRead) {
87:     throw nassh.Stream.ERR_STREAM_CLOSED;
github.com/playgameservices/play-games-plugin-for-unity:source/PluginDev/Assets/GooglePlayGames/BasicApi/CommonTypes.cs:[master, ]
124:         Stream = 1  // Not currently supported in the Unity Plugin.
github.com/google/skia-buildbot:go/metrics2/events/events.go:[master, ]
69: 	Stream    string
348: func (m *EventMetrics) GetEventStream(name string) *EventStream {
347: // GetEventStream returns an EventStream instance.
351: 	return &EventStream{
chromium.googlesource.com/webm/quickcapturesample:include/webmmuxstream.hpp:[master, ]
17: class Stream
19:   Stream(Stream&);
20:   Stream& operator=(const Stream&);
23:   virtual ~Stream();
47:     virtual void Write(const Stream& stream,
58:   explicit Stream(Context&);
29:   virtual int EndOfStream() = 0;
chromium.googlesource.com/native_client/nacl-toolchain:gcc/gcc/testsuite/gnat.dg/alignment4.adb:[master, ]
6:   type Stream is array (1..3) of Character;
8:   S1, S2 : Stream;
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('');
chromium.googlesource.com/external/github.com/numpy/numpy:numpy/core/_internal.py:[master, ]
443:     class Stream(object):
479:     stream = Stream(spec)
github.com/kubernetes/kubernetes:pkg/controller/podautoscaler/legacy_horizontal_test.go:[master, ]
60: func (w fakeResponseWrapper) Stream() (io.ReadCloser, error) {
github.com/google/trillian:vendor/github.com/coreos/etcd/cmd/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/periph:conn/gpio/gpiostream/gpiostream.go:[master, ]
14: type Stream interface {
33: type BitStream struct {
57: type EdgeStream struct {
13: // Stream is the interface to define a generic stream
39: // Resolution implement Stream.
47: // Duration implement Stream.
68: // Resolution implement Stream.
76: // Duration implement Stream.
93: 	Parts []Stream // Each part must be a BitStream, EdgeStream or Program
97: // Resolution implement Stream.
124: // Duration implement Stream.
139: var _ Stream = &BitStream{}
140: var _ Stream = &EdgeStream{}
141: var _ Stream = &Program{}
29: // BitStream is a stream of bits to be written or read.
40: func (b *BitStream) Resolution() time.Duration {
48: func (b *BitStream) Duration() time.Duration {
52: // EdgeStream is a stream of edges to be written.
54: // This struct is more efficient than BitStream for repetitive pulses, like
69: func (e *EdgeStream) Resolution() time.Duration {
77: func (e *EdgeStream) Duration() time.Duration {
github.com/fuchsia-mirror/third_party-rust:src/libstd/sync/mpsc/mod.rs:[master, ]
429:     Stream(Arc<UnsafeCell<stream::Packet<T>>>),
576:                         let rx = Receiver::new(Flavor::Stream(a.clone()));
595:             Flavor::Stream(ref p) => return unsafe {
605:             let tmp = Sender::new(Flavor::Stream(new_inner));
628:             Flavor::Stream(ref p) => {
662:             Flavor::Stream(ref mut p) => unsafe { (*p.get()).drop_chan(); },
772:                 Flavor::Stream(ref p) => {
873:                 Flavor::Stream(ref p) => {
952:                 Flavor::Stream(ref p) => {
1018:                 Flavor::Stream(ref p) => {
1048:                 Flavor::Stream(ref p) => {
1074:                 Flavor::Stream(ref p) => unsafe {
1137:             Flavor::Stream(ref mut p) => unsafe { (*p.get()).drop_port(); },
140: // * Streams - these channels are optimized for the non-shared use case. They
chromium.googlesource.com/external/github.com/coreos/etcd:cmd/vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
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/kubernetes/ingress:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
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, ]
duplicate result
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, ]
duplicate result
github.com/google/closure-compiler:contrib/nodejs/stream.js:[master, ]
duplicate result
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/autoscaler:cluster-autoscaler/vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
github.com/kubernetes/kube-aggregator:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
github.com/kubernetes/dns:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
github.com/kubernetes/kube-state-metrics:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
github.com/google/martian:marbl/marbl.go:[master, ]
76: type Stream struct {
85: func NewStream(w io.Writer) *Stream {
75: // Stream writes logs of requests and responses to a writer.
82: // NewStream initializes a Stream with an io.Writer to log requests and
86: 	s := &Stream{
97: func (s *Stream) loop() {
111: // Close signals Stream to stop listening for frames in the log loop and stop writing logs.
112: func (s *Stream) Close() error {
127: func (s *Stream) sendHeader(id string, mt MessageType, key, value string) {
140: func (s *Stream) sendData(id string, mt MessageType, i uint32, terminal bool, b []byte) {
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/google/vsaq:third_party/closure-compiler/contrib/nodejs/stream.js:[master, ]
duplicate result
github.com/kubernetes/perf-tests:clusterloader/vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
github.com/google/end-to-end:lib/closure-compiler/contrib/nodejs/stream.js:[master, ]
duplicate result
github.com/kubernetes/sample-apiserver:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ]
duplicate result
github.com/google/gae-secure-scaffold-python:closure-compiler/contrib/nodejs/stream.js:[master, ]
duplicate result
github.com/llvm-mirror/polly:include/polly/ScopDetection.h:[master, ]
621:   raw_ostream &Stream;
619:   ScopAnalysisPrinterPass(raw_ostream &O) : Stream(O) {}