Found 5605 results in 626 files, showing top 450 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
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);
gdsfmt:src/CoreArray/dBase.h: [ ]
705: 		COREARRAY_INLINE CdStream *Stream() const { return _Stream; }
717: 		CdStream *_Stream, *_BaseStream;
546: 	class COREARRAY_DLL_DEFAULT CdBufStream;
555: 	class COREARRAY_DLL_DEFAULT CdStream: public CdRef
635: 	class COREARRAY_DLL_DEFAULT CdBufStream;
653: 	class COREARRAY_DLL_DEFAULT CdBufStream: public CdRef
707: 		COREARRAY_INLINE CdStream *BaseStream() const { return _BaseStream; }
749: 		CdStream *fStream;
750: 		CLASS *fPStream;
787: 			SIZE64 StreamPos;
831: 	class COREARRAY_DLL_EXPORT ErrStream: public ErrCoreArray
834: 		ErrStream(): ErrCoreArray()
836: 		ErrStream(const char *fmt, ...): ErrCoreArray()
838: 		ErrStream(const std::string &msg): ErrCoreArray()
844: 	class COREARRAY_DLL_EXPORT ErrBufStream: public ErrCoreArray
847:         ErrBufStream(): ErrCoreArray()
849: 		ErrBufStream(const char *fmt, ...): ErrCoreArray()
851: 		ErrBufStream(const std::string &msg): ErrCoreArray()
630: 	const size_t BufStreamAlign = 4;  // 2^4 = 16 bytes aligned
638: 	class COREARRAY_DLL_DEFAULT CdStreamPipe: public CdAbstractItem
643: 		CdStreamPipe(): CdAbstractItem() {}
644: 		virtual ~CdStreamPipe() {}
730: 		class COREARRAY_DLL_DEFAULT CdStreamPipe2: public CdStreamPipe
733: 		CdStreamPipe2(): CdStreamPipe() { fStream = NULL; fPStream = NULL; }
759: 	class COREARRAY_DLL_EXPORT CdStreamIndex
543: 	// Stream Object
619: 	// Stream Buffer Object
738: 			fStream = BufStream->Stream();
739: 			fPStream = new CLASS(*BufStream->Stream());
554: 	/** CdStream provides basic interface for stream. **/
559: 		CdStream();
561: 		virtual ~CdStream();
601: 		/// copy from a CdStream object
606: 		virtual void CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count);
608: 		/// copy from a CdBufStream object
609: 		void CopyFromBuf(CdBufStream &Source, SIZE64 Pos, SIZE64 Count);
612: 		CdStream& operator= (const CdStream& m);
613: 		CdStream& operator= (CdStream& m);
622: 	/// Default buffer size in TBufdStream, 4K
624: 	/// Default small size of buffer in TBufdStream, 1K
626: 	/// Default large size of buffer in TBufdStream, 128K
633: 	// CdBufStream
641: 		friend class CdBufStream;
647: 		virtual CdStream *InitPipe(CdBufStream *BufStream) = 0;
648: 		virtual CdStream *FreePipe() = 0;
659: 		/** \param vStream    a stream object (it can be NULL)
662: 		CdBufStream(CdStream *vStream, ssize_t vBufSize=STREAM_BUFFER_SIZE);
664: 		virtual ~CdBufStream();
669: 		/// Copy from a CdStream object
670: 		void CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count);
671: 		/// Copy from a CdBufStream object
672: 		void CopyFromBuf(CdBufStream &Source, SIZE64 Pos, SIZE64 Count);
706: 		void SetStream(CdStream *Value);
714: 		TdOnNotify<CdBufStream> OnFlush;
736: 		virtual CdStream *InitPipe(CdBufStream *BufStream)
740: 			return fPStream;
742: 		virtual CdStream *FreePipe()
744: 			if (fPStream) { fPStream->Release(); fPStream = NULL; }
745: 			return fStream;
788: 			TPair(C_Int64 i, SIZE64 p) { Index = i; StreamPos = p; }
699: 		void PushPipe(CdStreamPipe* APipe);
724: 		std::vector<CdStreamPipe*> _PipeItems;
765: 		CdStreamIndex();
gdsfmt:src/CoreArray/dSerial.h: [ ]
157: 		COREARRAY_FORCEINLINE CdStream &Stream()
153: 		COREARRAY_FORCEINLINE CdBufStream &BufStream()
540: 			ctStream       ///< stream
154: 			{ return *fStorage.Stream; }
158: 			{ return *fStorage.Stream->Stream(); }
132: 		/** \param vBufStream    a stream buffer
136: 		CdSerialization(CdBufStream *vBufStream, CdLogRecord *vLog,
139: 		/** \param vStream       a stream object
143: 		CdSerialization(CdStream *vStream, CdLogRecord *vLog,
149: 		COREARRAY_FORCEINLINE BYTE_LE<CdBufStream> &Storage()
182: 		BYTE_LE<CdBufStream> fStorage;
247: 		/** \param vBufStream    a stream buffer
251: 		CdWriter(CdBufStream *vBufStream, CdLogRecord *vLog,
254: 		/** \param vStream       a stream object
258: 		CdWriter(CdStream *vStream, CdLogRecord *vLog,
358: 		/** \param vBufStream    a stream buffer
362: 		CdReader(CdBufStream *vBufStream, CdLogRecord *vLog,
365: 		/** \param vStream       a stream object
369: 		CdReader(CdStream *vStream, CdLogRecord *vLog,
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()
affxparser:src/fusion/util/MessageStream.h: [ ]
30: class MessageStream
39: 	MessageStream() { verbosity = 0; }
41:   virtual ~MessageStream() { }
23: #define _MessageStream_HEADER_
20: /* \file MessageStream.h Provides a base class for streaming messages from a component to its calling function. */
22: #ifndef _MessageStream_HEADER_
affxparser:src/fusion/util/LogStream.h: [ ]
44: class APTLIB_API LogStream : public MsgHandler, public ProgressHandler {
63:   std::ostream *m_Out;                      ///< Stream to print messages to
21:  * @file   LogStream.h
48:   LogStream(int verbosity=3, std::ostream *out=NULL, bool profile=true);
49:   ~LogStream();
50:   void setStream(std::ostream *out);
51:   void unsetStream(std::ostream *out);
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);
affxparser:src/fusion/util/MsgStream.h: [ ]
42: class MsgStream : public MsgHandler {
46:   MsgStream(int level, std::ostream *out=NULL) {
61:   std::ostream *m_Out;   ///< Stream to print messages to (cout by default.)
21:  * @file   MsgStream.h
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);
affxparser:src/fusion/util/OutputMessageStream.h: [ ]
32: class OutputMessageStream : public MessageStream
23: #define _OutputMessageStream_HEADER_
20: /* \file OutputMessageStream.h Provides streaming messages to a ofstream from a component to its calling function. */
22: #ifndef _OutputMessageStream_HEADER_
25: #include "util/MessageStream.h"
43: 	OutputMessageStream(int level, std::ostream *strm = &std::cout);
affxparser:src/fusion/util/OutputMessageStream.cpp: [ ]
30: OutputMessageStream::OutputMessageStream(int level, std::ostream *strm)
21: #include "util/OutputMessageStream.h"
39: void OutputMessageStream::Write(int level, const std::string &msg)
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))
ChemmineR:R/AllClasses.R: [ ]
2413: sdfStream <- function(input, output, append=FALSE, fct, Nlines=10000, startline=1, restartNlines=10000, silen...(15 bytes skipped)...
2406: ## (6.8) Streaming Through SD Files ##
2408: ## Streaming function to compute descriptors for large SD Files without consuming much memory.
2419: 	## For restarting sdfStream at specific line assigned to startline argument. If assigned
2521: # sdfStream(input="test.sdf", output="matrix.xls", fct=desc, Nlines=1000)
2530: ## as character strings to APset or FPset objects (e.g. generated by sdfStream).
2561: ## Extracts specific molecules from SD File based on a line position index computed by the sdfStream function
2592: ## Usage: see sdfStream()
Rmmquant:src/mmquant.h: [ ]
658:   std::ostream &getOutputStream () {
662:   std::ostream &getStatsStream () {
1814:         parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";
1816:           parameters.getOutputStream() << " \"" << arg << "\"";
1818:         parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";
1821:         parameters.getOutputStream() << "Gene";
1824:         parameters.getOutputStream() << "\t" << sample;
1826:       parameters.getOutputStream() << "\n";
1828:           parameters.getOutputStream() << line.first;
1830:               parameters.getOutputStream() << "\t" << i;
1832:           parameters.getOutputStream() << "\n";
1923:     dumpStats(parameters.getStatsStream(), parameters.names, stats);
Director:inst/www/js/d3.v3.js: [ ]
4246:   function d3_geo_pathProjectStream(project) {
3878:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3881:           lower48Stream.point(x, y);
3886:           lower48Stream.sphere();
3891:           lower48Stream.lineStart();
3896:           lower48Stream.lineEnd();
3901:           lower48Stream.polygonStart();
3906:           lower48Stream.polygonEnd();
3862:     var point, pointStream = {
3882:           alaskaStream.point(x, y);
3883:           hawaiiStream.point(x, y);
3887:           alaskaStream.sphere();
3888:           hawaiiStream.sphere();
3892:           alaskaStream.lineStart();
3893:           hawaiiStream.lineStart();
3897:           alaskaStream.lineEnd();
3898:           hawaiiStream.lineEnd();
3902:           alaskaStream.polygonStart();
3903:           hawaiiStream.polygonStart();
3907:           alaskaStream.polygonEnd();
3908:           hawaiiStream.polygonEnd();
3929: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3930: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3931: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
4200:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
4203:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
4204:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
4205:         d3.geo.stream(object, cacheStream);
4207:       return contextStream.result();
4211:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
4216:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4221:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4226:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
4231:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
4232:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
4237:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
4241:       cacheStream = null;
affxparser:src/fusion/file/TsvFile/TsvFile.h: [ ]
472:   std::fstream m_fileStream;
579:   int isFileOpen() { return (m_fileStream.is_open()? TSV_OK : TSV_ERR_FILEIO); }
581:   bool is_open() { return m_fileStream.is_open(); }
582:   bool good() { return m_fileStream.good(); }
Gviz:R/DataTrack-class.R: [ ]
356:     isStream <- FALSE
366:         isStream <- TRUE
400:     if (!isStream) {
LACE:inst/htmlwidgets/lib/d3.v4.js: [ ]
6898:     function geoStream(object, stream) {
7424:     function circleStream(stream, radius, delta, direction, t0, t1) {
8978:     function TransformStream() {}
9343:             point, pointStream = {point: function(x, y) { point = [x, y]; }};
6915:     var areaStream = {
6921:             areaStream.lineStart = areaRingStart;
6922:             areaStream.lineEnd = areaRingEnd;
6935:         areaStream.point = areaPointFirst;
6943:         areaStream.point = areaPoint;
6972:         geoStream(object, areaStream);
7020:     var boundsStream = {
7025:             boundsStream.point = boundsRingPoint;
7026:             boundsStream.lineStart = boundsRingStart;
7027:             boundsStream.lineEnd = boundsRingEnd;
7029:             areaStream.polygonStart();
7032:             areaStream.polygonEnd();
7033:             boundsStream.point = boundsPoint;
7034:             boundsStream.lineStart = boundsLineStart;
7035:             boundsStream.lineEnd = boundsLineEnd;
7099:         boundsStream.point = linePoint;
7104:         boundsStream.point = boundsPoint;
7115:         areaStream.point(lambda, phi);
7120:         areaStream.lineStart();
7125:         areaStream.lineEnd();
7151:         geoStream(feature, boundsStream);
7200:     var centroidStream = {
7206:             centroidStream.lineStart = centroidRingStart;
7207:             centroidStream.lineEnd = centroidRingEnd;
7210:             centroidStream.lineStart = centroidLineStart;
7211:             centroidStream.lineEnd = centroidLineEnd;
7230:         centroidStream.point = centroidLinePointFirst;
7239:         centroidStream.point = centroidLinePoint;
7258:         centroidStream.point = centroidPoint;
7264:         centroidStream.point = centroidRingPointFirst;
7269:         centroidStream.point = centroidPoint;
7275:         centroidStream.point = centroidRingPoint;
7310:         geoStream(object, centroidStream);
7470:             circleStream(stream, r, p, 1);
7906:             circleStream(stream, radius, delta, direction, from, to);
8182:             var activeStream = stream,
8183:                 bufferStream = clipBuffer(),
8192:             var clipStream = {
8201:                 if (visible(x, y)) activeStream.point(x, y);
8220:                 activeStream = bufferStream, segments = [], polygon = [], clean = true;
8239:                 activeStream = stream, segments = polygon = ring = null;
8243:                 clipStream.point = linePoint;
8256:                     if (v__ && v_) bufferStream.rejoin();
8257:                     segments.push(bufferStream.result());
8259:                 clipStream.point = point;
8260:                 if (v_) activeStream.lineEnd();
8270:                         activeStream.lineStart();
8271:                         activeStream.point(x, y);
8274:                     if (v && v_) activeStream.point(x, y);
8280:                                 activeStream.lineStart();
8281:                                 activeStream.point(a[0], a[1]);
8283:                             activeStream.point(b[0], b[1]);
8284:                             if (!v) activeStream.lineEnd();
8287:                             activeStream.lineStart();
8288:                             activeStream.point(x, y);
8296:             return clipStream;
8306:             cacheStream,
8311:                 return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream);
8314: ...(16 bytes skipped)...return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];
8324:     var lengthStream = {
8334:         lengthStream.point = lengthPointFirst;
8335:         lengthStream.lineEnd = lengthLineEnd;
8339:         lengthStream.point = lengthStream.lineEnd = noop$1;
8345:         lengthStream.point = lengthPoint;
8364:         geoStream(object, lengthStream);
8607:     var areaStream$1 = {
8612:             areaStream$1.lineStart = areaRingStart$1;
8613:             areaStream$1.lineEnd = areaRingEnd$1;
8616:             areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;
8628:         areaStream$1.point = areaPointFirst$1;
8632:         areaStream$1.point = areaPoint$1;
8650:     var boundsStream$1 = {
8686:     var centroidStream$1 = {
8691:             centroidStream$1.lineStart = centroidRingStart$1;
8692:             centroidStream$1.lineEnd = centroidRingEnd$1;
8695:             centroidStream$1.point = centroidPoint$1;
8696:             centroidStream$1.lineStart = centroidLineStart$1;
8697:             centroidStream$1.lineEnd = centroidLineEnd$1;
8718:         centroidStream$1.point = centroidPointFirstLine;
8722:         centroidStream$1.point = centroidPointLine;
8735:         centroidStream$1.point = centroidPoint$1;
8739:         centroidStream$1.point = centroidPointFirstRing;
8747:         centroidStream$1.point = centroidPointRing;
8817:     var lengthStream$1 = {
8820:             lengthStream$1.point = lengthPointFirst$1;
8824:             lengthStream$1.point = noop$1;
8840:         lengthStream$1.point = lengthPoint$1;
8912:             projectionStream,
8913:             contextStream;
8917:                 if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
8918:                 geoStream(object, projectionStream(contextStream));
8920:             return contextStream.result();
8924:             geoStream(object, projectionStream(areaStream$1));
8925:             return areaStream$1.result();
8929:             geoStream(object, projectionStream(lengthStream$1));
8930:             return lengthStream$1.result();
8934:             geoStream(object, projectionStream(boundsStream$1));
8935:             return boundsStream$1.result();
8939:             geoStream(object, projectionStream(centroidStream$1));
8940:             return centroidStream$1.result();
8944:             return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;
8949:             contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);
8950:             if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
8956:             pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
8971:             var s = new TransformStream;
8980:     TransformStream.prototype = {
8981:         constructor: TransformStream,
8994:         geoStream(object, projection.stream(boundsStream$1));
8995:         fitBounds(boundsStream$1.result());
9083:             var resampleStream = {
9087:                 polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },
9088:                 polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }
9098:                 resampleStream.point = linePoint;
9109:                 resampleStream.point = point;
9115:                 resampleStream.point = ringPoint;
9116:                 resampleStream.lineEnd = ringEnd;
9121:                 resampleStream.point = linePoint;
9126:                 resampleStream.lineEnd = lineEnd;
9130:             return resampleStream;
9163:             cacheStream;
9180:             return cache && cacheStream...(9 bytes skipped)...am ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
9244:             cache = cacheStream = null;
9339:             cacheStream,
9363:             return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
9385:                 .stream(pointStream);
9390:                 .stream(pointStream);
9395:                 .stream(pointStream);
9417:             cache = cacheStream = null;
9621:             cacheStream,
9625:             cache = cacheStream = null;
9631:                 return cache && cacheStream === stream ? cache : cache = transform$$1(postclip(cacheStream = stream));
16942:     exports.geoStream = geoStream;
rhdf5filters:src/blosc/lib/zstd-1.4.5/zstd.h: [ ]
641: typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */
761: typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
1308:  *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
56:     - unbounded multiple steps (described as Streaming compression)
240:  *   "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
371: ...(8 bytes skipped)...                      * When nbWorkers >= 1, triggers asynchronous mode when used with ZSTD_compressStream*() :
372:                               * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
374: ...(13 bytes skipped)...                 * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
375:                               *  in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
459:  *           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
509:  * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
563: *  Streaming
581: *  Streaming compression - HowTo
583: *  A ZSTD_CStream object is required to track streaming operation.
584: *  Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
585: *  ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
586: *  It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
588: *  For parallel execution, use one separate ZSTD_CStream per thread.
590: *  note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
599: *  Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to
616: *  using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.
618: *  In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.
619: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the
627: *  Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.
630: *  flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.
631: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to
643: /*===== ZSTD_CStream management functions =====*/
644: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
645: ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);
647: /*===== Streaming compression functions =====*/
661: /*! ZSTD_compressStream2() :
662:  *  Behaves about the same as ZSTD_compressStream, with additional control on end directive.
682: ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
689:  * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
690:  * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),
707:  * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().
720: ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
722:  * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
723:  * NOTE: The return value is different. ZSTD_compressStream() returns a hint for
724:  * the next read size (if non-zero and not an error). ZSTD_compressStream2()
727: ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
728: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */
729: ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
730: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */
731: ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
735: *  Streaming decompression - HowTo
737: *  A ZSTD_DStream object is required to track streaming operations.
738: *  Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
739: *  ZSTD_DStream objects can be re-used multiple times.
741: *  Use ZSTD_initDStream() to start a new decompression operation.
745: *  Use ZSTD_decompressStream() repetitively to consume your input.
752: *  In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
763: /*===== ZSTD_DStream management functions =====*/
764: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
765: ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);
767: /*===== Streaming decompression functions =====*/
774: ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
776: ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
898:  * ZSTD_compressStream2(), and ZSTD_decompress(). Dictionaries are sticky, and
991:  *  End of frame is reached when ZSTD_decompressStream() returns 0.
996:  *           reached when ZSTD_decompressStream() returns 0.
1012: ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
1013: ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
1304:  *  Note : CStream size estimation is only correct for single-threaded compression.
1305:  *  ZSTD_DStream memory budget depends on window Size.
1343:  *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
1348: ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
1351: ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */
1378: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
1380: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
1540:  *  - ZSTD_compressStream2() : Do compression using the CCtx.
1591: /*! ZSTD_compressStream2_simpleArgs() :
1592:  *  Same as ZSTD_compressStream2(),
1597: ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs (
1694: /*! ZSTD_decompressStream_simpleArgs() :
1695:  *  Same as ZSTD_decompressStream(),
1700: ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs (
1713: /*=====   Advanced Streaming compression functions  =====*/
1714: /**! ZSTD_initCStream_srcSize() :
1727: ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,
1731: /**! ZSTD_initCStream_usingDict() :
1744: ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,
1748: /**! ZSTD_initCStream_advanced() :
1764: ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
1769: /**! ZSTD_initCStream_usingCDict() :
1777: ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);
1779: /**! ZSTD_initCStream_usingCDict_advanced() :
1789:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters.
1795: ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
1800: /*! ZSTD_resetCStream() :
1807:  *  Note that zcs must be init at least once before using ZSTD_resetCStream().
1815: ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
1851: /*=====   Advanced Streaming decompression functions  =====*/
1861: ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
1872: ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);
1882: ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
701: ZSTDLIB_API size_t ZSTD_CStreamInSize(void);    /**< recommended size for input buffer */
702: ZSTDLIB_API size_t ZSTD_CStreamOutSize(void);   /**< recommended size for output buffer. Guarantee to successfully flush at least o...(32 bytes skipped)...
778: ZSTDLIB_API size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */
779: ZSTDLIB_API size_t ZSTD_DStreamOutSize(void);   /*!< recommended size for output buffer. Guarantee to successfully flush at least o...(42 bytes skipped)...
1276:  *  Note : Unlike ZSTD_estimateCStreamSize*(), this estimate
1298: /*! ZSTD_estimateCStreamSize() :
1299:  *  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
1301:  *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
1302:  *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionL...(5 bytes skipped)...
1303:  *  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-thread...(97 bytes skipped)...
1306:  *  This information can be passed manually, using ZSTD_estimateDStreamSize,
1307:  *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
1311: ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
1312: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
1313: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
1314: ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
1315: ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
seqTools:src/dna_fasta_stream.h: [ ]
52: } fafStream;
207: } faStream;
215: void faStream_destroy(faStream *fa)
275: faStream * faStream_init(const char* filename, unsigned k, unsigned mode)
135: // fasta Stream
54: static inline unsigned faf_isEof(fafStream *faf) { return faf->status & faf_file_eof; }
55: static inline unsigned faf_isOpen(fafStream *faf)
62: static fafStream* faf_stream_init(const char* filename, unsigned mode)
64: 	// Construct fafStream object from opened file
65: 	fafStream *faf = calloc(sizeof(fafStream), 1);
87: static void faf_destroy(fafStream *faf)
99: static size_t inline faf_read(fafStream *faf, char *dest, unsigned size)
187: 	fafStream *fasta;
230: int fas_fill(faStream *fa)
279: 		printf("[faStream_init] k > fas_size!\n");
283: 	faStream *fa = calloc(sizeof(faStream), 1);
292: 		printf("[faStream_init] Cannot open file '%s'!\n", filename);
293: 		faStream_destroy(fa);
308: 		printf("[faStream_init] Initial array filling failed!\n");
309: 		faStream_destroy(fa);
321: static inline int fas_fas_end(faStream *fa)		{ return fa->ffc == 0; }
322: static inline int fas_nuc_end(faStream *fa)		{ return fa->fnc == 0; }
333: static inline int fas_checkNewLine(faStream *fa)
343: static inline int fas_skipNewLine(faStream *fa)
366: static inline int fas_skipLine(faStream *fa)
386: static inline int fas_checkNewSeq(faStream *fa)
399: static inline int fas_skipSeqHeader(faStream *fa)
412: static inline int fas_checkComment(faStream *fa)
422: static inline int fas_skipComment(faStream *fa)
435: static inline int fas_checkN(faStream *fa)
445: static inline int fas_skipN(faStream *fa)
496: char * fas_getSeqName(faStream *fa)
551: int fas_initSeq(faStream *fa)
592: static inline int fas_returnFromTranfer(faStream *fa)
626: int fas_TransferNucArray(faStream *fa)
697: int fa_empty(faStream *fa)    { return (fa->stream_state & fas_stream_empty); }
698: int fa_NucReady(faStream *fa) { return (fa->stream_state & fas_nuc_ready);    }
699: int fa_K_Ready(faStream *fa)  { return (fa->stream_state & fas_loc_kReady);   }
700: int fa_NewSeq(faStream *fa)   { return (fa->stream_state & fas_loc_newSeq);   }
701: int fa_N_Nuc(faStream *fa)    { return (ACGTN[(unsigned)*fa->iter] == nval);  }
704: void fa_unsetNucReady(faStream *fa)
interacCircos:inst/htmlwidgets/lib/d3.js: [ ]
3639:   function d3_geo_pathProjectStream(project) {
3271:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3274:           lower48Stream.point(x, y);
3279:           lower48Stream.sphere();
3284:           lower48Stream.lineStart();
3289:           lower48Stream.lineEnd();
3294:           lower48Stream.polygonStart();
3299:           lower48Stream.polygonEnd();
3255:     var point, pointStream = {
3275:           alaskaStream.point(x, y);
3276:           hawaiiStream.point(x, y);
3280:           alaskaStream.sphere();
3281:           hawaiiStream.sphere();
3285:           alaskaStream.lineStart();
3286:           hawaiiStream.lineStart();
3290:           alaskaStream.lineEnd();
3291:           hawaiiStream.lineEnd();
3295:           alaskaStream.polygonStart();
3296:           hawaiiStream.polygonStart();
3300:           alaskaStream.polygonEnd();
3301:           hawaiiStream.polygonEnd();
3322: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3323: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3324: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3593:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
3596:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
3597:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
3598:         d3.geo.stream(object, cacheStream);
3600:       return contextStream.result();
3604:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
3609:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
3614:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
3619:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
3624:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
3625:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
3630:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
3634:       cacheStream = null;
Gviz:R/AnnotationTrack-class.R: [ ]
327:     isStream <- FALSE
350:         isStream <- TRUE
363:         if (!isStream) {
gdsfmt:src/CoreArray/dAllocator.h: [ ]
140: 		COREARRAY_FORCEINLINE CdBufStream *BufStream()
177: 		CdBufStream *_BufStream;
70: 		void Initialize(CdStream &Stream, bool CanRead, bool CanWrite);
137: 		void CopyTo(CdBufStream &Obj, SIZE64 Pos, SIZE64 Count);
141: 			{ return _BufStream; }
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: [ ]
370: getRNGStream <- function() {
379: setRNGStream <- function(seed = NULL) {
385: generateRNGStreams <- function(n = 1) {
387: 	s <- getRNGStream()
396: 			s <- nextRNGStream(seeds[[i - 1]])
BUSseq:src/rngstream.cpp: [ ]
303: RngStream::RngStream (const char *s) : name (s)
327: void RngStream::ResetStartStream ()
325: // Reset Stream to beginning of Stream.
335: // Reset Stream to beginning of SubStream.
345: // Reset Stream to NextSubStream.
3:  * File:           RngStream.cpp for multiple streams of Random Numbers
242: double RngStream::U01 ()
271: double RngStream::U01d ()
292: // declared RngStream, unless SetPackageSeed is called.
294: double RngStream::nextSeed[6] =
309:    state of the stream, the starting state of the current SubStream, and the
313:    will be the seed of the next declared RngStream. */
337: void RngStream::ResetStartSubstream ()
347: void RngStream::ResetNextSubstream ()
357: bool RngStream::SetPackageSeed (const unsigned long seed[6])
368: bool RngStream::SetSeed (const unsigned long seed[6])
384: void RngStream::AdvanceState (long e, long c)
415: void RngStream::GetState (unsigned long seed[6]) const
424: void RngStream::WriteState () const
439: void RngStream::WriteStateFull () const
443:     cout << "The RngStream";
470: void RngStream::IncreasedPrecis (bool incp)
477: void RngStream::SetAntithetic (bool a)
486: double RngStream::RandU01 ()
498: int RngStream::RandInt (int low, int high)
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/LZ4/lz4.c: [ ]
1486: LZ4_stream_t* LZ4_createStream(void)
1507: LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
1519: void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
1530: int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
1525: void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
2462: LZ4_streamDecode_t* LZ4_createStreamDecode(void)
2468: int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
2482: int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
2699: int LZ4_sizeofStreamState(void) { return sizeof(LZ4_stream_t); }
2701: int LZ4_resetStreamState(void* state, char* inputBuffer)
201:  *  - lz4   : LZ4_createStream, LZ4_freeStream,
1348:     LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
1375:  * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
1446:     void* const s = LZ4_initStream(state, sizeof (*state));
1482: *  Streaming functions
1490:     DEBUGLOG(4, "LZ4_createStream %p", lz4s);
1492:     LZ4_initStream(lz4s, sizeof(*lz4s));
1509:     DEBUGLOG(5, "LZ4_initStream");
1517: /* resetStream is now deprecated,
1518:  * prefer initStream() which is more general */
1521:     DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
1533:     DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
1555:     LZ4_resetStream(LZ4_dict);
1583: void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream)
1585:     const LZ4_stream_t_internal* dictCtx = (dictionaryStream == NULL) ? NULL :
1586:         &(dictionaryStream->internal_donotuse);
1589:              workingStream, dictionaryStream,
1598:         if (workingStream->internal_donotuse.currentOffset == 0) {
1599:             workingStream->internal_donotuse.currentOffset = 64 KB;
1608:     workingStream->internal_donotuse.dictCtx = dictCtx;
2697: /* Obsolete Streaming functions */
2704:     LZ4_resetStream((LZ4_stream_t*)state);
2712:     return LZ4_createStream();
202:  *            LZ4_createStreamDecode, LZ4_freeStreamDecode, LZ4_create (deprecated)
203:  *  - lz4hc : LZ4_createStreamHC, LZ4_freeStreamHC,
2476: /*! LZ4_setStreamDecode() :
2521:     and indicate where it stands using LZ4_setStreamDecode()
RSeqAn:inst/include/seqan/stream/file_stream.h: [ ]
1138: class FileStream :
1143:     typedef typename BasicStream<TValue, TDirection>::Type  TBasicStream;
1147:     FileStream() :
1151:     FileStream(const char * fileName, int openMode = DefaultOpenMode<FileStream>::VALUE) :
1157:     ~FileStream()
1198:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
1215:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
804: struct FileStreamBuffer :
831:     FileStreamBuffer()
836:     ~FileStreamBuffer()
1142:     typedef FileStreamBuffer<TValue, TDirection, TSpec>     TStreamBuffer;
1115: class FileStream;
1119: close(FileStream<TValue, TDirection, TSpec> & stream);
1130: struct DefaultOpenMode<FileStream<TValue, TDirection, TSpec>, TDummy>:
1134: // Class FileStream
1139:     public BasicStream<TValue, TDirection>::Type
1148:         TBasicStream(&buffer)
1152:         TBasicStream(&buffer)
1188: struct Value<FileStream<TValue, TDirection, TSpec> >:
1199:     typedef typename TStream_::TFile TFile_;
1205: struct Position<FileStream<TValue, TDirection, TSpec> >:
1216:     typedef typename TStream_::TFile TFile_;
1222: struct Size<FileStream<TValue, TDirection, TSpec> >:
1230: SEQAN_CONCEPT_IMPL((FileStream<TValue, Input, TSpec>), (InputStreamConcept));
1233: SEQAN_CONCEPT_IMPL((FileStream<TValue, Output, TSpec>), (OutputStreamConcept));
1236: SEQAN_CONCEPT_IMPL((FileStream<TValue, Bidirectional, TSpec>), (BidirectionalStreamConcept));
1257: open(FileStream<TValue, TDirection, TSpec> & stream, const char * fileName, int openMode = DefaultOpenMode<FileStream<TValue, TDirection, TSpec> >::VALUE)
1301: close(FileStream<TValue, TDirection, TSpec> & stream)
800: // Class FileStreamBuffer
1099: clear(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
1145:     TStreamBuffer buffer;
1182: struct Value<FileStreamBuffer<TValue, TDirection, TSpec> >
1189:     Value<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1196: struct Position<FileStreamBuffer<TValue, TDirection, TSpec> >
1206:     Position<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1213: struct Size<FileStreamBuffer<TValue, TDirection, TSpec> >
1223:     Size<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1293: close(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
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/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(
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);
Gviz:R/GeneRegionTrack-class.R: [ ]
350:     isStream <- FALSE
382:         isStream <- TRUE
396:     if (!isStream) {
CytoML:inst/include/CytoML/wsNode.hpp: [ ]
43:     class CytoStream : public std::ostream {
46:         CytoStream() : std::ostream(&cytobuf){}
54: extern CytoML::CytoStream  cytocout;
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)
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;
seqbias:src/yaml-cpp/scanner.h: [ ]
121: 		bool m_startedStream, m_endedStream;
115: 		Stream INPUT;
54: 		void StartStream();
55: 		void EndStream();
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(); }
gdsfmt:src/LZ4/lz4frame.c: [ ]
639: static void LZ4F_initStream(void* ctx,
494:         LZ4_initStream(&lz4ctx, sizeof(lz4ctx));
544:         LZ4_initStream(cdict->fastCtx, sizeof(LZ4_stream_t));
547:         LZ4_initStream(cdict->HCCtx, sizeof(LZ4_streamHC_t));
651:             LZ4_resetStream_fast((LZ4_stream_t*)ctx);
702:                     LZ4_initStream(cctxPtr->lz4CtxPtr, sizeof(LZ4_stream_t));
715:                 LZ4_initStream((LZ4_stream_t*)cctxPtr->lz4CtxPtr, sizeof(LZ4_stream_t));
747:         LZ4F_initStream(cctxPtr->lz4CtxPtr, cdict, cctxPtr->prefs.compressionLevel, LZ4F_blockLinked);
857:     LZ4F_initStream(ctx, cdict, level, LZ4F_blockIndependent);
875:     LZ4F_initStream(ctx, cdict, level, LZ4F_blockIndependent);
1272: /*==---   Streaming Decompression operations   ---==*/
655:         LZ4_resetStreamHC_fast((LZ4_streamHC_t*)ctx, level);
706:                     LZ4_initStreamHC(cctxPtr->lz4CtxPtr, sizeof(LZ4_streamHC_t));
717:                 LZ4_initStreamHC((LZ4_streamHC_t*)cctxPtr->lz4CtxPtr, sizeof(LZ4_streamHC_t));
rhdf5filters:src/blosc/lib/zstd-1.4.5/decompress/zstd_decompress.c: [ ]
1265: ZSTD_DStream* ZSTD_createDStream(void)
1271: ZSTD_DStream* ZSTD_initStaticDStream(void *workspace, size_t workspaceSize)
1281: size_t ZSTD_freeDStream(ZSTD_DStream* zds)
1343: size_t ZSTD_initDStream(ZSTD_DStream* zds)
1362: size_t ZSTD_resetDStream(ZSTD_DStream* dctx)
1479: size_t ZSTD_sizeof_DStream(const ZSTD_DStream* dctx)
1559: static size_t ZSTD_decompressContinueStream(
1588: size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
1276: ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem)
1334: size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize)
1352: size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* dctx, const ZSTD_DDict* ddict)
1873: size_t ZSTD_decompressStream_simpleArgs (
1289: size_t ZSTD_DStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX + ZSTD_blockHeaderSize; }
1290: size_t ZSTD_DStreamOutSize(void) { return ZSTD_BLOCKSIZE_MAX; }
1495: size_t ZSTD_estimateDStreamSize(size_t windowSize)
1503: size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
35:  *  maximum window size accepted by DStream __by default__.
45:  *  maximum allowed nb of calls to ZSTD_decompressStream()
837: *   Advanced Streaming Decompression API
959:                 dctx->expected = 0;  /* Streaming not supported */
970:                 dctx->expected = 0;  /* Streaming not supported */
1262: *   Streaming decompression
1267:     DEBUGLOG(3, "ZSTD_createDStream");
1268:     return ZSTD_createDStream_advanced(ZSTD_defaultCMem);
1331: /* ZSTD_initDStream_usingDict() :
1336:     DEBUGLOG(4, "ZSTD_initDStream_usingDict");
1345:     DEBUGLOG(4, "ZSTD_initDStream");
1346:     return ZSTD_initDStream_usingDDict(zds, NULL);
1349: /* ZSTD_initDStream_usingDDict() :
1359: /* ZSTD_resetDStream() :
1518: static int ZSTD_DCtx_isOverflow(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1523: static void ZSTD_DCtx_updateOversizedDuration(ZSTD_DStream* zds, size_t const neededInBuffSize, size_t const neededOutBuffSize)
1531: static int ZSTD_DCtx_isOversizedTooLong(ZSTD_DStream* zds)
1537: static size_t ZSTD_checkOutBuffer(ZSTD_DStream const* zds, ZSTD_outBuffer const* output)
1554: /* Calls ZSTD_decompressContinue() with the right parameters for ZSTD_decompressStream()
1560:             ZSTD_DStream* zds, char** op, char* oend,
1600:     DEBUGLOG(5, "ZSTD_decompressStream");
1632:                 {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);
1646:                         DEBUGLOG(5, "ZSTD_decompressStream: detected legacy version v0.%u", legacyVersion);
1649:                         FORWARD_IF_ERROR(ZSTD_initLegacyStream(&zds->legacyContext,
1653:                         {   size_t const hint = ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
1771:                     FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, ip, neededInSize), "");
1801:                 FORWARD_IF_ERROR(ZSTD_decompressContinueStream(zds, &op, oend, zds->inBuff, neededInSize), "");
1881:     size_t const cErr = ZSTD_decompressStream(dctx, &output, &input);
171:             ZSTD_freeLegacyStreamContext(dctx->legacyContext, dctx->previousLegacyVersion);
1512:     return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
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);
gdsfmt:src/CoreArray/dStruct.cpp: [ ]
1330: void CdAllocArray::GetOwnBlockStream(vector<const CdBlockStream*> &Out) const
1336: void CdAllocArray::GetOwnBlockStream(vector<CdStream*> &Out)
181: SIZE64 CdContainer::GDSStreamSize()
1314: SIZE64 CdAllocArray::GDSStreamSize()
1253: 					*(Src->fAllocator.BufStream()->Stream()),
1296: 		CdStream *s = Allocator().BufStream()->Stream();
889: 	vAllocStream = NULL;
897: 	if (fGDSStream) Synchronize();
962: 	if (fGDSStream) SaveToBlockStream();
1041: 		if (fGDSStream) SaveToBlockStream();
1113: 	if (fGDSStream && (!fGDSStream->ReadOnly()) && fNeedUpdate)
1115: 		if (fAllocator.BufStream())
1116: 			fAllocator.BufStream()->FlushWrite();
1123: 	if (fAllocator.BufStream())
1125: 		fAllocator.BufStream()->OnFlush.Clear();
1126: 		fAllocator.BufStream()->FlushWrite();
1129: 			if (fPipeInfo->WriteMode(*fAllocator.BufStream()))
1131:             	fPipeInfo->ClosePipe(*fAllocator.BufStream());
1135: 				vAllocStream->AddRef();
1137: 				vAllocStream->SetPosition(0);
1138: 				fAllocator.Initialize(*vAllocStream, true, false);
1141: 					fPipeInfo->PushReadPipe(*fAllocator.BufStream());
1142: 				vAllocStream->Release();
1157: 		if ((fTotalCount>0) && (vAllocStream!=NULL) && (fGDSStream!=NULL))
1168: 				CdStream *TmpStream = new CdTempStream;
1169: 				TdAutoRef<CdBufStream> Output(new CdBufStream(TmpStream));
1182: 				vAllocStream->SetPosition(0);
1183: 				vAllocStream->SetSizeOnly(0);
1184: 				vAllocStream->CopyFrom(*TmpStream, 0, -1);
1187: 			vAllocStream->SetPosition(0);
1191: 				fAllocator.Initialize(*vAllocStream, true, false);
1192: 				fPipeInfo->PushReadPipe(*fAllocator.BufStream());
1195: 				fAllocator.Initialize(*vAllocStream, true, true);
1199: 			SaveToBlockStream();
1207: 			if ((fPipeInfo!=NULL) && (vAllocStream!=NULL))
1209: 				vAllocStream->SetPosition(0);
1210: 				fAllocator.Initialize(*vAllocStream, false, true);
1211: 				fPipeInfo->PushWritePipe(*fAllocator.BufStream());
1248: 			if (fAllocator.BufStream())
1251: 				Src->fAllocator.BufStream()->FlushWrite();
1252: 				fAllocator.BufStream()->CopyFrom(
1274: 	if (vAllocStream)
1278: 		SIZE64 SavePos = vAllocStream->Position();
1279: 		vAllocStream->SetPosition(0);
1280: 		SIZE64 p=0, size=vAllocStream->GetSize();
1287: 			vAllocStream->ReadData(Buffer, L);
1291: 		vAllocStream->SetPosition(SavePos);
1294: 	if (Allocator().BufStream())
1316: 	vector<CdStream*> ss;
1317: 	GetOwnBlockStream(ss);
1333: 	if (vAllocStream) Out.push_back(vAllocStream);
1339: 	if (vAllocStream) Out.push_back(vAllocStream);
1413: 	if (fGDSStream ? fGDSStream->ReadOnly() : true)
1421: 	if (fGDSStream)
1425: 		vAllocStream = fGDSStream->Collection()[vAllocID];
1426: 		vAllocStream->SetPosition(0);
1427: 		fAllocator.Initialize(*vAllocStream, true, !fGDSStream->ReadOnly());
1429: 			fPipeInfo->PushReadPipe(*fAllocator.BufStream());
1452: 	if (fGDSStream != NULL)
1454: 		if (vAllocStream == NULL)
1456: 			vAllocStream = fGDSStream->Collection().NewBlockStream();
1457: 			fAllocator.Initialize(*vAllocStream, true, true);
1459: 				fPipeInfo->PushWritePipe(*fAllocator.BufStream());
1461: 		TdGDSBlockID Entry = vAllocStream->ID();
1469: 	if (fAllocator.BufStream())
1471: 		if (_GetStreamPipeInfo(fAllocator.BufStream(), false))
1476: void CdAllocArray::UpdateInfo(CdBufStream *Sender)
1483: 			if (_GetStreamPipeInfo(fAllocator.BufStream(), false))
1484: 				_UpdateStreamPipeInfo(*fGDSStream);
1494: 			BYTE_LE<CdStream> W(fGDSStream);
1505: 	//   fAllocator.BufStream()->OnFlush.Set(this, &CdAllocArray::UpdateInfo)
1506: 	if (fAllocator.BufStream())
1507: 		fAllocator.BufStream()->OnFlush.Clear();
1510: void CdAllocArray::UpdateInfoExt(CdBufStream *Sender)
1581: 	if (fAllocator.BufStream())
1583: 		if (fAllocator.BufStream()->BufSize() != STREAM_BUFFER_SMALL_SIZE)
1585: 			fAllocator.BufStream()->SetBufSize(STREAM_BUFFER_SMALL_SIZE);
1592: 	if (fAllocator.BufStream())
1594: 		if (fAllocator.BufStream()->BufSize() != STREAM_BUFFER_LARGE_SIZE)
1596: 			fAllocator.BufStream()->SetBufSize(STREAM_BUFFER_LARGE_SIZE);
1603: 	fAllocator.BufStream()->OnFlush.Set(this, &CdAllocArray::UpdateInfo);
1162: 			fPipeInfo = dStreamPipeMgr.Match(*this, Mode);
1178: 					fPipeInfo->GetStreamInfo(Output.get());
1203: 			fPipeInfo = dStreamPipeMgr.Match(*this, Mode);
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) {
gdsfmt:src/CoreArray/dStruct.h: [ ]
555: 		CdBlockStream *vAllocStream;
477: 		/// Get a list of CdBlockStream owned by this object, except fGDSStream
478: 		virtual void GetOwnBlockStream(vector<const CdBlockStream*> &Out) const;
479: 		/// Get a list of CdStream owned by this object, except fGDSStream
480: 		virtual void GetOwnBlockStream(vector<CdStream*> &Out);
529: 		void UpdateInfo(CdBufStream *Sender);
531: 		virtual void UpdateInfoExt(CdBufStream *Sender);
589: 			return TdTraits<TYPE>::StreamName();
137: 		virtual SIZE64 GDSStreamSize();
475: 		virtual SIZE64 GDSStreamSize();
rhdf5filters:src/blosc/lib/zstd-1.4.5/compress/huf_compress.c: [ ]
610: typedef enum { HUF_singleStream, HUF_fourStreams } HUF_nbStreams_e;
444: HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt* CTable)
467:     BIT_CStream_t bitC;
471:     { size_t const initErr = BIT_initCStream(&bitC, op, (size_t)(oend-op));
501:     return BIT_closeCStream(&bitC);
617:     size_t const cSize = (nbStreams==HUF_singleStream) ?
733:                                  maxSymbolValue, huffLog, HUF_singleStream,
745:                                  maxSymbolValue, huffLog, HUF_singleStream,
615:                 HUF_nbStreams_e nbStreams, const HUF_CElt* CTable, const int bmi2)
641:                        HUF_nbStreams_e nbStreams,
668:                                            nbStreams, oldHufTable, bmi2);
687:                                            nbStreams, oldHufTable, bmi2);
711:                                                    nbStreams, oldHufTable, bmi2);
723:                                        nbStreams, table->CTable, bmi2);
767:                                  maxSymbolValue, huffLog, HUF_fourStreams,
782:                                  maxSymbolValue, huffLog, HUF_fourStreams,
rhdf5filters:src/blosc/lib/zstd-1.4.5/decompress/zstd_decompress_block.c: [ ]
566:     BIT_DStream_t DStream;
98:                 U32 singleStream=0;
106:                     singleStream = !lhlCode;
133:                     if (singleStream) {
143:                     if (singleStream) {
796: ZSTD_initFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, const ZSTD_seqSymbol* dt)
803:     BIT_reloadDStream(bitD);
808: ZSTD_updateFseState(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD)
817: ZSTD_updateFseStateWithDInfo(ZSTD_fseState* DStatePtr, BIT_DStream_t* bitD, ZSTD_seqSymbol const DInfo)
859:                 U32 const extraBits = ofBits - MIN(ofBits, 32 - seqState->DStream.bitsConsumed);
860:                 offset = ofBase + (BIT_readBitsFast(&seqState->DStream, ofBits - extraBits) << extraBits);
861:                 BIT_reloadDStream(&seqState->DStream);
862:                 if (extraBits) offset += BIT_readBitsFast(&seqState->DStream, extraBits);
865:                 offset = ofBase + BIT_readBitsFast(&seqState->DStream, ofBits/*>0*/);   /* <=  (ZSTD_WINDOWLOG_MAX-1) bits */
866:                 if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);
882:                 offset = ofBase + ll0 + BIT_readBitsFast(&seqState->DStream, 1);
894:         seq.matchLength += BIT_readBitsFast(&seqState->DStream, mlBits/*>0*/);
897:         BIT_reloadDStream(&seqState->DStream);
899:         BIT_reloadDStream(&seqState->DStream);
905:         seq.litLength += BIT_readBitsFast(&seqState->DStream, llBits/*>0*/);
908:         BIT_reloadDStream(&seqState->DStream);
935:             ZSTD_updateFseState(&seqState->stateLL, &seqState->DStream);    /* <=  9 bits */
936:             ZSTD_updateFseState(&seqState->stateML, &seqState->DStream);    /* <=  9 bits */
937:             if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
938:             ZSTD_updateFseState(&seqState->stateOffb, &seqState->DStream);  /* <=  8 bits */
940:             ZSTD_updateFseStateWithDInfo(&seqState->stateLL, &seqState->DStream, llDInfo);    /* <=  9 bits */
941:             ZSTD_updateFseStateWithDInfo(&seqState->stateML, &seqState->DStream, mlDInfo);    /* <=  9 bits */
942:             if (MEM_32bits()) BIT_reloadDStream(&seqState->DStream);    /* <= 18 bits */
943:             ZSTD_updateFseStateWithDInfo(&seqState->stateOffb, &seqState->DStream, ofDInfo);  /* <=  8 bits */
1021:             ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
1023:         ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
1024:         ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
1025:         ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
1029:                 BIT_DStream_unfinished < BIT_DStream_completed &&
1030:                 BIT_DStream_endOfBuffer < BIT_DStream_completed &&
1031:                 BIT_DStream_completed < BIT_DStream_overflow);
1082:             BIT_reloadDStream(&(seqState.DStream));
1098:         RETURN_ERROR_IF(BIT_reloadDStream(&seqState.DStream) < BIT_DStream_completed, corruption_detected, "");
1164:             ERR_isError(BIT_initDStream(&seqState.DStream, ip, iend-ip)),
1166:         ZSTD_initFseState(&seqState.stateLL, &seqState.DStream, dctx->LLTptr);
1167:         ZSTD_initFseState(&seqState.stateOffb, &seqState.DStream, dctx->OFTptr);
1168:         ZSTD_initFseState(&seqState.stateML, &seqState.DStream, dctx->MLTptr);
1171:         for (seqNb=0; (BIT_reloadDStream(&seqState.DStream) <= BIT_DStream_completed) && (seqNb<seqAdvance); seqNb++) {
1178:         for ( ; (BIT_reloadDStream(&(seqState.DStream)) <= BIT_DStream_completed) && (seqNb<nbSeq) ; seqNb++) {
rhdf5filters:src/bzip2/bzip2-1.0.8/bzip2recover.c: [ ]
150:    BitStream;
154: static BitStream* bsOpenReadStream ( FILE* stream )
167: static BitStream* bsOpenWriteStream ( FILE* stream )
156:    BitStream *bs = malloc ( sizeof(BitStream) );
157:    if (bs == NULL) mallocFail ( sizeof(BitStream) );
169:    BitStream *bs = malloc ( sizeof(BitStream) );
170:    if (bs == NULL) mallocFail ( sizeof(BitStream) );
180: static void bsPutBit ( BitStream* bs, Int32 bit )
199: static Int32 bsGetBit ( BitStream* bs )
218: static void bsClose ( BitStream* bs )
242: static void bsPutUChar ( BitStream* bs, UChar c )
251: static void bsPutUInt32 ( BitStream* bs, UInt32 c )
305:    BitStream*  bsIn, *bsWr;
358:    bsIn = bsOpenReadStream ( inFile );
431:    bsIn = bsOpenReadStream ( inFile );
497:          bsWr = bsOpenWriteStream ( outFile );
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());
rhdf5filters:src/blosc/lib/zstd-1.4.5/common/bitstream.h: [ ]
183: MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
254: MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
272: MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
416: MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
445: MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
63: } BIT_CStream_t;
97: } BIT_DStream_t;
99: typedef enum { BIT_DStream_unfinished = 0,
100:                BIT_DStream_endOfBuffer = 1,
101:                BIT_DStream_completed = 2,
102:                BIT_DStream_overflow = 3 } BIT_DStream_status;  /* result of BIT_reloadDStream() */
400: MEM_STATIC BIT_DStream_status BIT_reloadDStreamFast(BIT_DStream_t* bitD)
51: *  bitStream encoding API (write forward)
53: /* bitStream can mix input from multiple sources.
65: MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC, void* dstBuffer, size_t dstCapacity);
66: MEM_STATIC void   BIT_addBits(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
67: MEM_STATIC void   BIT_flushBits(BIT_CStream_t* bitC);
68: MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC);
70: /* Start with initCStream, providing the size of buffer to write into.
71: *  bitStream will never write outside of this buffer.
82: *  Last operation is to close the bitStream.
83: *  The function returns the final size of CStream in bytes.
89: *  bitStream decoding API (read backward)
105: MEM_STATIC size_t   BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize);
106: MEM_STATIC size_t   BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits);
107: MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD);
108: MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* bitD);
111: /* Start by invoking BIT_initDStream().
112: *  A chunk of the bitStream is then stored into a local register.
115: *  Local register is explicitly reloaded from memory by the BIT_reloadDStream() method.
116: *  A reload guarantee a minimum of ((8*sizeof(bitD->bitContainer))-7) bits when its result is BIT_DStream_unfinished.
118: *  Checking if DStream has reached its end can be performed with BIT_endOfDStream().
125: MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC, size_t value, unsigned nbBits);
128: MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC);
131: MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits);
177: *  bitStream encoding
179: /*! BIT_initCStream() :
198: MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
211: MEM_STATIC void BIT_addBitsFast(BIT_CStream_t* bitC,
223: MEM_STATIC void BIT_flushBitsFast(BIT_CStream_t* bitC)
238:  *  overflow will be revealed later on using BIT_closeCStream() */
239: MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
251: /*! BIT_closeCStream() :
252:  *  @return : size of CStream, in bytes,
264: *  bitStream decoding
266: /*! BIT_initDStream() :
267:  *  Initialize a BIT_DStream_t.
268:  * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
269:  * `srcSize` must be the *exact* size of the bitStream, in bytes.
345: MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
361: MEM_STATIC size_t BIT_lookBitsFast(const BIT_DStream_t* bitD, U32 nbBits)
368: MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
377: MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, unsigned nbBits)
386: MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, unsigned nbBits)
395:  *  Similar to BIT_reloadDStream(), but with two differences:
397:  *  2. Returns BIT_DStream_overflow when bitD->ptr < bitD->limitPtr, at this
398:  *     point you must use BIT_reloadDStream() to reload.
403:         return BIT_DStream_overflow;
408:     return BIT_DStream_unfinished;
411: /*! BIT_reloadDStream() :
412:  *  Refill `bitD` from buffer previously set in BIT_initDStream() .
414:  * @return : status of `BIT_DStream_t` internal register.
415:  *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
419:         return BIT_DStream_overflow;
425:         if (bitD->bitsConsumed < sizeof(bitD->bitContainer)*8) return BIT_DStream_endOfBuffer;
426:         return BIT_DStream_completed;
430:         BIT_DStream_status result = BIT_DStream_unfinished;
433:             result = BIT_DStream_endOfBuffer;
442: /*! BIT_endOfDStream() :
443:  * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
447:     return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
394: /*! BIT_reloadDStreamFast() :
422:         return BIT_reloadDStreamFast(bitD);
gdsfmt:src/CoreArray/dBit.h: [ ]
313: 		static const char *StreamName()
319: 			return StreamName() + 1;
295: 	extern const char *BitStreamNames[];
298: 	extern const char *SBitStreamNames[];
315: 			return is_signed ? SBitStreamNames[bits] : BitStreamNames[bits];
gdsfmt:src/CoreArray/dBase.cpp: [ ]
370: CdStream::CdStream(): CdRef() {}
372: CdStream::~CdStream() {}
525: CdBufStream::CdBufStream(CdStream *vStream, ssize_t vBufSize): CdRef()
538: CdBufStream::~CdBufStream()
734: void CdBufStream::SetStream(CdStream *Value)
816: CdStreamIndex::CdStreamIndex()
363: 	"Stream Read Error, need %lld byte(s) but receive %lld";
365: 	"Stream Write Error";
522: // Stream Buffer Object
531: 	_Stream = _BaseStream = vStream;
542: 	if (_Stream) { _Stream->Release(); _Stream = NULL; }
553: 			_Stream->SetPosition(_BufStart);
554: 			_Stream->WriteData(_Buffer, _BufEnd - _BufStart);
567: 			_Stream->SetPosition(_BufStart);
568: 			_Stream->WriteData(_Buffer, _BufEnd - _BufStart);
587: 			_Stream->SetPosition(_BufStart);
588: 			_BufEnd = _BufStart + _Stream->Read(_Buffer, _BufSize);
603: 				_Stream->SetPosition(_BufStart);
604: 				_BufEnd = _BufStart + _Stream->Read(_Buffer, _BufSize);
619: 		_Stream->SetPosition(_BufStart);
620: 		_BufEnd = _BufStart + _Stream->Read(_Buffer, _BufSize);
708: 	_Stream->CopyFrom(Source, Pos, Count);
730: 	_Stream->SetSize(_Position);
736: 	if (_Stream != Value)
738: 		if (_Stream)
741: 			_Stream->Release();
743: 		_Stream = Value;
746: 		if (_Stream)
748: 			_Stream->AddRef();
768: 	return _Stream->GetSize();
774: 	_Stream->SetSize(Value);
788: 	_Stream = APipe->InitPipe(this);
789: 	_Stream->AddRef();
805: 		_Stream = FC->FreePipe();
358: // CdStream
361: // Error messages in CdStream
368: 	throw ErrStream(ERR_STREAM_READ, (C_Int64)need_n, (C_Int64)rec_n)
374: SIZE64 CdStream::GetSize()
383: SIZE64 CdStream::Position()
388: void CdStream::SetPosition(const SIZE64 pos)
393: void CdStream::ReadData(void *Buffer, ssize_t Count)
402: C_UInt8 CdStream::R8b()
410: C_UInt16 CdStream::R16b()
418: C_UInt32 CdStream::R32b()
426: C_UInt64 CdStream::R64b()
434: void CdStream::WriteData(const void *Buffer, ssize_t Count)
437: 		throw ErrStream(ERR_STREAM_WRITE);
440: void CdStream::W8b(C_UInt8 val)
443: 		throw ErrStream(ERR_STREAM_WRITE);
446: void CdStream::W16b(C_UInt16 val)
449: 		throw ErrStream(ERR_STREAM_WRITE);
452: void CdStream::W32b(C_UInt32 val)
455: 		throw ErrStream(ERR_STREAM_WRITE);
458: void CdStream::W64b(C_UInt64 val)
461: 		throw ErrStream(ERR_STREAM_WRITE);
464: CdStream& CdStream::operator= (const CdStream& m)
469: CdStream& CdStream::operator= (CdStream& m)
474: void CdStream::CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count)
504: void CdStream::CopyFromBuf(CdBufStream &Source, SIZE64 Pos, SIZE64 Count)
532: 	if (vStream)
533: 		vStream->AddRef();
546: void CdBufStream::FlushBuffer()
560: void CdBufStream::FlushWrite()
575: void CdBufStream::ReadData(void *Buf, ssize_t Count)
610: C_UInt8 CdBufStream::R8b()
630: C_UInt16 CdBufStream::R16b()
637: C_UInt32 CdBufStream::R32b()
644: C_UInt64 CdBufStream::R64b()
651: void CdBufStream::WriteData(const void *Buf, ssize_t Count)
682: void CdBufStream::W8b(C_UInt8 val)
687: void CdBufStream::W16b(C_UInt16 val)
692: void CdBufStream::W32b(C_UInt32 val)
697: void CdBufStream::W64b(C_UInt64 val)
702: void CdBufStream::CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count)
712: void CdBufStream::CopyFromBuf(CdBufStream &Source, SIZE64 Pos, SIZE64 Count)
727: void CdBufStream::Truncate()
744: 		if (!_BaseStream)
745: 			_BaseStream = Value;
754: void CdBufStream::SetBufSize(const ssize_t NewBufSize)
765: SIZE64 CdBufStream::GetSize()
771: void CdBufStream::SetSize(SIZE64 Value)
778: void CdBufStream::ClearPipe()
784: void CdBufStream::PushPipe(CdStreamPipe *APipe)
793: void CdBufStream::PopPipe()
865: 		p.StreamPos = stream_pos;
891: 			stream_pos = p.StreamPos;
586: 			_BufStart = (_Position >> BufStreamAlign) << BufStreamAlign;
618: 		_BufStart = (_Position >> BufStreamAlign) << BufStreamAlign;
756: 	if ((_BufSize!=NewBufSize) && (NewBufSize>=(1 << BufStreamAlign)))
759: 		_BufSize = (NewBufSize >> BufStreamAlign) << BufStreamAlign;
799: 		unique_ptr<CdStreamPipe> FC(_PipeItems[L-1]); // C++11
801: 		auto_ptr<CdStreamPipe> FC(_PipeItems[L-1]);
825: void CdStreamIndex::Reset(C_Int64 count)
832: void CdStreamIndex::Initialize()
837: void CdStreamIndex::_Init()
859: void CdStreamIndex::_Hit(SIZE64 stream_pos)
872: void CdStreamIndex::Set(C_Int64 index, C_Int64 &close_index, SIZE64 &stream_pos)
875: 		"CdStreamIndex::Set(): index is out of range.";
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;
gdsfmt:src/CoreArray/dVLIntGDS.h: [ ]
64: 		static const char *StreamName() { return "dVL_Int"; }
81: 		static const char *StreamName() { return "dVL_UInt"; }
117: 		CdBlockStream *fIndexingStream; ///< the GDS stream for indexing
353: 		CdBlockStream *fIndexingStream; ///< the GDS stream for indexing
114: 		SIZE64 fCurStreamPosition;
115: 		SIZE64 fTotalStreamSize;
354: 		SIZE64 fTotalStreamSize;    ///< the total stream size
355: 		SIZE64 fCurStreamPosition;  ///< the current stream position
65: 		static const char *TraitName() { return StreamName()+1; }
82: 		static const char *TraitName() { return StreamName()+1; }
106: 		/// get a list of CdBlockStream owned by this object, except fGDSStream
107: 		virtual void GetOwnBlockStream(vector<const CdBlockStream*> &Out) const;
108: 		/// get a list of CdStream owned by this object, except fGDSStream
109: 		virtual void GetOwnBlockStream(vector<CdStream*> &Out);
312: 					if (!(I.Ptr & 0xFFFF) && IT->fIndexingStream)
314: 						IT->fIndexingStream->SetPosition(((I.Ptr>>16)-1) * GDS_POS_SIZE);
316: 						BYTE_LE<CdStream>(IT->fIndexingStream) << pp;
345: 		/// get a list of CdBlockStream owned by this object, except fGDSStream
346: 		virtual void GetOwnBlockStream(vector<const CdBlockStream*> &Out) const;
347: 		/// get a list of CdStream owned by this object, except fGDSStream
348: 		virtual void GetOwnBlockStream(vector<CdStream*> &Out);
538: 					if (!(I.Ptr & 0xFFFF) && IT->fIndexingStream)
540: 						IT->fIndexingStream->SetPosition(((I.Ptr>>16)-1) * GDS_POS_SIZE);
542: 						BYTE_LE<CdStream>(IT->fIndexingStream) << pp;
124: 		void SetStreamPos(C_Int64 idx);
141: 			IT->SetStreamPos(I.Ptr);
182: 			IT->fCurStreamPosition = I.Allocator->Position();
193: 			IT->SetStreamPos(I.Ptr);
237: 			IT->fCurStreamPosition = I.Allocator->Position();
254: 				I.Allocator->SetPosition(IT->fTotalStreamSize);
310: 					IT->fTotalStreamSize += m;
363: 		void SetStreamPos(C_Int64 idx);
380: 			IT->SetStreamPos(I.Ptr);
418: 			IT->fCurStreamPosition = I.Allocator->Position();
429: 			IT->SetStreamPos(I.Ptr);
468: 			IT->fCurStreamPosition = I.Allocator->Position();
485: 				I.Allocator->SetPosition(IT->fTotalStreamSize);
536: 					IT->fTotalStreamSize += m;
affxparser:src/fusion/calvin_files/writers/src/GenericFileWriter.cpp: [ ]
84: void GenericFileWriter::OpenFileOStream(const std::string &file, bool truncate)
30:     OpenFileOStream(fileHdr->GetFilename(), truncate);
affxparser:src/fusion/util/CalvinToText.h: [ ]
61:     std::fstream* m_pfileStream;
mzR:src/pwiz/utility/misc/SHA1CalculatorTest.cpp: [ ]
71: void testStream()
164:         testStream();
affxparser:src/fusion/calvin_files/data/src/GenericData.h: [ ]
250: 	std::ifstream fileStream;
183: 	void OpenFStream(std::ifstream& ifs);
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));
gdsfmt:src/CoreArray/dVLIntGDS.cpp: [ ]
120: void CdVL_Int::GetOwnBlockStream(vector<const CdBlockStream*> &Out) const
126: void CdVL_Int::GetOwnBlockStream(vector<CdStream*> &Out)
312: void CdVL_UInt::GetOwnBlockStream(vector<const CdBlockStream*> &Out) const
318: void CdVL_UInt::GetOwnBlockStream(vector<CdStream*> &Out)
166: void CdVL_Int::SetStreamPos(C_Int64 idx)
359: void CdVL_UInt::SetStreamPos(C_Int64 idx)
68: 				*(Src->Allocator().BufStream()->Stream()), P1, SrcLen);
260: 				*(Src->Allocator().BufStream()->Stream()), P1, SrcLen);
50: 	fIndexingStream = NULL;
57: 		if (fAllocator.BufStream())
60: 			Src->Allocator().BufStream()->FlushWrite();
67: 			fAllocator.BufStream()->CopyFrom(
94: 						if (!(totcnt & 0xFFFF) && fIndexingStream)
96: 							fIndexingStream->SetPosition(((totcnt>>16)-1) * GDS_POS_SIZE);
97: 							BYTE_LE<CdStream>(fIndexingStream) << TdGDSPos(ppos + (s - Buf));
122: 	CdArray<TVL_Int>::GetOwnBlockStream(Out);
123: 	if (fIndexingStream) Out.push_back(fIndexingStream);
128: 	CdArray<TVL_Int>::GetOwnBlockStream(Out);
129: 	if (fIndexingStream) Out.push_back(fIndexingStream);
136: 	if (fGDSStream)
140: 		fIndexingStream = fGDSStream->Collection()[fIndexingID];
145: 			fTotalStreamSize = fPipeInfo->StreamTotalIn();
147: 			if (fAllocator.BufStream())
148: 				fTotalStreamSize = fAllocator.BufStream()->GetSize();
157: 	if (fGDSStream)
159: 		if (!fIndexingStream)
160: 			fIndexingStream = fGDSStream->Collection().NewBlockStream();
161: 		TdGDSBlockID Entry = fIndexingStream->ID();
185: 			if ((i <= 0) || !fIndexingStream)
189: 				fIndexingStream->SetPosition((i-1)*GDS_POS_SIZE);
191: 				BYTE_LE<CdStream>(fIndexingStream) >> pos;
197: 			if (((i << 16) > fCurIndex) && fIndexingStream)
199: 				fIndexingStream->SetPosition((i-1)*GDS_POS_SIZE);
201: 				BYTE_LE<CdStream>(fIndexingStream) >> pos;
242: 	fIndexingStream = NULL;
249: 		if (fAllocator.BufStream())
252: 			Src->Allocator().BufStream()->FlushWrite();
259: 			fAllocator.BufStream()->CopyFrom(
286: 						if (!(totcnt & 0xFFFF) && fIndexingStream)
288: 							fIndexingStream->SetPosition(((totcnt>>16)-1) * GDS_POS_SIZE);
289: 							BYTE_LE<CdStream>(fIndexingStream) << TdGDSPos(ppos + (s - Buf));
314: 	CdArray<TVL_UInt>::GetOwnBlockStream(Out);
315: 	if (fIndexingStream) Out.push_back(fIndexingStream);
320: 	CdArray<TVL_UInt>::GetOwnBlockStream(Out);
321: 	if (fIndexingStream) Out.push_back(fIndexingStream);
328: 	if (fGDSStream)
331: 		fIndexingStream = fGDSStream->Collection()[fIndexingID];
334: 	if (fGDSStream)
338: 			fTotalStreamSize = fPipeInfo->StreamTotalIn();
340: 			if (fAllocator.BufStream())
341: 				fTotalStreamSize = fAllocator.BufStream()->GetSize();
350: 	if (fGDSStream)
352: 		if (!fIndexingStream)
353: 			fIndexingStream = fGDSStream->Collection().NewBlockStream();
354: 		TdGDSBlockID Entry = fIndexingStream->ID();
378: 			if ((i == 0) || !fIndexingStream)
382: 				fIndexingStream->SetPosition((i-1)*GDS_POS_SIZE);
384: 				BYTE_LE<CdStream>(fIndexingStream) >> pos;
390: 			if (((i << 16) > fCurIndex) && fIndexingStream)
392: 				fIndexingStream->SetPosition((i-1)*GDS_POS_SIZE);
394: 				BYTE_LE<CdStream>(fIndexingStream) >> pos;
437: 			dObjManager().AddClass(TdTraits< T >::StreamName(), \
46: 	fCurStreamPosition = 0;
48: 	fTotalStreamSize = 0;
63: 			Src->SetStreamPos(I.Ptr);
64: 			SIZE64 P1 = Src->fCurStreamPosition;
65: 			Src->SetStreamPos(I.Ptr + Count);
66: 			SIZE64 SrcLen = Src->fCurStreamPosition - P1;
75: 			SIZE64 ppos = fTotalStreamSize;
107: 			fTotalStreamSize += SrcLen;
142: 		fTotalStreamSize = 0;
170: 		fAllocator.SetPosition(fCurStreamPosition);
176: 			fCurStreamPosition = fTotalStreamSize;
177: 			fAllocator.SetPosition(fCurStreamPosition);
181: 			throw ErrArray("CdVL_Int::SetStreamPos: Invalid Index.");
187: 				fCurIndex = fCurStreamPosition = 0;
193: 				fCurStreamPosition = pos;
203: 				fCurStreamPosition = pos;
207: 		fAllocator.SetPosition(fCurStreamPosition);
229: 		fCurStreamPosition = fAllocator.Position();
238: 	fCurStreamPosition = 0;
240: 	fTotalStreamSize = 0;
255: 			Src->SetStreamPos(I.Ptr);
256: 			SIZE64 P1 = Src->fCurStreamPosition;
257: 			Src->SetStreamPos(I.Ptr + Count);
258: 			SIZE64 SrcLen = Src->fCurStreamPosition - P1;
267: 			SIZE64 ppos = fTotalStreamSize;
299: 			fTotalStreamSize += SrcLen;
363: 		fAllocator.SetPosition(fCurStreamPosition);
369: 			fCurStreamPosition = fTotalStreamSize;
370: 			fAllocator.SetPosition(fCurStreamPosition);
374: 			throw ErrArray("CdVL_UInt::SetStreamPos: Invalid Index.");
380: 				fCurIndex = fCurStreamPosition = 0;
386: 				fCurStreamPosition = pos;
396: 				fCurStreamPosition = pos;
400: 		fAllocator.SetPosition(fCurStreamPosition);
422: 		fCurStreamPosition = fAllocator.Position();
affxparser:src/fusion/calvin_files/data/src/DataGroup.h: [ ]
105: 	std::ifstream* fileStream;
RSeqAn:inst/include/seqan/stream/stream_compressor.h: [ ]
416: guessFormatFromStream(TStream &istream, BgzfFile)
414: template <typename TStream>
affxparser:src/fusion/calvin_files/parsers/src/FileHeaderReader.h: [ ]
89: 	std::ifstream& fileStream;
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);
affxparser:src/fusion/calvin_files/parsers/src/DataSetReader.h: [ ]
121: 	std::ifstream& fileStream;
affxparser:src/fusion/calvin_files/writers/src/GenericFileWriter.h: [ ]
71: 	std::ofstream& GetFileOStream() { return os; }
75: 	void OpenFileOStream(const std::string &filename, bool truncate);
RSeqAn:inst/include/seqan/stream/buffered_stream.h: [ ]
73: class BufferedStream :
82:     typedef typename BasicStream<TValue, TDirection, TTraits>::Type TBasicStream;
98:     BufferedStream() :
102:     explicit BufferedStream(TUnbufferedStream & stream) :
127:     void setStream(TUnbufferedStream & stream)
83:     typedef std::basic_streambuf<TValue, TTraits>                   TStreamBuf;
114:     void setStreamBuf(TStreamBuf & streamBuf)
138: class BufferedStreamBuf :
142:     typedef std::basic_streambuf<TValue, TTraits>                   TStreamBuf;
164:     BufferedStreamBuf(size_t bufferSize = defaultBufferSize,
174:     BufferedStreamBuf(TStreamBuf &streamBuf,
190:     void setStreamBuf(TStreamBuf &streamBuf)
55: // Class BufferedStream
59:  * @class BufferedStream
60:  * @implements StreamConcept
62:  * @brief Adds a buffer to another @link StreamConcept stream @endlink.
64:  * @signature template <typename TUnbufferedStream, TDirection>
65:  *            class BufferedStream;
67:  * @tparam TUnbufferedStream The type of the unbuffered @link StreamConcept stream @endlink to wrap.
70: // TODO(esiragusa): @extends BasicStream::Type
72: template <typename TUnbufferedStream, typename TDirection>
74:     public BasicStream<
75:         typename TUnbufferedStream::char_type,
77:         typename TUnbufferedStream::traits_type>::Type
80:     typedef typename TUnbufferedStream::char_type                   TValue;
81:     typedef typename TUnbufferedStream::traits_type                 TTraits;
90:      * @fn BufferedStream::BufferedStream
93:      * @signature BufferedStream::BufferedStream();
94:      * @signature BufferedStream::BufferedStream(unbufferedStream);
99:         TBasicStream(&buf)
103:         TBasicStream(&buf), buf(stream.rdbuf())
107:      * @fn BufferedStream::setStreamBuf
108:      * @brief Set the stream buffer of the BufferedStream.
110:      * @signature void BufferedStream::setStreamBuf(streamBuf);
120:      * @fn BufferedStream::setStream
123:      * @signature void BufferedStream::setStream(stream);
125:      * @param[in] stream The <tt>TUnbufferedStream</tt> to use.
48: class BufferedStreamBuf;
85:     BufferedStreamBuf<TValue, TDirection, TTraits> buf;
116:         buf.setStreamBuf(streamBuf);
129:         setStreamBuf(*stream.rdbuf());
134: // Class BufferedStreamBuf
151:     using TStreamBuf::eback;
152:     using TStreamBuf::gptr;
153:     using TStreamBuf::egptr;
154:     using TStreamBuf::setg;
157:     TStreamBuf *streamBufPtr;
180:         setStreamBuf(streamBuf);
affxparser:src/fusion/calvin_files/parsers/src/DataGroupReader.h: [ ]
79: 	std::ifstream& fileStream;
RSeqAn:inst/include/seqan/stream/guess_format.h: [ ]
58: inline bool guessFormatFromStream(TFileSeq &, TagSelector<> &)
68: inline bool guessFormatFromStream(TFileSeq &seq, TagSelector<TTagList> &format)
53: // Function guessFormatFromStream()
64: // Function guessFormatFromStream(TagSelector)
75:         if (guessFormatFromStream(seq, TFormat()))
81:     return guessFormatFromStream(seq, static_cast<typename TagSelector<TTagList>::Base &>(format));
RSeqAn:inst/include/seqan/stream/stream_base.h: [ ]
196: guessFormatFromStream(TStream &istream, Tag<TFormat_>)
194: template <typename TStream, typename TFormat_>
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);
RSeqAn:inst/include/seqan/index/pipe_merger3.h: [ ]
66:         int             minStream;
67:         bool            twoStreams;
91:                     minStream = 0;
94:                     minStream = 1;
98:                 if (minStream >= 0)
99:                     tmp = minStream? N - (*in.in2).i1: N - (*in.in1).i1;
107:             if (minStream) {
113:                     minStream = (twoStreams)? 0: -1;
129:                     minStream = (twoStreams)? 1: -1;
152:         me.minStream = eof(me.in.in2)? -1: 1;
89:             if (twoStreams)
114:                     twoStreams = false;
130:                     twoStreams = false;
151:         me.twoStreams = !eof(me.in.in1);
RSeqAn:inst/include/seqan/ucsc_io/ucsc_io.h: [ ]
175: guessFormatFromStream(TStream &istream, Tag<Ucsc_<TFormatSpec> > const & format)
137: // Function guessFormatFromStream
173: template <typename TStream, typename TFormatSpec>
affxparser:src/fusion/calvin_files/writers/src/TextFileWriter.h: [ ]
54: 	std::ofstream fileStream;
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);
rhdf5filters:src/blosc/lib/zstd-1.4.5/decompress/zstd_decompress_internal.h: [ ]
90:                zdss_read, zdss_load, zdss_flush } ZSTD_dStreamStage;
134:     const ZSTD_DDict* ddict;     /* set by ZSTD_initDStream_usingDDict(), or ZSTD_DCtx_refDDict() */
140:     ZSTD_dStreamStage streamStage;
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); }
rhdf5filters:src/blosc/lib/zstd-1.4.5/decompress/huf_decompress.c: [ ]
215: HUF_decodeStreamX1(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX1* const dt, const U32 dtLog)
696: HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd,
195: HUF_decodeSymbolX1(BIT_DStream_t* Dstream, const HUF_DEltX1* dt, const U32 dtLog)
220:     while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-3)) {
229:         while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd))
249:     BIT_DStream_t bitD;
253:     CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
257:     if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
279:         BIT_DStream_t bitD1;
280:         BIT_DStream_t bitD2;
281:         BIT_DStream_t bitD3;
282:         BIT_DStream_t bitD4;
304:         CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
305:         CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
306:         CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
307:         CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
327:             endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
328:             endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
329:             endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
330:             endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
348:         { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
660: HUF_decodeSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
662:     size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
664:     BIT_skipBits(DStream, dt[val].nbBits);
669: HUF_decodeLastSymbolX2(void* op, BIT_DStream_t* DStream, const HUF_DEltX2* dt, const U32 dtLog)
671:     size_t const val = BIT_lookBitsFast(DStream, dtLog);   /* note : dtLog >= 1 */
673:     if (dt[val].length==1) BIT_skipBits(DStream, dt[val].nbBits);
675:         if (DStream->bitsConsumed < (sizeof(DStream->bitContainer)*8)) {
676:             BIT_skipBits(DStream, dt[val].nbBits);
677:             if (DStream->bitsConsumed > (sizeof(DStream->bitContainer)*8))
679:                 DStream->bitsConsumed = (sizeof(DStream->bitContainer)*8);
702:     while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p < pEnd-(sizeof(bitDPtr->bitContainer)-1))) {
710:     while ((BIT_reloadDStream(bitDPtr) == BIT_DStream_unfinished) & (p <= pEnd-2))
714:         HUF_DECODE_SYMBOLX2_0(p, bitDPtr);   /* no need to reload : reached the end of DStream */
728:     BIT_DStream_t bitD;
731:     CHECK_F( BIT_initDStream(&bitD, cSrc, cSrcSize) );
743:     if (!BIT_endOfDStream(&bitD)) return ERROR(corruption_detected);
765:         BIT_DStream_t bitD1;
766:         BIT_DStream_t bitD2;
767:         BIT_DStream_t bitD3;
768:         BIT_DStream_t bitD4;
790:         CHECK_F( BIT_initDStream(&bitD1, istart1, length1) );
791:         CHECK_F( BIT_initDStream(&bitD2, istart2, length2) );
792:         CHECK_F( BIT_initDStream(&bitD3, istart3, length3) );
793:         CHECK_F( BIT_initDStream(&bitD4, istart4, length4) );
806:             endSignal &= BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished;
807:             endSignal &= BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished;
816:             endSignal &= BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished;
817:             endSignal &= BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished;
836:                         (BIT_reloadDStreamFast(&bitD1) == BIT_DStream_unfinished)
837:                       & (BIT_reloadDStreamFast(&bitD2) == BIT_DStream_unfinished)
838:                       & (BIT_reloadDStreamFast(&bitD3) == BIT_DStream_unfinished)
839:                       & (BIT_reloadDStreamFast(&bitD4) == BIT_DStream_unfinished));
856:         { U32 const endCheck = BIT_endOfDStream(&bitD1) & BIT_endOfDStream(&bitD2) & BIT_endOfDStream(&bitD3) & BIT_endOfDStream(&bitD4);
203: #define HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr) \
204:     *ptr++ = HUF_decodeSymbolX1(DStreamPtr, dt, dtLog)
206: #define HUF_DECODE_SYMBOLX1_1(ptr, DStreamPtr)  \
208:         HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
210: #define HUF_DECODE_SYMBOLX1_2(ptr, DStreamPtr) \
212:         HUF_DECODE_SYMBOLX1_0(ptr, DStreamPtr)
255:     HUF_decodeStreamX1(op, &bitD, oend, dt, dtLog);
341:         /* finish bitStreams one by one */
342:         HUF_decodeStreamX1(op1, &bitD1, opStart2, dt, dtLog);
343:         HUF_decodeStreamX1(op2, &bitD2, opStart3, dt, dtLog);
344:         HUF_decodeStreamX1(op3, &bitD3, opStart4, dt, dtLog);
345:         HUF_decodeStreamX1(op4, &bitD4, oend,     dt, dtLog);
684: #define HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr) \
685:     ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
687: #define HUF_DECODE_SYMBOLX2_1(ptr, DStreamPtr) \
689:         ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
691: #define HUF_DECODE_SYMBOLX2_2(ptr, DStreamPtr) \
693:         ptr += HUF_decodeSymbolX2(ptr, DStreamPtr, dt, dtLog)
739:         HUF_decodeStreamX2(ostart, &bitD, oend, dt, dtd.tableLog);
849:         /* finish bitStreams one by one */
850:         HUF_decodeStreamX2(op1, &bitD1, opStart2, dt, dtLog);
851:         HUF_decodeStreamX2(op2, &bitD2, opStart3, dt, dtLog);
852:         HUF_decodeStreamX2(op3, &bitD3, opStart4, dt, dtLog);
853:         HUF_decodeStreamX2(op4, &bitD4, oend,     dt, dtLog);
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);
gdsfmt:src/LZ4/lz4hc.c: [ ]