Found 2393 results in 325 files, showing top 50 files (show more).
seqbias:src/yaml-cpp/stream.cpp: [ ]
180: 	Stream::Stream(std::istream& input)
224: 	Stream::~Stream()
311: 	void Stream::StreamInUtf8() const
320: 	void Stream::StreamInUtf16() const
426: 	void Stream::StreamInUtf32() const
149: 		// We are not allowed to queue the Stream::eof() codepoint, so
151: 		if (static_cast<unsigned long>(Stream::eof()) == ch)
229: 	char Stream::peek() const
233: 			return Stream::eof();
239: 	Stream::operator bool() const
241: 		return m_input.good() || (!m_readahead.empty() && m_readahead[0] != Stream::eof());
246: 	char Stream::get()
262: 	std::string Stream::get(int n)
273: 	void Stream::eat(int n)
279: 	void Stream::AdvanceCurrent()
290: 	bool Stream::_ReadAheadTo(size_t i) const
306: 			m_readahead.push_back(Stream::eof());
399: 	unsigned char Stream::GetNextByte() const
296: 			case utf8: StreamInUtf8(); break;
297: 			case utf16le: StreamInUtf16(); break;
298: 			case utf16be: StreamInUtf16(); break;
299: 			case utf32le: StreamInUtf32(); break;
300: 			case utf32be: StreamInUtf32(); break;
chromstaR:src/logging.h: [ ]
101: inline FILE*& Output2FILE::Stream()
97:     static FILE*& Stream();
109:     FILE* pStream = Stream();
137:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
103:     static FILE* pStream = stderr;
104:     return pStream;
110:     if (!pStream)
112:     fprintf(pStream, "%s", msg.c_str());
113:     fflush(pStream);
AneuFinder:src/logging.h: [ ]
108: inline FILE*& Output2FILE::Stream()
104:     static FILE*& Stream();
116:     FILE* pStream = Stream();
144:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
110:     static FILE* pStream = stderr;
111:     return pStream;
117:     if (!pStream)
119:     fprintf(pStream, "%s", msg.c_str());
120:     fflush(pStream);
iBMQ:src/RngStream.c: [ ]
307: RngStream RngStream_CreateStream (const char name[])
337: void RngStream_DeleteStream (RngStream g)
348: void RngStream_ResetStartStream (RngStream g)
357: void RngStream_ResetNextSubstream (RngStream g)
368: void RngStream_ResetStartSubstream (RngStream g)
377: int RngStream_SetPackageSeed (unsigned long seed[6])
389: int RngStream_SetSeed (RngStream g, unsigned long seed[6])
401: void RngStream_AdvanceState (RngStream g, long e, long c)
432: void RngStream_GetState (RngStream g, unsigned long seed[6])
441: void RngStream_WriteState (RngStream g)
459: void RngStream_WriteStateFull (RngStream g)
491: void RngStream_IncreasedPrecis (RngStream g, int incp)
498: void RngStream_SetAntithetic (RngStream g, int a)
505: double RngStream_RandU01 (RngStream g)
515: int RngStream_RandInt (RngStream g, int i, int j)
3:  * File:           RngStream.c for multiple streams of Random Numbers
14: #include "RngStream.h"
213: static double U01 (RngStream g)
246: static double U01d (RngStream g)
310:    RngStream g;
313:    g = (RngStream) malloc (sizeof (struct RngStream_InfoState));
315:       Rprintf ("RngStream_CreateStream: No more memory\n\n");
316:       error("RngStream allocation failed. Exiting.");
464:    Rprintf ("The RngStream");
517:    return i + (int) ((j - i + 1.0) * RngStream_RandU01 (g));
velociraptor:R/plotVelocityStream.R: [ ]
81: plotVelocityStream <- function(sce, embedded, use.dimred = 1,
3: #' Plot velocities embedded into low-dimensional space as a stream plot. Stream
48: #'   Streamlines are computed by simple integration with a forward Euler method,
70: #' plotVelocityStream(out, em)
71: #' plotVelocityStream(out, em, color.streamlines = TRUE)
112:         stop("'plotVelocityStream' requires the package 'ggplot2'.")
iBMQ:src/RngStream.h: [ ]
19: typedef struct RngStream_InfoState * RngStream;
21: struct RngStream_InfoState {
2:    RngStream.h for ANSI C
29: int RngStream_SetPackageSeed (unsigned long seed[6]);
32: RngStream RngStream_CreateStream (const char name[]);
35: void RngStream_DeleteStream (RngStream g);
38: void RngStream_ResetStartStream (RngStream g);
41: void RngStream_ResetStartSubstream (RngStream g);
44: void RngStream_ResetNextSubstream (RngStream g);
47: void RngStream_SetAntithetic (RngStream g, int a);
50: void RngStream_IncreasedPrecis (RngStream g, int incp);
53: int RngStream_SetSeed (RngStream g, unsigned long seed[6]);
56: void RngStream_AdvanceState (RngStream g, long e, long c);
59: void RngStream_GetState (RngStream g, unsigned long seed[6]);
62: void RngStream_WriteState (RngStream g);
65: void RngStream_WriteStateFull (RngStream g);
68: double RngStream_RandU01 (RngStream g);
71: int RngStream_RandInt (RngStream g, int i, int j);
mzR:src/pwiz/data/common/BinaryIndexStream.cpp: [ ]
417: PWIZ_API_DECL BinaryIndexStream::BinaryIndexStream(shared_ptr<iostream> isPtr) : impl_(new Impl(isPtr)) {}
259:     typedef stream_vector_const_iterator<Entry, EntryReader> IndexStreamIterator;
270:             throw runtime_error("[BinaryIndexStream::ctor] Stream is null");
25: #include "BinaryIndexStream.hpp"
215: class BinaryIndexStream::Impl
313:             throw runtime_error("[BinaryIndexStream::create] creating index with huge ids (" + longestIdEntryItr->id + ") probably means ids are not be...(23 bytes skipped)...
418: PWIZ_API_DECL void BinaryIndexStream::create(vector<Entry>& entries) {impl_->create(entries);}
419: PWIZ_API_DECL size_t BinaryIndexStream::size() const {return impl_->size();}
420: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(const string& id) const {return impl_->find(id);}
421: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(size_t index) const {return impl_->find(index);}
379:             IndexStreamIterator itr(isPtr_, entrySize_, entryReader_, indexBegin, indexEnd);
380:             itr = lower_bound(itr, IndexStreamIterator(), *entryPtr, EntryIdLessThan());
383:             if (itr == IndexStreamIterator())
netboost:src/mcupgma/clustering_round/myutils/StreamFromFileNameGenerator.hpp: [ ]
10: RCPtr<istream> InputStream(string const & filename) {
30: RCPtr<ostream> OutputStream(string const & filename) {
2: #define __StreamFromFileNameGenerator_hpp
1: #ifndef __StreamFromFileNameGenerator_hpp
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.cpp: [ ]
34: InFileStream::InFileStream() :
41: InFileStream::InFileStream(const char *filename) :
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
28: #include "InFileStream.h"
38:     //cout << "InFileStream() constructor 1" << endl;
44:     //cout << "InFileStream(f) constructor 2" << endl;
49: //- InFileStream::InFileStream(const InFileStream &copy) :
52: //-     cout << "InFileStream() constructor 3" << endl;
56: void InFileStream::open(const char *filename) 
67: void InFileStream::close() 
74: std::istream& InFileStream::getline(char *s, streamsize n) 
80: std::istream& InFileStream::getline(char *s, streamsize n, char delim) 
93:  * 09-02-07,Nigel Brown(EMBL): moved member into new InFileStream subclassed
95:  * that uses InFileStream in place of std::ifstream. Replaced if/then/else
98: char InFileStream::findDelimiter()
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.h: [ ]
22: class InFileStream : public std::ifstream
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
25:     InFileStream();
26:     InFileStream(const char *filename);
27:     //- InFileStream(const InFileStream &copy);
45:     InFileStream(const InFileStream &copy);
ChemmineR:R/AllClasses.R: [ ]
2413: sdfStream <- function(input, output, append=FALSE, fct, Nlines=10000, startline=1, restartNlines=10000, silen...(15 bytes skipped)...
2406: ## (6.8) Streaming Through SD Files ##
2408: ## Streaming function to compute descriptors for large SD Files without consuming much memory.
2419: 	## For restarting sdfStream at specific line assigned to startline argument. If assigned
2521: # sdfStream(input="test.sdf", output="matrix.xls", fct=desc, Nlines=1000)
2530: ## as character strings to APset or FPset objects (e.g. generated by sdfStream).
2561: ## Extracts specific molecules from SD File based on a line position index computed by the sdfStream function
2592: ## Usage: see sdfStream()
Rmmquant:src/mmquant.h: [ ]
658:   std::ostream &getOutputStream () {
662:   std::ostream &getStatsStream () {
1814:         parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";
1816:           parameters.getOutputStream() << " \"" << arg << "\"";
1818:         parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";
1821:         parameters.getOutputStream() << "Gene";
1824:         parameters.getOutputStream() << "\t" << sample;
1826:       parameters.getOutputStream() << "\n";
1828:           parameters.getOutputStream() << line.first;
1830:               parameters.getOutputStream() << "\t" << i;
1832:           parameters.getOutputStream() << "\n";
1923:     dumpStats(parameters.getStatsStream(), parameters.names, stats);
Director:inst/www/js/d3.v3.js: [ ]
4246:   function d3_geo_pathProjectStream(project) {
3878:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3881:           lower48Stream.point(x, y);
3886:           lower48Stream.sphere();
3891:           lower48Stream.lineStart();
3896:           lower48Stream.lineEnd();
3901:           lower48Stream.polygonStart();
3906:           lower48Stream.polygonEnd();
3862:     var point, pointStream = {
3882:           alaskaStream.point(x, y);
3883:           hawaiiStream.point(x, y);
3887:           alaskaStream.sphere();
3888:           hawaiiStream.sphere();
3892:           alaskaStream.lineStart();
3893:           hawaiiStream.lineStart();
3897:           alaskaStream.lineEnd();
3898:           hawaiiStream.lineEnd();
3902:           alaskaStream.polygonStart();
3903:           hawaiiStream.polygonStart();
3907:           alaskaStream.polygonEnd();
3908:           hawaiiStream.polygonEnd();
3929: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3930: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3931: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
4200:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
4203:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
4204:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
4205:         d3.geo.stream(object, cacheStream);
4207:       return contextStream.result();
4211:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
4216:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4221:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4226:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
4231:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
4232:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
4237:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
4241:       cacheStream = null;
affxparser:src/fusion/file/TsvFile/TsvFile.h: [ ]
472:   std::fstream m_fileStream;
579:   int isFileOpen() { return (m_fileStream.is_open()? TSV_OK : TSV_ERR_FILEIO); }
581:   bool is_open() { return m_fileStream.is_open(); }
582:   bool good() { return m_fileStream.good(); }
Gviz:R/DataTrack-class.R: [ ]
356:     isStream <- FALSE
366:         isStream <- TRUE
400:     if (!isStream) {
LACE:inst/htmlwidgets/lib/d3.v4.js: [ ]
6898:     function geoStream(object, stream) {
7424:     function circleStream(stream, radius, delta, direction, t0, t1) {
8978:     function TransformStream() {}
9343:             point, pointStream = {point: function(x, y) { point = [x, y]; }};
6915:     var areaStream = {
6921:             areaStream.lineStart = areaRingStart;
6922:             areaStream.lineEnd = areaRingEnd;
6935:         areaStream.point = areaPointFirst;
6943:         areaStream.point = areaPoint;
6972:         geoStream(object, areaStream);
7020:     var boundsStream = {
7025:             boundsStream.point = boundsRingPoint;
7026:             boundsStream.lineStart = boundsRingStart;
7027:             boundsStream.lineEnd = boundsRingEnd;
7029:             areaStream.polygonStart();
7032:             areaStream.polygonEnd();
7033:             boundsStream.point = boundsPoint;
7034:             boundsStream.lineStart = boundsLineStart;
7035:             boundsStream.lineEnd = boundsLineEnd;
7099:         boundsStream.point = linePoint;
7104:         boundsStream.point = boundsPoint;
7115:         areaStream.point(lambda, phi);
7120:         areaStream.lineStart();
7125:         areaStream.lineEnd();
7151:         geoStream(feature, boundsStream);
7200:     var centroidStream = {
7206:             centroidStream.lineStart = centroidRingStart;
7207:             centroidStream.lineEnd = centroidRingEnd;
7210:             centroidStream.lineStart = centroidLineStart;
7211:             centroidStream.lineEnd = centroidLineEnd;
7230:         centroidStream.point = centroidLinePointFirst;
7239:         centroidStream.point = centroidLinePoint;
7258:         centroidStream.point = centroidPoint;
7264:         centroidStream.point = centroidRingPointFirst;
7269:         centroidStream.point = centroidPoint;
7275:         centroidStream.point = centroidRingPoint;
7310:         geoStream(object, centroidStream);
7470:             circleStream(stream, r, p, 1);
7906:             circleStream(stream, radius, delta, direction, from, to);
8182:             var activeStream = stream,
8183:                 bufferStream = clipBuffer(),
8192:             var clipStream = {
8201:                 if (visible(x, y)) activeStream.point(x, y);
8220:                 activeStream = bufferStream, segments = [], polygon = [], clean = true;
8239:                 activeStream = stream, segments = polygon = ring = null;
8243:                 clipStream.point = linePoint;
8256:                     if (v__ && v_) bufferStream.rejoin();
8257:                     segments.push(bufferStream.result());
8259:                 clipStream.point = point;
8260:                 if (v_) activeStream.lineEnd();
8270:                         activeStream.lineStart();
8271:                         activeStream.point(x, y);
8274:                     if (v && v_) activeStream.point(x, y);
8280:                                 activeStream.lineStart();
8281:                                 activeStream.point(a[0], a[1]);
8283:                             activeStream.point(b[0], b[1]);
8284:                             if (!v) activeStream.lineEnd();
8287:                             activeStream.lineStart();
8288:                             activeStream.point(x, y);
8296:             return clipStream;
8306:             cacheStream,
8311:                 return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream);
8314: ...(16 bytes skipped)...return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];
8324:     var lengthStream = {
8334:         lengthStream.point = lengthPointFirst;
8335:         lengthStream.lineEnd = lengthLineEnd;
8339:         lengthStream.point = lengthStream.lineEnd = noop$1;
8345:         lengthStream.point = lengthPoint;
8364:         geoStream(object, lengthStream);
8607:     var areaStream$1 = {
8612:             areaStream$1.lineStart = areaRingStart$1;
8613:             areaStream$1.lineEnd = areaRingEnd$1;
8616:             areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;
8628:         areaStream$1.point = areaPointFirst$1;
8632:         areaStream$1.point = areaPoint$1;
8650:     var boundsStream$1 = {
8686:     var centroidStream$1 = {
8691:             centroidStream$1.lineStart = centroidRingStart$1;
8692:             centroidStream$1.lineEnd = centroidRingEnd$1;
8695:             centroidStream$1.point = centroidPoint$1;
8696:             centroidStream$1.lineStart = centroidLineStart$1;
8697:             centroidStream$1.lineEnd = centroidLineEnd$1;
8718:         centroidStream$1.point = centroidPointFirstLine;
8722:         centroidStream$1.point = centroidPointLine;
8735:         centroidStream$1.point = centroidPoint$1;
8739:         centroidStream$1.point = centroidPointFirstRing;
8747:         centroidStream$1.point = centroidPointRing;
8817:     var lengthStream$1 = {
8820:             lengthStream$1.point = lengthPointFirst$1;
8824:             lengthStream$1.point = noop$1;
8840:         lengthStream$1.point = lengthPoint$1;
8912:             projectionStream,
8913:             contextStream;
8917:                 if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
8918:                 geoStream(object, projectionStream(contextStream));
8920:             return contextStream.result();
8924:             geoStream(object, projectionStream(areaStream$1));
8925:             return areaStream$1.result();
8929:             geoStream(object, projectionStream(lengthStream$1));
8930:             return lengthStream$1.result();
8934:             geoStream(object, projectionStream(boundsStream$1));
8935:             return boundsStream$1.result();
8939:             geoStream(object, projectionStream(centroidStream$1));
8940:             return centroidStream$1.result();
8944:             return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;
8949:             contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);
8950:             if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
8956:             pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
8971:             var s = new TransformStream;
8980:     TransformStream.prototype = {
8981:         constructor: TransformStream,
8994:         geoStream(object, projection.stream(boundsStream$1));
8995:         fitBounds(boundsStream$1.result());
9083:             var resampleStream = {
9087:                 polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },
9088:                 polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }
9098:                 resampleStream.point = linePoint;
9109:                 resampleStream.point = point;
9115:                 resampleStream.point = ringPoint;
9116:                 resampleStream.lineEnd = ringEnd;
9121:                 resampleStream.point = linePoint;
9126:                 resampleStream.lineEnd = lineEnd;
9130:             return resampleStream;
9163:             cacheStream;
9180:             return cache && cacheStream...(9 bytes skipped)...am ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
9244:             cache = cacheStream = null;
9339:             cacheStream,
9363:             return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
9385:                 .stream(pointStream);
9390:                 .stream(pointStream);
9395:                 .stream(pointStream);
9417:             cache = cacheStream = null;
9621:             cacheStream,
9625:             cache = cacheStream = null;
9631:                 return cache && cacheStream === stream ? cache : cache = transform$$1(postclip(cacheStream = stream));
16942:     exports.geoStream = geoStream;
rhdf5filters:src/blosc/lib/zstd-1.4.5/zstd.h: [ ]
641: typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */
761: typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
1308:  *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
56:     - unbounded multiple steps (described as Streaming compression)
240:  *   "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
371: ...(8 bytes skipped)...                      * When nbWorkers >= 1, triggers asynchronous mode when used with ZSTD_compressStream*() :
372:                               * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
374: ...(13 bytes skipped)...                 * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
375:                               *  in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
459:  *           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
509:  * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
563: *  Streaming
581: *  Streaming compression - HowTo
583: *  A ZSTD_CStream object is required to track streaming operation.
584: *  Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
585: *  ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
586: *  It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
588: *  For parallel execution, use one separate ZSTD_CStream per thread.
590: *  note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
599: *  Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to
616: *  using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.
618: *  In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.
619: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the
627: *  Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.
630: *  flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.
631: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to
643: /*===== ZSTD_CStream management functions =====*/
644: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
645: ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);
647: /*===== Streaming compression functions =====*/
661: /*! ZSTD_compressStream2() :
662:  *  Behaves about the same as ZSTD_compressStream, with additional control on end directive.
682: ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
689:  * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
690:  * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),
707:  * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().
720: ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
722:  * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
723:  * NOTE: The return value is different. ZSTD_compressStream() returns a hint for
724:  * the next read size (if non-zero and not an error). ZSTD_compressStream2()
727: ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
728: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */
729: ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
730: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */
731: ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
735: *  Streaming decompression - HowTo
737: *  A ZSTD_DStream object is required to track streaming operations.
738: *  Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
739: *  ZSTD_DStream objects can be re-used multiple times.
741: *  Use ZSTD_initDStream() to start a new decompression operation.
745: *  Use ZSTD_decompressStream() repetitively to consume your input.
752: *  In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
763: /*===== ZSTD_DStream management functions =====*/
764: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
765: ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);
767: /*===== Streaming decompression functions =====*/
774: ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
776: ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
898:  * ZSTD_compressStream2(), and ZSTD_decompress(). Dictionaries are sticky, and
991:  *  End of frame is reached when ZSTD_decompressStream() returns 0.
996:  *           reached when ZSTD_decompressStream() returns 0.
1012: ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
1013: ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
1304:  *  Note : CStream size estimation is only correct for single-threaded compression.
1305:  *  ZSTD_DStream memory budget depends on window Size.
1343:  *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
1348: ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
1351: ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */
1378: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
1380: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
1540:  *  - ZSTD_compressStream2() : Do compression using the CCtx.
1591: /*! ZSTD_compressStream2_simpleArgs() :
1592:  *  Same as ZSTD_compressStream2(),
1597: ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs (
1694: /*! ZSTD_decompressStream_simpleArgs() :
1695:  *  Same as ZSTD_decompressStream(),
1700: ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs (
1713: /*=====   Advanced Streaming compression functions  =====*/
1714: /**! ZSTD_initCStream_srcSize() :
1727: ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,
1731: /**! ZSTD_initCStream_usingDict() :
1744: ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,
1748: /**! ZSTD_initCStream_advanced() :
1764: ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
1769: /**! ZSTD_initCStream_usingCDict() :
1777: ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);
1779: /**! ZSTD_initCStream_usingCDict_advanced() :
1789:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters.
1795: ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
1800: /*! ZSTD_resetCStream() :
1807:  *  Note that zcs must be init at least once before using ZSTD_resetCStream().
1815: ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
1851: /*=====   Advanced Streaming decompression functions  =====*/
1861: ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
1872: ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);
1882: ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
701: ZSTDLIB_API size_t ZSTD_CStreamInSize(void);    /**< recommended size for input buffer */
702: ZSTDLIB_API size_t ZSTD_CStreamOutSize(void);   /**< recommended size for output buffer. Guarantee to successfully flush at least o...(32 bytes skipped)...
778: ZSTDLIB_API size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */
779: ZSTDLIB_API size_t ZSTD_DStreamOutSize(void);   /*!< recommended size for output buffer. Guarantee to successfully flush at least o...(42 bytes skipped)...
1276:  *  Note : Unlike ZSTD_estimateCStreamSize*(), this estimate
1298: /*! ZSTD_estimateCStreamSize() :
1299:  *  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
1301:  *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
1302:  *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionL...(5 bytes skipped)...
1303:  *  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-thread...(97 bytes skipped)...
1306:  *  This information can be passed manually, using ZSTD_estimateDStreamSize,
1307:  *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
1311: ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
1312: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
1313: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
1314: ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
1315: ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
seqTools:src/dna_fasta_stream.h: [ ]
52: } fafStream;
207: } faStream;
215: void faStream_destroy(faStream *fa)
275: faStream * faStream_init(const char* filename, unsigned k, unsigned mode)
135: // fasta Stream
54: static inline unsigned faf_isEof(fafStream *faf) { return faf->status & faf_file_eof; }
55: static inline unsigned faf_isOpen(fafStream *faf)
62: static fafStream* faf_stream_init(const char* filename, unsigned mode)
64: 	// Construct fafStream object from opened file
65: 	fafStream *faf = calloc(sizeof(fafStream), 1);
87: static void faf_destroy(fafStream *faf)
99: static size_t inline faf_read(fafStream *faf, char *dest, unsigned size)
187: 	fafStream *fasta;
230: int fas_fill(faStream *fa)
279: 		printf("[faStream_init] k > fas_size!\n");
283: 	faStream *fa = calloc(sizeof(faStream), 1);
292: 		printf("[faStream_init] Cannot open file '%s'!\n", filename);
293: 		faStream_destroy(fa);
308: 		printf("[faStream_init] Initial array filling failed!\n");
309: 		faStream_destroy(fa);
321: static inline int fas_fas_end(faStream *fa)		{ return fa->ffc == 0; }
322: static inline int fas_nuc_end(faStream *fa)		{ return fa->fnc == 0; }
333: static inline int fas_checkNewLine(faStream *fa)
343: static inline int fas_skipNewLine(faStream *fa)
366: static inline int fas_skipLine(faStream *fa)
386: static inline int fas_checkNewSeq(faStream *fa)
399: static inline int fas_skipSeqHeader(faStream *fa)
412: static inline int fas_checkComment(faStream *fa)
422: static inline int fas_skipComment(faStream *fa)
435: static inline int fas_checkN(faStream *fa)
445: static inline int fas_skipN(faStream *fa)
496: char * fas_getSeqName(faStream *fa)
551: int fas_initSeq(faStream *fa)
592: static inline int fas_returnFromTranfer(faStream *fa)
626: int fas_TransferNucArray(faStream *fa)
697: int fa_empty(faStream *fa)    { return (fa->stream_state & fas_stream_empty); }
698: int fa_NucReady(faStream *fa) { return (fa->stream_state & fas_nuc_ready);    }
699: int fa_K_Ready(faStream *fa)  { return (fa->stream_state & fas_loc_kReady);   }
700: int fa_NewSeq(faStream *fa)   { return (fa->stream_state & fas_loc_newSeq);   }
701: int fa_N_Nuc(faStream *fa)    { return (ACGTN[(unsigned)*fa->iter] == nval);  }
704: void fa_unsetNucReady(faStream *fa)
interacCircos:inst/htmlwidgets/lib/d3.js: [ ]
3639:   function d3_geo_pathProjectStream(project) {
3271:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3274:           lower48Stream.point(x, y);
3279:           lower48Stream.sphere();
3284:           lower48Stream.lineStart();
3289:           lower48Stream.lineEnd();
3294:           lower48Stream.polygonStart();
3299:           lower48Stream.polygonEnd();
3255:     var point, pointStream = {
3275:           alaskaStream.point(x, y);
3276:           hawaiiStream.point(x, y);
3280:           alaskaStream.sphere();
3281:           hawaiiStream.sphere();
3285:           alaskaStream.lineStart();
3286:           hawaiiStream.lineStart();
3290:           alaskaStream.lineEnd();
3291:           hawaiiStream.lineEnd();
3295:           alaskaStream.polygonStart();
3296:           hawaiiStream.polygonStart();
3300:           alaskaStream.polygonEnd();
3301:           hawaiiStream.polygonEnd();
3322: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3323: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3324: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3593:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
3596:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
3597:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
3598:         d3.geo.stream(object, cacheStream);
3600:       return contextStream.result();
3604:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
3609:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
3614:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
3619:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
3624:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
3625:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
3630:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
3634:       cacheStream = null;
Gviz:R/AnnotationTrack-class.R: [ ]
327:     isStream <- FALSE
350:         isStream <- TRUE
363:         if (!isStream) {
gdsfmt:src/CoreArray/dAllocator.h: [ ]
140: 		COREARRAY_FORCEINLINE CdBufStream *BufStream()
177: 		CdBufStream *_BufStream;
70: 		void Initialize(CdStream &Stream, bool CanRead, bool CanWrite);
137: 		void CopyTo(CdBufStream &Obj, SIZE64 Pos, SIZE64 Count);
141: 			{ return _BufStream; }
rtracklayer:src/ucsc/bbiFile.h: [ ]
299: struct bbiSumOutStream
309: struct bbiSumOutStream *bbiSumOutStreamOpen(int allocCount, FILE *f, boolean doCompress);
310: /* Open new bbiSumOutStream. */
312: void bbiSumOutStreamClose(struct bbiSumOutStream **pStream);
313: /* Free up bbiSumOutStream */
315: void bbiSumOutStreamWrite(struct bbiSumOutStream *stream, struct bbiSummary *sum);
322: 	struct bbiSumOutStream *stream);
Cardinal:R/utils.R: [ ]
370: getRNGStream <- function() {
379: setRNGStream <- function(seed = NULL) {
385: generateRNGStreams <- function(n = 1) {
387: 	s <- getRNGStream()
396: 			s <- nextRNGStream(seeds[[i - 1]])
BUSseq:src/rngstream.cpp: [ ]
303: RngStream::RngStream (const char *s) : name (s)
327: void RngStream::ResetStartStream ()
325: // Reset Stream to beginning of Stream.
335: // Reset Stream to beginning of SubStream.
345: // Reset Stream to NextSubStream.
3:  * File:           RngStream.cpp for multiple streams of Random Numbers
242: double RngStream::U01 ()
271: double RngStream::U01d ()
292: // declared RngStream, unless SetPackageSeed is called.
294: double RngStream::nextSeed[6] =
309:    state of the stream, the starting state of the current SubStream, and the
313:    will be the seed of the next declared RngStream. */
337: void RngStream::ResetStartSubstream ()
347: void RngStream::ResetNextSubstream ()
357: bool RngStream::SetPackageSeed (const unsigned long seed[6])
368: bool RngStream::SetSeed (const unsigned long seed[6])
384: void RngStream::AdvanceState (long e, long c)
415: void RngStream::GetState (unsigned long seed[6]) const
424: void RngStream::WriteState () const
439: void RngStream::WriteStateFull () const
443:     cout << "The RngStream";
470: void RngStream::IncreasedPrecis (bool incp)
477: void RngStream::SetAntithetic (bool a)
486: double RngStream::RandU01 ()
498: int RngStream::RandInt (int low, int high)
affxparser:src/fusion/calvin_files/data/src/DataSet.cpp: [ ]
161: void DataSet::ReadDataSetUsingStream()
327: void DataSet::ClearStreamData()
71: 	fileStream = 0;
95: 	fileStream = &ifs;
129: 		ReadDataSetUsingStream();
170: 	fileStream->seekg(mapStart);
171: 	fileStream->read(data, mapLen);
444: 	fileStream->seekg(mapStart);
445: 	fileStream->read(data, mapLen);
182: 		ClearStreamData();
438: 	ClearStreamData();
RProtoBufLib:src/GatingSet_pb_lib/GatingSet.pb.cc: [ ]
1395: bool paramRange::MergePartialFromCodedStream(
1747: bool rangeGate::MergePartialFromCodedStream(
2025: bool paramPoly::MergePartialFromCodedStream(
2378: bool polygonGate::MergePartialFromCodedStream(
2685: bool coordinate::MergePartialFromCodedStream(
3030: bool ellipseGate::MergePartialFromCodedStream(
3432: bool BOOL_GATE_OP::MergePartialFromCodedStream(
3772: bool boolGate::MergePartialFromCodedStream(
4041: bool clusterGate::MergePartialFromCodedStream(
4330: bool quadGate::MergePartialFromCodedStream(
4795: bool gate::MergePartialFromCodedStream(
5341: bool POPSTATS::MergePartialFromCodedStream(
5740: bool calibrationTable::MergePartialFromCodedStream(
6391: bool biexpTrans::MergePartialFromCodedStream(
6814: bool fasinhTrans::MergePartialFromCodedStream(
7219: bool scaleTrans::MergePartialFromCodedStream(
7552: bool flinTrans::MergePartialFromCodedStream(
7869: bool logTrans::MergePartialFromCodedStream(
8234: bool logGML2Trans::MergePartialFromCodedStream(
8575: bool logicleTrans::MergePartialFromCodedStream(
9284: bool transformation::MergePartialFromCodedStream(
10062: bool trans_pair::MergePartialFromCodedStream(
10436: bool trans_local::MergePartialFromCodedStream(
10850: bool POPINDICES::MergePartialFromCodedStream(
11335: bool nodeProperties::MergePartialFromCodedStream(
11819: bool treeNodes::MergePartialFromCodedStream(
12116: bool populationTree::MergePartialFromCodedStream(
12488: bool COMP::MergePartialFromCodedStream(
13149: bool PARAM::MergePartialFromCodedStream(
13673: bool GatingHierarchy::MergePartialFromCodedStream(
14109: bool CytoFrame::MergePartialFromCodedStream(
14392: bool TRANS_TBL::MergePartialFromCodedStream(
14804: bool GatingSet::MergePartialFromCodedStream(
1396:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
1468:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
1748:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
1790:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
2026:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
2084:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
2379:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
2432:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
2686:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
2743:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
3031:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
3108:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
3433:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
3506:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
3773:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
3815:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
4042:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
4088:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
4331:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
4391:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
4796:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
4935:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
5342:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
5401:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
5741:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
5893:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
5982:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
5995:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6008:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6021:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6034:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6392:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
6488:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
6815:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
6911:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
7220:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
7290:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
7553:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
7610:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
7870:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
7953:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
8235:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
8292:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
8576:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
8698:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
9285:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
9487:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
10063:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
10133:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
10437:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
10510:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
10583:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
10851:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
10936:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
10999:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
11336:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
11439:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
11820:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
11875:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
12117:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
12159:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
12489:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
12643:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
12811:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
13150:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
13248:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
13674:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
13773:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
14110:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
14154:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
14393:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
14448:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
14805:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
14960:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
gdsfmt:src/LZ4/lz4.c: [ ]
1486: LZ4_stream_t* LZ4_createStream(void)
1507: LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
1519: void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
1530: int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
1525: void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
2462: LZ4_streamDecode_t* LZ4_createStreamDecode(void)
2468: int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
2482: int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
2699: int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); }
2701: int LZ4_resetStreamState(void* state, char* inputBuffer)
201:  *  - lz4   : LZ4_createStream, LZ4_freeStream,
1348:     LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
1375:  * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
1446:     void* const s = LZ4_initStream(state, sizeof (*state));
1482: *  Streaming functions
1490:     DEBUGLOG(4, "LZ4_createStream %p", lz4s);
1492:     LZ4_initStream(lz4s, sizeof(*lz4s));
1509:     DEBUGLOG(5, "LZ4_initStream");
1517: /* resetStream is now deprecated,
1518:  * prefer initStream() which is more general */
1521:     DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
1533:     DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
1555:     LZ4_resetStream(LZ4_dict);
1583: void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)
1585:     const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :
1586:         &(dictionaryStream->internal_donotuse);
1589:              workingStream, dictionaryStream,
1598:         if (workingStream->internal_donotuse.currentOffset == 0) {
1599:             workingStream->internal_donotuse.currentOffset = 64 KB;
1608:     workingStream->internal_donotuse.dictCtx = dictCtx;
2697: /* Obsolete Streaming functions */
2704:     LZ4_resetStream((LZ4_stream_t*)state);
2712:     return LZ4_createStream();
202:  *            LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated)
203:  *  - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC,
2476: /*! LZ4_setStreamDecode() :
2521:     and indicate where it stands using LZ4_setStreamDecode()
RSeqAn:inst/include/seqan/stream/file_stream.h: [ ]
1138: class FileStream :
1143:     typedef typename BasicStream<TValue, TDirection>::Type  TBasicStream;
1147:     FileStream() :
1151:     FileStream(const char * fileName, int openMode = DefaultOpenMode<FileStream>::VALUE) :
1157:     ~FileStream()
1198:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
1215:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
804: struct FileStreamBuffer :
831:     FileStreamBuffer()
836:     ~FileStreamBuffer()
1142:     typedef FileStreamBuffer<TValue, TDirection, TSpec>     TStreamBuffer;
1115: class FileStream;
1119: close(FileStream<TValue, TDirection, TSpec> & stream);
1130: struct DefaultOpenMode<FileStream<TValue, TDirection, TSpec>, TDummy>:
1134: // Class FileStream
1139:     public BasicStream<TValue, TDirection>::Type
1148:         TBasicStream(&buffer)
1152:         TBasicStream(&buffer)
1188: struct Value<FileStream<TValue, TDirection, TSpec> >:
1199:     typedef typename TStream_::TFile TFile_;
1205: struct Position<FileStream<TValue, TDirection, TSpec> >:
1216:     typedef typename TStream_::TFile TFile_;
1222: struct Size<FileStream<TValue, TDirection, TSpec> >:
1230: SEQAN_CONCEPT_IMPL((FileStream<TValue, Input, TSpec>), (InputStreamConcept));
1233: SEQAN_CONCEPT_IMPL((FileStream<TValue, Output, TSpec>), (OutputStreamConcept));
1236: SEQAN_CONCEPT_IMPL((FileStream<TValue, Bidirectional, TSpec>), (BidirectionalStreamConcept));
1257: open(FileStream<TValue, TDirection, TSpec> & stream, const char * fileName, int openMode = DefaultOpenMode<FileStream<TValue, TDirection, TSpec> >::VALUE)
1301: close(FileStream<TValue, TDirection, TSpec> & stream)
800: // Class FileStreamBuffer
1099: clear(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
1145:     TStreamBuffer buffer;
1182: struct Value<FileStreamBuffer<TValue, TDirection, TSpec> >
1189:     Value<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1196: struct Position<FileStreamBuffer<TValue, TDirection, TSpec> >
1206:     Position<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1213: struct Size<FileStreamBuffer<TValue, TDirection, TSpec> >
1223:     Size<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1293: close(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
CytoML:inst/include/CytoML/wsNode.hpp: [ ]
43:     class CytoStream : public std::ostream {
46:         CytoStream() : std::ostream(&cytobuf){}
54: extern CytoML::CytoStream  cytocout;
RSeqAn:inst/include/seqan/basic/basic_stream.h: [ ]
446: struct BasicStream :
47: struct StreamIterator;
56: inline void writeValue(Iter<TContainer, StreamIterator<Output> > &iter, TValue val);
94: // Concept StreamConcept
98:  * @concept StreamConcept
103:  * @signature concept StreamConcept;
107:  * @mfn StreamConcept#Value
110:  * @signature Value<TStream>::Type;
112:  * @tparam TStream The stream type to query for its value type.
117:  * @mfn StreamConcept#Size
120:  * @signature Size<TStream>::Type;
122:  * @tparam TStream The stream type to query for its size type.
127:  * @mfn StreamConcept#Position
130:  * @signature Position<TStream>::Type;
132:  * @tparam TStream The stream type to query for its position type.
137:  * @fn StreamConcept#position
143:  * @return TPosition Current position in stream, see @link StreamConcept#Position Position @endlink.
147:  * @fn StreamConcept#setPosition
157:  * @fn StreamConcept#atEnd
166: SEQAN_CONCEPT(StreamConcept, (TStream))
174:  * @concept InputStreamConcept Input StreamConcept
175:  * @extends StreamConcept
178:  * @signature concept InputStreamConcept : StreamConcept;
183: SEQAN_CONCEPT_REFINE(InputStreamConcept, (TStream), (StreamConcept))
185:     typedef typename Value<TStream>::Type       TValue;
186:     typedef typename Size<TStream>::Type        TSize;
187:     typedef typename Position<TStream>::Type    TPosition;
200:  * @concept OutputStreamConcept Output StreamConcept
201:  * @extends StreamConcept
204:  * @signature concept OutputStreamConcept : StreamConcept;
209: SEQAN_CONCEPT_REFINE(OutputStreamConcept, (TStream), (StreamConcept))
211:     typedef typename Value<TStream>::Type       TValue;
212:     typedef typename Size<TStream>::Type        TSize;
213:     typedef typename Position<TStream>::Type    TPosition;
226:  * @concept BidirectionalStreamConcept Bidirectional StreamConcept
227:  * @extends StreamConcept
230:  * @signature concept BidirectionalStreamConcept : StreamConcept;
235: SEQAN_CONCEPT_REFINE(BidirectionalStreamConcept, (TStream), (InputStreamConcept)(OutputStreamConcept))
402:  * @mfn StreamConcept#DirectionIterator
405:  * @signature DirectionIterator<TStream>::Type;
407:  * @tparam TStream The stream to query for its direction iterator.
423:     If<Is<StreamConcept<TObject> >,
424:        Iter<TObject, StreamIterator<TDirection> >,
429: // Metafunction BasicStream
433:  * @mfn BasicStream
437:  * @signature BasicStream<TValue, TDirection[, TTraits]>::Type;
991: // NOTE(esiragusa): should it be defined for Streams and Containers?
1302: template <typename TStream, typename TIterator>
1303: inline TStream &
1304: operator<<(TStream & target,
1307:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
1312: template <typename TStream, typename TValue>
1313: inline TStream &
1314: operator<<(TStream & target,
1317:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
170: // Concept InputStreamConcept
191:     SEQAN_CONCEPT_USAGE(InputStreamConcept)
196: // Concept OutputStreamConcept
217:     SEQAN_CONCEPT_USAGE(OutputStreamConcept)
222: // Concept BidirectionalStreamConcept
916: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
924: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
994: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
1026: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
1041: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
seqTools:src/dna_astream.h: [ ]
87: } daStream;
55: 	dfStream *dnaf;
95: static inline int dasEmpty(daStream *das) 		{ return das->r_iter == das->r_end; }
96: static inline int dasProcEmpty(daStream *das)	{ return das->p_iter == das->p_end; }
97: static inline int dasIsError(daStream *das)		{ return das->state & das_err; }
98: static inline int dasIsOpen(daStream *das)		{ return dfs_isOpen(das->dnaf); }
99: static inline int dasIsEof(daStream *das)		{ return dfs_stream_eof(das->dnaf); }
107: void das_destroy(daStream *das)
122: int das_fill(daStream *das)
176: daStream * das_init(const char* filename, unsigned das_size)
178: 	daStream *das = calloc(sizeof(daStream), 1);
Rfastp:src/FASTP/seprocessor.h: [ ]
68:     ofstream* mOutStream;
diffUTR:README.md: [ ]
3: ## Streamlining differential exon and 3' UTR usage analysis
BUSseq:src/rngstream.h: [ ]
8: class RngStream
12: RngStream (const char *name = "");
18: void ResetStartStream ();
CoGAPS:src/utils/Archive.h: [ ]
86:     std::fstream mStream;
24:     mStream(path.c_str(), std::ios::binary | flags)
43:         mStream.close();
49:         ar.mStream.write(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
56:         ar.mStream.read(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
beachmat:inst/include/byteme/ZlibBufferReader.hpp: [ ]
27:     struct ZStream {
28:         ZStream(int mode) {
56:         ~ZStream() {
62:         ZStream(const ZStream&) = delete;
63:         ZStream(ZStream&&) = delete;
64:         ZStream& operator=(const ZStream&) = delete;
65:         ZStream& operator=(ZStream&&) = delete;
126:     ZStream zstr;
mzR:src/pwiz/utility/misc/SHA1CalculatorTest.cpp: [ ]
71: void testStream()
164:         testStream();
chromDraw:src/libBoard/include/board/Tools.h: [ ]
57:   class MessageStream {
74:   MessageStream::MessageStream( std::ostream & out, const char * prefix )
60:     inline MessageStream( std::ostream & out, const char * prefix  );
63:     inline MessageStream operator<<( const T & v );
70:   extern MessageStream error;
71:   extern MessageStream warning;
72:   extern MessageStream notice;
81:   MessageStream MessageStream::operator<<( const T & v )
87:     return MessageStream( _out, 0 );
Streamer:R/stream-methods.R: [ ]
1: .Stream_set <- function(x, ..., verbose)
25:     .Stream$new(inputPipe=inputPipe, verbose=verbose)
28: setMethod(Stream, "Producer",
32:         .Stream_set(x, verbose=verbose)
34:         do.call(Stream, c(rev(list(..., verbose=verbose)), list(x)))
37: setMethod(Stream, "Consumer", .Stream_set)
3:     ## helper used to construct Streams
Streamer:R/Streamer-class.R: [ ]
1: .Streamer <- setRefClass("Streamer",
6: .Streamer$methods(
9:         "initialize 'Streamer'"
20:         "reset Streamer() -- noop"
21:         if (verbose) msg("Streamer$reset()")
27:         if (verbose) msg("Streamer$yield()")
33:         if (verbose) msg("Streamer$status()")
41: setMethod(reset, "Streamer", function(x, ...) x$reset())
43: setMethod(yield, "Streamer", function(x, ...) x$yield())
45: setMethod(status,"Streamer", function(x, ...) x$status())
msa:src/ClustalW/src/Makefile.in: [ ]
635: InFileStream.o: ./fileInput/InFileStream.cpp
642: InFileStream.obj: ./fileInput/InFileStream.cpp
61: 	InFileStream.$(OBJEXT) ClustalFileParser.$(OBJEXT) \
266:  ./fileInput/InFileStream.cpp \
269:  ./fileInput/InFileStream.h \
488: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/InFileStream.Po@am__quote@
636: ...(33 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.o -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
637: @am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
638: @AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='./fileInput/InFileStream.cpp' object='InFileStream.o' libtool=no @AMDEPBACKSLASH@
640: ...(36 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
643: ...(33 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.obj -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
644: @am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
645: @AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='./fileInput/InFileStream.cpp' object='InFileStream.obj' libtool=no @AMDEPBACKSLASH@
647: ...(36 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
msa:src/ClustalW/windows/src/Makefile: [ ]
635: InFileStream.o: ./fileInput/InFileStream.cpp
642: InFileStream.obj: ./fileInput/InFileStream.cpp
61: 	InFileStream.$(OBJEXT) ClustalFileParser.$(OBJEXT) \
266:  ./fileInput/InFileStream.cpp \
269:  ./fileInput/InFileStream.h \
488: # ./$(DEPDIR)/InFileStream.Po
636: ...(13 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.o -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
637: #	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
638: 	source='./fileInput/InFileStream.cpp' object='InFileStream.o' libtool=no \
640: ...(14 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
643: ...(13 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.obj -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
644: #	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
645: 	source='./fileInput/InFileStream.cpp' object='InFileStream.obj' libtool=no \
647: ...(14 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
Rfastp:src/FASTP/peprocessor.h: [ ]
74:     ofstream* mOutStream1;
75:     ofstream* mOutStream2;
rhdf5filters:src/blosc/lib/zstd-1.4.5/compress/zstd_compress_internal.h: [ ]
50: typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
1066: /*! ZSTD_initCStream_internal() :
1071: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
273:     ZSTD_cStreamStage streamStage;
DEsubs:R/subpathwayAnalysis.R: [ ]
72:     subStreamCases <- apply(cases, 1, function(x) {paste0(x, collapse='.')})
7:     supportedMethods <- c(  subTypes[['subStreamCases']], 
89:                 'subStreamCases'=subStreamCases,
167:     if ( method %in% subTypes[['subStreamCases']] )
HTSeqGenie:inst/unitTests/runit.io.R: [ ]
16: test.FastQStreamer.getReads.pefq <- function() {
35: test.FastQStreamer.getReads.truncated <- function() {
54: test.FastQStreamer.getReads.pefq.subsample <- function() {
75: test.FastQStreamer.subsampler.isdeterministic <- function() {
88: test.FastQStreamer.getReads.segz <- function() {
21:                      testname="test.FastQStreamer.getReads.pefq")
23:   ## init FastQStreamer
24:   FastQStreamer.init(input_file=getConfig("input_file"), input_file2=getConfig("input_file2"),
28:   lreads <- FastQStreamer.getReads()
29:   checkEquals(length(lreads[[2]]), 10, "FastQStreamer.getReads() doesn't return 10 reads")
31:   ## release FastQStreamer
32:   FastQStreamer.release()
40:                      testname="test.FastQStreamer.getReads.truncated")
42:   ## init FastQStreamer
43:   FastQStreamer.init(input_file=getPackageFile("test-data/truncated.fastq.gz"),
47:   lreads <- try(FastQStreamer.getReads(), silent=TRUE)
50:   ## release FastQStreamer
51:   FastQStreamer.release()
59:                      testname="test.FastQStreamer.getReads.pefq.subsample")
61:   ## init FastQStreamer
62:   FastQStreamer.init(input_file=getConfig("input_file"), input_file2=getConfig("input_file2"),
67:   lreads <- FastQStreamer.getReads()
68:   checkEquals(length(lreads[[2]]), 17, "FastQStreamer.getReads() doesn't return 17 reads")
70:   ## release FastQStreamer
71:   FastQStreamer.release()
77:   lreads1 <- test.FastQStreamer.getReads.pefq.subsample()
78:   lreads2 <- test.FastQStreamer.getReads.pefq.subsample()
85:   checkEquals(reads1, reads2, "FastQStreamer is not deterministic")
93:                      testname="test.FastQStreamer.getReads.segz")
95:   ## init FastQStreamer
96:   FastQStreamer.init(input_file=getConfig("input_file"), input_file2=getConfig("input_file2"),
100:   lreads <- FastQStreamer.getReads()
101:   checkEquals(length(lreads[[1]]), 10, "FastQStreamer.getReads() doesn't return 10 reads")
103:   ## release FastQStreamer
104:   FastQStreamer.release()
seqbias:src/yaml-cpp/emitter.cpp: [ ]
660: 	void Emitter::PreWriteStreamable(std::stringstream& str)
673: 	void Emitter::PostWriteStreamable(const std::stringstream& str)
lpsymphony:src/SYMPHONY/Osi/src/OsiMsk/OsiMskSolverInterface.cpp: [ ]
99: void MSKAPI OsiMskStreamFuncLog(MSKuserhandle_t handle, MSKCONST char* str) {
110: void MSKAPI OsiMskStreamFuncWarning(MSKuserhandle_t handle, MSKCONST char* str) {
121: void MSKAPI OsiMskStreamFuncError(MSKuserhandle_t handle, MSKCONST char* str) {
4575:   MSK_linkfunctotaskstream(getMutableLpPtr(), MSK_STREAM_LOG, messageHandler(), OsiMskStreamFuncLog);
4576:   MSK_linkfunctotaskstream(getMutableLpPtr(), MSK_STREAM_ERR, messageHandler(), OsiMskStreamFuncWarning);
4577:   MSK_linkfunctotaskstream(getMutableLpPtr(), MSK_STREAM_WRN, messageHandler(), OsiMskStreamFuncError);
4941:     err = MSK_linkfunctotaskstream(task_, MSK_STREAM_LOG, messageHandler(), OsiMskStreamFuncLog);
4944:     err = MSK_linkfunctotaskstream(task_, MSK_STREAM_WRN, messageHandler(), OsiMskStreamFuncWarning);
4947:     err = MSK_linkfunctotaskstream(task_, MSK_STREAM_ERR, messageHandler(), OsiMskStreamFuncError);
rtracklayer:src/ucsc/bbiWrite.c: [ ]
603: struct bbiSumOutStream *bbiSumOutStreamOpen(int allocCount, FILE *f, boolean doCompress)
615: void bbiSumOutStreamFlush(struct bbiSumOutStream *stream)
636: void bbiSumOutStreamClose(struct bbiSumOutStream **pStream)
648: void bbiSumOutStreamWrite(struct bbiSumOutStream *stream, struct bbiSummary *sum)
604: /* Allocate new bbiSumOutStream. */
606: struct bbiSumOutStream *stream;
637: /* Free up bbiSumOutStream */
639: struct bbiSumOutStream *stream = *pStream;
644:     freez(pStream);
671: 	struct bbiSumOutStream *stream)
642:     bbiSumOutStreamFlush(stream);
664:     bbiSumOutStreamFlush(stream);    
687: bbiSumOutStreamWrite(stream, sum);
ShortRead:inst/unitTests/test_ShortReadQ.R: [ ]
97: test_FastqStreamer <- function()
141: test_FastqStreamer_roundtrip <- function()
149: test_FastqStreamer_IRanges <- function()
101:     f <- FastqStreamer(fl, n=50)
112:     f <- FastqStreamer(fl, n=50)
118:     f <- FastqStreamer(fl, n=500)
130:     f <- FastqStreamer(fl, n=50, readerBlockSize=100)
145:     s <- FastqStreamer(out)
155:     f <- FastqStreamer(fl, rng)
164:     f <- FastqStreamer(fl, rng)
172:     f <- FastqStreamer(fl, rng)
179:     f <- FastqStreamer(fl, rng, readerBlockSize=10000)
185:     f <- FastqStreamer(fl, rng, readerBlockSize=10000)
192:     checkException(FastqStreamer(fl, rng), silent=TRUE)
194:     checkException(FastqStreamer(fl, rng), silent=TRUE)