Found 3816 results in 489 files, showing top 150 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;
gdsfmt:src/CoreArray/dEndian.h: [ ]
59: 		TYPE *Stream;
98: 		TYPE *Stream;
147: 		TYPE *Stream;
601: 		TYPE *Stream;
62: 		BIT_LE_R() { Stream = NULL; }
63: 		BIT_LE_R(TYPE *s) { Stream = s; Reminder = Offset = 0; }
64: 		BIT_LE_R(TYPE &s) { Stream = &s; Reminder = Offset = 0; }
73: 				if (Offset == 0) Reminder = Stream->R8b();
101: 		BIT_LE_W() { Stream = NULL; }
102: 		BIT_LE_W(TYPE *s) { Stream = s; Reminder = Offset = 0; }
103: 		BIT_LE_W(TYPE &s) { Stream = &s; Reminder = Offset = 0; }
110: 				Stream->W8b(Reminder);
128: 					Stream->W8b(Reminder);
149: 		BYTE_NT() { Stream = NULL; }
150: 		BYTE_NT(TYPE *s) { Stream = s; }
151: 		BYTE_NT(TYPE &s) { Stream = &s; }
156: 			return Stream->Position();
161: 			Stream->SetPosition(Pos);
167: 			Stream->ReadData(Buffer, Count);
172: 			return Stream->R8b();
178: 			Stream->WriteData(Buffer, Count);
183: 			Stream->W8b(val);
193: 			val = Stream->R8b(); return *this;
198: 			val = Stream->R8b(); return *this;
203: 			Stream->ReadData(pval, n); return *this;
208: 			Stream->ReadData(pval, n); return *this;
214: 			val = Stream->R16b(); return *this;
219: 			val = Stream->R16b(); return *this;
224: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
229: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
235: 			val = Stream->R32b(); return *this;
240: 			val = Stream->R32b(); return *this;
245: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
250: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
256: 			val = Stream->R64b(); return *this;
261: 			val = Stream->R64b(); return *this;
266: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
271: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
277: 			Stream->ReadData(&val, sizeof(val)); return *this;
282: 			Stream->ReadData(&val, sizeof(val)); return *this;
287: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
292: 			Stream->ReadData(pval, sizeof(*pval)*n); return *this;
302: 			Stream->W8b(val); return *this;
307: 			Stream->W8b(val); return *this;
312: 			Stream->WriteData(pval, n); return *this;
317: 			Stream->WriteData(pval, n); return *this;
323: 			Stream->W16b(val); return *this;
328: 			Stream->W16b(val); return *this;
333: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
338: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
344: 			Stream->W32b(val); return *this;
349: 			Stream->W32b(val); return *this;
354: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
359: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
365: 			Stream->W64b(val); return *this;
370: 			Stream->W64b(val); return *this;
375: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
380: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
386: 			Stream->WriteData(&val, sizeof(val)); return *this;
391: 			Stream->WriteData(&val, sizeof(val)); return *this;
396: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
401: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
456: 				Stream->WriteData(Buffer, sizeof(*pval)*L); \
603: 		BYTE_LE() { Stream = NULL; }
604: 		BYTE_LE(TYPE *s) { Stream = s; }
605: 		BYTE_LE(TYPE &s) { Stream = &s; }
610: 			return Stream->Position();
615: 			Stream->SetPosition(Pos);
621: 			Stream->ReadData(Buffer, Count);
626: 			return Stream->R8b();
632: 			Stream->WriteData(Buffer, Count);
637: 			Stream->W8b(val);
647: 			val = Stream->R8b(); return *this;
652: 			val = Stream->R8b(); return *this;
657: 			Stream->ReadData(pval, n); return *this;
662: 			Stream->ReadData(pval, n); return *this;
668: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R16b()); return *this;
673: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R16b()); return *this;
678: 			Stream->ReadData(pval, sizeof(*pval)*n);
685: 			Stream->ReadData(pval, sizeof(*pval)*n);
693: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R32b()); return *this;
698: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R32b()); return *this;
703: 			Stream->ReadData(pval, sizeof(*pval)*n);
710: 			Stream->ReadData(pval, sizeof(*pval)*n);
718: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R64b()); return *this;
723: 			val = COREARRAY_ENDIAN_LE_TO_NT(Stream->R64b()); return *this;
728: 			Stream->ReadData(pval, sizeof(*pval)*n);
735: 			Stream->ReadData(pval, sizeof(*pval)*n);
743: 			Stream->ReadData(&val, sizeof(val));
750: 			Stream->ReadData(&val, sizeof(val));
757: 			Stream->ReadData(pval, sizeof(*pval)*n);
764: 			Stream->ReadData(pval, sizeof(*pval)*n);
776: 			Stream->W8b(val); return *this;
781: 			Stream->W8b(val); return *this;
786: 			Stream->WriteData(pval, n); return *this;
791: 			Stream->WriteData(pval, n); return *this;
797: 			Stream->W16b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;
802: 			Stream->W16b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;
808: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
817: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
826: 			Stream->W32b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;
831: 			Stream->W32b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;
837: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
846: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
855: 			Stream->W64b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;
860: 			Stream->W64b(COREARRAY_ENDIAN_NT_TO_LE(val)); return *this;
866: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
875: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
885: 			Stream->WriteData(&val, sizeof(val));
892: 			Stream->WriteData(&val, sizeof(val));
899: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
908: 			Stream->WriteData(pval, sizeof(*pval)*n); return *this;
922: 			B = Stream->R8b(); rv = B & 0x7F;			// 1
924: 			B = Stream->R8b(); rv |= (B & 0x7F) << 7;	// 2
926: 			B = Stream->R8b(); rv |= (B & 0x7F) << 14;	// 3
933: 			B = Stream->R8b(); rv = B & 0x7F;			// 1
935: 			B = Stream->R8b(); rv |= (B & 0x7F) << 7;	// 2
937: 			B = Stream->R8b(); rv |= (B & 0x7F) << 14;	// 3
939: 			B = Stream->R8b(); rv |= (B & 0x7F) << 21;	// 4
941: 			B = Stream->R8b(); rv |= (B & 0x7F) << 28;	// 5
948: 			B = Stream->R8b(); rv = B & 0x7F;					// 1
950: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 7;	// 2
952: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 14;	// 3
954: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 21;	// 4
956: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 28;	// 5
958: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 35;	// 6
960: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 42;	// 7
962: 			B = Stream->R8b(); rv |= C_UInt64(B & 0x7F) << 49;	// 8
964: 			B = Stream->R8b(); rv |= C_UInt64(B) << 56;			// 9
973: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
975: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
976: 			Stream->W8b(val);				// 3
983: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
985: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
987: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
989: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
990: 			Stream->W8b(val);				// 5
997: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
999: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
1001: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
1003: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
1005: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
1007: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
1009: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
1011: 			if (val > 0) { Stream->W8b(B | 0x80); } else { Stream->W8b(B); return; }
1012: 			Stream->W8b(val);				// 9
1024: 			Stream->ReadData(&rv[0], L);
1031: 			BIT_LE_R<TYPE> RBit(Stream);
1055: 			Stream->WriteData(&(val[0]), val.size());
1062: 			BIT_LE_W<TYPE> WBit(Stream);
1093: 			Stream->ReadData(&v, GDS_POS_SIZE);
1095: 			v |= Stream->R8b();
1096: 			v |= (C_UInt64)Stream->R8b() << 8;
1097: 			v |= (C_UInt64)Stream->R8b() << 16;
1098: 			v |= (C_UInt64)Stream->R8b() << 24;
1099: 			v |= (C_UInt64)Stream->R8b() << 32;
1100: 			v |= (C_UInt64)Stream->R8b() << 40;
1110: 			Stream->WriteData(&v, GDS_POS_SIZE);
1112: 			Stream->W8b(v); v >>= 8;
1113: 			Stream->W8b(v); v >>= 8;
1114: 			Stream->W8b(v); v >>= 8;
1115: 			Stream->W8b(v); v >>= 8;
1116: 			Stream->W8b(v); v >>= 8;
1117: 			Stream->W8b(v);
54: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator
93: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator
143: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator
597: 	/** \tparam TYPE    it could be CdStream, CdBufStream or CdAllocator
MACPET:R/plot-methods.R: [ ]
187:     FDR = RegCount = X = Y = ymin = ymax = Dist = Tag = Stream = PeakID = NULL
310:                 xsub$end2), Dist = c(xsub$Dist, xsub$Dist), Stream = c(rep("Upper",
313:                 ymax = ymax, color = factor(Stream))) + ggplot2::geom_errorbar(width = 10) +
316:                 ggplot2::labs(color = "Stream") + ggplot2::theme(plot.title = ggplot2::element_text(hjust = 0.5))
seqbias:src/yaml-cpp/stream.h: [ ]
22: 	class Stream: private noncopyable
27: 		Stream(std::istream& input);
28: 		~Stream();
72: 	inline char Stream::CharAt(size_t i) const {
76: 	inline bool Stream::ReadAheadTo(size_t i) const {
25: 		friend class StreamCharSource;
64: 		void StreamInUtf8() const;
65: 		void StreamInUtf16() const;
66: 		void StreamInUtf32() const;
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);
Streamer:R/Stream-class.R: [ ]
1: .Stream <- setRefClass("Stream", contains = "Consumer")
3: .Stream$methods(
10: setMethod(length, "Stream",
22: setMethod("[[", c("Stream", "numeric"),
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())
affxparser:src/fusion/util/LogStream.cpp: [ ]
80: LogStream::LogStream(int verbosity, std::ostream *out, bool profile) :
86: LogStream::~LogStream() {
91: void LogStream::setStream(std::ostream *out) { 
96: void LogStream::unsetStream(std::ostream *out) { 
21:  * @file   LogStream.cpp
28: #include "util/LogStream.h"
107: void LogStream::message(int verbosity, const std::string &log, bool delimiter) {
133: void LogStream::progressBegin(int verbosity, const std::string &msg, int total) {
162: void LogStream::progressStep(int verbosity) {
184: void LogStream::progressEnd(int verbosity, const std::string &msg) {
232: void LogStream::setBaseVerbosity(int verbosity) { // do notthing
316: std::string LogStream::profileString() {
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()
msa:src/ClustalW/src/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);
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);
mzR:src/pwiz/data/common/BinaryIndexStream.hpp: [ ]
38: class PWIZ_API_DECL BinaryIndexStream : public Index
42:     BinaryIndexStream(boost::shared_ptr<std::iostream> indexStreamPtr);
Streamer:inst/unitTests/test_Stream.R: [ ]
1: .checkStream <- function(s, yield=list())
7: test_Stream_producer <- function()
14: test_Stream_consumer <- function()
22: test_Stream_producer_consumer <- function()
9:     ## Stream() should produce a stream with only a producer
11:     .checkStream(Stream(p))
16:     ## Stream() should error with only a consumer (?)
19:     checkException(Stream(c))
24:     ## Stream should succeed with producer / consumer in any order
27:     .checkStream(s1 <- Stream(c, p))
31:     .checkStream(s2 <- Stream(p, c))
Rmmquant:src/mmquant.h: [ ]
644:   std::ostream &getOutputStream () {
648:   std::ostream &getStatsStream () {
1799:         parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";
1801:           parameters.getOutputStream() << " \"" << arg << "\"";
1803:         parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";
1806:         parameters.getOutputStream() << "Gene";
1809:         parameters.getOutputStream() << "\t" << sample;
1811:       parameters.getOutputStream() << "\n";
1813:           parameters.getOutputStream() << line.first;
1815:               parameters.getOutputStream() << "\t" << i;
1817:           parameters.getOutputStream() << "\n";
1908:     dumpStats(parameters.getStatsStream(), parameters.names, stats);
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()
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; }
rhdf5filters:src/blosc/lib/zstd-1.4.5/compress/zstd_compress.c: [ ]
184: size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
3611: ZSTD_CStream* ZSTD_createCStream(void)
3617: ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)
3627: size_t ZSTD_freeCStream(ZSTD_CStream* zcs)
3673: size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
3781: size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
3956: size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
4090: size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
4097: size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
3622: ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)
3643: static size_t ZSTD_resetCStream_internal(ZSTD_CStream* cctx,
3690: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
3712: size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
3726: size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
3739: size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
3757: size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
3766: size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
3803: static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
3963: size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
4049: size_t ZSTD_compressStream2_simpleArgs (
1190: size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
1206: size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
1212: static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
1218: size_t ZSTD_estimateCStreamSize(int compressionLevel)
3636: size_t ZSTD_CStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }
3638: size_t ZSTD_CStreamOutSize(void)
3608: *  Streaming
3613:     DEBUGLOG(3, "ZSTD_createCStream");
3614:     return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
3623: {   /* CStream and CCtx are now same object */
3648:     DEBUGLOG(4, "ZSTD_resetCStream_internal");
3671: /* ZSTD_resetCStream():
3680:     DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
3686: /*! ZSTD_initCStream_internal() :
3695:     DEBUGLOG(4, "ZSTD_initCStream_internal");
3710: /* ZSTD_initCStream_usingCDict_advanced() :
3711:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
3717:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
3728:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
3735: /* ZSTD_initCStream_advanced() :
3748:     DEBUGLOG(4, "ZSTD_initCStream_advanced");
3759:     DEBUGLOG(4, "ZSTD_initCStream_usingDict");
3773:     DEBUGLOG(4, "ZSTD_initCStream_srcSize");
3783:     DEBUGLOG(4, "ZSTD_initCStream");
3799: /** ZSTD_compressStream_generic():
3800:  *  internal function for all *compressStream*() variants
3817:     DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode);
3829:             RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
3958:     FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");
3968:     DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
3981:         DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
3994:                 DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
4000:             DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
4001:             FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
4009:         {   FORWARD_IF_ERROR( ZSTD_resetCStream_internal(cctx,
4029:             flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
4034:             FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
4036:         DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
4044:     FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");
4045:     DEBUGLOG(5, "completed ZSTD_compressStream2");
4057:     /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
4058:     size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
4072:         size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
4076:         FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
4088: /*! ZSTD_flushStream() :
4093:     return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
4100:     size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
4101:     FORWARD_IF_ERROR( remainingToFlush , "ZSTD_compressStream2 failed");
4107:         DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
1209:     return ZSTD_estimateCStreamSize_usingCCtxParams(&params);
1215:     return ZSTD_estimateCStreamSize_usingCParams(cParams);
1223:         size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
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);
Gviz:R/AlignmentsTrack-class.R: [ ]
251:     isStream <- FALSE
283:         isStream <- TRUE
310:     if (!isStream) {
rhdf5filters:src/blosc/lib/lz4-1.9.2/lz4.c: [ ]
1333: LZ4_stream_t* LZ4_createStream(void)
1353: LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
1369: void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
1379: int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
1375: void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
2168: LZ4_streamDecode_t* LZ4_createStreamDecode(void)
2175: int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
2188: int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
2377: int LZ4_sizeofStreamState() { return LZ4_STREAMSIZE; }
2379: int LZ4_resetStreamState(void* state, char* inputBuffer)
1182:     LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
1208:  * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
1278:     LZ4_initStream(&ctx, sizeof(ctx));
1294:     void* const s = LZ4_initStream(state, sizeof (*state));
1330: *  Streaming functions
1337:     DEBUGLOG(4, "LZ4_createStream %p", lz4s);
1339:     LZ4_initStream(lz4s, sizeof(*lz4s));
1355:     DEBUGLOG(5, "LZ4_initStream");
1367: /* resetStream is now deprecated,
1368:  * prefer initStream() which is more general */
1371:     DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
1382:     DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
1403:     LZ4_resetStream(LZ4_dict);
1431: void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) {
1432:     const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL :
1433:         &(dictionaryStream->internal_donotuse);
1436:              workingStream, dictionaryStream,
1439:     /* Calling LZ4_resetStream_fast() here makes sure that changes will not be
1440:      * erased by subsequent calls to LZ4_resetStream_fast() in case stream was
1443:     LZ4_resetStream_fast(workingStream);
1451:         if (workingStream->internal_donotuse.currentOffset == 0) {
1452:             workingStream->internal_donotuse.currentOffset = 64 KB;
1461:     workingStream->internal_donotuse.dictCtx = dictCtx;
2375: /* Obsolete Streaming functions */
2382:     LZ4_resetStream((LZ4_stream_t*)state);
2389:     return LZ4_createStream();
2182: /*! LZ4_setStreamDecode() :
2222:     and indicate where it stands using LZ4_setStreamDecode()
Cardinal:R/utils.R: [ ]
401: getRNGStream <- function() {
410: setRNGStream <- function(seed = NULL) {
416: generateRNGStreams <- function(n = 1) {
418: 	s <- getRNGStream()
427: 			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)
rhdf5filters:src/blosc/lib/zstd-1.4.5/compress/zstdmt_compress.c: [ ]
1564: size_t ZSTDMT_resetCStream(ZSTDMT_CCtx* mtctx, unsigned long long pledgedSrcSize)
1571: size_t ZSTDMT_initCStream(ZSTDMT_CCtx* mtctx, int compressionLevel) {
2102: size_t ZSTDMT_compressStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
2129: size_t ZSTDMT_flushStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output)
2137: size_t ZSTDMT_endStream(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output)
1415: size_t ZSTDMT_initCStream_internal(
1533: size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
1546: size_t ZSTDMT_initCStream_usingCDict(ZSTDMT_CCtx* mtctx,
2014: size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
2111: static size_t ZSTDMT_flushStream_internal(ZSTDMT_CCtx* mtctx, ZSTD_outBuffer* output, ZSTD_EndDirective endFrame)
1412: /* =======      Streaming API     ======= */
1421:     DEBUGLOG(4, "ZSTDMT_initCStream_internal (pledgedSrcSize=%u, nbWorkers=%u, cctxPool=%u)",
1438:         DEBUGLOG(5, "ZSTDMT_initCStream_internal: switch to single blocking thread mode");
1440:         return ZSTD_initCStream_internal(mtctx->cctxPool->cctx[0],
1445:     DEBUGLOG(4, "ZSTDMT_initCStream_internal: %u workers", params.nbWorkers);
1539:     DEBUGLOG(4, "ZSTDMT_initCStream_advanced (pledgedSrcSize=%u)", (U32)pledgedSrcSize);
1542:     return ZSTDMT_initCStream_internal(mtctx, dict, dictSize, ZSTD_dct_auto, NULL,
1555:     return ZSTDMT_initCStream_internal(mtctx, NULL, 0 /*dictSize*/, ZSTD_dct_auto, cdict,
1560: /* ZSTDMT_resetCStream() :
1567:     return ZSTDMT_initCStream_internal(mtctx, NULL, 0, ZSTD_dct_auto, 0, mtctx->params,
1574:     DEBUGLOG(4, "ZSTDMT_initCStream (cLevel=%i)", compressionLevel);
1577:     return ZSTDMT_initCStream_internal(mtctx, NULL, 0, ZSTD_dct_auto, NULL, cctxParams, ZSTD_CONTENTSIZE_UNKNOWN);
2010: /** ZSTDMT_compressStream_generic() :
2020:     DEBUGLOG(5, "ZSTDMT_compressStream_generic (endOp=%u, srcSize=%u)",
2026:         return ZSTD_compressStream2(mtctx->cctxPool->cctx[0], output, input, endOp);
2073:             DEBUGLOG(5, "ZSTDMT_compressStream_generic: adding %u bytes on top of %u to buffer of size %u",
2096:         DEBUGLOG(5, "end of ZSTDMT_compressStream_generic: remainingToFlush = %u", (U32)remainingToFlush);
2104:     FORWARD_IF_ERROR( ZSTDMT_compressStream_generic(mtctx, output, input, ZSTD_e_continue) , "");
2114:     DEBUGLOG(5, "ZSTDMT_flushStream_internal");
2119:            DEBUGLOG(5, "ZSTDMT_flushStream_internal : create a new job (%u bytes, end:%u)",
2131:     DEBUGLOG(5, "ZSTDMT_flushStream");
2133:         return ZSTD_flushStream(mtctx->cctxPool->cctx[0], output);
2134:     return ZSTDMT_flushStream_internal(mtctx, output, ZSTD_e_flush);
2139:     DEBUGLOG(4, "ZSTDMT_endStream");
2141:         return ZSTD_endStream(mtctx->cctxPool->cctx[0], output);
2142:     return ZSTDMT_flushStream_internal(mtctx, output, ZSTD_e_end);
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/CoreArray/dRealGDS.h: [ ]
86: 		static const char *StreamName() { return "dPackedReal8"; }
109: 		static const char *StreamName() { return "dPackedReal8U"; }
132: 		static const char *StreamName() { return "dPackedReal16"; }
155: 		static const char *StreamName() { return "dPackedReal16U"; }
178: 		static const char *StreamName() { return "dPackedReal24"; }
201: 		static const char *StreamName() { return "dPackedReal24U"; }
224: 		static const char *StreamName() { return "dPackedReal32"; }
247: 		static const char *StreamName() { return "dPackedReal32U"; }
299: 						*(Src->Allocator().BufStream()->Stream()),
87: 		static const char *TraitName() { return StreamName()+1; }
110: 		static const char *TraitName() { return StreamName()+1; }
133: 		static const char *TraitName() { return StreamName()+1; }
156: 		static const char *TraitName() { return StreamName()+1; }
179: 		static const char *TraitName() { return StreamName()+1; }
202: 		static const char *TraitName() { return StreamName()+1; }
225: 		static const char *TraitName() { return StreamName()+1; }
248: 		static const char *TraitName() { return StreamName()+1; }
295: 					this->fAllocator.BufStream())
297: 					Src->Allocator().BufStream()->FlushWrite();
298: 					this->fAllocator.BufStream()->CopyFrom(
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)
rhdf5filters:src/bzip2/bzip2-1.0.8/bzip2.c: [ ]
329: void compressStream ( FILE *stream, FILE *zStream )
433: Bool uncompressStream ( FILE *zStream, FILE *stream )
554: Bool testStream ( FILE *zStream )
774: void compressedStreamEOF ( void )
339:    SET_BINARY_MODE(zStream);
342:    if (ferror(zStream)) goto errhandler_io;
344:    bzf = BZ2_bzWriteOpen ( &bzerr, zStream, 
365:    if (ferror(zStream)) goto errhandler_io;
366:    ret = fflush ( zStream );
368:    if (zStream != stdout) {
369:       Int32 fd = fileno ( zStream );
372:       ret = fclose ( zStream );
447:    SET_BINARY_MODE(zStream);
450:    if (ferror(zStream)) goto errhandler_io;
455:                &bzerr, zStream, verbosity, 
479:       if (nUnused == 0 && myfeof(zStream)) break;
483:    if (ferror(zStream)) goto errhandler_io;
489:    ret = fclose ( zStream );
506:       rewind(zStream);
508:       	 if (myfeof(zStream)) break;
509:       	 nread = fread ( obuf, sizeof(UChar), 5000, zStream );
510:       	 if (ferror(zStream)) goto errhandler_io;
532:          if (zStream != stdin) fclose(zStream);
567:    SET_BINARY_MODE(zStream);
568:    if (ferror(zStream)) goto errhandler_io;
573:                &bzerr, zStream, verbosity, 
593:       if (nUnused == 0 && myfeof(zStream)) break;
597:    if (ferror(zStream)) goto errhandler_io;
598:    ret = fclose ( zStream );
625:          if (zStream != stdin) fclose(zStream);
1295:    compressStream ( inStr, outStr );
1472:    magicNumberOK = uncompressStream ( inStr, outStr );
1592:    allOK = testStream ( inStr );
219: static void    compressedStreamEOF   ( void )        NORETURN;
530:          compressedStreamEOF();
gdsfmt:src/CoreArray/dSparse.h: [ ]
83: 		static const char *StreamName() { return "dSparseInt8"; }
101: 		static const char *StreamName() { return "dSparseUInt8"; }
119: 		static const char *StreamName() { return "dSparseInt16"; }
137: 		static const char *StreamName() { return "dSparseUInt16"; }
155: 		static const char *StreamName() { return "dSparseInt32"; }
173: 		static const char *StreamName() { return "dSparseUInt32"; }
191: 		static const char *StreamName() { return "dSparseInt64"; }
209: 		static const char *StreamName() { return "dSparseUInt64"; }
227: 		static const char *StreamName() { return "dSparseReal32"; }
248: 		static const char *StreamName() { return "dSparseReal64"; }
355: 		CdBlockStream *fIndexingStream; ///< the GDS stream for indexing
356: 		SIZE64 fTotalStreamSize;    ///< the total stream size
357: 		SIZE64 fCurStreamPosition;  ///< the current stream position
506: 		inline void SetStreamPos(C_Int64 idx)
82: 		static const char *TraitName() { return StreamName()+1; }
100: 		static const char *TraitName() { return StreamName()+1; }
118: 		static const char *TraitName() { return StreamName()+1; }
136: 		static const char *TraitName() { return StreamName()+1; }
154: 		static const char *TraitName() { return StreamName()+1; }
172: 		static const char *TraitName() { return StreamName()+1; }
190: 		static const char *TraitName() { return StreamName()+1; }
208: 		static const char *TraitName() { return StreamName()+1; }
228: 		static const char *TraitName() { return StreamName()+1; }
249: 		static const char *TraitName() { return StreamName()+1; }
360: 		vector<C_Int64> fArrayIndex;  ///< array indices in fIndexingStream
364: 		void SpLoad(CdReader &Reader, CdBlockStream *GDSStream,
367: 		void SpSave(CdWriter &Writer, CdBlockStream *GDSStream);
495: 			SpLoad(Reader, this->fGDSStream, this->fPipeInfo, this->fAllocator);
502: 			SpSave(Writer, this->fGDSStream);
725: 				BYTE_LE<CdStream>(IT->fIndexingStream) << I <<
486: 				return fTotalStreamSize;
521: 			SetStreamPos(I.Ptr);
543: 						this->fCurStreamPosition += sz + sizeof(ElmTypeEx);
544: 						I.Allocator->SetPosition(this->fCurStreamPosition);
555: 							this->fCurStreamPosition += sz;
570: 					this->fCurStreamPosition += sz + sizeof(Val);
585: 						this->fCurStreamPosition += sz;
609: 			IT->SetStreamPos(I.Ptr);
617: 					// IT->fCurIndex should be = I.Ptr (calling SetStreamPos)
620: 					IT->fCurStreamPosition += sizeof(C_UInt16) + sizeof(Val);
631: 						IT->fCurStreamPosition += sz;
646: 			IT->SetStreamPos(I.Ptr);
665: 						IT->fCurStreamPosition += sz + sizeof(TYPE);
666: 						I.Allocator->SetPosition(IT->fCurStreamPosition);
677: 							IT->fCurStreamPosition += sz;
696: 					IT->fCurStreamPosition += sz + sizeof(Val);
708: 						IT->fCurStreamPosition += sz;
726: 					TdGDSPos(IT->fTotalStreamSize);
742: 				I.Allocator->SetPosition(IT->fTotalStreamSize);
760: 									IT->fTotalStreamSize += sizeof(L);
766: 								IT->fTotalStreamSize += sizeof(C_UInt16) + GDS_POS_SIZE;
772: 						IT->fTotalStreamSize += sizeof(C_UInt16) + sizeof(TYPE);
gdsfmt:src/LZ4/lz4.c: [ ]
1423: LZ4_stream_t* LZ4_createStream(void)
1443: LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
1455: void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
1465: int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
1461: void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
2265: LZ4_streamDecode_t* LZ4_createStreamDecode(void)
2272: int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
2285: int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
2474: int LZ4_sizeofStreamState(void) { return LZ4_STREAMSIZE; }
2476: int LZ4_resetStreamState(void* state, char* inputBuffer)
1286:     LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
1313:  * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
1384:     void* const s = LZ4_initStream(state, sizeof (*state));
1420: *  Streaming functions
1427:     DEBUGLOG(4, "LZ4_createStream %p", lz4s);
1429:     LZ4_initStream(lz4s, sizeof(*lz4s));
1445:     DEBUGLOG(5, "LZ4_initStream");
1453: /* resetStream is now deprecated,
1454:  * prefer initStream() which is more general */
1457:     DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
1468:     DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
1489:     LZ4_resetStream(LZ4_dict);
1517: void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) {
1518:     const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL :
1519:         &(dictionaryStream->internal_donotuse);
1522:              workingStream, dictionaryStream,
1531:         if (workingStream->internal_donotuse.currentOffset == 0) {
1532:             workingStream->internal_donotuse.currentOffset = 64 KB;
1541:     workingStream->internal_donotuse.dictCtx = dictCtx;
2472: /* Obsolete Streaming functions */
2479:     LZ4_resetStream((LZ4_stream_t*)state);
2486:     return LZ4_createStream();
2279: /*! LZ4_setStreamDecode() :
2319:     and indicate where it stands using LZ4_setStreamDecode()
Gviz:R/GeneRegionTrack-class.R: [ ]
350:     isStream <- FALSE
382:         isStream <- TRUE
396:     if (!isStream) {
gdsfmt:inst/include/dTrait.h: [ ]
106: 		static const char *StreamName() { return "dInt8"; }
124: 		static const char *StreamName() { return "dUInt8"; }
142: 		static const char *StreamName() { return "dInt16"; }
160: 		static const char *StreamName() { return "dUInt16"; }
178: 		static const char *StreamName() { return "dInt32"; }
196: 		static const char *StreamName() { return "dUInt32"; }
214: 		static const char *StreamName() { return "dInt64"; }
232: 		static const char *StreamName() { return "dUInt64"; }
255: 		static const char *StreamName() { return "dFloat32"; }
275: 		static const char *StreamName() { return "dFloat64"; }
294: 		static const char *StreamName() { return "dLongFloat"; }
295: 		static const char *TraitName() { return StreamName()+1; }
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)
MACPET:R/Stage_0_FilteringLinkersFunctions.R: [ ]
103:     Streamfastq1 = ShortRead::FastqStreamer(con = S0_fastq1, n = S0_fastqStream)
104:     Streamfastq2 = ShortRead::FastqStreamer(con = S0_fastq2, n = S0_fastqStream)
101:     # Stream the fastq files:
8:     S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_image, S0_fastqStream,
27:         S0_LinkerOccurence = S0_LinkerOccurence, S0_fastqStream = S0_fastqStream,
98:     S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_fastqStream, S0_Totfastqreads,
128:         fastq1yield = ShortRead::yield(Streamfastq1)
130:         fastq2yield = ShortRead::yield(Streamfastq2)
216:     close(Streamfastq1)
217:     close(Streamfastq2)
1: #' @importFrom ShortRead FastqStreamer yield writeFastq
3: #' @importClassesFrom ShortRead FastqStreamer ShortReadQ SFastqQuality SRFilterResult
seqbias:src/yaml-cpp/scanner.h: [ ]
121: 		bool m_startedStream, m_endedStream;
115: 		Stream INPUT;
54: 		void StartStream();
55: 		void EndStream();
gdsfmt:src/CoreArray/dStrGDS.h: [ ]
69: 		static const char *StreamName() { return "dFStr8"; }
83: 		static const char *StreamName() { return "dFStr16"; }
97: 		static const char *StreamName() { return "dFStr32"; }
318: 		static const char *StreamName() { return "dVStr8"; }
332: 		static const char *StreamName() { return "dVStr16"; }
346: 		static const char *StreamName() { return "dVStr32"; }
634: 		static const char *StreamName() { return "dStr8"; }
648: 		static const char *StreamName() { return "dStr16"; }
662: 		static const char *StreamName() { return "dStr32"; }
68: 		static const char *TraitName() { return StreamName()+1; }
82: 		static const char *TraitName() { return StreamName()+1; }
96: 		static const char *TraitName() { return StreamName()+1; }
159: 		virtual void UpdateInfoExt(CdBufStream *Sender)
163: 				this->fGDSStream->SetPosition(this->vElmSize_Ptr);
164: 				BYTE_LE<CdStream>(this->fGDSStream) << C_UInt32(this->fElmSize);
319: 		static const char *TraitName() { return StreamName()+1; }
333: 		static const char *TraitName() { return StreamName()+1; }
347: 		static const char *TraitName() { return StreamName()+1; }
440: 			if (this->fGDSStream)
444: 					this->_TotalSize = this->fPipeInfo->StreamTotalIn();
446: 					if (this->fAllocator.BufStream())
447: 						this->_TotalSize = this->fAllocator.BufStream()->GetSize();
635: 		static const char *TraitName() { return StreamName()+1; }
649: 		static const char *TraitName() { return StreamName()+1; }
663: 		static const char *TraitName() { return StreamName()+1; }
755: 			if (this->fGDSStream)
759: 					this->_TotalSize = this->fPipeInfo->StreamTotalIn();
761: 					if (this->fAllocator.BufStream())
762: 						this->_TotalSize = this->fAllocator.BufStream()->GetSize();
389: 		CdStreamIndex fIndexing;
704: 		CdStreamIndex fIndexing;
RSeqAn:inst/include/seqan/basic/profiling.h: [ ]
164:         static ProfileFile_*    _proPFileStream;
173:     template <typename T> ProfileFile_*     ProfileData_<T>::_proPFileStream = NULL;
178:     inline ProfileFile_* & _proPFileStream()    { return ProfileData_<>::_proPFileStream; }
478:         if (ProfileData_<>::_proPFileStream) ProfileData_<>::_proPFileStream->signalDumpTest(now);
484:             if (ProfileData_<>::_proPFileStream) ProfileData_<>::_proPFileStream->signalNewMax(valNum);
491:         if (ProfileData_<>::_proPFileStream) ProfileData_<>::_proPFileStream->setMark(text);
497:         if (ProfileData_<>::_proPFileStream) { ProfileData_<>::_proPFileStream->setEndMark(text); }
503:         if (ProfileData_<>::_proPFileStream) { ProfileData_<>::_proPFileStream->reset(); }
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);
seqTools:src/dna_fstream.h: [ ]
39: } dfStream;
41: static inline int dfs_isOpen(dfStream *dfs)	{ return dfs->state == dfs_file_open; }
43: static inline int dfs_stream_open(dfStream *dfs, const char *filename)
65: static inline void dfs_stream_close(dfStream *dfs)
79: static inline int dfs_stream_eof(dfStream *dfs)
89: static dfStream* dfs_stream_init(const char* filename)
91: 	dfStream *dfs = calloc(sizeof(dfStream), 1);
98: static void dfs_destroy(dfStream *dfs)
108: static inline size_t dfs_read(dfStream *dfs, char *dest, unsigned size)
Rfastp:src/FASTP/seprocessor.h: [ ]
68:     ofstream* mOutStream;
Gviz:R/ReferenceTrack-class.R: [ ]
116:         isStream <- !is.null(defMap[[".stream"]]) && defMap[[".stream"]]
118:         if (!isStream) {
RSeqAn:inst/include/seqan/stream/iter_stream.h: [ ]
51: struct StreamIterator {};
77: struct StreamBuffer : public std::basic_streambuf<TValue, TTraits_>
80:     using TBasicStream = std::basic_streambuf<TValue, TTraits_>;
104: class StreamBufferWrapper
116:     explicit StreamBufferWrapper(TBasicStreamBuffer * _basicStreamBuf) : streamBuf(_basicStreamBuf)
252:     typedef std::basic_istream<TValue>                       TIStream;
303:     typedef std::basic_ostream<TValue>                       TOStream;
108:     typedef std::basic_streambuf<TValue, TTraits_> TBasicStreamBuffer;
109:     typedef StreamBuffer<TValue, TTraits_>         TPubStreamBuffer_;
254:     typedef StreamBufferWrapper<TValue>                      TStreamBufferWrapper;
255:     typedef typename TStreamBufferWrapper::TPubStreamBuffer_ TStreamBuffer;
305:     typedef StreamBufferWrapper<TValue>                      TStreamBufferWrapper;
306:     typedef typename TStreamBufferWrapper::TPubStreamBuffer_ TStreamBuffer;
729:     typedef StreamBuffer<TValue> TStreamBuffer;
750:     typedef StreamBuffer<TValue> TStreamBuffer;
484:  * @brief Returns direction iterator for Stream.
58: // Class StreamBuffer
62:  * @class StreamBuffer
67:  *            class StreamBuffer : public std::basic_streambuf<TValue, TTraits>;
82:     using TBasicStream::eback;
83:     using TBasicStream::gptr;
84:     using TBasicStream::egptr;
85:     using TBasicStream::gbump;
86:     using TBasicStream::underflow;
88:     using TBasicStream::pbase;
89:     using TBasicStream::pptr;
90:     using TBasicStream::epptr;
91:     using TBasicStream::pbump;
92:     using TBasicStream::overflow;
95: // NOTE(rrahn): This is a wrapper for the StreamBuffer class.
97: // std::basic_filebuf to StreamBuffer to expose it's protected member functions.
98: // To do so, we only use the StreamBuffer to inherit from basic_streambuf (the base class of all buffer implementations.)
101: // basic_streambuf* into the public StreamBuffer*. The reinterpret_cast has zero overhead.
114:     StreamBufferWrapper() = default;
217: // Class StreamIterator
221:  * @class StreamIterator
225:  * @signature template <typename TStream, typename TDirection>
226:  *            class Iter<TStream, StreamIterator<TDirection> >;
228:  * @tparam TStream    The @link StreamConcept @endlink to iterate over.
233: // Class Input StreamIterator
237:  * @class InputStreamIterator Input StreamIterator
238:  * @extends StreamIterator
239:  * @brief @link Iter @endlink specialiazion for reading from @link StreamConcept streams @endlink.
241:  * @signature template <typename TStream>
242:  *            class Iter<TStream, StreamIterator<Input> >;
244:  * @tparam TStream    The @link StreamConcept @endlink to iterate over.
247: template <typename TStream>
248: class Iter<TStream, StreamIterator<Input> >
251:     typedef typename Value<TStream>::Type                    TValue;
267:      * @param[in] stream    The <tt>TStream</tt> to read from.
268:      * @param[in] streamBuf A @link StreamBuffer @endlink to read from.
270:      * Allows default construction, construction from stream, as well as from a @link StreamBuffer @endlink.
274:     Iter(TIStream & stream) : streamBufWrapper(stream.rdbuf())
285: // Class StreamIterator
289:  * @class OutputStreamIterator Output StreamIterator
290:  * @extends StreamIterator
291:  * @brief @link Iter @endlink specialiazion for writing to @link StreamConcept streams @endlink.
293:  * @signature template <typename TStream>
294:  *            class Iter<TStream, StreamIterator<Output> >;
296:  * @tparam TStream    The @link StreamConcept @endlink to iterate over.
298: template <typename TStream>
299: class Iter<TStream, StreamIterator<Output> >
302:     typedef typename Value<TStream>::Type                    TValue;
318:      * @param[in] stream    The <tt>TStream</tt> to write to.
319:      * @param[in] streamBuf A @link StreamBuffer @endlink to write to.
321:      * Allows default construction, construction from stream, as well as from a @link StreamBuffer @endlink.
325:     Iter(TOStream & stream) : streamBufWrapper(stream.rdbuf())
358:  * @mfn StreamBuffer#Chunk
359:  * @brief Return chunk type for StreamBuffer
363:  * @tparam TStreamBuffer The StreamBuffer to query for its chunk type.
368: struct Chunk<StreamBuffer<TValue, TTraits> >
373: template <typename TStream, typename TDirection>
374: struct Chunk<Iter<TStream, StreamIterator<Tag<TDirection> > > >:
375:     Chunk<typename Iter<TStream, StreamIterator<Tag<TDirection> > >::TStreamBuffer> {};
382:  * @mfn StreamBuffer#Reference
383:  * @brief Return reference for StreamBuffer.
387:  * @tparam TStreamBuffer The StreamBuffer to query for its reference type.
391: template <typename TStream>
392: struct Reference<Iter<TStream, StreamIterator<Input> > >:
393:     Value<Iter<TStream, StreamIterator<Input> > > {};
395: template <typename TStream>
396: struct Reference<Iter<TStream, StreamIterator<Input> > const>:
397:     Value<Iter<TStream, StreamIterator<Input> > > {};
399: template <typename TStream>
400: struct Reference<Iter<TStream, StreamIterator<Output> > >
402:     typedef Iter<TStream, StreamIterator<Output> > Type;
410:  * @mfn StreamBuffer#GetValue
411:  * @brief Return get value for StreamBuffer.
415:  * @tparam TStreamBuffer The StreamBuffer to query for its get value type.
419: template <typename TStream>
420: struct GetValue<Iter<TStream, StreamIterator<Input> > >:
421:     Reference<Iter<TStream, StreamIterator<Input> > const> {};
428:  * @mfn StreamBuffer#Position
429:  * @brief Return position for StreamBuffer.
433:  * @tparam TStreamBuffer The StreamBuffer to query for its position type.
437: template <typename TStream, typename TDirection>
438: struct Position<Iter<TStream, StreamIterator<TDirection> > > : Position<TStream> {};
445:  * @mfn StreamBuffer#Difference
446:  * @brief Return difference for StreamBuffer.
450:  * @tparam TStreamBuffer The StreamBuffer to query for its difference type.
454: template <typename TStream, typename TDirection>
455: struct Difference<Iter<TStream, StreamIterator<TDirection> > > : Difference<TStream> {};
462:  * @mfn StreamBuffer#Size
463:  * @brief Return size for StreamBuffer.
467:  * @tparam TStreamBuffer The StreamBuffer to query for its size type.
471: template <typename TStream, typename TDirection>
472: struct Size<Iter<TStream, StreamIterator<TDirection> > > : Size<TStream> {};
483:  * @fn StreamConcept#directionIterator
488:  * @param[in] stream The @link StreamConcept @endlink object to compute iterator for.
492: template <typename TStream, typename TDirection>
493: inline SEQAN_FUNC_ENABLE_IF(Is<StreamConcept<TStream> >, Iter<TStream, StreamIterator<TDirection> >)
494: directionIterator(TStream &stream, TDirection const &)
496:     return Iter<TStream, StreamIterator<TDirection> >(stream);
512: inline SEQAN_FUNC_DISABLE_IF(Is<StreamConcept<TContainer> >, typename Iterator<TContainer, Rooted>::Type)
523:  * @fn StreamIterator#reserveChunk
524:  * @brief Reserve a chunk in the host of the StreamIterator
528:  * @param[in] iter   The @link StreamIterator @endlink object to reserve chunks for.
534: template <typename TStream, typename TDirection, typename TSize>
535: inline void reserveChunk(Iter<TStream, StreamIterator<TDirection> > &iter, TSize, Input dir)
540: template <typename TStream, typename TDirection, typename TSize>
541: inline void reserveChunk(Iter<TStream, StreamIterator<TDirection> > &iter, TSize, Output dir)
552: template <typename TStream, typename TDirection, typename TSize>
553: inline void advanceChunk(Iter<TStream, StreamIterator<TDirection> > &iter, TSize size)
562: // StreamBuffer
565: getChunk(TChunk &result, StreamBuffer<TValue, TTraits> &buf, Input)
572: getChunk(TChunk &result, StreamBuffer<TValue, TTraits> &buf, Output)
577: // StreamIterator
578: template <typename TChunk, typename TStream, typename TDirection>
580: getChunk(TChunk &result, Iter<TStream, StreamIterator<Tag<TDirection> > > &iter, Tag<TDirection>)
590: template <typename TStream>
591: inline typename Reference<Iter<TStream, StreamIterator<Input> > >::Type
592: value(Iter<TStream, StreamIterator<Input> > &iter)
597: template <typename TStream>
598: inline typename Reference<Iter<TStream, StreamIterator<Input> > const>::Type
599: value(Iter<TStream, StreamIterator<Input> > const &iter)
609: template <typename TStream>
610: inline Iter<TStream, StreamIterator<Output> > &
611: value(Iter<TStream, StreamIterator<Output> > & iter)
615: template <typename TStream>
616: inline Iter<TStream, StreamIterator<Output> > const &
617: value(Iter<TStream, StreamIterator<Output> > const & iter)
626: template <typename TStream, typename TValue>
628: setValue(Iter<TStream, StreamIterator<Output> > & iter, TValue const &val)
630:     return setValue(const_cast<Iter<TStream, StreamIterator<Output> > const &>(iter), val);
633: template <typename TStream, typename TValue>
635: setValue(Iter<TStream, StreamIterator<Output> > const & iter, TValue const &val)
638:     iter.streamBufWrapper.baseBuf()->sputc((typename Value<Iter<TStream, StreamIterator<Output> > >::Type)val);
647: inline void writeValue(Iter<TContainer, StreamIterator<Output> > &iter, TValue val)
657: template <typename TStream>
659: goNext(Iter<TStream, StreamIterator<Input> > & iter)
665: template <typename TStream>
667: goNext(Iter<TStream, StreamIterator<Output> > &)
677: operator++(Iter<TContainer, StreamIterator<Input> > & iter, int)
687: template <typename TStream, typename TOffset, typename TDirection>
689: goFurther(Iter<TStream, StreamIterator<TDirection> > &iter, TOffset ofs)
699: template <typename TStream, typename TDirection>
700: inline typename Position<Iter<TStream, StreamIterator<TDirection> > const>::Type
701: position(Iter<TStream, StreamIterator<TDirection> > const & iter)
712: template <typename TStream, typename TDirection, typename TPosition>
714: setPosition(Iter<TStream, StreamIterator<TDirection> > const & iter, TPosition pos)
724: template <typename TStream>
726: atEnd(Iter<TStream, StreamIterator<Input> > const & iter)
728:     typedef typename Value<Iter<TStream, StreamIterator<Input> > >::Type TValue;
745: template <typename TStream>
747: atEnd(Iter<TStream, StreamIterator<Output> > const & iter)
749:     typedef typename Value<Iter<TStream, StreamIterator<Input> > >::Type TValue;
110:     typedef typename TPubStreamBuffer_::TTraits    TTraits;
112:     TBasicStreamBuffer * streamBuf{nullptr};
210:     TPubStreamBuffer_* baseBuf() const
212:         return reinterpret_cast<TPubStreamBuffer_ *>(streamBuf);
257:     TStreamBufferWrapper streamBufWrapper{nullptr};
260:      * @fn InputStreamIterator::Iter
308:     TStreamBufferWrapper streamBufWrapper{nullptr};
361:  * @signature Chunk<TStreamBuffer>::Type;
385:  * @signature Reference<TStreamBuffer>::Type;
413:  * @signature GetValue<TStreamBuffer>::Type;
431:  * @signature Position<TStreamBuffer>::Type;
448:  * @signature Difference<TStreamBuffer>::Type;
465:  * @signature Size<TStreamBuffer>::Type;
737:         TStreamBuffer * const buf = iter.streamBufWrapper.baseBuf();
741:             return TStreamBuffer::TTraits::eq_int_type(buf->sgetc(), TStreamBuffer::TTraits::eof());
758:         TStreamBuffer * const buf = iter.streamBufWrapper.baseBuf();
762:             return TStreamBuffer::TTraits::eq_int_type(buf->overflow(), TStreamBuffer::TTraits::eof());
RSeqAn:inst/include/seqan/index/pipe_merger7.h: [ ]
87:     struct SkewDCStream
109:     struct CompareSkewDCStream :
210:         typedef SkewDCStream<TInValue0>             TSkewDCStream;
250:         inline void insertStream(unsigned stream)
355:         typedef SkewDCStream<TInValue0>             TSkewDCStream;
397:         inline void insertStream(unsigned stream)
94:     std::ostream& operator<<(std::ostream &out, const SkewDCStream<TValue> &s)
110:         public std::binary_function < SkewDCStream<TValue>,
111:                                         SkewDCStream<TValue>,
114:         inline bool operator()(const SkewDCStream<TValue> &a,
115:                                const SkewDCStream<TValue> &b) const
142:     struct CompareSkewDCStream< Triple<T1, T2, Tuple<T, SIZE, BitPacked<> >, Pack> > :
143:         public std::binary_function < SkewDCStream<Triple<T1, T2, Tuple<T, SIZE, BitPacked<> >, Pack> >,
144:                                         SkewDCStream<Triple<T1, T2, Tuple<T, SIZE, BitPacked<> >, Pack> >,
148:         inline bool operator()(const SkewDCStream<Triple<T1, T2, T3, Pack> > &a,
149:                                const SkewDCStream<Triple<T1, T2, T3, Pack> > &b) const
212:         TSkewDCStream                                inValue[7];
215:         CompareSkewDCStream<TInValue0>                streamGreater;
230:         inline static void _copy(TSkewDCStream &dst, Triple<T1,T2,T3, Pack> const &src)
237:         inline static void _copy(TSkewDCStream &dst, Triple<T1,T2,Tuple<T,SIZE, BitPacked<> >, Pack> const &src)
320:             insertStream(rank[first]);
331:             first = 4;    insertStream(0);
332:             --first;    insertStream(3);
333:             --first;    insertStream(5);
334:             --first;    insertStream(6);
335:             --first;    insertStream(1);
357:         TSkewDCStream                                inValue[7];
360:         CompareSkewDCStream<TInValue0>                streamGreater;
375:         inline static void _copy(TSkewDCStream &dst, Triple<T1,T2,T3, Pack> const &src)
383:         inline static void _copy(TSkewDCStream &dst, Triple<T1,T2,Tuple<T,SIZE, BitPacked<> >, Pack> const &src)
465:             insertStream(rank[first]);
476:             first = 4;    insertStream(0);
477:             --first;    insertStream(3);
478:             --first;    insertStream(5);
479:             --first;    insertStream(6);
480:             --first;    insertStream(1);
107:     // greater-operator for two SkewDCStreams
140:     // greater-operator for two SkewDCStreams (optimized for bit-packed character tuples)
affxparser:src/fusion/calvin_files/data/src/DataSet.h: [ ]
371: 	std::ifstream* fileStream;
208: 	void ReadDataSetUsingStream();
214: 	void ClearStreamData();
seqbias:src/yaml-cpp/scanner.cpp: [ ]
233: 	void Scanner::StartStream()
244: 	void Scanner::EndStream()
11: 		: INPUT(in), m_startedStream(false), m_endedStream(false), m_simpleKeyAllowed(false), m_canBeJSONFlow(false)
77: 			if(m_endedStream)
90: 		if(m_endedStream)
93: 		if(!m_startedStream)
94: 			return StartStream();
108: 			return EndStream();
231: 	// StartStream
235: 		m_startedStream = true;
242: 	// EndStream
254: 		m_endedStream = true;
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
affxparser:src/fusion/util/LineFile.h: [ ]
114:   std::ifstream & getStream() {
131:   std::ifstream m_fileStream;
115:     return m_fileStream;
119:     return m_fileStream.is_open();
122:     return m_fileStream.fail();
125:     return m_fileStream.eof() ;
Rfastp:src/FASTP/fastareader.h: [ ]
60:     ifstream mFastaFileStream;
affxparser:src/fusion/calvin_files/parsers/src/GenericFileReader.h: [ ]
150: 	std::ifstream fileStream;
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();
Rfastp:src/FASTP/writer.h: [ ]
39:     ofstream* mOutStream;
seqbias:src/yaml-cpp/streamcharsource.h: [ ]
14: 	class StreamCharSource
17: 		StreamCharSource(const Stream& stream): m_offset(0), m_stream(stream) {}
18: 		StreamCharSource(const StreamCharSource& source): m_offset(source.m_offset), m_stream(source.m_stream) {}
19: 		~StreamCharSource() {}
29: 		const Stream& m_stream;
25: 		const StreamCharSource operator + (int i) const;
31: 		StreamCharSource& operator = (const StreamCharSource&); // non-assignable
34: 	inline StreamCharSource::operator bool() const {
38: 	inline const StreamCharSource StreamCharSource::operator + (int i) const {
39: 		StreamCharSource source(*this);
mzR:src/pwiz/analysis/demux/FSDemux.cpp: [ ]
78: class IterationListenerStream : public IterationListener
81:     explicit IterationListenerStream(ostream &os = std::cerr) : os_(os), entfmt_("%5.1f"){}
138:     IterationListenerPtr listenerPtr(new IterationListenerStream(std::cerr));
RSeqAn:inst/include/seqan/stream/stream_compressor.h: [ ]
416: guessFormatFromStream(TStream &istream, BgzfFile)
414: template <typename TStream>
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 );
mzR:src/pwiz/data/identdata/IdentDataFile.cpp: [ ]
125: void writeStream(ostream& os, const IdentData& idd, const string& filename,
167:     writeStream(*os, idd, filename, config, iterationListenerRegistry);
180:     writeStream(os, idd, filename, config2, iterationListenerRegistry);
mzR:src/pwiz/analysis/demux/MatrixIO.cpp: [ ]
30:     void MatrixIO::GetWriteStream(ofstream& out, const string& filename)
68:     void MatrixIO::GetReadStream(ifstream& in, const string& filename)
58:         GetWriteStream(out, filename);
94:         GetReadStream(in, filename);
mzR:src/libraries/doctest.h: [ ]
1794:     struct StringStream : StringStreamBase<has_insertion_operator<T>::value>
1798:     void toStream(std::ostream* stream, const T& value) {
1848:             virtual void toStream(std::ostream* stream) const { // override
3405:     std::ostream* createStream() { return new std::ostringstream(); }
3409:     void freeStream(std::ostream* in) { delete in; }
4324:     void writeStringToStream(std::ostream* stream, const String& str) { *stream << str; }
4327:     void toStream(std::ostream* stream, char* in) { *stream << in; }
4328:     void toStream(std::ostream* stream, const char* in) { *stream << in; }
4330:     void toStream(std::ostream* stream, bool in) {
4333:     void toStream(std::ostream* stream, float in) { *stream << in; }
4334:     void toStream(std::ostream* stream, double in) { *stream << in; }
4335:     void toStream(std::ostream* stream, double long in) { *stream << in; }
4337:     void toStream(std::ostream* stream, char in) { *stream << in; }
4338:     void toStream(std::ostream* stream, char signed in) { *stream << in; }
4339:     void toStream(std::ostream* stream, char unsigned in) { *stream << in; }
4340:     void toStream(std::ostream* stream, int short in) { *stream << in; }
4341:     void toStream(std::ostream* stream, int short unsigned in) { *stream << in; }
4342:     void toStream(std::ostream* stream, int in) { *stream << in; }
4343:     void toStream(std::ostream* stream, int unsigned in) { *stream << in; }
4344:     void toStream(std::ostream* stream, int long in) { *stream << in; }
4345:     void toStream(std::ostream* stream, int long unsigned in) { *stream << in; }
4348:     void toStream(std::ostream* stream, int long long in) { *stream << in; }
4349:     void toStream(std::ostream* stream, int long long unsigned in) { *stream << in; }
1770:     struct StringStreamBase
1785:     struct StringStreamBase<true>
3406:     String getStreamResult(std::ostream* in) {
811:     DOCTEST_INTERFACE std::ostream* createStream();
813:     DOCTEST_INTERFACE void   freeStream(std::ostream*);
829:             std::ostream* stream = createStream();
832:             freeStream(stream);
1767:     DOCTEST_INTERFACE void writeStringToStream(std::ostream* stream, const String& str);
1774:             writeStringToStream(stream, toString(in));
1780:             writeStringToStream(stream, String(in));
1799:         StringStream<T>::convert(stream, value);
1803:     DOCTEST_INTERFACE void toStream(std::ostream* stream, char* in);
1804:     DOCTEST_INTERFACE void toStream(std::ostream* stream, const char* in);
1806:     DOCTEST_INTERFACE void toStream(std::ostream* stream, bool in);
1807:     DOCTEST_INTERFACE void toStream(std::ostream* stream, float in);
1808:     DOCTEST_INTERFACE void toStream(std::ostream* stream, double in);
1809:     DOCTEST_INTERFACE void toStream(std::ostream* stream, double long in);
1811:     DOCTEST_INTERFACE void toStream(std::ostream* stream, char in);
1812:     DOCTEST_INTERFACE void toStream(std::ostream* stream, char signed in);
1813:     DOCTEST_INTERFACE void toStream(std::ostream* stream, char unsigned in);
1814:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int short in);
1815:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int short unsigned in);
1816:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int in);
1817:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int unsigned in);
1818:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int long in);
1819:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int long unsigned in);
1822:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int long long in);
1823:     DOCTEST_INTERFACE void toStream(std::ostream* stream, int long long unsigned in);
1839:         { virtual void toStream(std::ostream*) const = 0; };
1849:                 doctest::detail::toStream(stream, *capture);
1873:                 reinterpret_cast<const ICapture*>(stackChunks[curr++].buf)->toStream(stream);
1877:                 reinterpret_cast<const ICapture*>(curr_elem->chunk.buf)->toStream(stream);
1985:             doctest::detail::toStream(m_stream, in);
4944:             : m_stream(createStream())
4991:     MessageBuilder::~MessageBuilder() { freeStream(m_stream); }
790:         yes& testStreamable(std::ostream&);
791:         no   testStreamable(no);
800:             static const bool value = sizeof(testStreamable(s << t)) == sizeof(yes);
812:     DOCTEST_INTERFACE String getStreamResult(std::ostream*);
831:             String result = getStreamResult(stream);
4970:         String info = getStreamResult(m_stream);
RSeqAn:inst/include/seqan/pipe/pool_sorter.h: [ ]
296:         typedef MergeStreamComparer<TValue, TCompare>   StreamComparer;
42:     struct MergeStreamComparer : public std::binary_function < PageBucket<TValue>,
47:         MergeStreamComparer(Compare &tmpC): C(tmpC) { }
186:         typedef MergeStreamComparer<TValue, TCompare>   TStreamComparer;
310:             pqueue(StreamComparer(_pool.handlerData.compare)) { }
315:             pqueue(StreamComparer(_pool.handlerData.compare)) { }
190:             MergeStreamComparer<Type, Compare> >        PQueue;
192:         typedef PriorityType<TPageBucket, TStreamComparer> TPrioQueue;
200:             pqueue(TStreamComparer(_pool.handlerArgs)) { }
300:             MergeStreamComparer<TValue, TCompare> >     TPrioQueue;
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())
Streamer:src/R_init_Streamer.c: [ ]
12: R_init_Streamer(DllInfo *info)
Streamer:inst/unitTests/test_Streamer.R: [ ]
1: test_Streamer_initialize_fields <- function()
14:     s1 <- setRefClass("Stream1",
15:                       contains="Stream",
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;
iBMQ:src/norm_gamma_generation.c: [ ]
166: double RngStream_N01 (RngStream r)
220: double RngStream_GA1 (const double a, RngStream r)
276: double RngStream_Beta(double aa, double bb, RngStream rng)
380: double RngStream_LogitBeta(double a, const double b, RngStream rng)
174:       i = (unsigned long int) RngStream_RandInt (r, 0, 255); /*  choose the step */
175:       j = (unsigned long int) RngStream_RandInt (r, 0, 16777216);
189:           U1 = RngStream_RandU01(r);
195:           U1 = 1.0 - RngStream_RandU01(r);
196:           U2 = RngStream_RandU01(r);
226:       double u = RngStream_RandU01 (r);
227:       return RngStream_GA1 (1.0 + a, r) * pow (u, 1.0 / a);
239:             x = RngStream_N01 (r);
245:         u =  RngStream_RandU01 (r);
261: 	RngStream rng;
262: 	rng = RngStream_CreateStream("");
267: 		out[i] = RngStream_Beta(*a, *b, rng);
270: 	RngStream_DeleteStream(rng);
327: 	    u1 = RngStream_RandU01(rng);
328: 	    u2 = RngStream_RandU01(rng);
359: 	    u1 = RngStream_RandU01(rng);
360: 	    u2 = RngStream_RandU01(rng);
384: 		top = (1.0/a)*log(RngStream_RandU01(rng)) + log(RngStream_GA1(1.0 + a,rng));
386: 		top = log(RngStream_GA1(a, rng));
390: 		bot = (1.0/b)*log(RngStream_RandU01(rng)) + log(RngStream_GA1(1.0 + b,rng));
392: 		bot = log(RngStream_GA1(b, rng));
408: 	RngStream rng;
409: 	rng = RngStream_CreateStream("");
414: 		out[i] = RngStream_LogitBeta(*a, *b, rng);
416: 	RngStream_DeleteStream(rng);
affxparser:src/fusion/file/TsvFile/TsvJoin.h: [ ]
121:   affx::TsvFile m_StreamTsv;
123:   std::vector<std::string> m_StreamColNames;
125:   std::string m_StreamKeyValue;
127:   std::vector<std::string> m_StreamData;
141:   unsigned int m_StreamDataColCount;
120:   /// Stream mode input file tsv object.
122:   /// Stream mode input file column names.
124:   /// Stream mode input file key value for row.
126:   /// Stream mode input file data values for row.
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);
rhdf5filters:src/blosc/lib/lz4-1.9.2/lz4hc.c: [ ]
951: LZ4_streamHC_t* LZ4_createStreamHC(void)
959: int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr)
968: LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size)
992: void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
998: void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
1166: int LZ4_sizeofStreamStateHC(void) { return LZ4_STREAMHCSIZE; }
1170: int LZ4_resetStreamStateHC(void* state, char* inputBuffer)
948: *  Streaming Functions
905:     LZ4_resetStreamHC_fast((LZ4_streamHC_t*)state, compressionLevel);
915:     LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
938:     LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
955:     LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));  /* full initialization, malloc'ed buffer can be full...(14 bytes skipped)...
961:     DEBUGLOG(4, "LZ4_freeStreamHC(%p)", LZ4_streamHCPtr);
980:     DEBUGLOG(4, "LZ4_initStreamHC(%p, %u)", LZ4_streamHCPtr, (unsigned)size);
994:     LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
1000:     DEBUGLOG(4, "LZ4_resetStreamHC_fast(%p, %d)", LZ4_streamHCPtr, compressionLevel);
1002:         LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
1039:         LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
1172:     LZ4_streamHC_t* const hc4 = LZ4_initStreamHC(state, sizeof(*hc4));
1180:     LZ4_streamHC_t* const hc4 = LZ4_createStreamHC();
1207:     LZ4_resetStreamHC_fast(ctx, ctx->internal_donotuse.compressionLevel);
seqbias:src/yaml-cpp/emitter.h: [ ]
115: 	inline Emitter& Emitter::WriteStreamable(T value)
65: 		Emitter& WriteStreamable(T value);
69: 		void PreWriteStreamable(std::stringstream& str);
71: 		void PostWriteStreamable(const std::stringstream& str);
121: 		PreWriteStreamable(str);
123: 		PostWriteStreamable(str);
148: 	inline Emitter& operator << (Emitter& emitter, float v) { return emitter.WriteStreamable(v); }
149: 	inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(v); }
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)
velociraptor:man/plotVelocityStream.Rd: [ ]
76: Plot velocities embedded into low-dimensional space as a stream plot. Stream
2: % Please edit documentation in R/plotVelocityStream.R
3: \name{plotVelocityStream}
4: \alias{plotVelocityStream}
7: plotVelocityStream(
90:   Streamlines are computed by simple integration with a forward Euler method,
108: plotVelocityStream(out, em)
109: plotVelocityStream(out, em, color.streamlines = TRUE)
Streamer:man/Streamer-package.Rd: [ ]
21:   The central paradigm in this package is a \code{Stream} composed of a
26:   transformations on it. The \code{\link{Stream}} function is used to
45:   main types of stream components. Use \code{\link{Stream}} to connect
61: s <- Stream(RawToChar(), Rev(), b)
68: s <- Stream(RawToChar(), d, b)
1: \name{Streamer-package}
2: \alias{Streamer-package}
3: \alias{Streamer}
4: \alias{Streamer-class}
52: packageDescription("Streamer")
59: fl <- system.file("extdata", "s_1_sequence.txt", package="Streamer")
Streamer:man/Stream-class.Rd: [ ]
1: \name{Stream}
4: \alias{Stream-class}
6: \alias{Stream}
7: \alias{Stream-methods}
8: \alias{Stream,Consumer-method}
9: \alias{Stream,Producer-method}
11: \alias{[[,Stream,numeric-method}
12: \alias{length,Stream-method}
13: \alias{lapply,Stream-method}
14: \alias{sapply,Stream-method}
22:   \code{yield} to \code{Stream} invokes \code{yield} on the terminal
30: Stream(x, ..., verbose=FALSE)
32: \S4method{length}{Stream}(x)
34: \S4method{[[}{Stream,numeric}(x, i, j, ...)
36: \S4method{lapply}{Stream}(X, FUN, ...)
38: \S4method{sapply}{Stream}(X, FUN, ..., simplify=TRUE, USE.NAMES=TRUE)
43:   \item{x, X}{For \code{Stream}, \code{x} is a \code{Producer}
44:   instance. For other functions, an instance of class \code{Stream}.}
52:   \item{...}{For \code{Stream}, zero or more \code{Consumer}
68:   Arguments to \code{Stream} must consist of a single \code{Producer}
72:   \code{Stream(P, C1, C2)} produces a stream in which the data is read
77:   argument. \code{Stream(C1, C2, P)} produces a stream in which the data
132: s <- Stream(b, Rev(), RawToChar())
139: strm <- Stream(Seq(to=10), FunctionConsumer(function(y) 1/y))
124:   \code{\link{Streamer-package}}, \code{\linkS4class{Consumer}-class},
130: fl <- system.file("extdata", "s_1_sequence.txt", package="Streamer")
Streamer:vignettes/StreamerClasses.xmi: [ ]
237: ...(63 bytes skipped)...mespace="Logical View" isAbstract="false" isLeaf="false" isRoot="false" xmi.id="5kYfIy6jEtAo" name="Stream">
33: ...(62 bytes skipped)...amespace="Logical View" isAbstract="true" isLeaf="false" isRoot="false" xmi.id="2MWMxkB40wg3" name="Streamer">
317: ...(82 bytes skipped)...snapy="10" linewidth="0" showattsig="1" showpubliconly="0" showpackage="1" showstereotype="1" name="Streamer Classes" font="Sans Serif,9,-1,0,50,0,0,0,0,0" canvasheight="612" canvaswidth="1458" localid="" s...(175 bytes skipped)...
441:      <listitem open="0" type="807" id="3wXoDzhETTKi" label="Streamer Classes"/>
Streamer:inst/unitTests/test_RevStream.R: [ ]
7:     s <- Stream(Rev(), RawInput(fl))
6:     fl <- system.file("extdata", "s_1_sequence.txt", package="Streamer")
OncoSimulR:src/UnityOncoSimul/exprtk.h: [ ]
39089:          template <typename Stream, typename Ptr>
39092:             Stream* stream = reinterpret_cast<Stream*>(p);
chopsticks:src/deflate.h: [ ]
58: /* Stream status */
CancerInSilico:src/Tests/catch.h: [ ]
639:     class Stream;
667:     Stream createStream( std::string const& streamName );
488:     //    >> +StreamEndStop
490:     //    >> stuff +StreamEndStop
491:     struct StreamEndStop {
497:     T const& operator + ( T const& value, StreamEndStop ) {
1200:     struct CopyableStream {
1201:         CopyableStream() {}
1202:         CopyableStream( CopyableStream const& other ) {
1205:         CopyableStream& operator=( CopyableStream const& other ) {
1262:         CopyableStream &stream()
1264:             if(!m_usedStream)
1266:                 m_usedStream = true;
1272:         static CopyableStream &m_stream()
1274:             static CopyableStream s;
1281:         bool m_usedStream;
2232:             __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
2240:             __catchResult << log + ::Catch::StreamEndStop(); \
3832:     class StreamBufBase : public std::streambuf {
3834:         virtual ~StreamBufBase() CATCH_NOEXCEPT;
3849:     struct IStream {
3850:         virtual ~IStream() CATCH_NOEXCEPT;
3854:     class FileStream : public IStream {
3857:         FileStream( std::string const& filename );
3858:         virtual ~FileStream() CATCH_NOEXCEPT;
3859:     public: // IStream
3863:     class CoutStream : public IStream {
3866:         CoutStream();
3867:         virtual ~CoutStream() CATCH_NOEXCEPT;
3869:     public: // IStream
3873:     class DebugOutStream : public IStream {
3874:         CATCH_AUTO_PTR( StreamBufBase ) m_streamBuf;
3877:         DebugOutStream();
3878:         virtual ~DebugOutStream() CATCH_NOEXCEPT;
3880:     public: // IStream
3966:             m_stream( openStream() )
4013:         IStream const* openStream() {
4015:                 return new CoutStream();
4018:                     return new DebugOutStream();
4023:                 return new FileStream( m_data.outputFilename );
4027:         CATCH_AUTO_PTR( IStream const ) m_stream;
6537:     class StreamRedirect {
6540:         StreamRedirect( std::ostream& stream, std::string& targetString )
6548:         ~StreamRedirect() {
6562:     // order of writes and cannot use StreamRedirect on its own
6839:                     StreamRedirect coutRedir( Catch::cout(), redirectedCout );
7632:     class StreamBufImpl : public StreamBufBase {
7637:         StreamBufImpl() {
7641:         ~StreamBufImpl() CATCH_NOEXCEPT {
7669:     FileStream::FileStream( std::string const& filename ) {
7678:     std::ostream& FileStream::stream() const {
7689:     DebugOutStream::DebugOutStream()
7690:     :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
7694:     std::ostream& DebugOutStream::stream() const {
7700:     CoutStream::CoutStream()
7704:     std::ostream& CoutStream::stream() const {
9108:         m_usedStream( false )
9231:         if(m_usedStream)
9565:     struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
9567:         StreamingReporterBase( ReporterConfig const& _config )
9578:         virtual ~StreamingReporterBase() CATCH_OVERRIDE;
9794:     struct TestEventListenerBase : StreamingReporterBase {
9796:         :   StreamingReporterBase( _config )
10132:     class XmlReporter : public StreamingReporterBase {
10135:         :   StreamingReporterBase( _config ),
10158:     public: // StreamingReporterBase
10161:             StreamingReporterBase::noMatchingTestCases( s );
10165:             StreamingReporterBase::testRunStarting( testInfo );
10175:             StreamingReporterBase::testGroupStarting( groupInfo );
10181:             StreamingReporterBase::testCaseStarting(testInfo);
10195:             StreamingReporterBase::sectionStarting( sectionInfo );
10284:             StreamingReporterBase::sectionEnded( sectionStats );
10299:             StreamingReporterBase::testCaseEnded( testCaseStats );
10315:             StreamingReporterBase::testGroupEnded( testGroupStats );
10325:             StreamingReporterBase::testRunEnded( testRunStats );
10595:     struct ConsoleReporter : StreamingReporterBase {
10597:         :   StreamingReporterBase( _config ),
10632:             StreamingReporterBase::sectionStarting( _sectionInfo );
10650:             StreamingReporterBase::sectionEnded( _sectionStats );
10654:             StreamingReporterBase::testCaseEnded( _testCaseStats );
10664:             StreamingReporterBase::testGroupEnded( _testGroupStats );
10670:             StreamingReporterBase::testRunEnded( _testRunStats );
11025:     struct CompactReporter : StreamingReporterBase {
11028:         : StreamingReporterBase( _config )
11077:             StreamingReporterBase::testRunEnded( _testRunStats );
11318:     IStream::~IStream() CATCH_NOEXCEPT {}
11319:     FileStream::~FileStream() CATCH_NOEXCEPT {}
11320:     CoutStream::~CoutStream() CATCH_NOEXCEPT {}
11321:     DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {}
11322:     StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
11343:     StreamingReporterBase::~StreamingReporterBase() {}
1542:     TrueType& testStreamable( std::ostream& );
1543:     FalseType testStreamable( FalseType );
1548:     struct IsStreamInsertable {
1551:         enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
1555:     class IsStreamInsertable {
1623:     Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
5737:     struct IStreamingReporter : IShared {
5738:         virtual ~IStreamingReporter();
5770:         virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
5779:         virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const = 0;
5784:     Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter );
6592:         explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
6904:         Ptr<IStreamingReporter> m_reporter;
6959:     Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
6960:         Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );...(1 bytes skipped)...
6973:     Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
6978:         Ptr<IStreamingReporter> reporter;
6985:     Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
6998:         Ptr<IStreamingReporter> reporter = makeReporter( config );
7414:         virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRID...(4 bytes skipped)...
8470:     class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
9399: class MultipleReporters : public SharedImpl<IStreamingReporter> {
9400:     typedef std::vector<Ptr<IStreamingReporter> > Reporters;
9404:     void add( Ptr<IStreamingReporter> const& reporter ) {
9408: public: // IStreamingReporter
9507: Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
9508:     Ptr<IStreamingReporter> resultingReporter;
9514:             resultingReporter = Ptr<IStreamingReporter>( multi );
9627:     struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
9816:             virtual IStreamingReporter* create( ReporterConfig const& config ) const {
9840:             // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
9848:             virtual IStreamingReporter* create( ReporterConfig const& config ) const {
9869:             virtual IStreamingReporter* create( ReporterConfig const& config ) const {
11334:     IStreamingReporter::~IStreamingReporter() {}
Rbowtie:src/sstring.h: [ ]
2599: // Stream put operators
SICtools:src/misc/bamcheck.c: [ ]
1487:         // Stream through the entire BAM ignoring off-target regions if -t is given
Rbowtie2:src/bowtie2-2.4.4/sstring.h: [ ]
2536: // Stream put operators
Rhtslib:src/htslib-1.15.1/htslib/synced_bcf_reader.h: [ ]
2: /// Stream through multiple VCF files.
ompBAM:inst/include/pbam_in.hpp: [ ]
141:     size_t          IS_LENGTH;     // size of BAM file (Input Stream Length)
Rfastp:src/FASTP/zlib/deflate.h: [ ]
61: /* Stream status */
Rhisat2:src/sstring.h: [ ]
2550: // Stream put operators
nanotatoR:R/RNASEQ_Analysis_Duo_Trio_SVMerge_SE.r: [ ]
1300:   ##Extracting NonOverlapped Down Stream Genes
1250:     print("###NonOverlapUPStreamGenes###")
1305:     print("###NonOverlapDNStreamGenes###")
zlibbioc:src/zlib-1.2.5/deflate.h: [ ]
58: /* Stream status */
RSeqAn:inst/include/seqan/stream/iostream_bgzf.h: [ ]
431:                             streamBuf->serializer.error = new IOError("Stream read error.");
464:                             streamBuf->serializer.error = new IOError("Stream read error.");
seqbias:src/yaml-cpp/exp.h: [ ]
175: 		std::string Escape(Stream& in);
nanotatoR:R/RNASEQ_Analysis_solo_SVMerge_SE.r: [ ]
715:   ##Extracting NonOverlapped Down Stream Genes
663:             print("###NonOverlapUPStreamGenes###") 
719:     print("###NonOverlapDNStreamGenes###") 
mzR:src/boost/endian/buffers.hpp: [ ]
179:   // Stream inserter
189:   // Stream extractor
seqTools:src/fa_traverse.h: [ ]
122: 	// Stream is not yet initialized.
65: 	daStream *das;
243: 	daStream *das = fat->das;
281: 	daStream *das=fat->das;
322: 	daStream *das = fat->das;
405: 	daStream *das=fat->das;
461: 	daStream *das = fat->das;
Streamer:R/Consumer-class.R: [ ]
53:         txt <- sprintf("Stream: %s", inp)
2:     contains="Streamer",
mzR:src/boost/locale/formatting.hpp: [ ]
272:             /// \defgroup manipulators I/O Stream manipulators
seqTools:src/fq_traverse.h: [ ]
96: 	// Stream is not yet initialized.
45: 	daStream *das;
123: 	daStream *das=faq->das;
177: 	daStream *das=faq->das;
191: 	daStream *das=faq->das;
228: 	daStream *das=faq->das;
313: 	daStream *das=faq->das;
mzR:src/boost/iostreams/compose.hpp: [ ]
363: template<typename Filter, typename Stream>
364: composite<Filter, Stream>
365: compose(const Filter& flt, const Stream& strm, mpl::true_)
367:     return composite<Filter, Stream>(flt, const_cast<Stream&>(strm));
rtracklayer:src/ucsc/bwgCreate.c: [ ]
196: /* Stream through section until get to end of file or next section,
275: /* Stream through section until get to end of file or next section,
XNAString:src/ViennaRNA/datastructures/char_stream.c: [ ]
2:  *  Buffered Character Stream
seqbias:src/yaml-cpp/scanscalar.h: [ ]
41: 	std::string ScanScalar(Stream& INPUT, ScanScalarParams& info);
affxparser:src/fusion/util/RowFile.h: [ ]
219:   /// Stream that we are reading from.
RSeqAn:inst/include/seqan/journaled_string_tree/journaled_string_tree_sequence_buffer.h: [ ]
382:     // Stream from the beginning to the expected range to get the begin positions of the current segment.
RSeqAn:inst/include/seqan/align/align_base.h: [ ]
473:  * @param[in,out] stream The Stream to write to.
601:  * @brief Stream-output for Align objects.
469:  * @brief Writing of Gaps to Streams in human-readable format.
603:  * @signature TStream operator<<(stream, align);
608:  * @return TStream Reference to stream after output of align.
613: template <typename TStream, typename TSource, typename TSpec>
614: inline TStream &
615: operator<<(TStream & target,
618:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
rRDP:vignettes/rRDP.bib: [ ]
2:     title = {{rEMM}: Extensible Markov Model for Data Stream Clustering in {R}},
seqbias:src/yaml-cpp/regeximpl.h: [ ]
26: 	inline bool RegEx::Matches(const Stream& in) const {
48: 	inline int RegEx::Match(const Stream& in) const
109: 		return source[0] == Stream::eof() ? 0 : -1;
50: 		StreamCharSource source(in);
RSeqAn:inst/include/seqan/basic/tuple_base.h: [ ]
242: // Function operator<<();  Stream Output.
260: template <typename TStream, typename TValue, unsigned SIZE, typename TSpec>
261: inline TStream &
262: operator<<(TStream & target,
265:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
mzR:src/boost/iostreams/detail/streambuf/chainbuf.hpp: [ ]
32: // Description: Stream buffer which operates by delegating to the first
Streamer:R/lapply-methods.R: [ ]
33: setMethod(lapply, "Stream", .lapply_Streamer)
52: setMethod(sapply, "Stream", .sapply_Streamer)
1: .lapply_Streamer <-
35: setMethod(lapply, "Producer", .lapply_Streamer)
37: .sapply_Streamer <-
54: setMethod(sapply, "Producer", .sapply_Streamer)
mzR:src/pwiz/utility/misc/unit.hpp: [ ]
31: #include "Stream.hpp"
mzR:src/boost/fusion/sequence/io/detail/manip.hpp: [ ]
23: #define FUSION_STRING_OF_STREAM(Stream)                                         \
25:         FUSION_GET_CHAR_TYPE(Stream)                                            \
26:       , FUSION_GET_TRAITS_TYPE(Stream)                                          \
46:         template <typename Stream, typename Tag, typename T>
65:             static void attach(Stream& stream, T const& data)
72:             static T const* get(Stream& stream)
78:         template <typename Tag, typename Stream>
83:             typedef FUSION_STRING_OF_STREAM(Stream) string_type;
85:             typedef stream_data<Stream, Tag, string_type> stream_data_t;
87:             string_ios_manip(Stream& str_)
145:             Stream& stream;
234:         template <typename Stream, typename Char, typename Traits>              \
235:         Stream& operator>>(Stream& s, const name##_type<Char,Traits>& m)        \
237:             string_ios_manip<name##_tag, Stream> manip(s);                      \
242:         template <typename Stream, typename Char, typename Traits>              \
243:         Stream& operator<<(Stream& s, const name##_type<Char,Traits>& m)        \
245:             string_ios_manip<name##_tag, Stream> manip(s);                      \
seqbias:src/yaml-cpp/regex.h: [ ]
14: 	class Stream;
37: 		bool Matches(const Stream& in) const;
41: 		int Match(const Stream& in) const;
chromstaR:src/R_interface.cpp: [ ]
14:  	//Output2FILE::Stream() = pFile;
281: 	//Output2FILE::Stream() = pFile;
isobar:inst/pl/pidresParser2.pl: [ ]
828:   my $parser = new XML::Parser(Style => 'Stream');
rtracklayer:src/bigBedHelper.c: [ ]
172:  *   2) Stream through the range tree, outputting the initial summary level and
176: struct bbiSumOutStream *stream = bbiSumOutStreamOpen(itemsPerSlot, f, doCompress);
266: bbiSumOutStreamClose(&stream);
AneuFinder:src/R_interface.cpp: [ ]
17: // 	Output2FILE::Stream() = pFile;
222: // 	Output2FILE::Stream() = pFile;
Rdisop:src/imslib/src/ims/tclap/XorHandler.h: [ ]
75: 		 * \param os - Stream to print to.
mzR:src/boost/thread/externally_locked_stream.hpp: [ ]
24:   template <typename Stream, typename RecursiveMutex=recursive_mutex>
27:   template <class Stream, typename RecursiveMutex=recursive_mutex>
31:     friend class externally_locked_stream<Stream, RecursiveMutex> ;
33:     typedef typename externally_locked_stream<Stream, RecursiveMutex>::mutex_type mutex_type;
37:     stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx) :
43:     stream_guard(externally_locked_stream<Stream, RecursiveMutex>& mtx, adopt_lock_t) :
67:     Stream& get() const
72:     Stream& bypass() const
79:     externally_locked_stream<Stream, RecursiveMutex>* mtx_;
82:   template <typename Stream, typename RecursiveMutex>
83:   struct is_strict_lock_sur_parole<stream_guard<Stream, RecursiveMutex> > : true_type
88:    * externally_locked_stream cloaks a reference to an stream of type Stream, and actually
94:   template <typename Stream, typename RecursiveMutex>
95:   class externally_locked_stream: public externally_locked<Stream&, RecursiveMutex>
97:     typedef externally_locked<Stream&, RecursiveMutex> base_type;
104:     externally_locked_stream(Stream& stream, RecursiveMutex& mtx) BOOST_NOEXCEPT :
109:     stream_guard<Stream, RecursiveMutex> hold() BOOST_NOEXCEPT
111:       return stream_guard<Stream, RecursiveMutex> (*this);
113:     Stream& bypass() const
115:       stream_guard<Stream, RecursiveMutex> lk(*this);
121:   template <typename Stream, typename RecursiveMutex, typename T>
122:   inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, T arg)
128:   template <typename Stream, typename RecursiveMutex>
129:   inline const stream_guard<Stream, RecursiveMutex>& operator<<(const stream_guard<Stream, RecursiveMutex>& lck, Stream& (*arg)(Stream&))
135:   template <typename Stream, typename RecursiveMutex, typename T>
136:   inline const stream_guard<Stream, RecursiveMutex>& operator>>(const stream_guard<Stream, RecursiveMutex>& lck, T& arg)
142:   template <typename Stream, typename RecursiveMutex, typename T>
143:   inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, T arg)
145:     stream_guard<Stream, RecursiveMutex> lk(mtx);
150:   template <typename Stream, typename RecursiveMutex>
151:   inline stream_guard<Stream, RecursiveMutex> operator<<(externally_locked_stream<Stream, RecursiveMutex>& mtx, Stream& (*arg)(Stream&))
153:     stream_guard<Stream, RecursiveMutex> lk(mtx);
158:   template <typename Stream, typename RecursiveMutex, typename T>
159:   inline stream_guard<Stream, RecursiveMutex> operator>>(externally_locked_stream<Stream, RecursiveMutex>& mtx, T& arg)
161:     stream_guard<Stream, RecursiveMutex> lk(mtx);
chromDraw:src/libBoard/include/board/Rect.h: [ ]
103:  * Stream output operator for Rect structure.
mzR:src/boost/date_time/gregorian/parsers.hpp: [ ]
78:   //! Stream should hold a date in the form of: 2002-1-25. Month number, abbrev, or name are accepted
RSeqAn:inst/include/seqan/parse_lm/local_match_store.h: [ ]
394:     typedef Stream<CharArray<char const *> > TCharArrayStream;
395:     TCharArrayStream cigarStream(&cigarStringBuffer[0], &cigarStringBuffer[0] + length(cigarStringBuffer));
396:     RecordReader<TCharArrayStream, SinglePass<> > recordReader(cigarStream);
Streamer:R/AllGenerics.R: [ ]
7: setGeneric("Stream",
8:     function(x, ..., verbose=FALSE) standardGeneric("Stream"),
Streamer:man/status.Rd: [ ]
23:   \item{x}{A \code{Stream}, \code{Producer}, or \code{Consumer} object.}
37:   \code{\link{Stream}}, \code{\linkS4class{Producer}},
43: ## see example(Stream)
5: \alias{status,Streamer-method}
19: \S4method{status}{Streamer}(x, ...)
Streamer:man/reset.Rd: [ ]
7: \title{Function to reset a Stream, Producer, or Consumer}
23:   \item{x}{A \code{Stream}, \code{Producer}, or \code{Consumer} object.}
40:   \code{\link{Stream}}, \code{\linkS4class{Producer}},
46: ## see example(Stream)
5: \alias{reset,Streamer-method}
Streamer:NAMESPACE: [ ]
32:     Stream,
1: useDynLib(Streamer, .registration=TRUE)
31:     Streamer,
Streamer:man/yield.Rd: [ ]
7: \title{Function to yield one task from a Stream or Producer}
23:   \item{x}{A \code{Stream}, \code{Producer}, or \code{Consumer} object.}
40:   \code{\link{Stream}}, \code{\linkS4class{Producer}},
46: ## see example(Stream)
5: \alias{yield,Streamer-method}
Doscheda:R/doscheda.R: [ ]
1: #' Doscheda: A package for Down Stream Chemo-Proteomics Data Analysis