Found 2475 results in 330 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: //Rcpp::Rcout << "InFileStream() constructor 1" << endl;
|
44: //Rcpp::Rcout << "InFileStream(f) constructor 2" << endl;
|
49: //- InFileStream::InFileStream(const InFileStream ©) :
|
52: //- Rcpp::Rcout << "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 ©);
|
45: InFileStream(const InFileStream ©);
|
| ChemmineR:R/AllClasses.R: [ ] |
|---|
2440: sdfStream <- function(input, output, append=FALSE, fct, Nlines=10000, startline=1, restartNlines=10000, silen...(15 bytes skipped)...
|
2433: ## (6.8) Streaming Through SD Files ##
|
2435: ## Streaming function to compute descriptors for large SD Files without consuming much memory.
|
2446: ## For restarting sdfStream at specific line assigned to startline argument. If assigned
|
2548: # sdfStream(input="test.sdf", output="matrix.xls", fct=desc, Nlines=1000)
|
2557: ## as character strings to APset or FPset objects (e.g. generated by sdfStream).
|
2588: ## Extracts specific molecules from SD File based on a line position index computed by the sdfStream function
|
2619: ## Usage: see sdfStream()
|
| 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;
|
| 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);
|
| Rarr:src/compression_tools/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);
|
| 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;
|
| 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;
|
| rhdf5filters:src/zstd/compress/zstd_compress.c: [ ] |
|---|
213: size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
|
5687: ZSTD_CStream* ZSTD_createCStream(void)
|
5693: ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)
|
5703: size_t ZSTD_freeCStream(ZSTD_CStream* zcs)
|
5729: size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
|
5837: size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
|
6060: size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
|
6846: size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
|
6854: size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
|
5698: ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)
|
5746: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
|
5768: size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
|
5782: size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
|
5795: size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
|
5813: size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
|
5822: size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
|
5863: static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
|
6103: static size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,
|
6201: size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
|
6300: size_t ZSTD_compressStream2_simpleArgs (
|
1755: size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
|
1775: size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
|
1792: static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
|
1798: size_t ZSTD_estimateCStreamSize(int compressionLevel)
|
5712: size_t ZSTD_CStreamInSize(void) { return ZSTD_BLOCKSIZE_MAX; }
|
5714: size_t ZSTD_CStreamOutSize(void)
|
3679: U32 singleStream = litSize < 256;
|
3688: if (!singleStream) cLitSizeEstimate += 6; /* multi-stream huffman uses 6-byte jump table */
|
5684: * Streaming
|
5689: DEBUGLOG(3, "ZSTD_createCStream");
|
5690: return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
|
5699: { /* CStream and CCtx are now same object */
|
5727: /* ZSTD_resetCStream():
|
5736: DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
|
5742: /*! ZSTD_initCStream_internal() :
|
5751: DEBUGLOG(4, "ZSTD_initCStream_internal");
|
5766: /* ZSTD_initCStream_usingCDict_advanced() :
|
5767: * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
|
5773: DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
|
5784: DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
|
5791: /* ZSTD_initCStream_advanced() :
|
5804: DEBUGLOG(4, "ZSTD_initCStream_advanced");
|
5815: DEBUGLOG(4, "ZSTD_initCStream_usingDict");
|
5829: DEBUGLOG(4, "ZSTD_initCStream_srcSize");
|
5839: DEBUGLOG(4, "ZSTD_initCStream");
|
5860: /** ZSTD_compressStream_generic():
|
5861: * internal function for all *compressStream*() variants
|
5877: DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%i, srcSize = %zu", (int)flushMode, input->size - input->pos);
|
5903: RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
|
6062: FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");
|
6119: DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
|
6155: DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
|
6161: DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
|
6162: FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
|
6206: DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
|
6234: FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, endOp, totalInputSize), "compressStream2 initialization failed");
|
6258: flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
|
6267: FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
|
6285: DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
|
6294: FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");
|
6295: DEBUGLOG(5, "completed ZSTD_compressStream2");
|
6314: /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
|
6315: { size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
|
6335: size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
|
6343: FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
|
6802: /* Transparent initialization stage, same as compressStream2() */
|
6805: FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, srcSize), "CCtx initialization failed");
|
6837: static ZSTD_inBuffer inBuffer_forEndFlush(const ZSTD_CStream* zcs)
|
6844: /*! ZSTD_flushStream() :
|
6850: return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
|
6857: size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
|
6858: FORWARD_IF_ERROR(remainingToFlush , "ZSTD_compressStream2(,,ZSTD_e_end) failed");
|
6864: DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
|
1783: noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
|
1785: rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
|
1788: return ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
|
1795: return ZSTD_estimateCStreamSize_usingCParams(cParams);
|
1803: size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
|
| 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)
|
| RProtoBufLib:src/GatingSet_pb_lib/GatingSet.pb.cc: [ ] |
|---|
1460: bool paramRange::MergePartialFromCodedStream(
|
1810: bool Range::MergePartialFromCodedStream(
|
2113: bool rangeGate::MergePartialFromCodedStream(
|
2391: bool MultiRangeGate::MergePartialFromCodedStream(
|
2724: bool paramPoly::MergePartialFromCodedStream(
|
3077: bool polygonGate::MergePartialFromCodedStream(
|
3384: bool coordinate::MergePartialFromCodedStream(
|
3729: bool ellipseGate::MergePartialFromCodedStream(
|
4131: bool BOOL_GATE_OP::MergePartialFromCodedStream(
|
4471: bool boolGate::MergePartialFromCodedStream(
|
4740: bool clusterGate::MergePartialFromCodedStream(
|
5029: bool quadGate::MergePartialFromCodedStream(
|
5519: bool gate::MergePartialFromCodedStream(
|
6100: bool POPSTATS::MergePartialFromCodedStream(
|
6499: bool calibrationTable::MergePartialFromCodedStream(
|
7150: bool biexpTrans::MergePartialFromCodedStream(
|
7573: bool fasinhTrans::MergePartialFromCodedStream(
|
7978: bool scaleTrans::MergePartialFromCodedStream(
|
8311: bool flinTrans::MergePartialFromCodedStream(
|
8628: bool logTrans::MergePartialFromCodedStream(
|
8993: bool logGML2Trans::MergePartialFromCodedStream(
|
9334: bool logicleTrans::MergePartialFromCodedStream(
|
10043: bool transformation::MergePartialFromCodedStream(
|
10821: bool trans_pair::MergePartialFromCodedStream(
|
11195: bool trans_local::MergePartialFromCodedStream(
|
11609: bool POPINDICES::MergePartialFromCodedStream(
|
12094: bool nodeProperties::MergePartialFromCodedStream(
|
12578: bool treeNodes::MergePartialFromCodedStream(
|
12875: bool populationTree::MergePartialFromCodedStream(
|
13247: bool COMP::MergePartialFromCodedStream(
|
13908: bool PARAM::MergePartialFromCodedStream(
|
14432: bool GatingHierarchy::MergePartialFromCodedStream(
|
14868: bool CytoFrame::MergePartialFromCodedStream(
|
15151: bool TRANS_TBL::MergePartialFromCodedStream(
|
15563: bool GatingSet::MergePartialFromCodedStream(
|
1461: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
1533: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
1811: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
1868: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
2114: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
2156: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
2392: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
2449: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
2725: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
2783: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
3078: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
3131: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
3385: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
3442: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
3730: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
3807: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
4132: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
4205: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
4472: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
4514: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
4741: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
4787: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
5030: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
5090: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
5520: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
5670: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
6101: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
6160: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
6500: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
6652: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
6741: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6754: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6767: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6780: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6793: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
7151: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
7247: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
7574: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
7670: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
7979: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
8049: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
8312: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
8369: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
8629: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
8712: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
8994: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
9051: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
9335: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
9457: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
10044: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
10246: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
10822: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
10892: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
11196: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
11269: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
11342: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
11610: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
11695: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
11758: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
12095: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
12198: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
12579: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
12634: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
12876: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
12918: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
13248: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
13402: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
13570: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
13909: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
14007: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
14433: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
14532: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
14869: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
14913: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
15152: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
15207: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
15564: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
15719: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
| 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();
|
| 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)
|
| 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()
|
| 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;
|
| alabaster.base:inst/include/byteme/ZlibBufferReader.hpp: [ ] |
|---|
27: struct ZStream {
|
28: ZStream(int mode) {
|
58: ~ZStream() {
|
64: ZStream(const ZStream&) = delete;
|
65: ZStream(ZStream&&) = delete;
|
66: ZStream& operator=(const ZStream&) = delete;
|
67: ZStream& operator=(ZStream&&) = delete;
|
133: ZStream zstr;
|
| beachmat:inst/include/tatami/utils/Oracles.hpp: [ ] |
|---|
90: struct OracleStream {
|
99: OracleStream(std::unique_ptr<Oracle<Index_> > o) : oracle(std::move(o)) {}
|
78: * @brief Stream predictions from the oracle.
|
84: * The `OracleStream` is primarily intended for `Matrix` developers to use within subclass implementations that can expl...(25 bytes skipped)...
|
85: * Users should not have to construct `OracleStream` instances.
|
94: OracleStream() = default;
|
| alabaster.base:inst/include/byteme/ZlibBufferWriter.hpp: [ ] |
|---|
27: struct ZStream {
|
28: ZStream(int mode, int level) {
|
53: ~ZStream() {
|
59: ZStream(const ZStream&) = delete;
|
60: ZStream(ZStream&&) = delete;
|
61: ZStream& operator=(const ZStream&) = delete;
|
62: ZStream& operator=(ZStream&&) = delete;
|
95: ZStream zstr;
|
| diffUTR:README.md: [ ] |
|---|
3: ## Streamlining differential exon and 3' UTR usage analysis
|
| 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
|
| BUSseq:src/rngstream.h: [ ] |
|---|
8: class RngStream
|
12: RngStream (const char *name = "");
|
18: void ResetStartStream ();
|
| 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;
|
| Rarr:src/compression_tools/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;
|