Found 156632 results in 27249 files, showing top 50 files (show more).
android.googlesource.com/platform/frameworks/ex:framesequence/jni/Stream.cpp: [ master, ] 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/apache/accumulo-testing:core/src/main/java/org/apache/accumulo/testing/core/stress/Stream.java: [ master, ] java
25: public abstract class Stream<T> implements Iterator<T> {
github.com/googlearchive/todomvc-mongodb:node_modules/angular/node_modules/jsdom/node_modules/htmlparser2/lib/Stream.js: [ master, ] 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, ] 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, ] 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();
github.com/GoogleCloudPlatform/todomvc-mongodb:node_modules/angular/node_modules/jsdom/node_modules/htmlparser2/lib/Stream.js: [ master, ] javascript Duplicate result
github.com/apache/pdfbox:debugger/src/main/java/org/apache/pdfbox/debugger/streampane/Stream.java: [ trunk, ] java
40: public class Stream
58:     Stream(COSStream cosStream, boolean isThumb)
136:     public InputStream getStream(String key)
237:     private boolean isImageStream(COSDictionary dic, boolean isThumb)
246:     private boolean isXmlMetadataStream(COSDictionary dic)
213:     private String getPartialStreamCommand(final int indexOfStopFilter)
21: import java.io.InputStream;
30: import org.apache.pdfbox.cos.COSStream;
32: import org.apache.pdfbox.pdmodel.common.PDStream;
38:  * A class that provides the COSStream in different version and related informations.
45:     private final COSStream stream;
55:      * @param cosStream COSStream instance.
60:         this.stream = cosStream;
62:         this.isImage = isImageStream(cosStream, isThumb);
63:         this.isXmlMetadata = isXmlMetadataStream(cosStream);
65:         filters = createFilterList(cosStream);
131:      * Returns a InputStream of a partially filtered stream.
134:      * @return an InputStream.
142:                 return stream.createInputStream();
146:                 return stream.createRawInputStream();
150:                 return new PDStream(stream).createInputStream(filters.get(key));
177:                 imageXObject = new PDImageXObject(new PDStream(stream), resources);
188:     private Map<String, List<String>> createFilterList(COSStream stream)
198:         PDStream pdStream = new PDStream(stream);
200:         if (pdStream.getFilters() != null)
202:             int filtersSize = pdStream.getFilters().size();
215:         List<COSName> avaiablrFilters = new PDStream(stream).getFilters();
229:         List<COSName> avaiablrFilters = new PDStream(stream).getFilters();
206:                 filterList.put(getPartialStreamCommand(i), getStopFilterList(i));
android.googlesource.com/platform/external/cherry:third_party/sax/lib/sax.js: [ master, ] javascript
157:   var Stream = require("stream").Stream
159:   var Stream = function () {}
249:   return Stream.prototype.on.call(me, ev, handler)
167: function createStream (strict, opt) {
174:   Stream.apply(this)
213: SAXStream.prototype = Object.create(Stream.prototype,
6: sax.SAXStream = SAXStream
7: sax.createStream = createStream
168:   return new SAXStream(strict, opt)
171: function SAXStream (strict, opt) {
172:   if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)
214:   { constructor: { value: SAXStream } })
216: SAXStream.prototype.write = function (data) {
232: SAXStream.prototype.end = function (chunk) {
238: SAXStream.prototype.on = function (ev, handler) {
github.com/kubernetes/helm:pkg/releasetesting/environment.go: [ master, ] go
36: 	Stream     services.ReleaseService_RunReleaseTestServer
111: 	return env.Stream.Send(resp)
github.com/googleapis/nodejs-bigtable:system-test/read-rows-acceptance-tests.js: [ master, ] javascript
20: const Stream = require('stream').PassThrough;
86:         var stream = new Stream({
85:       table.requestStream = function() {
114:         .createReadStream({})
github.com/google/rspirv:rspirv/sr/decoration.rs: [ master, ] rust
50:     Stream(u32),
github.com/google/google-auth-library-php:tests/HttpHandler/Guzzle5HttpHandlerTest.php: [ master, ] php
26: use GuzzleHttp\Stream\Stream;
72:             Stream::factory('Body Text')
134:             Stream::factory('Body Text')
189:         $mockBody = $this->getMock('Psr\Http\Message\StreamInterface');
github.com/apache/cordova-android:node_modules/nopt/examples/my-program.js: [ master, ] javascript
7:   , Stream = require("stream").Stream
10:                 , "bar" : [Stream, Number]
github.com/google/highwayhash:highwayhash/scalar.h: [ master, ] 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, ] 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;
github.com/apache/cordova-windows:node_modules/nopt/lib/nopt.js: [ master, ] javascript
9:   , Stream = require("stream").Stream
21:   , Stream  : { type: Stream,  validate: validateStream  }
169: function validateStream (data, k, val) {
170:   if (!(val instanceof Stream)) return false
github.com/apache/cordova-windows:node_modules/nopt/examples/my-program.js: [ master, ] javascript Duplicate result
github.com/google/io-captions-gadget:test_stream/stream.py: [ master, ] 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)
go.googlesource.com/arch:vendor/rsc.io/pdf/read.go: [ master, ] 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/GoogleCloudPlatform/google-cloud-ruby:google-cloud-pubsub/lib/google/cloud/pubsub/subscriber/stream.rb: [ master, ] ruby
29:         class Stream
41:           # @private Create an empty Subscriber::Stream object.
304:             Google::Pubsub::V1::StreamingPullRequest.new.tap do |req|
go.googlesource.com/talks:2014/readability/close-cond-good.go: [ master, ] 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, ] go
4: type Stream struct {
11: func (s *Stream) Wait() error {
19: func (s *Stream) Close() {
26: func (s *Stream) IsClosed() bool {
github.com/playgameservices/play-games-plugin-for-unity:source/PluginDev/Assets/GooglePlayGames/BasicApi/CommonTypes.cs: [ master, ] c#
124:         Stream = 1  // Not currently supported in the Unity Plugin.
github.com/kubernetes/dashboard:vendor/github.com/beorn7/perks/quantile/stream.go: [ master, ] 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/googlearchive/net-chromeify:examples/server/bundle.js: [ master, ] 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;
chromium.googlesource.com/webm/quickcapturesample:include/webmmuxstream.hpp: [ master, ] 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;
android.googlesource.com/platform/external/gemmlowp:meta/base.h: [ master, ] 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/client-go:rest/request.go: [ master, ] go
562: func (r *Request) Stream() (io.ReadCloser, error) {
64: 	Stream() (io.ReadCloser, error)
558: // Stream formats and executes the request, and offers streaming of the response.
779: 			glog.V(2).Infof("Stream error %#v when reading response body, may be caused by closed connection.", err)
780: 			streamErr := fmt.Errorf("Stream error %#v when reading response body, may be caused by closed connection. Please retry.", err)
536: 	decoder := streaming.NewDecoder(framer, r.serializers.StreamingSerializer)
771: 		case http2.StreamError:
537: 	return watch.NewStreamWatcher(restclientwatch.NewDecoder(decoder, r.serializers.Decoder)), nil
github.com/google/gemmlowp:meta/base.h: [ master, ] c++ Duplicate result
skia.googlesource.com/buildbot:go/metrics2/events/events.go: [ master, ] go
68: 	Stream    string
349: func (m *EventMetrics) GetEventStream(name string) *EventStream {
348: // GetEventStream returns an EventStream instance.
352: 	return &EventStream{
github.com/llvm-mirror/lnt:lnt/testing/profile/cPerf.cpp: [ master, ] 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/apache/chemistry-dotcmis:DotCMIS/binding/http.cs: [ trunk, ] c#
213:             public Stream Stream { get; private set; }
287:             public void CloseStream()
36:         public delegate void Output(Stream stream);
166:                     Stream requestStream = conn.GetRequestStream();
178:                         Stream requestStream = conn.GetRequestStream();
235:                         Stream = new BufferedStream(new CryptoStream(httpResponse.GetResponseStream(), new FromBase64Transform(), CryptoStreamMode.Read), 64 * 1024);
239:                         Stream = new BufferedStream(httpResponse.GetResponseStream(), 64 * 1024);
289:                 if (Stream != null)
291:                     Stream.Close();
167:                     writer(requestStream);
168:                     requestStream.Close();
179:                         requestStream.Close();
264:                         using (StreamReader sr = new StreamReader(httpResponse.GetResponseStream()))
github.com/google/skia-buildbot:go/metrics2/events/events.go: [ master, ] go Duplicate result
chromium.googlesource.com/native_client/nacl-toolchain:gcc/gcc/testsuite/gnat.dg/alignment4.adb: [ master, ] ada
6:   type Stream is array (1..3) of Character;
8:   S1, S2 : Stream;
github.com/apache/cordova-blackberry:node_modules/prompt/node_modules/read/node_modules/mute-stream/mute.js: [ master, ] javascript
1: var Stream = require('stream')
89:   return Stream.prototype.pipe.call(this, dest)
7: function MuteStream (opts) {
8:   Stream.apply(this)
22: MuteStream.prototype = Object.create(Stream.prototype)
3: module.exports = MuteStream
5: // var out = new MuteStream(process.stdout)
24: Object.defineProperty(MuteStream.prototype, 'constructor', {
25:   value: MuteStream,
29: MuteStream.prototype.mute = function () {
33: MuteStream.prototype.unmute = function () {
37: Object.defineProperty(MuteStream.prototype, '_onpipe', {
48: Object.defineProperty(MuteStream.prototype, 'isTTY', {
72: Object.defineProperty(MuteStream.prototype, 'rows', {
79: Object.defineProperty(MuteStream.prototype, 'columns', {
87: MuteStream.prototype.pipe = function (dest) {
92: MuteStream.prototype.pause = function () {
96: MuteStream.prototype.resume = function () {
100: MuteStream.prototype.write = function (c) {
119: MuteStream.prototype.end = function (c) {
138: MuteStream.prototype.destroy = proxy('destroy')
139: MuteStream.prototype.destroySoon = proxy('destroySoon')
140: MuteStream.prototype.close = proxy('close')
android.googlesource.com/tools/repo:platform_utils.py: [ master, ] 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))
gerrit.googlesource.com/git-repo:platform_utils.py: [ master, ] python Duplicate result
github.com/apache/aurora:src/main/java/org/apache/aurora/scheduler/log/Log.java: [ master, ] java
51:   interface Stream {
71:     class StreamAccessException extends RuntimeException {
72:       public StreamAccessException(String message, Throwable cause) {
23:  * <p>Logs are accessed by {@link #open() opening} a {@link Stream}.  All stream
68:      * Indicates a {@link Stream} could not be read from, written to or truncated due to some
118:   Stream open() throws IOException;
82:      * @throws StreamAccessException if contents could not be appended to the stream
84:     Position append(byte[] contents) throws StreamAccessException;
91:      * {@code StreamAccessException} on any call to {@link Iterator#hasNext()} or
97:      * @throws StreamAccessException if the stream could not be read from
99:     Iterator<Entry> readAll() throws InvalidPositionException, StreamAccessException;
106:      * @throws StreamAccessException if the stream could not be truncated
108:     void truncateBefore(Position position) throws InvalidPositionException, StreamAccessException;
github.com/apache/cordova-ubuntu:node_modules/elementtree/node_modules/sax/lib/sax.js: [ master, ] javascript
141:   var Stream = require("stream").Stream
143:   var Stream = function () {}
221:   return Stream.prototype.on.call(me, ev, handler)
151: function createStream (strict, opt) {
158:   Stream.apply(me)
195: SAXStream.prototype = Object.create(Stream.prototype,
6: sax.SAXStream = SAXStream
7: sax.createStream = createStream
152:   return new SAXStream(strict, opt)
155: function SAXStream (strict, opt) {
156:   if (!(this instanceof SAXStream)) return new SAXStream(strict, opt)
196:   { constructor: { value: SAXStream } })
198: SAXStream.prototype.write = function (data) {
204: SAXStream.prototype.end = function (chunk) {
210: SAXStream.prototype.on = function (ev, handler) {
github.com/apache/cordova-wp8:node_modules/nopt/lib/nopt.js: [ master, ] javascript
9:   , Stream = require("stream").Stream
21:   , Stream  : { type: Stream,  validate: validateStream  }
169: function validateStream (data, k, val) {
170:   if (!(val instanceof Stream)) return false
github.com/apache/incubator-openwhisk-client-go:whisk/activation.go: [ master, ] go
69: 	Stream string `json:"stream,omitempty"`
github.com/apache/cordova-wp8:node_modules/nopt/examples/my-program.js: [ master, ] javascript Duplicate result
github.com/google/trillian:vendor/github.com/coreos/etcd/cmd/vendor/github.com/beorn7/perks/quantile/stream.go: [ master, ] go Duplicate result
github.com/apache/cordova-ios:node_modules/ios-sim/node_modules/nopt/lib/nopt.js: [ master, ] javascript
9:   , Stream = require("stream").Stream
21:   , Stream  : { type: Stream,  validate: validateStream  }
150: function validateStream (data, k, val) {
151:   if (!(val instanceof Stream)) return false
390:     , nullstream: [null, Stream]
404:     , logfd : [Number, Stream]
411:     , outfd : [Number, Stream]
github.com/apache/cordova-ios:node_modules/ios-sim/node_modules/nopt/examples/my-program.js: [ master, ] javascript Duplicate result
github.com/apache/cordova-blackberry:node_modules/elementtree/node_modules/sax/lib/sax.js: [ master, ] javascript Duplicate result
gerrit.googlesource.com/gerrit:java/com/google/gerrit/extensions/restapi/BinaryResult.java: [ master, ] java
235:   private static class Stream extends BinaryResult {
238:     Stream(InputStream src) {
56:     return new Stream(data);
19: import java.io.ByteArrayOutputStream;
22: import java.io.InputStream;
23: import java.io.OutputStream;
52:    * Produce an {@code application/octet-stream} of unknown length by copying the InputStream until
55:   public static BinaryResult create(InputStream data) {
141:    * @throws IOException if the data cannot be produced, or the OutputStream {@code os} throws any
144:   public abstract void writeTo(OutputStream os) throws IOException;
157:     ByteArrayOutputStream buf;
159:       buf = new ByteArrayOutputStream((int) len);
161:       buf = new ByteArrayOutputStream();
209:     public void writeTo(OutputStream os) throws IOException {
236:     private final InputStream src;
243:     public void writeTo(OutputStream dst) throws IOException {
github.com/kubernetes/kubernetes:pkg/controller/podautoscaler/legacy_horizontal_test.go: [ master, ] go
62: func (w fakeResponseWrapper) Stream() (io.ReadCloser, error) {
github.com/google/certificate-transparency-go:vendor/github.com/coreos/etcd/cmd/vendor/github.com/beorn7/perks/quantile/stream.go: [ master, ] go Duplicate result
github.com/llvm-mirror/parallel-libs:acxxel/acxxel.h: [ master, ] c++
233: class Stream {
384:   Stream(Platform *APlatform, int DeviceIndex, void *AHandle,
148: using StreamCallback = std::function<void(Stream &, const Status &)>;
595:   Stream constructStream(Platform *APlatform, int DeviceIndex, void *AHandle,
591:   void *getStreamHandle(Stream &Stream) { return Stream.TheHandle.get(); }
121: /// A acxxel::Stream instance will be implicitly convertible to a CUstream_st*,
123: /// CUDA kernel launch. This means that a acxxel::Stream can be passed without
132: class Stream;
178: /// kernel is enqueued into a Stream by calling Stream::asyncKernelLaunch.
194:   friend class Stream;
229: /// All operations enqueued on a Stream are serialized, but operations enqueued
232: /// Each Stream is associated with a specific, fixed device.
235:   Stream(const Stream &) = delete;
236:   Stream &operator=(const Stream &) = delete;
237:   Stream(Stream &&) noexcept;
238:   Stream &operator=(Stream &&) noexcept;
239:   ~Stream() = default;
241:   /// Gets the index of the device on which this Stream operates.
244:   /// Blocks the host until the Stream is done executing all previously enqueued
248:   /// Stream, or by any error in the synchronization process itself. Clears the
260:   /// Stream, or by any error in the synchronization process itself. Clears the
269:   Stream &addCallback(std::function<void(Stream &, const Status &)> Callback);
289:   Stream &asyncCopyDToD(DeviceSrcTy &&DeviceSrc, DeviceDstTy &&DeviceDst);
293:   Stream &asyncCopyDToD(DeviceSrcTy &&DeviceSrc, DeviceDstTy &&DeviceDst,
298:   Stream &asyncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst);
302:   Stream &asyncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst,
307:   Stream &asyncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &&DeviceDst);
311:   Stream &asyncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &DeviceDst,
316:   /// \name Stream-synchronous device memory copies
329:   Stream &syncCopyDToD(DeviceSrcTy &&DeviceSrc, DeviceDstTy &&DeviceDst);
332:   Stream &syncCopyDToD(DeviceSrcTy &&DeviceSrc, DeviceDstTy &&DeviceDst,
336:   Stream &syncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst);
339:   Stream &syncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst,
343:   Stream &syncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &&DeviceDst);
346:   Stream &syncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &DeviceDst,
356:   Stream &asyncMemsetD(DeviceDstTy &&DeviceDst, char ByteValue);
359:   Stream &asyncKernelLaunch(const Kernel &TheKernel,
365:   Stream &enqueueEvent(Event &E);
368:   // kernel calls look nicer because you can just pass a acxxel::Stream
374:   /// Gets the current status for the Stream and clears the Stream's status.
418: /// This is useful for setting synchronization points in a Stream. The host can
419: /// synchronize with a Stream without using events, but that requires all the
420: /// work in the Stream to be finished in order for the host to be notified.
422: /// single Event in the Stream is finished, rather than all the work in the
423: /// Stream.
475:   virtual Expected<Stream> createStream(int DeviceIndex = 0) = 0;
586:   friend class Stream;
594:   // Pass along access to Stream constructor to subclasses.
597:     return Stream(APlatform, DeviceIndex, AHandle, Destructor);
612:   virtual Status streamSync(void *Stream) = 0;
613:   virtual Status streamWaitOnEvent(void *Stream, void *Event) = 0;
615:   virtual Status enqueueEvent(void *Event, void *Stream) = 0;
642:                                ptrdiff_t ByteCount, void *Stream) = 0;
645:                                ptrdiff_t ByteCount, void *Stream) = 0;
648:                                ptrdiff_t ByteCount, void *Stream) = 0;
652:                               void *Stream) = 0;
654:   virtual Status addStreamCallback(Stream &Stream, StreamCallback Callback) = 0;
660:   virtual Status rawEnqueueKernelLaunch(void *Stream, void *Kernel,
667: // Implementation of templated Stream functions.
670: Stream &Stream::asyncCopyDToD(DeviceSrcTy &&DeviceSrc,
695: Stream &Stream::asyncCopyDToD(DeviceSrcTy &&DeviceSrc, DeviceDstTy &&DeviceDst,
727: Stream &Stream::asyncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst) {
746: Stream &Stream::asyncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst,
774: Stream &Stream::asyncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &&DeviceDst) {
793: Stream &Stream::asyncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &DeviceDst,
821: Stream &Stream::asyncMemsetD(DeviceDstTy &&DeviceDst, char ByteValue) {
832: Stream &Stream::syncCopyDToD(DeviceSrcTy &&DeviceSrc, DeviceDstTy &&DeviceDst) {
860: Stream &Stream::syncCopyDToD(DeviceSrcTy &&DeviceSrc, DeviceDstTy &&DeviceDst,
896: Stream &Stream::syncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst) {
920: Stream &Stream::syncCopyDToH(DeviceSrcTy &&DeviceSrc, HostDstTy &&HostDst,
952: Stream &Stream::syncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &&DeviceDst) {
976: Stream &Stream::syncCopyHToD(HostSrcTy &&HostSrc, DeviceDstTy &DeviceDst,
230: /// on different Streams may run concurrently.

Took 2.622583775s for 6179KB index data, 347591 ngram matches, 49553 docs considered, 49500 docs (759MB) loaded, 5801981 docs and 0 shards skipped