Search some code: Max results:

Found 95874 results in 15886 files (30MB index data, 3938698 ngram matches, 292174 docs considered, 32171 docs (530MB) loaded, 259971 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 380.176927ms (queued: 3.582µs)

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

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/Stream.js:[master, ] lang:javascript
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, ] lang:c++
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, ] lang:java
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, ] lang:javascript
159:   var Stream = function () {}
249:   return Stream.prototype.on.call(me, ev, handler)
167: function createStream (strict, opt) {
232: SAXStream.prototype.end = function (chunk) {
157:   var Stream = require("stream").Stream
174:   Stream.apply(this)
213: SAXStream.prototype = Object.create(Stream.prototype,
6: sax.SAXStream = SAXStream
7: sax.createStream = createStream
168:   return new SAXStream(strict, opt)
171: function SAXStream (strict, opt) {
172:   if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)
214:   { constructor: { value: SAXStream } })
216: SAXStream.prototype.write = function (data) {
238: SAXStream.prototype.on = function (ev, handler) {
github.com/kubernetes/helm:pkg/releasetesting/environment.go:[master, ] lang:go
36: 	Stream     services.ReleaseService_RunReleaseTestServer
111: 	return env.Stream.Send(resp)
github.com/google/rspirv:rspirv/sr/decoration.rs:[master, ] lang:rust
50:     Stream(u32),
github.com/google/io-captions-gadget:test_stream/stream.py:[master, ] lang:python
18: class Stream(db.Model):
31:     stream = Stream.get_by_key_name(event)
37:         stream = Stream.get_or_insert(event)
54:         stream = Stream.get_or_insert(event)
github.com/openconfig/reference:telemetry/client/fake/fake.go:[master, ] lang:go
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, ] lang:go
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, ] lang:go
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/google/highwayhash:highwayhash/scalar.h:[master, ] lang:c++
315: HH_INLINE void Stream(const Scalar<T>& v, T* const HH_RESTRICT to) {
chromium.googlesource.com/apps/libapps:nassh/js/nassh_stream.js:[master, ] lang:javascript
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';
38: nassh.Stream.binaryToAscii = function(b) {
48: nassh.Stream.asciiToBinary = function(a) {
55: nassh.Stream.prototype.asyncOpen_ = function(path, onOpen) {
66: nassh.Stream.prototype.asyncRead = function(size, onRead) {
68:     throw nassh.Stream.ERR_NOT_IMPLEMENTED;
76: nassh.Stream.prototype.asyncWrite = function(data, onSuccess) {
77:   throw nassh.Stream.ERR_NOT_IMPLEMENTED;
83: nassh.Stream.prototype.close = function(reason) {
91: nassh.Stream.prototype.setIo = function(io) {
100: nassh.Stream.Random = function(fd) {
101:   nassh.Stream.apply(this, [fd]);
104: nassh.Stream.Random.prototype = Object.create(nassh.Stream.prototype);
105: nassh.Stream.Random.constructor = nassh.Stream.Random;
107: nassh.Stream.Random.prototype.asyncOpen_ = function(path, onOpen) {
112: nassh.Stream.Random.prototype.asyncRead = function(size, onRead) {
114:     throw nassh.Stream.ERR_STREAM_CLOSED;
go.googlesource.com/talks:2014/readability/close-cond-good.go:[master, ] lang:go
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, ] lang:go
4: type Stream struct {
11: func (s *Stream) Wait() error {
19: func (s *Stream) Close() {
26: func (s *Stream) IsClosed() bool {
github.com/googlearchive/net-chromeify:examples/server/bundle.js:[master, ] lang:javascript
1228: function Stream() {
1236: Stream.prototype.pipe = function(dest, options) {
401: var Stream = require('stream');
560: util.inherits(net.Socket, Stream);
1231: util.inherits(Stream, events.EventEmitter);
1232: module.exports = Stream;
1234: Stream.Stream = Stream;
github.com/GoogleChrome/net-chromeify:examples/server/bundle.js:[master, ] lang:javascript
duplicate result
github.com/llvm-mirror/lnt:lnt/testing/profile/cPerf.cpp:[master, ] lang:c++
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();
github.com/playgameservices/play-games-plugin-for-unity:source/PluginDev/Assets/GooglePlayGames/BasicApi/CommonTypes.cs:[master, ] lang:c#
124:         Stream = 1  // Not currently supported in the Unity Plugin.
android.googlesource.com/platform/external/gemmlowp:meta/base.h:[master, ] lang:c++
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/kubernetes/dashboard:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ] lang:go
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(ƒ)
chromium.googlesource.com/webm/quickcapturesample:include/webmmuxstream.hpp:[master, ] lang:c++
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;
github.com/GoogleCloudPlatform/google-cloud-ruby:google-cloud-pubsub/lib/google/cloud/pubsub/subscriber/stream.rb:[master, ] lang:ruby
29:         class Stream
41:           # @private Create an empty Subscriber::Stream object.
268:             Google::Pubsub::V1::StreamingPullRequest.new.tap do |req|
github.com/google/skia-buildbot:go/metrics2/events/events.go:[master, ] lang:go
69: 	Stream    string
348: func (m *EventMetrics) GetEventStream(name string) *EventStream {
347: // GetEventStream returns an EventStream instance.
351: 	return &EventStream{
skia.googlesource.com/buildbot:go/metrics2/events/events.go:[master, ] lang:go
duplicate result
github.com/google/gemmlowp:meta/base.h:[master, ] lang:c++
duplicate result
chromium.googlesource.com/native_client/nacl-toolchain:gcc/gcc/testsuite/gnat.dg/alignment4.adb:[master, ] lang:ada
6:   type Stream is array (1..3) of Character;
8:   S1, S2 : Stream;
github.com/kubernetes/client-go:rest/request.go:[master, ] lang:go
543: func (r *Request) Stream() (io.ReadCloser, error) {
64: 	Stream() (io.ReadCloser, error)
539: // Stream formats and executes the request, and offers streaming of the response.
760: 			glog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err)
761: 			streamErr := fmt.Errorf("Stream error %#v when reading response body, may be caused by closed connection. Please retry.", err)
517: 	decoder := streaming.NewDecoder(framer, r.serializers.StreamingSerializer)
752: 		case http2.StreamError:
518: 	return watch.NewStreamWatcher(restclientwatch.NewDecoder(decoder, r.serializers.Decoder)), nil
gerrit.googlesource.com/git-repo:platform_utils.py:[master, ] lang:python
87:   class Stream(object):
145:   class Stream(object):
36: class FileDescriptorStreams(object):
83: class _FileDescriptorStreamsNonBlocking(FileDescriptorStreams):
117: class _FileDescriptorStreamsThreads(FileDescriptorStreams):
110:     return self.Stream(fd, dest, std_name)
129:     return self.Stream(fd, dest, std_name, self.queue)
47:       return _FileDescriptorStreamsThreads()
49:       return _FileDescriptorStreamsNonBlocking()
84:   """ Implementation of FileDescriptorStreams for platforms that support
118:   """ Implementation of FileDescriptorStreams for platforms that don't support
123:     super(_FileDescriptorStreamsThreads, self).__init__()
170:         self.queue.put(_FileDescriptorStreamsThreads.QueueItem(self, line))
172:       self.queue.put(_FileDescriptorStreamsThreads.QueueItem(self, None))
android.googlesource.com/tools/repo:platform_utils.py:[master, ] lang:python
duplicate result
github.com/GoogleCloudPlatform/container-diff:vendor/github.com/docker/docker/api/types/client.go:[master, ] lang:go
33: 	Stream     bool
github.com/google/trillian:vendor/github.com/coreos/etcd/cmd/vendor/github.com/beorn7/perks/quantile/stream.go:[master, ] lang:go
duplicate result
github.com/fuchsia-mirror/third_party-libarchive:libarchive/archive_ppmd7_private.h:[master, ] lang:c++
80:   IByteIn *Stream;
91:   IByteOut *Stream;
github.com/GoogleCloudPlatform/runtimes-common:vendor/github.com/docker/docker/api/types/client.go:[master, ] lang:go
duplicate result
github.com/kubernetes/kubernetes:pkg/controller/podautoscaler/legacy_horizontal_test.go:[master, ] lang:go
59: func (w fakeResponseWrapper) Stream() (io.ReadCloser, error) {
github.com/fuchsia-mirror/third_party-rust-crates:vendor/futures-0.1.15/src/future/flatten_stream.rs:[master, ] lang:rust
45:     Stream(F::Item),
10: pub struct FlattenStream<F>
17: impl<F> fmt::Debug for FlattenStream<F>
52: impl<F> Stream for FlattenStream<F>
3: use stream::Stream;
12:           <F as Future>::Item: Stream<Error=F::Error>,
19:           <F as Future>::Item: Stream<Error=F::Error> + fmt::Debug,
30:           <F as Future>::Item: Stream<Error=F::Error>,
40:           <F as Future>::Item: Stream<Error=F::Error>,
44:     // future resolved to Stream
54:           <F as Future>::Item: Stream<Error=F::Error>,
56:     type Item = <F::Item as Stream>::Item;
57:     type Error = <F::Item as Stream>::Error;
72:                             (State::Stream(stream), None)
79:                 State::Stream(ref mut s) => {
22:         fmt.debug_struct("FlattenStream")
28: pub fn new<F>(f: F) -> FlattenStream<F>
32:     FlattenStream {
github.com/google/certificate-transparency-go:vendor/github.com/coreos/etcd/cmd/vendor/github.com/beorn7/perks/quantile/stream.go:[master, ] lang:go
duplicate result
github.com/googlevr/webvr-polyfill:examples/basic/node_modules/three/examples/js/loaders/ctm/ctm.js:[master, ] lang:javascript
592: CTM.Stream = function(data) {
571: CTM.InterleavedStream = function(data, count) {
597: CTM.Stream.prototype.TWO_POW_MINUS23 = Math.pow(2, -23);
599: CTM.Stream.prototype.TWO_POW_MINUS126 = Math.pow(2, -126);
601: CTM.Stream.prototype.readByte = function() {
605: CTM.Stream.prototype.readInt32 = function() {
612: CTM.Stream.prototype.readFloat32 = function() {
635: CTM.Stream.prototype.readString = function() {
643: CTM.Stream.prototype.readArrayInt32 = function(array) {
653: CTM.Stream.prototype.readArrayFloat32 = function(array) {
225: 	var interleaved = new CTM.InterleavedStream(indices, 3);
235: 	var interleaved = new CTM.InterleavedStream(vertices, 1);
243: 	var interleaved = new CTM.InterleavedStream(normals, 3);
257: 		var interleaved = new CTM.InterleavedStream(uvMaps[i].uv, 2);
271: 		var interleaved = new CTM.InterleavedStream(attrMaps[i].attr, 4);
300: 	var interleaved = new CTM.InterleavedStream(vertices, 3);
314: 	var interleaved = new CTM.InterleavedStream(gridIndices, 1);
326: 	var interleaved = new CTM.InterleavedStream(indices, 3);
336: 	var interleaved = new CTM.InterleavedStream(body.normals, 3);
356: 		var interleaved = new CTM.InterleavedStream(uvMaps[i].uv, 2);
374: 		var interleaved = new CTM.InterleavedStream(attrMaps[i].attr, 4);
578: CTM.InterleavedStream.prototype.writeByte = function(value) {
github.com/google/periph:conn/gpio/gpiostream/gpiostream.go:[master, ] lang:go
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/googlearchive/net-chromeify:examples/client/bundle.js:[master, ] lang:javascript
1245: function Stream() {
1253: Stream.prototype.pipe = function(dest, options) {
417: var Stream = require('stream');
577: util.inherits(net.Socket, Stream);
1248: util.inherits(Stream, events.EventEmitter);
1249: module.exports = Stream;
1251: Stream.Stream = Stream;
github.com/GoogleChrome/net-chromeify:examples/client/bundle.js:[master, ] lang:javascript
duplicate result
chromium.googlesource.com/infra/luci/recipes-py:recipe_engine/stream.py:[master, ] lang:python
50:   class Stream(object):
149:   class Stream(StreamEngine.Stream):
218:   class Stream(StreamEngine.Stream):
277:   class Stream(StreamEngine.Stream):
49: class StreamEngine(object):
69:   class StepStream(Stream):
163:   class StepStream(Stream):
229:   class StepStream(Stream):
281:   class StepStream(Stream):
296: class StreamEngineInvariants(StreamEngine):
311:   class StepStream(StreamEngine.StepStream):
367:   class LogStream(StreamEngine.Stream):
435:   class StepStream(StreamEngine.StepStream):
494:   class StepLogStream(StreamEngine.Stream):
506:   class AllowSubannotationsStepStream(StepStream):
132: class ProductStreamEngine(StreamEngine):
199: class MultiStreamEngine(StreamEngine):
276: class NoopStreamEngine(StreamEngine):
390: class AnnotatorStreamEngine(StreamEngine):
16: Stream is a virtual well-behaved stream (associated with an Engine) which you
40:     stream (StreamEngine.Stream): The stream to output to.
172:       return ProductStreamEngine.Stream(
242:         return MultiStreamEngine.Stream(*log_streams)
283:       return NoopStreamEngine.Stream()
12: StreamEngine will coordinate the multiplexing of streams.  In the case of
103:     """Creates a new StepStream in this engine.
110:     is to implement an annotations parser that converts to StreamEngine calls;
133:   """A StreamEngine that forms the non-commutative product of two other
134:   StreamEngines.
136:   Because StreamEngine has no observations (i.e. it is an F-Algebra), we can
186:     return self.StepStream(
200:   """A StreamEngine consisting of one or more inner StreamEngines.
202:   A call to this StreamEngine will be distributed to the inner StreamEngines.
257:     return self.StepStream(
269:     assert isinstance(se, StreamEngine)
293:     return self.StepStream()
297:   """Checks that the users are using a StreamEngine hygenically.
299:   Multiply with actually functional StreamEngines so you don't have to check
313:       super(StreamEngineInvariants.StepStream, self).__init__()
335:       ret = self._engine.LogStream(self, log_name)
387:     return self.StepStream(self, step_config.name)
437:       super(AnnotatorStreamEngine.StepStream, self).__init__()
462:       return self._engine.StepLogStream(self, log_name)
524:       stream = self.AllowSubannotationsStepStream(self, outstream,
527:       stream = self.StepStream(self, outstream, step_config.name)
307:     """Returns (ProductStreamEngine): A product applying invariants to "other".
309:     return ProductStreamEngine(cls(), other)
399:     super(AnnotatorStreamEngine, self).open()
404:     super(AnnotatorStreamEngine, self).close()
github.com/googlearchive/erlnmyr:core/stream.js:[master, ] lang:javascript
24: function Stream() {
20: function newStreamID() {
29: Stream.prototype = {
49: module.exports.Stream = Stream;
26:   this.id = newStreamID();
github.com/GoogleChrome/erlnmyr:core/stream.js:[master, ] lang:javascript
duplicate result
github.com/kubernetes/apiserver:pkg/endpoints/handlers/negotiation/negotiate.go:[master, ] lang:go
182: 	Stream string
62: func NegotiateOutputStreamSerializer(req *http.Request, ns runtime.NegotiatedSerializer) (runtime.SerializerInfo, error) {
159: func (emptyEndpointRestrictions) AllowsStreamSchema(s string) bool              { return s == "watch" }
233: 			options.Stream = v
35: 		if info.StreamSerializer != nil {
64: 	if !ok || mediaType.Accepted.Serializer.StreamSerializer == nil {
230: 			if len(v) > 0 && (accepts.Serializer.StreamSerializer == nil || !endpoint.AllowsStreamSchema(v)) {
148: 	// AllowsStreamSchema should return true if the specified stream schema is
150: 	AllowsStreamSchema(schema string) bool
github.com/GoogleCloudPlatform/konlet:gce-containers-startup/vendor/github.com/docker/docker/pkg/jsonlog/jsonlogbytes.go:[master, ] lang:go
14: 	Stream  string `json:"stream,omitempty"`
32: 	if len(mj.Stream) != 0 {
39: 		ffjsonWriteJSONString(buf, mj.Stream)
github.com/GoogleCloudPlatform/konlet:gce-containers-startup/vendor/github.com/docker/docker/pkg/jsonlog/jsonlog.go:[master, ] lang:go
15: 	Stream string `json:"stream,omitempty"`
14: 	// Stream is the log source
38: 	jl.Stream = ""
github.com/kubernetes/kompose:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ] lang:go
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/heapster:vendor/github.com/beorn7/perks/quantile/stream.go:[master, ] lang:go
duplicate result
chromium.googlesource.com/native_client/pnacl-gcc:libgo/go/crypto/cipher/cipher.go:[master, ] lang:go
29: type Stream interface {
28: // A Stream represents a stream cipher.
30: 	// XORKeyStream XORs each byte in the given slice with a byte from the
32: 	XORKeyStream(dst, src []byte)