Found 4974 results in 514 files, showing top 150 files (show more).
seqbias:src/yaml-cpp/stream.cpp: [ ]
180: 	Stream::Stream(std::istream& input)
224: 	Stream::~Stream()
311: 	void Stream::StreamInUtf8() const
320: 	void Stream::StreamInUtf16() const
426: 	void Stream::StreamInUtf32() const
149: 		// We are not allowed to queue the Stream::eof() codepoint, so
151: 		if (static_cast<unsigned long>(Stream::eof()) == ch)
229: 	char Stream::peek() const
233: 			return Stream::eof();
239: 	Stream::operator bool() const
241: 		return m_input.good() || (!m_readahead.empty() && m_readahead[0] != Stream::eof());
246: 	char Stream::get()
262: 	std::string Stream::get(int n)
273: 	void Stream::eat(int n)
279: 	void Stream::AdvanceCurrent()
290: 	bool Stream::_ReadAheadTo(size_t i) const
306: 			m_readahead.push_back(Stream::eof());
399: 	unsigned char Stream::GetNextByte() const
296: 			case utf8: StreamInUtf8(); break;
297: 			case utf16le: StreamInUtf16(); break;
298: 			case utf16be: StreamInUtf16(); break;
299: 			case utf32le: StreamInUtf32(); break;
300: 			case utf32be: StreamInUtf32(); break;
MACPET:R/plot-methods.R: [ ]
187:     FDR = RegCount = X = Y = ymin = ymax = Dist = Tag = Stream = PeakID = NULL
310:                 xsub$end2), Dist = c(xsub$Dist, xsub$Dist), Stream = c(rep("Upper",
313:                 ymax = ymax, color = factor(Stream))) + ggplot2::geom_errorbar(width = 10) +
316:                 ggplot2::labs(color = "Stream") + ggplot2::theme(plot.title = ggplot2::element_text(hjust = 0.5))
seqbias:src/yaml-cpp/stream.h: [ ]
22: 	class Stream: private noncopyable
27: 		Stream(std::istream& input);
28: 		~Stream();
72: 	inline char Stream::CharAt(size_t i) const {
76: 	inline bool Stream::ReadAheadTo(size_t i) const {
25: 		friend class StreamCharSource;
64: 		void StreamInUtf8() const;
65: 		void StreamInUtf16() const;
66: 		void StreamInUtf32() const;
chromstaR:src/logging.h: [ ]
101: inline FILE*& Output2FILE::Stream()
97:     static FILE*& Stream();
109:     FILE* pStream = Stream();
137:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
103:     static FILE* pStream = stderr;
104:     return pStream;
110:     if (!pStream)
112:     fprintf(pStream, "%s", msg.c_str());
113:     fflush(pStream);
AneuFinder:src/logging.h: [ ]
108: inline FILE*& Output2FILE::Stream()
104:     static FILE*& Stream();
116:     FILE* pStream = Stream();
144:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
110:     static FILE* pStream = stderr;
111:     return pStream;
117:     if (!pStream)
119:     fprintf(pStream, "%s", msg.c_str());
120:     fflush(pStream);
gdsfmt:src/CoreArray/dStream.h: [ ]
263: 		COREARRAY_INLINE CdStream &Stream() const { return *fStream; }
993: 		COREARRAY_INLINE CdStream *Stream() const
586: 	class COREARRAY_DLL_DEFAULT CdBaseLZ4Stream: public CdRecodeStream
82: 	class COREARRAY_DLL_DEFAULT CdHandleStream: public CdStream
101: 	class COREARRAY_DLL_DEFAULT CdFileStream: public CdHandleStream
121: 		CdFileStream(): CdHandleStream() {}
127: 	class COREARRAY_DLL_DEFAULT CdForkFileStream: public CdFileStream
152: 	class COREARRAY_DLL_DEFAULT CdTempStream: public CdFileStream
162: 	class COREARRAY_DLL_DEFAULT CdMemoryStream: public CdStream
191: 	class COREARRAY_DLL_DEFAULT CdStdInStream: public CdStream
206: 	class COREARRAY_DLL_DEFAULT CdStdOutStream: public CdStream
240: 	class COREARRAY_DLL_DEFAULT CdRecodeStream: public CdStream
268: 		CdStream *fStream;
290: 	class COREARRAY_DLL_EXPORT ErrRecodeStream: public ErrStream
293: 		ErrRecodeStream(): ErrStream()
295: 		ErrRecodeStream(const std::string &msg): ErrStream()
297: 		ErrRecodeStream(const char *fmt, ...): ErrStream()
449: 	class COREARRAY_DLL_DEFAULT CdBaseZStream: public CdRecodeStream
455: 		z_stream fZStream;
771: 	class COREARRAY_DLL_DEFAULT CdBaseXZStream: public CdRecodeStream
777: 		lzma_stream fXZStream;
905: 	class COREARRAY_DLL_DEFAULT CdBlockStream: public CdStream
917: 			SIZE64 StreamStart, StreamNext;	// Stream Position
963: 	typedef CdBlockStream* PdBlockStream;
1005: 		CdStream *fStream;
965: 	typedef CdBlockStream::TBlockInfo* PdBlockStream_BlockInfo;
269: 		SIZE64 fStreamPos, fStreamBase;
1006: 		SIZE64 fStreamSize;
9: // dStream.h: Stream classes and functions
33:  *	\brief    Stream classes and functions
81: 	/// Stream with a handle
190: 	/// Stream for standard input
205: 	/// Stream for standard output
394: 		/// read the magic number on Stream, return true if succeeds
395: 		virtual bool ReadMagicNumber(CdStream &Stream) = 0;
438: 		/// write the magic number on Stream
439: 		virtual void WriteMagicNumber(CdStream &Stream) = 0;
535: 		virtual void WriteMagicNumber(CdStream &Stream);
554: 		/// read the magic number on Stream
555: 		virtual bool ReadMagicNumber(CdStream &Stream);
602: 		CdBaseLZ4Stream(CdStream &vStream);
607: 		public CdBaseLZ4Stream, public CdRecodeLevel
638: 	class COREARRAY_DLL_DEFAULT CdLZ4Decoder: public CdBaseLZ4Stream
664: 		protected CdRA_Write, public CdBaseLZ4Stream, public CdRecodeLevel
704: 		virtual void WriteMagicNumber(CdStream &Stream);
711: 		public CdRA_Read, public CdBaseLZ4Stream
740: 		/// read the magic number on Stream
741: 		virtual bool ReadMagicNumber(CdStream &Stream);
848: 		virtual void WriteMagicNumber(CdStream &Stream);
867: 		/// read the magic number on Stream
868: 		virtual bool ReadMagicNumber(CdStream &Stream);
923: 			void SetSize(CdStream &Stream, SIZE64 _Size);
924: 			void SetNext(CdStream &Stream, SIZE64 _Next);
925: 			void SetSize2(CdStream &Stream, SIZE64 _Size, SIZE64 _Next);
29:  *	\file     dStream.h
85: 		CdHandleStream();
86: 		CdHandleStream(TSysHandle AHandle);
111: 		CdFileStream(const char *const AFileName, TdOpenMode mode);
112: 		virtual ~CdFileStream();
130: 		CdForkFileStream(const char *const AFileName, TdOpenMode Mode);
155: 		CdTempStream();
156: 		CdTempStream(const char *Path);
157: 		virtual ~CdTempStream();
165: 		CdMemoryStream(size_t Size=0);
166: 		virtual ~CdMemoryStream();
194: 		CdStdInStream();
195: 		virtual ~CdStdInStream();
209: 		CdStdOutStream();
210: 		virtual ~CdStdOutStream();
260: 		CdRecodeStream(CdStream &vStream);
261: 		virtual ~CdRecodeStream();
280: 		CdRecodeLevel(CdRecodeStream::TLevel level);
282: 		COREARRAY_INLINE CdRecodeStream::TLevel Level() const { return fLevel; }
285: 		CdRecodeStream::TLevel fLevel;
331: 		CdRAAlgorithm(CdRecodeStream &owner);
337: 		CdRecodeStream &fOwner;
347: 		CdRA_Read(CdRecodeStream *owner);
387: 		void InitReadStream();
389: 		bool SeekStream(SIZE64 Position);
408: 		CdRA_Write(CdRecodeStream *owner, TBlockSize bs);
411: 		void InitWriteStream();
413: 		void DoneWriteStream();
452: 		CdBaseZStream(CdStream &vStream);
461: 		public CdBaseZStream, public CdRecodeLevel
469: 		CdZEncoder(CdStream &Dest, TLevel Level);
470: 		CdZEncoder(CdStream &Dest, TLevel Level, int windowBits,
493: 	class COREARRAY_DLL_DEFAULT CdZDecoder: public CdBaseZStream
496: 		CdZDecoder(CdStream &Source);
497: 		CdZDecoder(CdStream &Source, int windowBits);
518: 		CdZEncoder_RA(CdStream &Dest, TLevel Level, TBlockSize BlockSize);
523: 		/// Copy from a CdStream object
528: 		virtual void CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count);
548: 		CdZDecoder_RA(CdStream &Source);
562: 	class COREARRAY_DLL_EXPORT EZLibError: public ErrRecodeStream
566: 		EZLibError(const char *fmt, ...): ErrRecodeStream()
610: 		CdLZ4Encoder(CdStream &Dest, CdRecodeStream::TLevel level,
623: 		COREARRAY_INLINE CdRecodeStream::TLevel Level() const { return fLevel; }
641: 		CdLZ4Decoder(CdStream &Source);
667: 		CdLZ4Encoder_RA(CdStream &Dest, TLevel Level,
677: 		/// Copy from a CdStream object
682: 		virtual void CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count);
686: 		COREARRAY_INLINE CdRecodeStream::TLevel Level() const { return fLevel; }
716: 		CdLZ4Decoder_RA(CdStream &Source);
724: 		COREARRAY_INLINE CdRecodeStream::TLevel Level() const { return fLevel; }
728: 		CdRecodeStream::TLevel fLevel;
748: 	class COREARRAY_DLL_EXPORT ELZ4Error: public ErrRecodeStream
751: 		ELZ4Error(): ErrRecodeStream()
753: 		ELZ4Error(const char *fmt, ...): ErrRecodeStream()
755: 		ELZ4Error(const std::string &msg): ErrRecodeStream()
774: 		CdBaseXZStream(CdStream &vStream);
783: 		public CdBaseXZStream, public CdRecodeLevel
786: 		CdXZEncoder(CdStream &Dest, TLevel Level);
787: 		CdXZEncoder(CdStream &Dest, int DictKB);
803: 		void InitXZStream();
808: 	class COREARRAY_DLL_DEFAULT CdXZDecoder: public CdBaseXZStream
811: 		CdXZDecoder(CdStream &Source);
831: 		CdXZEncoder_RA(CdStream &Dest, TLevel Level, TBlockSize BlockSize);
836: 		/// Copy from a CdStream object
841: 		virtual void CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count);
861: 		CdXZDecoder_RA(CdStream &Source);
875: 	class COREARRAY_DLL_EXPORT EXZError: public ErrRecodeStream
878: 		EXZError(): ErrRecodeStream()
880: 		EXZError(const char *fmt, ...): ErrRecodeStream()
882: 		EXZError(const std::string &msg): ErrRecodeStream()
884: 		EXZError(int code): ErrRecodeStream()
928: 		CdBlockStream(CdBlockCollection &vCollection);
929: 		virtual ~CdBlockStream();
972: 		friend class CdBlockStream;
977: 		void LoadStream(CdStream *vStream, bool vReadOnly, bool vAllowError,
979: 		void WriteStream(CdStream *vStream);
982:     	CdBlockStream *NewBlockStream();
984:     	void DeleteBlockStream(TdGDSBlockID id);
987: 		CdBlockStream *operator[] (const TdGDSBlockID &id);
994: 			{ return fStream; }
999: 		COREARRAY_INLINE const vector<CdBlockStream*> &BlockList() const
1001: 		COREARRAY_INLINE const CdBlockStream::TBlockInfo* UnusedBlock() const
1007: 		PdBlockStream_BlockInfo fUnuse;
1008: 		vector<CdBlockStream*> fBlockList;
1013: 		void _IncStreamSize(CdBlockStream &Block, const SIZE64 NewSize);
1014: 		void _DecStreamSize(CdBlockStream &Block, const SIZE64 NewSize);
1015: 		PdBlockStream_BlockInfo _NeedBlock(SIZE64 Size, bool Head);
272: 		inline void UpdateStreamPosition();
gdsfmt:src/CoreArray/dStream.cpp: [ ]
1466: CdBaseLZ4Stream::CdBaseLZ4Stream(CdStream &vStream):
44: CdHandleStream::CdHandleStream(): CdStream()
49: CdHandleStream::CdHandleStream(TSysHandle AHandle): CdStream()
88: CdFileStream::CdFileStream(const char *const AFileName, TdOpenMode Mode):
94: CdFileStream::~CdFileStream()
128: CdForkFileStream::CdForkFileStream(const char *const AFileName, TdOpenMode Mode):
192: CdTempStream::CdTempStream(): CdFileStream(
196: CdTempStream::CdTempStream(const char *Path): CdFileStream(
200: CdTempStream::~CdTempStream()
218: CdMemoryStream::CdMemoryStream(size_t Size): CdStream()
225: CdMemoryStream::~CdMemoryStream()
313: CdStdInStream::CdStdInStream(): CdStream()
316: CdStdInStream::~CdStdInStream()
349: CdStdOutStream::CdStdOutStream(): CdStream()
352: CdStdOutStream::~CdStdOutStream()
391: CdRecodeStream::CdRecodeStream(CdStream &vStream): CdStream()
399: CdRecodeStream::~CdRecodeStream()
462: void CdRA_Read::InitReadStream()
530: bool CdRA_Read::SeekStream(SIZE64 Position)
696: void CdRA_Write::InitWriteStream()
722: void CdRA_Write::DoneWriteStream()
859: CdBaseZStream::CdBaseZStream(CdStream &vStream): CdRecodeStream(vStream)
2211: CdBaseXZStream::CdBaseXZStream(CdStream &vStream): CdRecodeStream(vStream)
2253: void CdXZEncoder::InitXZStream()
2863: CdBlockStream::CdBlockStream(CdBlockCollection &vCollection):
2877: CdBlockStream::~CdBlockStream()
3284: CdBlockStream *CdBlockCollection::NewBlockStream()
3319: void CdBlockCollection::LoadStream(CdStream *vStream, bool vReadOnly,
3482: void CdBlockCollection::WriteStream(CdStream *vStream)
3525: void CdBlockCollection::DeleteBlockStream(TdGDSBlockID id)
405: inline void CdRecodeStream::UpdateStreamPosition()
3122: void CdBlockCollection::_IncStreamSize(CdBlockStream &Block,
3180: void CdBlockCollection::_DecStreamSize(CdBlockStream &Block,
9: // dStream.cpp: Stream classes and functions
1221: void CdZEncoder_RA::WriteMagicNumber(CdStream &Stream)
1223: 	Stream.WriteData(ZRA_MAGIC_HEADER, ZRA_MAGIC_HEADER_SIZE);
1416: bool CdZDecoder_RA::ReadMagicNumber(CdStream &Stream)
1419: 	Stream.SetPosition(fStreamBase);
1420: 	Stream.ReadData(Header, sizeof(Header));
1460: 	"Invalid LZ4 Deflate Stream operation '%s'!";
1462: 	"Invalid LZ4 Inflate Stream operation '%s'!";
1474: 	TLZ4Chunk chunk): CdBaseLZ4Stream(Dest), CdRecodeLevel(level)
1613: CdLZ4Decoder::CdLZ4Decoder(CdStream &Source): CdBaseLZ4Stream(Source)
1732: 	CdRA_Write(this, BK), CdBaseLZ4Stream(Dest), CdRecodeLevel(Level)
1862: void CdLZ4Encoder_RA::WriteMagicNumber(CdStream &Stream)
1864: 	Stream.WriteData(LZ4_MAGIC_HEADER, LZ4_MAGIC_HEADER_SIZE);
1865: 	Stream.W8b(fLevel);
2011: 	CdRA_Read(this), CdBaseLZ4Stream(Source)
2134: bool CdLZ4Decoder_RA::ReadMagicNumber(CdStream &Stream)
2137: 	Stream.SetPosition(fStreamBase);
2138: 	Stream.ReadData(Header, sizeof(Header));
2141: 		fLevel = (CdRecodeStream::TLevel)((C_Int8)Stream.R8b());
2167: 	"Invalid xz deflate Stream operation '%s'!";
2169: 	"Invalid xz inflate Stream operation '%s'!";
2574: void CdXZEncoder_RA::WriteMagicNumber(CdStream &Stream)
2576: 	Stream.WriteData(XZ_RA_MAGIC_HEADER, XZ_RA_MAGIC_HEADER_SIZE);
2765: bool CdXZDecoder_RA::ReadMagicNumber(CdStream &Stream)
2768: 	Stream.SetPosition(fStreamBase);
2769: 	Stream.ReadData(Header, sizeof(Header));
2796: // CoreArray GDS Stream position mask
2833: void CdBlockStream::TBlockInfo::SetSize(CdStream &Stream, SIZE64 _Size)
2837: 	Stream.SetPosition(StreamStart - L);
2838: 	BYTE_LE<CdStream>(Stream) <<
2842: void CdBlockStream::TBlockInfo::SetNext(CdStream &Stream, SIZE64 _Next)
2845: 	Stream.SetPosition(StreamStart -
2847: 	BYTE_LE<CdStream>(Stream) << TdGDSPos(_Next);
2850: void CdBlockStream::TBlockInfo::SetSize2(CdStream &Stream,
2856: 	Stream.SetPosition(StreamStart - L);
2857: 	BYTE_LE<CdStream>(Stream)
2893: 		CdStream *vStream = fCollection.Stream();
2936: 		CdStream *vStream = fCollection.Stream();
3073: 			CdStream *s = fCollection.Stream();
28: #include "dStream.h"
42: // CdHandleStream
54: ssize_t CdHandleStream::Read(void *Buffer, ssize_t Count)
62: ssize_t CdHandleStream::Write(const void *Buffer, ssize_t Count)
70: SIZE64 CdHandleStream::Seek(SIZE64 Offset, TdSysSeekOrg Origin)
78: void CdHandleStream::SetSize(SIZE64 NewSize)
86: // CdFileStream
89: 	CdHandleStream()
103: void CdFileStream::Init(const char *const AFileName, TdOpenMode mode)
113: 			throw ErrStream(ERR_FILE_CREATE, AFileName, LastSysErrMsg().c_str());
118: 			throw ErrStream(ERR_FILE_OPEN, AFileName, LastSysErrMsg().c_str());
129: 	CdFileStream()
136: 	if (Mode == fmCreate) throw ErrStream(ERR_FORK_FILE);
140: ssize_t CdForkFileStream::Read(void *Buffer, ssize_t Count)
143: 	return CdFileStream::Read(Buffer, Count);
146: ssize_t CdForkFileStream::Write(const void *Buffer, ssize_t Count)
149: 	return CdFileStream::Write(Buffer, Count);
152: SIZE64 CdForkFileStream::Seek(SIZE64 Offset, TdSysSeekOrg Origin)
155: 	return CdFileStream::Seek(Offset, Origin);
158: SIZE64 CdForkFileStream::GetSize()
161: 	return CdFileStream::GetSize();
164: void CdForkFileStream::SetSize(SIZE64 NewSize)
167: 	CdFileStream::SetSize(NewSize);
170: COREARRAY_INLINE void CdForkFileStream::RedirectFile()
190: // CdTempStream
193: 	TempFileName("tmp", ".").c_str(), CdFileStream::fmCreate)
197: 	TempFileName("tmp", Path).c_str(), CdFileStream::fmCreate)
216: // CdMemoryStream
234: ssize_t CdMemoryStream::Read(void *Buffer, ssize_t Count)
247: ssize_t CdMemoryStream::Write(const void *Buffer, ssize_t Count)
257: SIZE64 CdMemoryStream::Seek(SIZE64 Offset, TdSysSeekOrg Origin)
272: 		throw ErrStream(ERR_SEEK, fPosition);
276: SIZE64 CdMemoryStream::GetSize()
281: void CdMemoryStream::SetSize(SIZE64 NewSize)
291: 				throw ErrStream(ERR_SETSIZE, NewSize);
302: void *CdMemoryStream::BufPointer()
309: // CdStdInStream
319: ssize_t CdStdInStream::Read(void *Buffer, ssize_t Count)
325: ssize_t CdStdInStream::Write(const void *Buffer, ssize_t Count)
327: 	static const char *ERR_STDIN_WRITE = "CdStdInStream::Write() fails.";
328: 	throw ErrStream(ERR_STDIN_WRITE);
331: SIZE64 CdStdInStream::Seek(SIZE64 Offset, TdSysSeekOrg Origin)
336: SIZE64 CdStdInStream::GetSize()
341: void CdStdInStream::SetSize(SIZE64 NewSize)
343: 	static const char *ERR_STDIN_SETSIZE = "CdStdInStream::SetSize() fails.";
344: 	throw ErrStream(ERR_STDIN_SETSIZE);
347: // CdStdOutStream
355: ssize_t CdStdOutStream::Read(void *Buffer, ssize_t Count)
357: 	static const char *ERR_STDOUT_READ = "CdStdOutStream::Read() fails.";
358: 	throw ErrStream(ERR_STDOUT_READ);
361: ssize_t CdStdOutStream::Write(const void *Buffer, ssize_t Count)
367: SIZE64 CdStdOutStream::Seek(SIZE64 Offset, TdSysSeekOrg Origin)
372: SIZE64 CdStdOutStream::GetSize()
377: void CdStdOutStream::SetSize(SIZE64 NewSize)
379: 	static const char *ERR_STDOUT_SETSIZE = "CdStdOutStream::SetSize() fails.";
380: 	throw ErrStream(ERR_STDOUT_SETSIZE);
389: // CdRecodeStream
393: 	fStream = &vStream;
394: 	fStream->AddRef();
395: 	fStreamBase = fStreamPos = vStream.Position();
401: 	if (fStream)
402: 		fStream->Release();
407: 	if (fStream->Position() != fStreamPos)
408: 		fStream->SetPosition(fStreamPos);
412: CdRecodeLevel::CdRecodeLevel(CdRecodeStream::TLevel level)
415: 	if ((level < CdRecodeStream::clMin) || (level > CdRecodeStream::clCustom))
416: 		throw ErrRecodeStream(ERR_LEVEL, (int)level);
425: // CdRandomAccessStream
435: CdRAAlgorithm::CdRAAlgorithm(CdRecodeStream &owner):
444: CdRA_Read::CdRA_Read(CdRecodeStream *owner):
470: 	fOwner.fStreamBase = fOwner.fStream->Position();
472: 	if (!ReadMagicNumber(*fOwner.fStream))
473: 		throw ErrRecodeStream("Invalid stream header with random access.");
475: 	fVersion = fOwner.fStream->R8b();
477: 		throw ErrStream(ERR_UNSUPPORT, fVersion >> 4, fVersion & 0x0F);
479: 	C_Int8 b = fOwner.fStream->R8b();
483: 	BYTE_LE<CdStream>(fOwner.fStream) >> fBlockNum;
484: 	fBlockListStart = fOwner.fStreamPos = fOwner.fStream->Position();
492: 		throw ErrStream(ERR_BLOCK_NUM);
513: 		BYTE_LE<CdStream>(fOwner.fStream) >> Len;
527: 		throw ErrStream(ERR_UNSUPPORT, fVersion >> 4, fVersion & 0x0F);
534: 		throw ErrStream(ERR_SEEK, Position);
559: 							throw ErrStream(ERR_SEEK, Position);
563: 				throw ErrStream(ERR_SEEK, Position);
646: 	fOwner.fStream->SetPosition(fCB_ZStart);
647: 	fOwner.fStream->ReadData(BSZ, SIZE_RA_BLOCK_HEADER);
659: 		fOwner.fStream->SetPosition(fIndexingStart);
664: 			fOwner.fStream->ReadData(BSZ, SIZE_RA_BLOCK_HEADER);
675: 		fOwner.fStream->SetPosition(fOwner.fStreamPos);
682: CdRA_Write::CdRA_Write(CdRecodeStream *owner, TBlockSize bs):
699: 	fOwner.fStreamBase = fOwner.fStream->Position();
701: 	WriteMagicNumber(*fOwner.fStream);
703: 	fOwner.fStream->W8b(fVersion);
705: 	fOwner.fStream->W8b(fSizeType);
707: 	BYTE_LE<CdStream>(fOwner.fStream) << C_Int32(-1);
709: 	fBlockListStart = fOwner.fStreamPos = fOwner.fStream->Position();
713: 		BYTE_LE<CdStream>(fOwner.fStream) << TdGDSPos(0);
729: 		fOwner.fStream->WriteData(&Val, SIZE_RA_BLOCK_HEADER);
740: 		fOwner.fStream->SetPosition(fBlockListStart - sizeof(C_Int32));
741: 		BYTE_LE<CdStream>(fOwner.fStream) << C_Int32(fBlockNum);
744: 		fOwner.fStream->SetPosition(fBlockListStart - sizeof(C_Int32) -
746: 		BYTE_LE<CdStream>(fOwner.fStream) << C_Int32(fBlockNum) <<
749: 		fOwner.fStream->SetPosition(OldPos);
765: 			fOwner.fStream->WriteData(SZ, SIZE_RA_BLOCK_HEADER);
770: 	fOwner.fStream->SetPosition(fOwner.fStreamPos=OldPos);
782: 			fOwner.fStream->WriteData(&Val, SIZE_RA_BLOCK_HEADER);
809: 			fOwner.fStream->SetPosition(fCB_ZStart);
810: 			fOwner.fStream->WriteData(SZ, SIZE_RA_BLOCK_HEADER);
811: 			fOwner.fStream->SetPosition(fOwner.fStreamPos);
857: // CdBaseZStream
861: 	memset((void*)&fZStream, 0, sizeof(z_stream));
866: CdZEncoder::CdZEncoder(CdStream &Dest, TLevel Level):
867: 	CdBaseZStream(Dest), CdRecodeLevel(Level)
870: 	fZStream.next_out = fBuffer;
871: 	fZStream.avail_out = sizeof(fBuffer);
873: 	ZCheck( deflateInit_(&fZStream, ZLevels[Level],
874: 		ZLIB_VERSION, sizeof(fZStream)) );
877: CdZEncoder::CdZEncoder(CdStream &Dest, TLevel Level, int windowBits,
878: 	int memLevel, int Strategy): CdBaseZStream(Dest), CdRecodeLevel(Level)
881: 	fZStream.next_out = fBuffer;
882: 	fZStream.avail_out = sizeof(fBuffer);
886: 	ZCheck( deflateInit2_(&fZStream, ZLevels[Level],
888: 		ZLIB_VERSION, sizeof(fZStream)) );
895: 	deflateEnd(&fZStream);
907: 	fZStream.next_in = (Bytef*)Buffer;
908: 	fZStream.avail_in = Count;
909: 	ssize_t L = fZStream.avail_in;
911: 	while (fZStream.avail_in > 0)
913: 		ZCheck(deflate(&fZStream, Z_NO_FLUSH));
914: 		fTotalIn += L - fZStream.avail_in;
915: 		L = fZStream.avail_in;
916: 		if (fZStream.avail_out <= 0)
919: 			fStream->WriteData(fBuffer, sizeof(fBuffer));
922: 			fZStream.next_out = fBuffer;
923: 			fZStream.avail_out = sizeof(fBuffer);
970: 	return sizeof(fBuffer) - fZStream.avail_out;
975: 	fZStream.next_in = NULL;
976: 	fZStream.avail_in = 0;
979: 	while (ZCheck(deflate(&fZStream, Z_FINISH)) != Z_STREAM_END)
981: 		ssize_t L = sizeof(fBuffer) - fZStream.avail_out;
982: 		fStream->WriteData(fBuffer, L);
984: 		fZStream.next_out = fBuffer;
985: 		fZStream.avail_out = sizeof(fBuffer);
988: 	if (fZStream.avail_out < sizeof(fBuffer))
990: 		ssize_t L = sizeof(fBuffer) - fZStream.avail_out;
991: 		fStream->WriteData(fBuffer, L);
1001: CdZDecoder::CdZDecoder(CdStream &Source):
1002: 	CdBaseZStream(Source)
1004: 	fZStream.next_in = fBuffer;
1005: 	fZStream.avail_in = 0;
1007: 	ZCheck(inflateInit_(&fZStream, ZLIB_VERSION, sizeof(fZStream)));
1010: CdZDecoder::CdZDecoder(CdStream &Source, int windowBits):
1011: 	CdBaseZStream(Source)
1013: 	fZStream.next_in = fBuffer;
1014: 	fZStream.avail_in = 0;
1016: 	ZCheck(inflateInit2_(&fZStream, windowBits, ZLIB_VERSION, sizeof(fZStream)));
1021: 	inflateEnd(&fZStream);
1026: 	fZStream.next_out = (Bytef*)Buffer;
1032: 		if (fZStream.avail_in <= 0)
1035: 			fZStream.avail_in = fStream->Read(fBuffer, sizeof(fBuffer));
1036: 			fStreamPos += fZStream.avail_in;
1037: 			if (fZStream.avail_in <= 0)
1039: 			fZStream.next_in = fBuffer;
1042: 		fZStream.avail_out = Count;
1043: 		ZResult = ZCheck(inflate(&fZStream, Z_NO_FLUSH));
1045: 		ssize_t L = Count - fZStream.avail_out;
1050: 	if ((ZResult==Z_STREAM_END) && (fZStream.avail_in>0))
1052: 		fStreamPos -= fZStream.avail_in;
1053: 		fStream->SetPosition(fStreamPos);
1054: 		fZStream.avail_in = 0;
1074: 		ZCheck(inflateReset(&fZStream));
1075: 		fZStream.next_in = fBuffer;
1076: 		fZStream.avail_in = 0;
1077: 		fStream->SetPosition(fStreamPos = fStreamBase);
1140: CdZEncoder_RA::CdZEncoder_RA(CdStream &Dest, TLevel Level,
1149: 	InitWriteStream();
1165: 		fZStream.next_in = (Bytef*)pBuf;
1166: 		fZStream.avail_in = Count;
1168: 		while (fZStream.avail_in > 0)
1170: 			ZCheck(deflate(&fZStream, Z_NO_FLUSH));
1171: 			ssize_t L = Count - fZStream.avail_in;
1173: 			Count = fZStream.avail_in;
1176: 			if (fZStream.avail_out <= 0)
1179: 				fStream->WriteData(fBuffer, sizeof(fBuffer));
1181: 				fZStream.next_out = fBuffer;
1182: 				fZStream.avail_out = sizeof(fBuffer);
1187: 				ZCheck(ZLIB_DEFLATE_PENDING(&fZStream, &pending, &bits));
1194: 					// 'fZStream.avail_in = 0' in SyncFinishBlock()
1216: 		DoneWriteStream();
1233: 		fZStream.next_out = fBuffer;
1234: 		fZStream.avail_out = sizeof(fBuffer);
1235: 		ZCheck(deflateReset(&fZStream));
1239: void CdZEncoder_RA::CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count)
1271: 				Src->SeekStream(Pos);
1289: 					fStream->CopyFrom(*Src->fStream, Start, ZSize);
1310: 	CdStream::CopyFrom(Source, Pos, Count);
1318: CdZDecoder_RA::CdZDecoder_RA(CdStream &Source):
1321: 	InitReadStream();
1334: 		fZStream.next_out = (Bytef*)pBuf;
1339: 			if (fZStream.avail_in <= 0)
1346: 					fStream->SetPosition(fStreamPos);
1347: 					fZStream.avail_in = fStream->Read(fBuffer, s);
1348: 					if (fZStream.avail_in <= 0)
1351: 					fStreamPos += fZStream.avail_in;
1352: 					fZStream.next_in = fBuffer;
1356: 			fZStream.avail_out = Count;
1357: 			ZResult = ZCheck(inflate(&fZStream, Z_NO_FLUSH));
1359: 			ssize_t L = Count - fZStream.avail_out;
1373: 				fZStream.next_in = fBuffer;
1374: 				fZStream.avail_in = 0;
1375: 				ZCheck(inflateReset(&fZStream));
1398: 	bool flag = SeekStream(Offset);
1426: 	fZStream.next_in = fBuffer;
1427: 	fZStream.avail_in = 0;
1428: 	ZCheck(inflateReset(&fZStream));
1437: EZLibError::EZLibError(int Code): ErrRecodeStream()
1467: 	CdRecodeStream(vStream)
1473: CdLZ4Encoder::CdLZ4Encoder(CdStream &Dest, CdRecodeStream::TLevel level,
1505: 	fStream->SetPosition(fStreamBase);
1506: 	fStream->WriteData(fCompress, s);
1553: 			fStream->WriteData(fCompress, s);
1602: 		fStream->WriteData(fCompress, s);
1644: 			ssize_t Cnt = fStream->Read(fBuffer, sizeof(fBuffer));
1688: 		fStream->SetPosition(fStreamPos = fStreamBase);
1731: CdLZ4Encoder_RA::CdLZ4Encoder_RA(CdStream &Dest, TLevel Level, TBlockSize BK):
1753: 	InitWriteStream();
1857: 		DoneWriteStream();
1881: 		BYTE_LE<CdStream>(fStream) << (C_UInt16)(bufsize);
1882: 		fStream->WriteData(fRawBuffer[_IdxRaw], bufsize);
1895: 		fStream->WriteData(LZ4Buffer, size);
1907: 		fStream->WriteData(LZ4Buffer, size);
1927: void CdLZ4Encoder_RA::CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count)
1959: 				Src->SeekStream(Pos);
1982: 					fStream->CopyFrom(*Src->fStream, Start, ZSize);
2003: 	CdStream::CopyFrom(Source, Pos, Count);
2010: CdLZ4Decoder_RA::CdLZ4Decoder_RA(CdStream &Source):
2014: 	InitReadStream();
2036: 			BYTE_LE<CdStream>(fStream) >> Len;
2041: 				fStream->ReadData(LZ4Buffer, Len);
2053: 				fStream->ReadData(fRawBuffer[_IdxRaw], Len);
2106: 	bool flag = SeekStream(Offset);
2209: // CdBaseXZStream
2213: 	memset((void*)&fXZStream, 0, sizeof(fXZStream));
2219: CdXZEncoder::CdXZEncoder(CdStream &Dest, TLevel Level):
2220: 	CdBaseXZStream(Dest), CdRecodeLevel(Level)
2224: 	InitXZStream();
2227: CdXZEncoder::CdXZEncoder(CdStream &Dest, int DictKB):
2228: 	CdBaseXZStream(Dest), CdRecodeLevel(clCustom)
2244: 	XZCheck(lzma_stream_encoder(&fXZStream, filters, LZMA_CHECK_CRC32));
2250: 	lzma_end(&fXZStream);
2257: 		XZCheck(lzma_easy_encoder(&fXZStream, XZLevels[fLevel],
2270: 		XZCheck(lzma_stream_encoder(&fXZStream, filters, LZMA_CHECK_CRC32));
2287: 	fXZStream.next_in = (const C_UInt8 *)Buffer;
2288: 	fXZStream.avail_in = Count;
2289: 	ssize_t L = fXZStream.avail_in;
2291: 	while (fXZStream.avail_in > 0)
2293: 		fXZStream.avail_out = sizeof(buf);
2294: 		fXZStream.next_out = buf;
2296: 		XZCheck(lzma_code(&fXZStream, LZMA_RUN));
2297: 		fTotalIn += L - fXZStream.avail_in;
2298: 		L = fXZStream.avail_in;
2300: 		size_t nout = sizeof(buf) - fXZStream.avail_out;
2304: 			fStream->WriteData(buf, nout);
2358: 		fXZStream.avail_out = sizeof(buffer);
2359: 		fXZStream.next_out = buffer;
2361: 		ret = lzma_code(&fXZStream, LZMA_FINISH);
2364: 		size_t nout = sizeof(buffer) - fXZStream.avail_out;
2368: 			fStream->WriteData(buffer, nout);
2385: CdXZDecoder::CdXZDecoder(CdStream &Source): CdBaseXZStream(Source)
2387: 	fXZStream.avail_in = 0;
2389: 	XZCheck(lzma_stream_decoder(&fXZStream, UINT64_MAX, XZ_DECODER_FLAG));
2394: 	lzma_end(&fXZStream);
2405: 		if (fXZStream.avail_in <= 0)
2408: 			fXZStream.avail_in = fStream->Read(fBuffer, sizeof(fBuffer));
2409: 			if (fXZStream.avail_in <= 0)
2411: 			fStreamPos += fXZStream.avail_in;
2412: 			fXZStream.next_in = fBuffer;
2415: 		fXZStream.avail_out = Count;
2416: 		fXZStream.next_out = pBuffer;
2417: 		ret = lzma_code(&fXZStream, LZMA_RUN);
2421: 		ssize_t n = Count - fXZStream.avail_out;
2427: 	if ((ret==LZMA_STREAM_END) && (fXZStream.avail_in>0))
2429: 		fStreamPos -= fXZStream.avail_in;
2430: 		fStream->SetPosition(fStreamPos);
2431: 		fXZStream.avail_in = 0;
2451: 		lzma_end(&fXZStream);
2452: 		XZCheck(lzma_stream_decoder(&fXZStream, UINT64_MAX, XZ_DECODER_FLAG));
2453: 		fXZStream.avail_in = 0;
2454: 		fStream->SetPosition(fStreamPos = fStreamBase);
2498: CdXZEncoder_RA::CdXZEncoder_RA(CdStream &Dest, TLevel Level,
2502: 	InitWriteStream();
2519: 		fXZStream.next_in = pBuf;
2520: 		fXZStream.avail_in = Count;
2521: 		fXZStream.next_out = buf;
2522: 		fXZStream.avail_out = sizeof(buf);
2524: 		while (fXZStream.avail_in > 0)
2526: 			XZCheck(lzma_code(&fXZStream, LZMA_RUN));
2527: 			ssize_t L = Count - fXZStream.avail_in;
2530: 			Count = fXZStream.avail_in;
2533: 			ssize_t n  = sizeof(buf) - fXZStream.avail_out;
2537: 				fStream->WriteData(buf, n);
2539: 				fXZStream.next_out = buf;
2540: 				fXZStream.avail_out = sizeof(buf);
2547: 					// 'fZStream.avail_in = 0' in SyncFinishBlock()
2569: 		DoneWriteStream();
2583: 		fXZStream.avail_in = 0;
2587: 		lzma_end(&fXZStream);
2588: 		InitXZStream();
2592: void CdXZEncoder_RA::CopyFrom(CdStream &Source, SIZE64 Pos, SIZE64 Count)
2624: 				Src->SeekStream(Pos);
2642: 					fStream->CopyFrom(*Src->fStream, Start, ZSize);
2663: 	CdStream::CopyFrom(Source, Pos, Count);
2669: CdXZDecoder_RA::CdXZDecoder_RA(CdStream &Source): CdRA_Read(this),
2672: 	InitReadStream();
2689: 			if (fXZStream.avail_in <= 0)
2695: 				fXZStream.avail_in = fStream->Read(fBuffer, n);
2696: 				if (fXZStream.avail_in <= 0)
2698: 				fStreamPos += fXZStream.avail_in;
2699: 				fXZStream.next_in = fBuffer;
2702: 			fXZStream.avail_out = Count;
2703: 			fXZStream.next_out = pBuffer;
2704: 			ret = lzma_code(&fXZStream, LZMA_RUN);
2708: 			ssize_t n = Count - fXZStream.avail_out;
2722: 				lzma_end(&fXZStream);
2723: 				XZCheck(lzma_stream_decoder(&fXZStream, UINT64_MAX, XZ_DECODER_FLAG));
2724: 				fXZStream.avail_in = 0;
2747: 	bool flag = SeekStream(Offset);
2775: 	lzma_end(&fXZStream);
2776: 	XZCheck(lzma_stream_decoder(&fXZStream, UINT64_MAX, XZ_DECODER_FLAG));
2777: 	fXZStream.avail_in = 0;
2792: 	"Invalid Position: %lld in CdBlockStream (current blocksize: %lld).";
2801: // CdBlockStream
2803: inline static void xClearList(CdBlockStream::TBlockInfo *Head)
2805: 	for (CdBlockStream::TBlockInfo *p=Head; p; )
2807: 		CdBlockStream::TBlockInfo *q = p;
2813: CdBlockStream::TBlockInfo::TBlockInfo()
2816: 	BlockStart = BlockSize = StreamStart = StreamNext = 0;
2820: CdBlockStream::TBlockInfo::TBlockInfo(bool head, SIZE64 bs, SIZE64 ss, SIZE64 sn)
2824: 	BlockSize = bs; StreamStart = ss; StreamNext = sn;
2828: SIZE64 CdBlockStream::TBlockInfo::AbsStart() const
2830: 	return StreamStart - (Head ? (HEAD_SIZE+2*GDS_POS_SIZE) : (2*GDS_POS_SIZE));
2844: 	StreamNext = _Next;
2854: 	StreamNext = _Next;
2864: 	CdStream(), fCollection(vCollection)
2871: 	if (vCollection.fStream)
2873: 		vCollection.fStream->AddRef();
2881: 	if (fCollection.fStream)
2882: 		fCollection.fStream->Release();
2885: ssize_t CdBlockStream::Read(void *Buffer, ssize_t Count)
2894: 		if (!vStream) return 0;
2904: 				vStream->SetPosition(fCurrent->StreamStart + I);
2905: 				RL = vStream->Read((void*)p, Count);
2911: 					vStream->SetPosition(fCurrent->StreamStart + I);
2912: 					RL = vStream->Read((void*)p, L);
2926: ssize_t CdBlockStream::Write(const void *Buffer, ssize_t Count)
2937: 		if (!vStream) return 0;
2946: 				vStream->SetPosition(fCurrent->StreamStart + I);
2947: 				fPosition += vStream->Write(p, Count);
2952: 					vStream->SetPosition(fCurrent->StreamStart + I);
2953: 					RL = vStream->Write(p, L);
2973: SIZE64 CdBlockStream::Seek(SIZE64 Offset, TdSysSeekOrg Origin)
3000: 		throw ErrStream(ERR_BLOCK_INVALID_POS, rv, (C_Int64)fBlockSize);
3005: SIZE64 CdBlockStream::GetSize()
3010: SIZE64 CdBlockStream::GetSize() const
3015: void CdBlockStream::SetSize(SIZE64 NewSize)
3034: void CdBlockStream::SetSizeOnly(SIZE64 NewSize)
3054: bool CdBlockStream::ReadOnly() const
3059: int CdBlockStream::ListCount() const
3067: void CdBlockStream::SyncSizeInfo()
3074: 			s->SetPosition(fList->StreamStart - GDS_POS_SIZE);
3075: 			BYTE_LE<CdStream>(*s) << TdGDSPos(fBlockSize);
3081: CdBlockStream::TBlockInfo *CdBlockStream::_FindCur(const SIZE64 Pos)
3108: 	fStream = NULL;
3128: 		CdBlockStream::TBlockInfo *p = Block.fList;
3131: 		SIZE64 L = p->BlockSize + p->StreamStart;
3138: 			fStream->SetSize(L); fStreamSize = L;
3140: 			p->SetSize(*fStream, NewCapacity - p->BlockStart);
3152: 			CdBlockStream::TBlockInfo *n =
3157: 			p->SetNext(*fStream, n->AbsStart());
3163: 			throw ErrStream(ERR_INVALID_BLOCK_LEN);
3167: 		CdBlockStream::TBlockInfo *n =
3174: 		fStream->SetPosition(n->StreamStart -
3175: 			CdBlockStream::TBlockInfo::HEAD_SIZE);
3176: 		BYTE_LE<CdStream>(fStream) << Block.fID << TdGDSPos(0);
3184: 	CdBlockStream::TBlockInfo *p, *q;
3204: 		q->SetNext(*fStream, 0);
3210: 			p->SetSize2(*fStream, p->BlockSize, 0);
3220: CdBlockStream::TBlockInfo *CdBlockCollection::_NeedBlock(
3224: 		Size += CdBlockStream::TBlockInfo::HEAD_SIZE;
3227: 	CdBlockStream::TBlockInfo *p = fUnuse;
3228: 	CdBlockStream::TBlockInfo *rv, *q, *qrv;
3252: 		fStream->SetSize(fStreamSize);
3255: 		rv = new CdBlockStream::TBlockInfo;
3256: 		rv->StreamStart = Pos + 2*GDS_POS_SIZE +
3257: 			(Head ? CdBlockStream::TBlockInfo::HEAD_SIZE : 0);
3259: 		rv->SetSize2(*fStream,
3260: 			Size - (Head ? CdBlockStream::TBlockInfo::HEAD_SIZE : 0), 0);
3275: 			rv->BlockSize -= CdBlockStream::TBlockInfo::HEAD_SIZE;
3276: 			rv->StreamStart += CdBlockStream::TBlockInfo::HEAD_SIZE;
3278: 		rv->SetSize2(*fStream, rv->BlockSize, 0);
3287: 	static const char *ERR_INTERNAL = "CdBlockCollection::fStream = NULL.";
3288: 	if (!fStream) throw ErrStream(ERR_INTERNAL);
3293: 	CdBlockStream *rv = new CdBlockStream(*this);
3302: 	vector<CdBlockStream*>::const_iterator it;
3311: 	vector<CdBlockStream*>::const_iterator it;
3314: 	for (CdBlockStream::TBlockInfo *p=fUnuse; p; p=p->Next)
3331: 	if (fStream) throw ErrStream(ERR_INTERNAL_CALL);
3332: 	(fStream=vStream)->AddRef();
3334: 	CdBlockStream::TBlockInfo *p = fUnuse;
3335: 	fStream->SetPosition(fCodeStart);
3336: 	fStreamSize = fStream->GetSize();
3337: 	SIZE64 pos = fStream->Position();
3345: 		BYTE_LE<CdStream>(fStream) >> sSize >> sNext;
3352: 				throw ErrStream(ERR_SIZE1, sz, pos);
3357: 		pos = fStream->Position() + s;
3361: 				throw ErrStream(ERR_SIZE_END, sz, pos);
3365: 			s = pos - fStream->Position();
3371: 				throw ErrStream(ERR_NEXT, sNext.Get());
3378: 		int L = head ? CdBlockStream::TBlockInfo::HEAD_SIZE : 0;
3382: 				throw ErrStream(ERR_SIZE2, sz, pos);
3387: 		CdBlockStream::TBlockInfo *n = new CdBlockStream::TBlockInfo(head, s - L,
3388: 			fStream->Position() + L, sNext);
3392: 		fStream->SetPosition(pos);
3399: 			throw ErrStream(ERR_GDS_END);
3408: 		CdBlockStream::TBlockInfo *q=NULL;
3420: 			CdBlockStream *bs = new CdBlockStream(*this);
3424: 			fStream->SetPosition(p->StreamStart - CdBlockStream::TBlockInfo::HEAD_SIZE);
3425: 			BYTE_LE<CdStream>(fStream) >> bs->fID >> bs->fBlockSize;
3430: 			CdBlockStream::TBlockInfo *n = fUnuse;
3432: 			while (n && (p->StreamNext != 0))
3434: 				if (p->StreamNext == n->AbsStart())
3450: 							throw ErrStream(ERR_BLOCK, id, p->StreamNext);
3452: 							Log->Add(CdLogRecord::LOG_ERROR, ERR_BLOCK, id, p->StreamNext);
3453: 						p->StreamNext = 0;
3460: 			if (!n && (p->StreamNext != 0))
3464: 					throw ErrStream(ERR_BLOCK, id, p->StreamNext);
3466: 					Log->Add(CdLogRecord::LOG_ERROR, ERR_BLOCK, id, p->StreamNext);
3467: 				p->StreamNext = 0;
3484: 	if (fStream) throw ErrStream(ERR_INTERNAL_CALL);
3485: 	(fStream=vStream)->AddRef();
3487: 	fStream->SetSize(fStreamSize=fCodeStart);
3494: 		"CdBlockStream::Release() should return 0 in CdBlockCollection::Clear().";
3496: 	vector<CdBlockStream*>::iterator it;
3499: 		CdBlockStream *p = *it;
3504: 			if (p->Release() != 0) throw ErrStream(ERR_INTERNAL);
3512: 	if (fStream)
3515: 		if (fStream->Release() != 0) throw ErrStream(ERR_INTERNAL);
3517: 		fStream->Release();
3519: 		fStream = NULL;
3528: 	vector<CdBlockStream*>::iterator it;
3535: 		CdBlockStream::TBlockInfo *p=(*it)->fList, *q=NULL;
3540: 				p->BlockSize += CdBlockStream::TBlockInfo::HEAD_SIZE;
3541: 				p->StreamStart -= CdBlockStream::TBlockInfo::HEAD_SIZE;
3544: 			p->SetSize2(*fStream, p->BlockSize, 0);
3559: 		throw ErrStream(ERR_INVALID_BLOCK_ID, int(id.Get()));
3563: CdBlockStream *CdBlockCollection::operator[] (const TdGDSBlockID &id)
3566: 	vector<CdBlockStream*>::iterator it;
3570: 	CdBlockStream *rv = new CdBlockStream(*this);
514: 		fOwner.fStreamPos += GDS_POS_SIZE;
515: 		fCB_ZStart = fIndex[0].CmpStart = fBlockListStart = fOwner.fStreamPos;
598: 			fOwner.fStreamPos = fCB_ZStart;
600: 				 fOwner.fStreamPos += SIZE_RA_BLOCK_HEADER;
648: 	fOwner.fStreamPos = fCB_ZStart + SIZE_RA_BLOCK_HEADER;
714: 		fOwner.fStreamPos += GDS_POS_SIZE;
715: 		fBlockListStart = fOwner.fStreamPos;
718: 	fOwner.fTotalOut = (fOwner.fStreamPos - fOwner.fStreamBase);
730: 		fOwner.fStreamPos += SIZE_RA_BLOCK_HEADER;
731: 		fOwner.fTotalOut = fOwner.fStreamPos - fOwner.fStreamBase;
735: 	SIZE64 OldPos = fOwner.fStreamPos;
777: 		fCB_ZStart = fOwner.fStreamPos;
783: 			fOwner.fStreamPos += SIZE_RA_BLOCK_HEADER;
793: 		C_UInt32 SC = fOwner.fStreamPos - fCB_ZStart;
918: 			UpdateStreamPosition();
920: 			fStreamPos += sizeof(fBuffer);
977: 	UpdateStreamPosition();
983: 		fStreamPos += L;
992: 		fStreamPos += L;
995: 	fTotalOut = fStreamPos - fStreamBase;
1034: 			UpdateStreamPosition();
1057: 	SIZE64 tmp = fStreamPos - fStreamBase;
1178: 				UpdateStreamPosition();
1180: 				fStreamPos += sizeof(fBuffer);
1201: 	fTotalOut = fStreamPos - fStreamBase;
1291: 					fStreamPos += ZSize;
1292: 					fTotalOut = fStreamPos - fStreamBase;
1341: 				ssize_t s = fCB_ZStart + fCB_ZSize - fStreamPos;
1381: 	SIZE64 tmp = fStreamPos - fStreamBase;
1429: 	fStreamPos = fCB_ZStart;
1431: 		fStreamPos += SIZE_RA_BLOCK_HEADER;
1507: 	fStreamPos = fStreamBase + (int)s;
1508: 	fTotalOut = (fStreamPos - fStreamBase);
1554: 			fStreamPos += s;
1561: 	fTotalOut = (fStreamPos - fStreamBase);
1603: 		fStreamPos += s;
1604: 		fTotalOut = (fStreamPos - fStreamBase);
1643: 			UpdateStreamPosition();
1645: 			fStreamPos += Cnt;
1664: 	SIZE64 tmp = fStreamPos - fStreamBase;
1741: 		fLZ4Ptr = LZ4_createStreamHC();
1763: 		LZ4_freeStreamHC((LZ4_streamHC_t*)fLZ4Ptr); break;
1794: 				LZ4_resetStreamHC((LZ4_streamHC_t*)fLZ4Ptr,
1797: 				LZ4_resetStreamHC((LZ4_streamHC_t*)fLZ4Ptr,
1876: 	UpdateStreamPosition();
1914: 	fStreamPos += size;
1915: 	fTotalOut = fStreamPos - fStreamBase;
1984: 					fStreamPos += ZSize;
1985: 					fTotalOut = fStreamPos - fStreamBase;
2034: 			UpdateStreamPosition();
2042: 				fStreamPos += sizeof(Len) + Len;
2054: 				fStreamPos += sizeof(Len) + Len;
2084: 	SIZE64 tmp = fStreamPos - fStreamBase;
2151: 	fStreamPos = fCB_ZStart;
2153: 		fStreamPos += SIZE_RA_BLOCK_HEADER;
2303: 			UpdateStreamPosition();
2305: 			fStreamPos += nout;
2367: 			UpdateStreamPosition();
2369: 			fStreamPos += nout;
2407: 			UpdateStreamPosition();
2434: 	SIZE64 tmp = fStreamPos - fStreamBase;
2536: 				UpdateStreamPosition();
2538: 				fStreamPos += n;
2554: 	fTotalOut = fStreamPos - fStreamBase;
2644: 					fStreamPos += ZSize;
2645: 					fTotalOut = fStreamPos - fStreamBase;
2691: 				UpdateStreamPosition();
2692: 				ssize_t n = fCB_ZSize - (fStreamPos - fCB_ZStart);
2730: 	SIZE64 tmp = fStreamPos - fStreamBase;
2778: 	fStreamPos = fCB_ZStart;
2780: 		fStreamPos += SIZE_RA_BLOCK_HEADER;
2934: 			fCollection._IncStreamSize(*this, L);
3020: 			fCollection._IncStreamSize(*this, NewSize);
3022: 			fCollection._DecStreamSize(*this, NewSize);
3109: 	fStreamSize = 0;
3134: 		if (L == fStreamSize)
3149: 		} else if (L < fStreamSize)
3250: 		SIZE64 Pos = fStreamSize;
3251: 		fStreamSize += 2*GDS_POS_SIZE + Size;
3338: 	SIZE64 stream_end = fStreamSize - GDS_POS_SIZE*2;
3358: 		if (pos > fStreamSize)
3364: 			pos = fStreamSize;
3368: 		if (sNext >= fStreamSize)
3396: 	if (pos < fStreamSize)
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())
netboost:src/mcupgma/clustering_round/myutils/StreamFromFileNameGenerator.hpp: [ ]
10: RCPtr<istream> InputStream(string const & filename) {
30: RCPtr<ostream> OutputStream(string const & filename) {
2: #define __StreamFromFileNameGenerator_hpp
1: #ifndef __StreamFromFileNameGenerator_hpp
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.cpp: [ ]
34: InFileStream::InFileStream() :
41: InFileStream::InFileStream(const char *filename) :
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
28: #include "InFileStream.h"
38:     //cout << "InFileStream() constructor 1" << endl;
44:     //cout << "InFileStream(f) constructor 2" << endl;
49: //- InFileStream::InFileStream(const InFileStream &copy) :
52: //-     cout << "InFileStream() constructor 3" << endl;
56: void InFileStream::open(const char *filename) 
67: void InFileStream::close() 
74: std::istream& InFileStream::getline(char *s, streamsize n) 
80: std::istream& InFileStream::getline(char *s, streamsize n, char delim) 
93:  * 09-02-07,Nigel Brown(EMBL): moved member into new InFileStream subclassed
95:  * that uses InFileStream in place of std::ifstream. Replaced if/then/else
98: char InFileStream::findDelimiter()
msa:src/ClustalW/src/fileInput/InFileStream.h: [ ]
22: class InFileStream : public std::ifstream
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
25:     InFileStream();
26:     InFileStream(const char *filename);
27:     //- InFileStream(const InFileStream &copy);
45:     InFileStream(const InFileStream &copy);
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.h: [ ]
22: class InFileStream : public std::ifstream
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
25:     InFileStream();
26:     InFileStream(const char *filename);
27:     //- InFileStream(const InFileStream &copy);
45:     InFileStream(const InFileStream &copy);
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))
ChIC:R/privateFunctions.R: [ ]
843:     up_downStream <- 4020
755: ## f_one.point.scaling <- function(x, pos, strand=NULL,m=up_downStream/2,
847:     estimated_bin_size_1P <- up_downStream/predefnum_bins_1P
860:         settings$up_downStream <- up_downStream
1024:             m = (settings$up_downStream / 2), 
1032:             m = (settings$up_downStream / 2), 
1114: ## gdl=annotatedGenesPerChr,m=up_downStream, nbins=predefnum_bins_1P,
1177: ## m=up_downStream, nbins=predefnum_bins_1P,separate.strands=F,mc=1) {
gdsfmt:src/CoreArray/dFile.cpp: [ ]
278: static const char *ERR_GDSStream    = "%s: GDSStream should not be NULL.";
427: void CdGDSObj::GetOwnBlockStream(vector<const CdBlockStream*> &Out) const
432: void CdGDSObj::GetOwnBlockStream(vector<CdStream*> &Out)
477: void CdGDSObj::SaveToBlockStream()
504: void CdGDSObj::_CheckGDSStream()
583: 		CdStream *fStream;
584: 		CLASS *fPStream;
616: 		CdStream *fStream;
617: 		CLASS *fPStream;
732: 		virtual void LoadStream(CdReader &Reader, TdVersion Version)
778: 		virtual void SaveStream(CdWriter &Writer)
1032: void CdPipeMgrItem::LoadStream(CdReader &Reader, TdVersion Version) { }
1034: void CdPipeMgrItem::SaveStream(CdWriter &Writer) { }
2493: void CdGDSStreamContainer::GetOwnBlockStream(vector<const CdBlockStream*> &Out) const
2499: void CdGDSStreamContainer::GetOwnBlockStream(vector<CdStream*> &Out)
2634: void CdGDSFile::LoadStream(CdStream *Stream, bool ReadOnly, bool AllowError)
2690: void CdGDSFile::SaveStream(CdStream *Stream)
679: 		virtual bool GetStreamInfo(CdBufStream *buf)
723: 		virtual void UpdateStreamInfo(CdStream &Stream)
1026: void CdPipeMgrItem::UpdateStreamSize()
1155: CdStreamPipeMgr CoreArray::dStreamPipeMgr;
1157: CdStreamPipeMgr::CdStreamPipeMgr(): CdAbstractManager()
1171: CdStreamPipeMgr::~CdStreamPipeMgr()
2231: CdGDSStreamContainer::CdGDSStreamContainer(): CdGDSObjPipe()
2241: CdGDSStreamContainer::~CdGDSStreamContainer()
543: // Stream Manage Pipe
590: 			fStream = BufStream->Stream();
624: 			fStream = BufStream->Stream();
670: 			return (dynamic_cast<CLASS*>(buf.Stream()) != NULL);
675: 			CLASS *s = dynamic_cast<CLASS*>(buf.Stream());
684: 				CLASS *s = dynamic_cast<CLASS*>(buf->Stream());
727: 				BYTE_LE<CdStream> S(Stream);
865: 	typedef CdWritePipe2<CdLZ4Encoder, CdBaseLZ4Stream::TLZ4Chunk> CdLZ4WritePipe;
875: 		public CdPipe<CdBaseLZ4Stream::bsLast, CdBaseLZ4Stream::bsDefault,
876: 		CdBaseLZ4Stream::TLZ4Chunk, CdLZ4Encoder, CdPipeLZ4>
2255: 	return "Stream";
2645: 	Stream->ReadData((void*)&buf[0], L);
2650: 	fVersion = Stream->R8b();
2651: 	fVersion |= Stream->R8b() << 8;
2660: 	BYTE_LE<CdStream>(Stream) >> Entry;
2663: 	CdBlockCollection::LoadStream(Stream, ReadOnly, AllowError, &Log());
2699: 	Stream->WriteData((void*)GDSFilePrefix(), L);
2702: 	Stream->W8b(fVersion & 0xFF);
2703:     Stream->W8b(fVersion >> 8);
2705: 	SIZE64 _EntryPos = Stream->Position();
2706: 	BYTE_LE<CdStream>(Stream) << TdGDSBlockID(0);
2708: 	CdBlockCollection::WriteStream(Stream);
2711: 	SIZE64 _NewPos = Stream->Position();
2713: 	Stream->SetPosition(_EntryPos);
2714: 	BYTE_LE<CdStream>(Stream) << fRoot.fGDSStream->ID();
2715: 	Stream->SetPosition(_NewPos);
288: 	fGDSStream = NULL;
294: 	if (fGDSStream)
295: 		fGDSStream->Release();
393: 	if (fGDSStream && folder.GDSStream() && fFolder)
395: 		CdBlockCollection *n1 = &fGDSStream->Collection();
396: 		CdBlockCollection *n2 = &folder.GDSStream()->Collection();
424: 		SaveToBlockStream();
439: 	if (fGDSStream)
441: 		CdBlockCollection *collect = &fGDSStream->Collection();
479: 	_CheckGDSStream();
480: 	if (fGDSStream)
482: 		CdWriter Writer(fGDSStream, &GDSFile()->Log());
506: 	if (!fGDSStream)
507: 		throw ErrGDSObj(ERR_GDSStream, "CdGDSObj");
537: 		static_cast<CdGDSObj*>(Obj)->fGDSStream = (CdBlockStream*)Data;
552: 	static const CdRecodeStream::TLevel CompressionLevels[] =
554: 		CdRecodeStream::clMin,
555: 		CdRecodeStream::clFast,
556: 		CdRecodeStream::clDefault,
557: 		CdRecodeStream::clMax,
558: 		CdRecodeStream::clUltra,     // ultra  (LZMA 512MiB)
559: 		CdRecodeStream::clUltraMax,  // ultra_max  (LZMA 1536MiB)
560: 		CdRecodeStream::clDefault
575: 		CdWritePipe(CdRecodeStream::TLevel vLevel,
585: 		CdRecodeStream::TLevel fLevel;
588: 		virtual CdStream *InitPipe(CdBufStream *BufStream)
591: 			fPStream = new CLASS(*fStream, fLevel);
592: 			fPStream->PtrExtRec = &fRemainder;
593: 			return fPStream;
595: 		virtual CdStream *FreePipe()
597: 			if (fPStream) { fPStream->Release(); fPStream = NULL; }
598: 			return fStream;
607: 		CdWritePipe2(CdRecodeStream::TLevel vLevel, BSIZE bs,
618: 		CdRecodeStream::TLevel fLevel;
622: 		virtual CdStream *InitPipe(CdBufStream *BufStream)
625: 			fPStream = new CLASS(*fStream, fLevel, fBSize);
626: 			fPStream->PtrExtRec = &fRemainder;
627: 			return fPStream;
629: 		virtual CdStream *FreePipe()
631: 			if (fPStream) { fPStream->Release(); fPStream = NULL; }
632: 			return fStream;
648: 			fLevel = CdRecodeStream::clDefault;
663: 		virtual void PopPipe(CdBufStream &buf)
668: 		virtual bool WriteMode(CdBufStream &buf) const
673: 		virtual void ClosePipe(CdBufStream &buf)
703: 		CdRecodeStream::TLevel fLevel;
758: 				fLevel = (CdRecodeStream::TLevel)I;
760: 				fLevel = CdRecodeStream::clUnknown;
814: 		virtual void PushReadPipe(CdBufStream &buf)
816: 		virtual void PushWritePipe(CdBufStream &buf)
847: 		virtual void PushReadPipe(CdBufStream &buf)
849: 		virtual void PushWritePipe(CdBufStream &buf)
889: 		virtual void PushReadPipe(CdBufStream &buf)
891: 		virtual void PushWritePipe(CdBufStream &buf)
928: 		virtual void PushReadPipe(CdBufStream &buf)
930: 		virtual void PushWritePipe(CdBufStream &buf)
964: 		virtual void PushReadPipe(CdBufStream &buf)
966: 		virtual void PushWritePipe(CdBufStream &buf)
997: 		virtual void PushReadPipe(CdBufStream &buf)
999: 		virtual void PushWritePipe(CdBufStream &buf)
1250: 			fPipeInfo->LoadStream(Reader, Version);
1261: 		fPipeInfo->SaveStream(Writer);
1304: 	StreamID = 0;
1367: 	_CheckGDSStream();
1376: 	rv->fGDSStream = fGDSStream->Collection().NewBlockStream();
1377: 	rv->fGDSStream->AddRef();
1383: 	I.StreamID = rv->fGDSStream->ID();
1408: 	_CheckGDSStream();
1436: 	if (val->fGDSStream == NULL)
1438: 		val->fGDSStream = fGDSStream->Collection().NewBlockStream();
1439: 		val->fGDSStream->AddRef();
1440: 		I.StreamID = val->fGDSStream->ID();
1442: 		val->SaveToBlockStream();
1533: 		CdBlockStream *stream = it->Obj->fGDSStream;
1535: 		vector<const CdBlockStream*> BL;
1536: 		it->Obj->GetOwnBlockStream(BL);
1558: 		if (fGDSStream)
1561: 				fGDSStream->Collection().DeleteBlockStream(stream->ID());
1563: 			vector<const CdBlockStream*>::iterator it;
1566: 				fGDSStream->Collection().DeleteBlockStream((*it)->ID());
1749: 				Reader[VAR_DIR_ID]   >> I.StreamID;
1777: 				Writer[VAR_DIR_ID] << it->StreamID;
1844: 		_CheckGDSStream();
1845: 		CdBlockStream *IStream = fGDSStream->Collection()[I.StreamID];
1846: 		CdReader Reader(IStream, &GDSFile()->Log());
1860: 			vObj->fGDSStream = IStream;
1861: 			IStream->AddRef();
1875: 			vObj->fGDSStream = IStream;
1876: 			IStream->AddRef();
1890: 			vObj->fGDSStream = IStream;
1891: 			IStream->AddRef();
1901: 			vObj->fGDSStream = IStream;
1902: 			IStream->AddRef();
1913: 				obj = fGDSStream->Collection().ClassMgr()->
1914: 					ToObj(Reader, _GDSObjInitProc, fGDSStream, false);
1928: 				I.Obj->fGDSStream = IStream;
1929: 				IStream->AddRef();
1943: 		SaveToBlockStream();
2233: 	fBufStream = new CdBufStream(new CdMemoryStream);
2234: 	fBufStream->AddRef();
2235: 	vAllocStream = NULL;
2244: 	if (fBufStream)
2245: 		fBufStream->Release();
2250: 	return "dStream";
2273: 		S->CopyTo(*BufStream());
2283: 	if (fGDSStream)
2289: 		if (fBufStream)
2290: 			fBufStream->Release();
2291: 		fBufStream = new CdBufStream(fGDSStream->Collection()[vAllocID]);
2292: 		fBufStream->AddRef();
2295: 			fPipeInfo->PushReadPipe(*fBufStream);
2297: 		throw ErrGDSStreamContainer(ERR_GDSStream, "CdGDSStreamContainer");
2305: 	if (fGDSStream)
2307: 		if (vAllocStream == NULL)
2309: 			_CheckGDSStream();
2310: 			vAllocStream = fGDSStream->Collection().NewBlockStream();
2312: 			if (fBufStream) fBufStream->Release();
2313: 			fBufStream = new CdBufStream(vAllocStream);
2314: 			fBufStream->AddRef();
2316: 				fPipeInfo->PushWritePipe(*fBufStream);
2318: 		TdGDSBlockID Entry = vAllocStream->ID();
2322: 		throw ErrGDSStreamContainer(ERR_GDSStream, "CdGDSStreamContainer");
2329: 		return fPipeInfo->StreamTotalIn();
2331:     	return fBufStream->GetSize();
2343: 		if (vAllocStream && fGDSStream && (vAllocStream->GetSize()>0))
2357: 				CdStream *TmpStream = new CdTempStream;
2358: 				TdAutoRef<CdBufStream> Output(new CdBufStream(TmpStream));
2371: 				vAllocStream->SetPosition(0);
2372: 				vAllocStream->SetSizeOnly(0);
2373: 				vAllocStream->CopyFrom(*TmpStream, 0, -1);
2376: 			vAllocStream->SetPosition(0);
2377: 			if (fBufStream)
2378: 				fBufStream->Release();
2379: 			fBufStream = new CdBufStream(vAllocStream);
2380: 			fBufStream->AddRef();
2382: 				fPipeInfo->PushReadPipe(*fBufStream);
2385: 			SaveToBlockStream();
2398: 	fBufStream->OnFlush.Clear();
2399: 	fBufStream->FlushWrite();
2400: 	if (fPipeInfo && vAllocStream)
2402: 		if (fPipeInfo->WriteMode(*fBufStream))
2404: 			fPipeInfo->ClosePipe(*fBufStream);
2405: 			if (_GetStreamPipeInfo(fBufStream, false))
2406: 				_UpdateStreamPipeInfo(*fGDSStream);
2408: 			if (fBufStream)
2409: 				fBufStream->Release();
2410: 			vAllocStream->SetPosition(0);
2411: 			fBufStream = new CdBufStream(vAllocStream);
2412:         	fBufStream->AddRef();
2414: 				fPipeInfo->PushReadPipe(*fBufStream);
2419: void CdGDSStreamContainer::CopyFromBuf(CdBufStream &Source, SIZE64 Count)
2432: 		fBufStream->WriteData((void*)Buffer, N);
2437: void CdGDSStreamContainer::CopyFrom(CdStream &Source, SIZE64 Count)
2450: 		fBufStream->WriteData((void*)Buffer, N);
2455: void CdGDSStreamContainer::CopyTo(CdBufStream &Dest, SIZE64 Count)
2461: 		fBufStream->SetPosition(0);
2468: 		fBufStream->ReadData((void*)Buffer, N);
2474: void CdGDSStreamContainer::CopyTo(CdStream &Dest, SIZE64 Count)
2480: 		fBufStream->SetPosition(0);
2487: 		fBufStream->ReadData((void*)Buffer, N);
2496: 	if (vAllocStream) Out.push_back(vAllocStream);
2502: 	if (vAllocStream) Out.push_back(vAllocStream);
2673: 		fRoot.fGDSStream = (*this)[Entry];
2674: 		fRoot.fGDSStream->AddRef();
2679: 			(double)fRoot.fGDSStream->Size());
2682: 		CdReader Reader(fRoot.fGDSStream, &Log());
2693: 	if (fStream != NULL)
2709: 	fRoot.fGDSStream = NewBlockStream();
2710: 	fRoot.fGDSStream->AddRef();
2717: 	fRoot.SaveToBlockStream();
2722: 	TdAutoRef<CdStream> F(new CdFileStream(RawText(fn).c_str(),
2723: 		ReadOnly ? CdFileStream::fmOpenRead : CdFileStream::fmOpenReadWrite));
2724: 	LoadStream(F.get(), ReadOnly, AllowError);
2730: 	TdAutoRef<CdStream> F(new CdFileStream(fn,
2731: 		ReadOnly ? CdFileStream::fmOpenRead : CdFileStream::fmOpenReadWrite));
2732: 	LoadStream(F.get(), ReadOnly, AllowError);
2738: 	TdAutoRef<CdStream> F(new CdForkFileStream(fn,
2739: 		ReadOnly ? CdFileStream::fmOpenRead : CdFileStream::fmOpenReadWrite));
2740: 	LoadStream(F.get(), ReadOnly, AllowError);
2746: 	if (fStream == NULL)
2753: 	TdAutoRef<CdStream> F(new CdFileStream(RawText(fn).c_str(),
2754: 		CdFileStream::fmCreate));
2756: 	SaveStream(F.get());
2761: 	TdAutoRef<CdStream> F(new CdFileStream(fn, CdFileStream::fmCreate));
2763: 	SaveStream(F.get());
2774: 		TdAutoRef<CdStream> F(new CdFileStream(RawText(fn).c_str(),
2775: 			CdFileStream::fmCreate));
2786: 		BYTE_LE<CdStream>(*F) << fRoot.fGDSStream->ID();
2793: 				CdBlockStream::TBlockInfo::HEAD_SIZE + bSize) |
2796: 			BYTE_LE<CdStream>(*F) <<
2810: 	if (fStream)
2818: 		if (fRoot.fGDSStream)
2821: 			fRoot.fGDSStream->Release();
2822: 			fRoot.fGDSStream = NULL;
2879: 	return (dynamic_cast<CdForkFileStream*>(fStream) != NULL);
572: 		class COREARRAY_DLL_DEFAULT CdWritePipe: public CdStreamPipe
577: 			CdStreamPipe(), fRemainder(vRemainder)
604: 		class COREARRAY_DLL_DEFAULT CdWritePipe2: public CdStreamPipe
609: 			CdStreamPipe(), fRemainder(vRemainder)
693: 			if ((in!=fStreamTotalIn) || (out!=fStreamTotalOut))
695: 				fStreamTotalIn = in;
696: 				fStreamTotalOut = out;
729: 				S << fStreamTotalIn << fStreamTotalOut;
740: 				fStreamTotalIn = Ary[0];
741: 				fStreamTotalOut = Ary[1];
744: 				fStreamTotalIn = fStreamTotalOut = -1;
780: 			UpdateStreamSize();
781: 			C_Int64 Ary[2] = { fStreamTotalIn, fStreamTotalOut };
798: 	typedef CdStreamPipe2<CdZDecoder> CdZIPReadPipe;
829: 	typedef CdStreamPipe2<CdZDecoder_RA> CdZRAReadPipe;
864: 	typedef CdStreamPipe2<CdLZ4Decoder> CdLZ4ReadPipe;
904: 	typedef CdStreamPipe2<CdLZ4Decoder_RA> CdLZ4RAReadPipe;
947: 	typedef CdStreamPipe2<CdXZDecoder> CdXZReadPipe;
979: 	typedef CdStreamPipe2<CdXZDecoder_RA> CdXZReadPipe_RA;
1021: 	fStreamTotalIn = fStreamTotalOut = -1;
1153: // CdStreamPipeMgr
1178: void CdStreamPipeMgr::Register(CdPipeMgrItem *vNewPipe)
1185: CdPipeMgrItem *CdStreamPipeMgr::Match(CdGDSObjPipe &Obj, const char *Mode)
1247: 			fPipeInfo = dStreamPipeMgr.Match(*this, RawText(Coder).c_str());
1429: 	} else if (dynamic_cast<CdGDSStreamContainer*>(val))
1896: 			CdGDSStreamContainer *vObj = new CdGDSStreamContainer;
2227: // CdGDSStreamContainer
2248: const char *CdGDSStreamContainer::dName()
2253: const char *CdGDSStreamContainer::dTraitName()
2258: CdGDSObj *CdGDSStreamContainer::NewObject()
2260: 	return (new CdGDSStreamContainer)->AssignPipe(*this);
2263: void CdGDSStreamContainer::Assign(CdGDSObj &Source, bool Full)
2265: 	if (dynamic_cast<CdGDSStreamContainer*>(&Source))
2271: 		CdGDSStreamContainer *S = static_cast<CdGDSStreamContainer*>(&Source);
2276: 		RaiseInvalidAssign("CdGDSStreamContainer", &Source);
2279: void CdGDSStreamContainer::Loading(CdReader &Reader, TdVersion Version)
2301: void CdGDSStreamContainer::Saving(CdWriter &Writer)
2326: SIZE64 CdGDSStreamContainer::GetSize()
2334: void CdGDSStreamContainer::SetPackedMode(const char *Mode)
2351: 			fPipeInfo = dStreamPipeMgr.Match(*this, Mode);
2353: 				throw ErrGDSStreamContainer(ERR_PACKED_MODE, Mode);
2367: 					fPipeInfo->GetStreamInfo(Output.get());
2389: 			fPipeInfo = dStreamPipeMgr.Match(*this, Mode);
2391: 				throw ErrGDSStreamContainer(ERR_PACKED_MODE, Mode);
2396: void CdGDSStreamContainer::CloseWriter()
2869:     return fStreamSize;
Director:inst/www/js/d3.v3.js: [ ]
4246:   function d3_geo_pathProjectStream(project) {
3878:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3881:           lower48Stream.point(x, y);
3886:           lower48Stream.sphere();
3891:           lower48Stream.lineStart();
3896:           lower48Stream.lineEnd();
3901:           lower48Stream.polygonStart();
3906:           lower48Stream.polygonEnd();
3862:     var point, pointStream = {
3882:           alaskaStream.point(x, y);
3883:           hawaiiStream.point(x, y);
3887:           alaskaStream.sphere();
3888:           hawaiiStream.sphere();
3892:           alaskaStream.lineStart();
3893:           hawaiiStream.lineStart();
3897:           alaskaStream.lineEnd();
3898:           hawaiiStream.lineEnd();
3902:           alaskaStream.polygonStart();
3903:           hawaiiStream.polygonStart();
3907:           alaskaStream.polygonEnd();
3908:           hawaiiStream.polygonEnd();
3929: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3930: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3931: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
4200:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
4203:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
4204:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
4205:         d3.geo.stream(object, cacheStream);
4207:       return contextStream.result();
4211:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
4216:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4221:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4226:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
4231:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
4232:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
4237:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
4241:       cacheStream = null;
Rmmquant:src/mmquant.h: [ ]
644:   std::ostream &getOutputStream () {
648:   std::ostream &getStatsStream () {
1799:         parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";
1801:           parameters.getOutputStream() << " \"" << arg << "\"";
1803:         parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";
1806:         parameters.getOutputStream() << "Gene";
1809:         parameters.getOutputStream() << "\t" << sample;
1811:       parameters.getOutputStream() << "\n";
1813:           parameters.getOutputStream() << line.first;
1815:               parameters.getOutputStream() << "\t" << i;
1817:           parameters.getOutputStream() << "\n";
1908:     dumpStats(parameters.getStatsStream(), parameters.names, stats);
R453Plus1Toolbox:R/methods-AVASet.R: [ ]
1078:         upDownStream = max(width(dnaSet))
1088:             seqType="gene_exon_intron", upstream=upDownStream, mart=ensembl)
1093:             seqType="gene_exon_intron", downstream=upDownStream, mart=ensembl)    
1122:             pos[refName] = geneInfo$start_position[ind] - upDownStream + start(m) - 1
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()
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) {
rtracklayer:src/ucsc/udc.c: [ ]
48: FILE *udcLogStream = NULL;
62:     udcLogStream = fp;
1124: if (udcLogStream)
1125:     fprintf(udcLogStream, "Open %s\n", url);
1264:     if (udcLogStream)
1266:         fprintf(udcLogStream, "Close %s %s %lld %lld bit %lld %lld %lld %lld %lld sparse %lld %lld %lld %lld %lld udc  %lld %lld...(49 bytes skipped)...
LACE:inst/htmlwidgets/lib/d3.v4.js: [ ]
6898:     function geoStream(object, stream) {
7424:     function circleStream(stream, radius, delta, direction, t0, t1) {
8978:     function TransformStream() {}
9343:             point, pointStream = {point: function(x, y) { point = [x, y]; }};
6915:     var areaStream = {
6921:             areaStream.lineStart = areaRingStart;
6922:             areaStream.lineEnd = areaRingEnd;
6935:         areaStream.point = areaPointFirst;
6943:         areaStream.point = areaPoint;
6972:         geoStream(object, areaStream);
7020:     var boundsStream = {
7025:             boundsStream.point = boundsRingPoint;
7026:             boundsStream.lineStart = boundsRingStart;
7027:             boundsStream.lineEnd = boundsRingEnd;
7029:             areaStream.polygonStart();
7032:             areaStream.polygonEnd();
7033:             boundsStream.point = boundsPoint;
7034:             boundsStream.lineStart = boundsLineStart;
7035:             boundsStream.lineEnd = boundsLineEnd;
7099:         boundsStream.point = linePoint;
7104:         boundsStream.point = boundsPoint;
7115:         areaStream.point(lambda, phi);
7120:         areaStream.lineStart();
7125:         areaStream.lineEnd();
7151:         geoStream(feature, boundsStream);
7200:     var centroidStream = {
7206:             centroidStream.lineStart = centroidRingStart;
7207:             centroidStream.lineEnd = centroidRingEnd;
7210:             centroidStream.lineStart = centroidLineStart;
7211:             centroidStream.lineEnd = centroidLineEnd;
7230:         centroidStream.point = centroidLinePointFirst;
7239:         centroidStream.point = centroidLinePoint;
7258:         centroidStream.point = centroidPoint;
7264:         centroidStream.point = centroidRingPointFirst;
7269:         centroidStream.point = centroidPoint;
7275:         centroidStream.point = centroidRingPoint;
7310:         geoStream(object, centroidStream);
7470:             circleStream(stream, r, p, 1);
7906:             circleStream(stream, radius, delta, direction, from, to);
8182:             var activeStream = stream,
8183:                 bufferStream = clipBuffer(),
8192:             var clipStream = {
8201:                 if (visible(x, y)) activeStream.point(x, y);
8220:                 activeStream = bufferStream, segments = [], polygon = [], clean = true;
8239:                 activeStream = stream, segments = polygon = ring = null;
8243:                 clipStream.point = linePoint;
8256:                     if (v__ && v_) bufferStream.rejoin();
8257:                     segments.push(bufferStream.result());
8259:                 clipStream.point = point;
8260:                 if (v_) activeStream.lineEnd();
8270:                         activeStream.lineStart();
8271:                         activeStream.point(x, y);
8274:                     if (v && v_) activeStream.point(x, y);
8280:                                 activeStream.lineStart();
8281:                                 activeStream.point(a[0], a[1]);
8283:                             activeStream.point(b[0], b[1]);
8284:                             if (!v) activeStream.lineEnd();
8287:                             activeStream.lineStart();
8288:                             activeStream.point(x, y);
8296:             return clipStream;
8306:             cacheStream,
8311:                 return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream);
8314: ...(16 bytes skipped)...return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];
8324:     var lengthStream = {
8334:         lengthStream.point = lengthPointFirst;
8335:         lengthStream.lineEnd = lengthLineEnd;
8339:         lengthStream.point = lengthStream.lineEnd = noop$1;
8345:         lengthStream.point = lengthPoint;
8364:         geoStream(object, lengthStream);
8607:     var areaStream$1 = {
8612:             areaStream$1.lineStart = areaRingStart$1;
8613:             areaStream$1.lineEnd = areaRingEnd$1;
8616:             areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;
8628:         areaStream$1.point = areaPointFirst$1;
8632:         areaStream$1.point = areaPoint$1;
8650:     var boundsStream$1 = {
8686:     var centroidStream$1 = {
8691:             centroidStream$1.lineStart = centroidRingStart$1;
8692:             centroidStream$1.lineEnd = centroidRingEnd$1;
8695:             centroidStream$1.point = centroidPoint$1;
8696:             centroidStream$1.lineStart = centroidLineStart$1;
8697:             centroidStream$1.lineEnd = centroidLineEnd$1;
8718:         centroidStream$1.point = centroidPointFirstLine;
8722:         centroidStream$1.point = centroidPointLine;
8735:         centroidStream$1.point = centroidPoint$1;
8739:         centroidStream$1.point = centroidPointFirstRing;
8747:         centroidStream$1.point = centroidPointRing;
8817:     var lengthStream$1 = {
8820:             lengthStream$1.point = lengthPointFirst$1;
8824:             lengthStream$1.point = noop$1;
8840:         lengthStream$1.point = lengthPoint$1;
8912:             projectionStream,
8913:             contextStream;
8917:                 if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
8918:                 geoStream(object, projectionStream(contextStream));
8920:             return contextStream.result();
8924:             geoStream(object, projectionStream(areaStream$1));
8925:             return areaStream$1.result();
8929:             geoStream(object, projectionStream(lengthStream$1));
8930:             return lengthStream$1.result();
8934:             geoStream(object, projectionStream(boundsStream$1));
8935:             return boundsStream$1.result();
8939:             geoStream(object, projectionStream(centroidStream$1));
8940:             return centroidStream$1.result();
8944:             return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;
8949:             contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);
8950:             if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
8956:             pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
8971:             var s = new TransformStream;
8980:     TransformStream.prototype = {
8981:         constructor: TransformStream,
8994:         geoStream(object, projection.stream(boundsStream$1));
8995:         fitBounds(boundsStream$1.result());
9083:             var resampleStream = {
9087:                 polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },
9088:                 polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }
9098:                 resampleStream.point = linePoint;
9109:                 resampleStream.point = point;
9115:                 resampleStream.point = ringPoint;
9116:                 resampleStream.lineEnd = ringEnd;
9121:                 resampleStream.point = linePoint;
9126:                 resampleStream.lineEnd = lineEnd;
9130:             return resampleStream;
9163:             cacheStream;
9180:             return cache && cacheStream...(9 bytes skipped)...am ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
9244:             cache = cacheStream = null;
9339:             cacheStream,
9363:             return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
9385:                 .stream(pointStream);
9390:                 .stream(pointStream);
9395:                 .stream(pointStream);
9417:             cache = cacheStream = null;
9621:             cacheStream,
9625:             cache = cacheStream = null;
9631:                 return cache && cacheStream === stream ? cache : cache = transform$$1(postclip(cacheStream = stream));
16942:     exports.geoStream = geoStream;
rhdf5filters:src/blosc/lib/zstd-1.4.5/zstd.h: [ ]
641: typedef ZSTD_CCtx ZSTD_CStream;  /**< CCtx and CStream are now effectively same object (>= v1.3.0) */
761: typedef ZSTD_DCtx ZSTD_DStream;  /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
1308:  *  Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
56:     - unbounded multiple steps (described as Streaming compression)
240:  *   "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
371: ...(8 bytes skipped)...                      * When nbWorkers >= 1, triggers asynchronous mode when used with ZSTD_compressStream*() :
372:                               * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
374: ...(13 bytes skipped)...                 * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
375:                               *  in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
459:  *           or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
509:  * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
563: *  Streaming
581: *  Streaming compression - HowTo
583: *  A ZSTD_CStream object is required to track streaming operation.
584: *  Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
585: *  ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
586: *  It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
588: *  For parallel execution, use one separate ZSTD_CStream per thread.
590: *  note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
599: *  Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to
616: *  using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.
618: *  In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.
619: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the
627: *  Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.
630: *  flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.
631: *  You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to
643: /*===== ZSTD_CStream management functions =====*/
644: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
645: ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);
647: /*===== Streaming compression functions =====*/
661: /*! ZSTD_compressStream2() :
662:  *  Behaves about the same as ZSTD_compressStream, with additional control on end directive.
682: ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
689:  * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
690:  * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),
707:  * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().
720: ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
722:  * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
723:  * NOTE: The return value is different. ZSTD_compressStream() returns a hint for
724:  * the next read size (if non-zero and not an error). ZSTD_compressStream2()
727: ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
728: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */
729: ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
730: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */
731: ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
735: *  Streaming decompression - HowTo
737: *  A ZSTD_DStream object is required to track streaming operations.
738: *  Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
739: *  ZSTD_DStream objects can be re-used multiple times.
741: *  Use ZSTD_initDStream() to start a new decompression operation.
745: *  Use ZSTD_decompressStream() repetitively to consume your input.
752: *  In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
763: /*===== ZSTD_DStream management functions =====*/
764: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
765: ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);
767: /*===== Streaming decompression functions =====*/
774: ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
776: ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
898:  * ZSTD_compressStream2(), and ZSTD_decompress(). Dictionaries are sticky, and
991:  *  End of frame is reached when ZSTD_decompressStream() returns 0.
996:  *           reached when ZSTD_decompressStream() returns 0.
1012: ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
1013: ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
1304:  *  Note : CStream size estimation is only correct for single-threaded compression.
1305:  *  ZSTD_DStream memory budget depends on window Size.
1343:  *                 ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
1348: ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticCCtx() */
1351: ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize);    /**< same as ZSTD_initStaticDCtx() */
1378: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
1380: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
1540:  *  - ZSTD_compressStream2() : Do compression using the CCtx.
1591: /*! ZSTD_compressStream2_simpleArgs() :
1592:  *  Same as ZSTD_compressStream2(),
1597: ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs (
1694: /*! ZSTD_decompressStream_simpleArgs() :
1695:  *  Same as ZSTD_decompressStream(),
1700: ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs (
1713: /*=====   Advanced Streaming compression functions  =====*/
1714: /**! ZSTD_initCStream_srcSize() :
1727: ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,
1731: /**! ZSTD_initCStream_usingDict() :
1744: ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,
1748: /**! ZSTD_initCStream_advanced() :
1764: ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
1769: /**! ZSTD_initCStream_usingCDict() :
1777: ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);
1779: /**! ZSTD_initCStream_usingCDict_advanced() :
1789:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters.
1795: ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
1800: /*! ZSTD_resetCStream() :
1807:  *  Note that zcs must be init at least once before using ZSTD_resetCStream().
1815: ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
1851: /*=====   Advanced Streaming decompression functions  =====*/
1861: ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
1872: ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);
1882: ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
701: ZSTDLIB_API size_t ZSTD_CStreamInSize(void);    /**< recommended size for input buffer */
702: ZSTDLIB_API size_t ZSTD_CStreamOutSize(void);   /**< recommended size for output buffer. Guarantee to successfully flush at least o...(32 bytes skipped)...
778: ZSTDLIB_API size_t ZSTD_DStreamInSize(void);    /*!< recommended size for input buffer */
779: ZSTDLIB_API size_t ZSTD_DStreamOutSize(void);   /*!< recommended size for output buffer. Guarantee to successfully flush at least o...(42 bytes skipped)...
1276:  *  Note : Unlike ZSTD_estimateCStreamSize*(), this estimate
1298: /*! ZSTD_estimateCStreamSize() :
1299:  *  ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
1301:  *  If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
1302:  *  ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionL...(5 bytes skipped)...
1303:  *  ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-thread...(97 bytes skipped)...
1306:  *  This information can be passed manually, using ZSTD_estimateDStreamSize,
1307:  *  or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
1311: ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
1312: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
1313: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
1314: ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
1315: ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
seqTools:src/dna_fasta_stream.h: [ ]
52: } fafStream;
207: } faStream;
215: void faStream_destroy(faStream *fa)
275: faStream * faStream_init(const char* filename, unsigned k, unsigned mode)
135: // fasta Stream
54: static inline unsigned faf_isEof(fafStream *faf) { return faf->status & faf_file_eof; }
55: static inline unsigned faf_isOpen(fafStream *faf)
62: static fafStream* faf_stream_init(const char* filename, unsigned mode)
64: 	// Construct fafStream object from opened file
65: 	fafStream *faf = calloc(sizeof(fafStream), 1);
87: static void faf_destroy(fafStream *faf)
99: static size_t inline faf_read(fafStream *faf, char *dest, unsigned size)
187: 	fafStream *fasta;
230: int fas_fill(faStream *fa)
279: 		printf("[faStream_init] k > fas_size!\n");
283: 	faStream *fa = calloc(sizeof(faStream), 1);
292: 		printf("[faStream_init] Cannot open file '%s'!\n", filename);
293: 		faStream_destroy(fa);
308: 		printf("[faStream_init] Initial array filling failed!\n");
309: 		faStream_destroy(fa);
321: static inline int fas_fas_end(faStream *fa)		{ return fa->ffc == 0; }
322: static inline int fas_nuc_end(faStream *fa)		{ return fa->fnc == 0; }
333: static inline int fas_checkNewLine(faStream *fa)
343: static inline int fas_skipNewLine(faStream *fa)
366: static inline int fas_skipLine(faStream *fa)
386: static inline int fas_checkNewSeq(faStream *fa)
399: static inline int fas_skipSeqHeader(faStream *fa)
412: static inline int fas_checkComment(faStream *fa)
422: static inline int fas_skipComment(faStream *fa)
435: static inline int fas_checkN(faStream *fa)
445: static inline int fas_skipN(faStream *fa)
496: char * fas_getSeqName(faStream *fa)
551: int fas_initSeq(faStream *fa)
592: static inline int fas_returnFromTranfer(faStream *fa)
626: int fas_TransferNucArray(faStream *fa)
697: int fa_empty(faStream *fa)    { return (fa->stream_state & fas_stream_empty); }
698: int fa_NucReady(faStream *fa) { return (fa->stream_state & fas_nuc_ready);    }
699: int fa_K_Ready(faStream *fa)  { return (fa->stream_state & fas_loc_kReady);   }
700: int fa_NewSeq(faStream *fa)   { return (fa->stream_state & fas_loc_newSeq);   }
701: int fa_N_Nuc(faStream *fa)    { return (ACGTN[(unsigned)*fa->iter] == nval);  }
704: void fa_unsetNucReady(faStream *fa)
interacCircos:inst/htmlwidgets/lib/d3.js: [ ]
3639:   function d3_geo_pathProjectStream(project) {
3271:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3274:           lower48Stream.point(x, y);
3279:           lower48Stream.sphere();
3284:           lower48Stream.lineStart();
3289:           lower48Stream.lineEnd();
3294:           lower48Stream.polygonStart();
3299:           lower48Stream.polygonEnd();
3255:     var point, pointStream = {
3275:           alaskaStream.point(x, y);
3276:           hawaiiStream.point(x, y);
3280:           alaskaStream.sphere();
3281:           hawaiiStream.sphere();
3285:           alaskaStream.lineStart();
3286:           hawaiiStream.lineStart();
3290:           alaskaStream.lineEnd();
3291:           hawaiiStream.lineEnd();
3295:           alaskaStream.polygonStart();
3296:           hawaiiStream.polygonStart();
3300:           alaskaStream.polygonEnd();
3301:           hawaiiStream.polygonEnd();
3322: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3323: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3324: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3593:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
3596:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
3597:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
3598:         d3.geo.stream(object, cacheStream);
3600:       return contextStream.result();
3604:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
3609:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
3614:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
3619:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
3624:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
3625:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
3630:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
3634:       cacheStream = null;
Gviz:R/AnnotationTrack-class.R: [ ]
327:     isStream <- FALSE
350:         isStream <- TRUE
363:         if (!isStream) {
gdsfmt:src/CoreArray/dAllocator.h: [ ]
140: 		COREARRAY_FORCEINLINE CdBufStream *BufStream()
177: 		CdBufStream *_BufStream;
70: 		void Initialize(CdStream &Stream, bool CanRead, bool CanWrite);
137: 		void CopyTo(CdBufStream &Obj, SIZE64 Pos, SIZE64 Count);
141: 			{ return _BufStream; }
rhdf5filters:src/blosc/lib/zstd-1.4.5/compress/zstd_compress.c: [ ]
184: size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
3611: ZSTD_CStream* ZSTD_createCStream(void)
3617: ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)
3627: size_t ZSTD_freeCStream(ZSTD_CStream* zcs)
3673: size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
3781: size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
3956: size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
4090: size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
4097: size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
3622: ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)
3643: static size_t ZSTD_resetCStream_internal(ZSTD_CStream* cctx,
3690: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
3712: size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
3726: size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
3739: size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
3757: size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
3766: size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
3803: static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
3963: size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
4049: size_t ZSTD_compressStream2_simpleArgs (
1190: size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
1206: size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
1212: static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
1218: size_t ZSTD_estimateCStreamSize(int compressionLevel)
3636: size_t ZSTD_CStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }
3638: size_t ZSTD_CStreamOutSize(void)
3608: *  Streaming
3613:     DEBUGLOG(3, "ZSTD_createCStream");
3614:     return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
3623: {   /* CStream and CCtx are now same object */
3648:     DEBUGLOG(4, "ZSTD_resetCStream_internal");
3671: /* ZSTD_resetCStream():
3680:     DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
3686: /*! ZSTD_initCStream_internal() :
3695:     DEBUGLOG(4, "ZSTD_initCStream_internal");
3710: /* ZSTD_initCStream_usingCDict_advanced() :
3711:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
3717:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
3728:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
3735: /* ZSTD_initCStream_advanced() :
3748:     DEBUGLOG(4, "ZSTD_initCStream_advanced");
3759:     DEBUGLOG(4, "ZSTD_initCStream_usingDict");
3773:     DEBUGLOG(4, "ZSTD_initCStream_srcSize");
3783:     DEBUGLOG(4, "ZSTD_initCStream");
3799: /** ZSTD_compressStream_generic():
3800:  *  internal function for all *compressStream*() variants
3817:     DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%u", (unsigned)flushMode);
3829:             RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
3958:     FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");
3968:     DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
3981:         DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
3994:                 DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
4000:             DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
4001:             FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
4009:         {   FORWARD_IF_ERROR( ZSTD_resetCStream_internal(cctx,
4029:             flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
4034:             FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
4036:         DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
4044:     FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");
4045:     DEBUGLOG(5, "completed ZSTD_compressStream2");
4057:     /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
4058:     size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
4072:         size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
4076:         FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
4088: /*! ZSTD_flushStream() :
4093:     return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
4100:     size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
4101:     FORWARD_IF_ERROR( remainingToFlush , "ZSTD_compressStream2 failed");
4107:         DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
1209:     return ZSTD_estimateCStreamSize_usingCCtxParams(&params);
1215:     return ZSTD_estimateCStreamSize_usingCParams(cParams);
1223:         size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
rtracklayer:src/ucsc/bbiFile.h: [ ]
299: struct bbiSumOutStream
309: struct bbiSumOutStream *bbiSumOutStreamOpen(int allocCount, FILE *f, boolean doCompress);
310: /* Open new bbiSumOutStream. */
312: void bbiSumOutStreamClose(struct bbiSumOutStream **pStream);
313: /* Free up bbiSumOutStream */
315: void bbiSumOutStreamWrite(struct bbiSumOutStream *stream, struct bbiSummary *sum);
322: 	struct bbiSumOutStream *stream);
Gviz:R/AlignmentsTrack-class.R: [ ]
251:     isStream <- FALSE
283:         isStream <- TRUE
310:     if (!isStream) {
rhdf5filters:src/blosc/lib/lz4-1.9.2/lz4.c: [ ]
1333: LZ4_stream_t* LZ4_createStream(void)
1353: LZ4_stream_t* LZ4_initStream (void* buffer, size_t size)
1369: void LZ4_resetStream (LZ4_stream_t* LZ4_stream)
1379: int LZ4_freeStream (LZ4_stream_t* LZ4_stream)
1375: void LZ4_resetStream_fast(LZ4_stream_t* ctx) {
2168: LZ4_streamDecode_t* LZ4_createStreamDecode(void)
2175: int LZ4_freeStreamDecode (LZ4_streamDecode_t* LZ4_stream)
2188: int LZ4_setStreamDecode (LZ4_streamDecode_t* LZ4_streamDecode, const char* dictionary, int dictSize)
2377: int LZ4_sizeofStreamState() { return LZ4_STREAMSIZE; }
2379: int LZ4_resetStreamState(void* state, char* inputBuffer)
1182:     LZ4_stream_t_internal* const ctx = & LZ4_initStream(state, sizeof(LZ4_stream_t)) -> internal_donotuse;
1208:  * (see comment in lz4.h on LZ4_resetStream_fast() for a definition of
1278:     LZ4_initStream(&ctx, sizeof(ctx));
1294:     void* const s = LZ4_initStream(state, sizeof (*state));
1330: *  Streaming functions
1337:     DEBUGLOG(4, "LZ4_createStream %p", lz4s);
1339:     LZ4_initStream(lz4s, sizeof(*lz4s));
1355:     DEBUGLOG(5, "LZ4_initStream");
1367: /* resetStream is now deprecated,
1368:  * prefer initStream() which is more general */
1371:     DEBUGLOG(5, "LZ4_resetStream (ctx:%p)", LZ4_stream);
1382:     DEBUGLOG(5, "LZ4_freeStream %p", LZ4_stream);
1403:     LZ4_resetStream(LZ4_dict);
1431: void LZ4_attach_dictionary(LZ4_stream_t* workingStream, const LZ4_stream_t* dictionaryStream) {
1432:     const LZ4_stream_t_internal* dictCtx = dictionaryStream == NULL ? NULL :
1433:         &(dictionaryStream->internal_donotuse);
1436:              workingStream, dictionaryStream,
1439:     /* Calling LZ4_resetStream_fast() here makes sure that changes will not be
1440:      * erased by subsequent calls to LZ4_resetStream_fast() in case stream was
1443:     LZ4_resetStream_fast(workingStream);
1451:         if (workingStream->internal_donotuse.currentOffset == 0) {
1452:             workingStream->internal_donotuse.currentOffset = 64 KB;
1461:     workingStream->internal_donotuse.dictCtx = dictCtx;
2375: /* Obsolete Streaming functions */
2382:     LZ4_resetStream((LZ4_stream_t*)state);
2389:     return LZ4_createStream();
2182: /*! LZ4_setStreamDecode() :
2222:     and indicate where it stands using LZ4_setStreamDecode()
Cardinal:R/utils.R: [ ]
401: getRNGStream <- function() {
410: setRNGStream <- function(seed = NULL) {
416: generateRNGStreams <- function(n = 1) {
418: 	s <- getRNGStream()
427: 			s <- nextRNGStream(seeds[[i - 1]])
Glimma:inst/htmlwidgets/lib/datatables/JSZip-2.5.0/jszip.js: [ ]
9127: function ZStream() {
9152: module.exports = ZStream;
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 {
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();
Gviz:R/GeneRegionTrack-class.R: [ ]
350:     isStream <- FALSE
382:         isStream <- TRUE
396:     if (!isStream) {
RSeqAn:inst/include/seqan/basic/basic_stream.h: [ ]
446: struct BasicStream :
47: struct StreamIterator;
56: inline void writeValue(Iter<TContainer, StreamIterator<Output> > &iter, TValue val);
94: // Concept StreamConcept
98:  * @concept StreamConcept
103:  * @signature concept StreamConcept;
107:  * @mfn StreamConcept#Value
110:  * @signature Value<TStream>::Type;
112:  * @tparam TStream The stream type to query for its value type.
117:  * @mfn StreamConcept#Size
120:  * @signature Size<TStream>::Type;
122:  * @tparam TStream The stream type to query for its size type.
127:  * @mfn StreamConcept#Position
130:  * @signature Position<TStream>::Type;
132:  * @tparam TStream The stream type to query for its position type.
137:  * @fn StreamConcept#position
143:  * @return TPosition Current position in stream, see @link StreamConcept#Position Position @endlink.
147:  * @fn StreamConcept#setPosition
157:  * @fn StreamConcept#atEnd
166: SEQAN_CONCEPT(StreamConcept, (TStream))
174:  * @concept InputStreamConcept Input StreamConcept
175:  * @extends StreamConcept
178:  * @signature concept InputStreamConcept : StreamConcept;
183: SEQAN_CONCEPT_REFINE(InputStreamConcept, (TStream), (StreamConcept))
185:     typedef typename Value<TStream>::Type       TValue;
186:     typedef typename Size<TStream>::Type        TSize;
187:     typedef typename Position<TStream>::Type    TPosition;
200:  * @concept OutputStreamConcept Output StreamConcept
201:  * @extends StreamConcept
204:  * @signature concept OutputStreamConcept : StreamConcept;
209: SEQAN_CONCEPT_REFINE(OutputStreamConcept, (TStream), (StreamConcept))
211:     typedef typename Value<TStream>::Type       TValue;
212:     typedef typename Size<TStream>::Type        TSize;
213:     typedef typename Position<TStream>::Type    TPosition;
226:  * @concept BidirectionalStreamConcept Bidirectional StreamConcept
227:  * @extends StreamConcept
230:  * @signature concept BidirectionalStreamConcept : StreamConcept;
235: SEQAN_CONCEPT_REFINE(BidirectionalStreamConcept, (TStream), (InputStreamConcept)(OutputStreamConcept))
402:  * @mfn StreamConcept#DirectionIterator
405:  * @signature DirectionIterator<TStream>::Type;
407:  * @tparam TStream The stream to query for its direction iterator.
423:     If<Is<StreamConcept<TObject> >,
424:        Iter<TObject, StreamIterator<TDirection> >,
429: // Metafunction BasicStream
433:  * @mfn BasicStream
437:  * @signature BasicStream<TValue, TDirection[, TTraits]>::Type;
991: // NOTE(esiragusa): should it be defined for Streams and Containers?
1302: template <typename TStream, typename TIterator>
1303: inline TStream &
1304: operator<<(TStream & target,
1307:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
1312: template <typename TStream, typename TValue>
1313: inline TStream &
1314: operator<<(TStream & target,
1317:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
170: // Concept InputStreamConcept
191:     SEQAN_CONCEPT_USAGE(InputStreamConcept)
196: // Concept OutputStreamConcept
217:     SEQAN_CONCEPT_USAGE(OutputStreamConcept)
222: // Concept BidirectionalStreamConcept
916: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
924: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
994: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
1026: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
1041: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
MACPET:R/Stage_0_FilteringLinkersFunctions.R: [ ]
103:     Streamfastq1 = ShortRead::FastqStreamer(con = S0_fastq1, n = S0_fastqStream)
104:     Streamfastq2 = ShortRead::FastqStreamer(con = S0_fastq2, n = S0_fastqStream)
101:     # Stream the fastq files:
8:     S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_image, S0_fastqStream,
27:         S0_LinkerOccurence = S0_LinkerOccurence, S0_fastqStream = S0_fastqStream,
98:     S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_fastqStream, S0_Totfastqreads,
128:         fastq1yield = ShortRead::yield(Streamfastq1)
130:         fastq2yield = ShortRead::yield(Streamfastq2)
216:     close(Streamfastq1)
217:     close(Streamfastq2)
1: #' @importFrom ShortRead FastqStreamer yield writeFastq
3: #' @importClassesFrom ShortRead FastqStreamer ShortReadQ SFastqQuality SRFilterResult
seqbias:src/yaml-cpp/scanner.h: [ ]
121: 		bool m_startedStream, m_endedStream;
115: 		Stream INPUT;
54: 		void StartStream();
55: 		void EndStream();
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(); }
mzR:src/boost/nowide/fstream.hpp: [ ]
23:         struct StreamTypeIn
32:         struct StreamTypeOut
41:         struct StreamTypeInOut
56:         /// \tparam T_StreamType One of StreamType* above.
61:                  typename T_StreamType,
72:     class basic_ifstream : public detail::fstream_impl<CharType, Traits, detail::StreamTypeIn>
74:         using fstream_impl = detail::fstream_impl<CharType, Traits, detail::StreamTypeIn>;
123:     class basic_ofstream : public detail::fstream_impl<CharType, Traits, detail::StreamTypeOut>
125:         using fstream_impl = detail::fstream_impl<CharType, Traits, detail::StreamTypeOut>;
175:     class basic_fstream : public detail::fstream_impl<CharType, Traits, detail::StreamTypeInOut>
177:         using fstream_impl = detail::fstream_impl<CharType, Traits, detail::StreamTypeInOut>;
272:         template<typename CharType, typename Traits, typename T_StreamType, int>
274:                              public T_StreamType::template stream_base<CharType, Traits>::type
278:             using stream_base = typename T_StreamType::template stream_base<CharType, Traits>::type;
310:             void open(const std::string& file_name, std::ios_base::openmode mode = T_StreamType::mode())
316:                                                       std::ios_base::openmode mode = T_StreamType::mode())
320:             void open(const char* file_name, std::ios_base::openmode mode = T_StreamType::mode())
322:                 if(!rdbuf()->open(file_name, mode | T_StreamType::mode_modifier()))
328:             void open(const wchar_t* file_name, std::ios_base::openmode mode = T_StreamType::mode())
330:                 if(!rdbuf()->open(file_name, mode | T_StreamType::mode_modifier()))
seqTools:src/dna_astream.h: [ ]
87: } daStream;
55: 	dfStream *dnaf;
95: static inline int dasEmpty(daStream *das) 		{ return das->r_iter == das->r_end; }
96: static inline int dasProcEmpty(daStream *das)	{ return das->p_iter == das->p_end; }
97: static inline int dasIsError(daStream *das)		{ return das->state & das_err; }
98: static inline int dasIsOpen(daStream *das)		{ return dfs_isOpen(das->dnaf); }
99: static inline int dasIsEof(daStream *das)		{ return dfs_stream_eof(das->dnaf); }
107: void das_destroy(daStream *das)
122: int das_fill(daStream *das)
176: daStream * das_init(const char* filename, unsigned das_size)
178: 	daStream *das = calloc(sizeof(daStream), 1);
seqTools:src/dna_fstream.h: [ ]
39: } dfStream;
41: static inline int dfs_isOpen(dfStream *dfs)	{ return dfs->state == dfs_file_open; }
43: static inline int dfs_stream_open(dfStream *dfs, const char *filename)
65: static inline void dfs_stream_close(dfStream *dfs)
79: static inline int dfs_stream_eof(dfStream *dfs)
89: static dfStream* dfs_stream_init(const char* filename)
91: 	dfStream *dfs = calloc(sizeof(dfStream), 1);
98: static void dfs_destroy(dfStream *dfs)
108: static inline size_t dfs_read(dfStream *dfs, char *dest, unsigned size)
Rfastp:src/FASTP/seprocessor.h: [ ]
68:     ofstream* mOutStream;
RSeqAn:inst/include/seqan/stream/virtual_stream.h: [ ]
237: class VirtualStream: public BasicStream<TValue, TDirection, TTraits>::Type
240:     typedef typename BasicStream<TValue, TDirection, TTraits>::Type TStream;                // the stream base class we expose
243:     typedef BufferedStream<TStream, TDirection>                     TBufferedStream;        // if input stream is not buffered
249:     TBufferedStream         bufferedStream;
268:     VirtualStream():
274:     VirtualStream(TStreamBuffer &streamBuf):
280:     VirtualStream(TStream &stream):
288:     VirtualStream(const char *fileName,
297:     ~VirtualStream()
360: struct StreamFormat<VirtualStream<TValue, TDirection, TTraits> >
433:     typedef VirtualStream<TValue, TDirection, TTraits>  TVirtualStream;
434:     typedef typename TVirtualStream::TStream            TStream;
556:     typedef VirtualStream<TValue, TDirection, TTraits> TVirtualStream;
557:     typedef typename TVirtualStream::TBufferedStream TBufferedStream;
616:     typedef VirtualStream<TValue, TDirection, TTraits> TVirtualStream;
115: struct VirtualStreamSwitch_
122: struct VirtualStreamSwitch_<TValue, Input, GZFile>
128: struct VirtualStreamSwitch_<TValue, Output, GZFile>
134: struct VirtualStreamSwitch_<TValue, Input, BgzfFile>
140: struct VirtualStreamSwitch_<TValue, Output, BgzfFile>
150: struct VirtualStreamSwitch_<TValue, Input, BZ2File>
156: struct VirtualStreamSwitch_<TValue, Output, BZ2File>
181: struct VirtualStreamContextBase_
184:     VirtualStreamContextBase_(): streamBuf() {}
185:     virtual ~VirtualStreamContextBase_() {}
190: struct VirtualStreamContext_:
196:     VirtualStreamContext_(TObject &object):
205: struct VirtualStreamContext_<TValue, TDirection, TTraits, Nothing>:
209:     VirtualStreamContext_(TObject &object)
244:     typedef std::basic_streambuf<TValue, TTraits>                   TStreamBuffer;          // the streambuf to use
245:     typedef VirtualStreamContextBase_<TValue, TTraits>              TVirtualStreamContext;  // the owner of the streambuf
303:     operator TStreamBuffer*() const
431: struct VirtualStreamFactoryContext_<VirtualStream<TValue, TDirection, TTraits> >
437:     VirtualStreamFactoryContext_(TStream &stream):
345:  * @defgroup StreamFormats Stream Formats
49: template <typename TStream>
50: struct StreamFormat;
170: template <typename TVirtualStream>
216: // Class VirtualStream
218: // The VirtualStream class auto-detects data compression from file name or stream.
223:  * @class VirtualStream
224:  * @implements StreamConcept
226:  * @brief Provides seamless (de)compression for another @link StreamConcept stream @endlink.
229:  *            class VirtualStream;
242: //    typedef FileStream<TValue, TDirection>                          TFile;                  // if a real file should be op...(4 bytes skipped)...
246:     typedef typename StreamFormat<VirtualStream>::Type              TFormat;                // detected stream format
255:      * @fn VirtualStream::VirtualStream
258:      * @signature VirtualStream::VirtualStream();
259:      * @signature VirtualStream::VirtualStream(stream);
260:      * @signature VirtualStream::VirtualStream(streamBuf);
261:      * @signature VirtualStream::VirtualStream(fileName, openMode);
263:      * @param[in] stream    The @link StreamConcept stream @endlink to attach to.
264:      * @param[in] streamBuf The @link StreamBuffer stream buffer @endlink to attach to.
269:         TStream(NULL),
275:         TStream(NULL),
281:         TStream(NULL),
289:                   int openMode = DefaultOpenMode<VirtualStream>::VALUE):
290:         TStream(NULL),
324:      * @fn VirtualStream::getFileExtensions
341: // Metafunction StreamFormat
350:  * @mfn VirtualStream#StreamFormat
351:  * @brief Metafunction for retrieving the format type of a @link VirtualStream @endlink.
353:  * @signature StreamFormat<TStream>::Type;
355:  * @tparam TStream  The stream file type to query for its file format type.
356:  * @return Type     The resulting @link VirtualStream @endlink file formats type.
370: struct Value<VirtualStream<TValue, TDirection, TTraits> >
380: struct Position<VirtualStream<TValue, TDirection, TTraits> >:
381:     Position<typename VirtualStream<TValue, TDirection, TTraits>::TFile> {};
388: struct Iterator<VirtualStream<TValue, TDirection, TTraits>, TDirection>
390:     typedef Iter<VirtualStream<TValue, TDirection, TTraits>, StreamIterator<TDirection> > Type;
398: struct DefaultOpenMode<VirtualStream<TValue, Input, TTraits>, TDummy>
408: struct DefaultOpenMode<VirtualStream<TValue, Output, TTraits>, TDummy>
418: SEQAN_CONCEPT_IMPL((VirtualStream<TValue, Input>), (InputStreamConcept));
421: SEQAN_CONCEPT_IMPL((VirtualStream<TValue, Output>), (OutputStreamConcept));
424: SEQAN_CONCEPT_IMPL((VirtualStream<TValue, Bidirectional>), (BidirectionalStreamConcept));
436:     TStream &stream;
441: template <typename TVirtualStream>
442: struct Value<VirtualStreamFactoryContext_<TVirtualStream> >
444:     typedef typename TVirtualStream::TVirtualStreamContext *Type;
458: tagApply(VirtualStreamFactoryContext_<VirtualStream<TValue, TDirection, TTraits> > &ctx, Tag<TFormat>)
467: template <typename TValue, typename TStream, typename TCompressionType>
468: inline bool _guessFormat(VirtualStream<TValue, Input> &, TStream &fileStream, TCompressionType &compressionType)
471:     fileStream.rdbuf()->sgetc();
472:     return guessFormatFromStream(fileStream, compressionType);
475: template <typename TValue, typename TStream, typename TCompressionType>
476: inline bool _guessFormat(VirtualStream<TValue, Output> &, TStream &, TCompressionType &)
537:  * @fn VirtualStream#open
538:  * @brief Open a VirtualStream.
540:  * @signature bool open(stream, fileStream);
543:  * @param[in,out] stream        The VirtualStream to open.
544:  * @param[in,out  fileStream    File stream to attach to. Type: <tt>std::fstream</tt>.
550: template <typename TValue, typename TDirection, typename TTraits, typename TStream, typename TCompressionType>
551: inline SEQAN_FUNC_DISABLE_IF(IsPointer<TStream>, bool)
552: open(VirtualStream<TValue, TDirection, TTraits> &stream, TStream &fileStream, TCompressionType & compressionType)
554:     SEQAN_ASSERT_MSG(stream.context == NULL, "VirtualStream: close() must be called before re-opening.");
561:         fileStream.rdbuf()->sgetc();
563:     SEQAN_IF_CONSTEXPR (IsSameType<TDirection, Input>::VALUE && !IsSameType<TStream, TBufferedStream>::VALUE)
565:         if (fileStream.rdbuf()->in_avail() < 2)
567:             stream.bufferedStream.setStream(fileStream);
568:             return open(stream, stream.bufferedStream, compressionType);
572:     VirtualStreamFactoryContext_<TVirtualStream> ctx(fileStream);
575:     if (!_guessFormat(stream, fileStream, compressionType))
591: template <typename TValue, typename TDirection, typename TTraits, typename TStream, typename TCompressionType>
592: inline SEQAN_FUNC_DISABLE_IF(IsPointer<TStream>, bool)
593: open(VirtualStream<TValue, TDirection, TTraits> &stream, TStream &fileStream, TCompressionType const & compressionType)
596:     return open(stream, fileStream, stream.format);
599: template <typename TValue, typename TStream>
600: inline SEQAN_FUNC_DISABLE_IF(IsPointer<TStream>, bool)
601: open(VirtualStream<TValue, Input> &stream, TStream &fileStream)
604:     assign(stream.format, typename StreamFormat<VirtualStream<TValue, Input> >::Type());
605:     return open(stream, fileStream, stream.format);
610: open(VirtualStream<TValue, TDirection, TTraits> &stream,
612:      int openMode = DefaultOpenMode<VirtualStream<TValue, TDirection, TTraits> >::VALUE)
614:     SEQAN_ASSERT_MSG(stream.context == NULL, "VirtualStream: close() must be called before re-opening.");
622:     assign(stream.format, typename StreamFormat<TVirtualStream>::Type());
629:     VirtualStreamFactoryContext_<TVirtualStream> ctx(stream.file);
650:  * @fn VirtualStream#close
651:  * @brief Close a VirtualStream.
655:  * @param[in,out] stream The VirtualStream to close.
661: close(VirtualStream<TValue, TDirection, TTraits> &stream)
666:     assign(stream.format, typename StreamFormat<VirtualStream<TValue, TDirection, TTraits> >::Type());
675:  * @fn VirtualStream#format
676:  * @brief Return the format of a VirtualStream.
680:  * @param[in] stream The VirtualStream to check.
681:  * @return TFormat   The type as returned from @link VirtualStream#StreamFormat @endlink.
685: inline typename StreamFormat<VirtualStream<TValue, TDirection, TTraits> >::Type &
686: format(VirtualStream<TValue, TDirection, TTraits> &stream)
103: SEQAN_CONCEPT_IMPL((basic_bgzf_istream<Elem, Tr, ElemA, ByteT, ByteAT>), (InputStreamConcept));
106: SEQAN_CONCEPT_IMPL((basic_bgzf_ostream<Elem, Tr, ElemA, ByteT, ByteAT>), (OutputStreamConcept));
111: // Metafunction VirtualStreamSwitch_
167: // Class VirtualStreamFactoryContext_
171: struct VirtualStreamFactoryContext_;
174: // Class VirtualStreamContext_
177: // a compressed stream lives in the VirtualStreamContext_ and provides a basic_streambuf
191:     VirtualStreamContextBase_<TValue, TTraits>
193:     typename VirtualStreamSwitch_<TValue, TDirection, TFormatTag>::Type stream;
206:     VirtualStreamContextBase_<TValue, TTraits>
250:     TStreamBuffer           *streamBuf;
251:     TVirtualStreamContext   *context;
318:     TStreamBuffer* rdbuf() const
427: // Class VirtualStreamFactoryContext_
457: inline VirtualStreamContextBase_<TValue, TTraits> *
460:     return new VirtualStreamContext_<TValue, TDirection, TTraits, Tag<TFormat> >(ctx.stream);
Gviz:R/ReferenceTrack-class.R: [ ]
116:         isStream <- !is.null(defMap[[".stream"]]) && defMap[[".stream"]]
118:         if (!isStream) {
affxparser:src/fusion/calvin_files/data/src/GenericData.cpp: [ ]
442: void GenericData::OpenFStream(std::ifstream& ifs)
281: 		return new affymetrix_calvin_io::DataSet(Header().GetFilename(), *dsh, fileStream, loadEntireDataSetHint);
298: 	std::ifstream* pfs = &fileStream;	// initialize to use GenericData::fileStream
303: 		OpenFStream(fs);
329: 		return affymetrix_calvin_io::DataGroup(Header().GetFilename(), dch, fileStream, loadEntireDataSetHint);
408: 		std::ifstream* pfs = &fileStream;	// initialize to use GenericData::ifs
411: 			OpenFStream(fs);
458: 		if (fileStream.is_open() == false)
459: 			OpenFStream(fileStream);
467: 	if (fileStream.is_open())
468: 		fileStream.close();
RSeqAn:inst/include/seqan/stream/formatted_file.h: [ ]
215:     typedef VirtualStream<char, TDirection>                                     TStream;
617: _checkThatStreamOutputFormatIsSet(TFormattedFile const &, TFormat const &)
622: _checkThatStreamOutputFormatIsSet(FormattedFile<TFileFormat, Output, TSpec> const &, TagSelector<TFileFormatList> co...(12 bytes skipped)...
134:  * FormattedFile encapsulates a VirtualStream and provides access to its @link StreamConcept#DirectionIterator @endlink.
216:     typedef typename Iterator<TStream, TDirection>::Type                        TIter;
221:     TStream             stream;
459:     Value<typename FormattedFile<TFileFormat, TDirection, TSpec>::TStream> {};
467:     Position<typename FormattedFile<TFileFormat, TDirection, TSpec>::TStream> {};
475:     DefaultOpenMode<typename FormattedFile<TFileFormat, TDirection, TSpec>::TStream, TDummy> {};
565:     return guessFormatFromStream(file.stream, file.format);
645:           typename TStream, typename TCompressionFormat, typename TThrowExceptions>
647:                   TStream &stream,
668: template <typename TFileFormat, typename TDirection, typename TSpec, typename TStream>
669: inline SEQAN_FUNC_ENABLE_IF(Is<StreamConcept<TStream> >, bool)
671:      TStream &stream)
676: template <typename TFileFormat, typename TSpec, typename TStream, typename TFormat_>
678:                  TStream &stream,
685: template <typename TFileFormat, typename TSpec, typename TStream, typename TFormats>
687:                  TStream &stream,
801: inline SEQAN_FUNC_ENABLE_IF(Is<InputStreamConcept<typename FormattedFile<TFileFormat, TDirection, TSpec>::TStream> >, bool)
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());
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
mzR:src/pwiz/utility/misc/VendorReaderTestHarness.cpp: [ ]
196: string headStream(istream& is, size_t maxLength)
187:     stringstream diffStream;
188:     diffStream << diff;
189:     string diffString = diffStream.str();
426:             if (diff_mzXML && !os_) cerr << "mzXML:\n" << headStream(*serializedStreamPtr, 5000) << endl;
447:             if (diff_MGF && !os_) cerr << "MGF:\n" << headStream(*serializedStreamPtr, 5000) << endl;
357:         boost::shared_ptr<std::iostream> serializedStreamPtr(stringstreamPtr);
423:             serializer_mzXML.read(serializedStreamPtr, msd_mzXML);
443:             serializer_MGF.read(serializedStreamPtr, msd_MGF);
566:             boost::shared_ptr<std::iostream> serializedStreamPtr(stringstreamPtr);
affxparser:src/fusion/util/LineFile.h: [ ]
114:   std::ifstream & getStream() {
131:   std::ifstream m_fileStream;
115:     return m_fileStream;
119:     return m_fileStream.is_open();
122:     return m_fileStream.fail();
125:     return m_fileStream.eof() ;
Rfastp:src/FASTP/fastareader.h: [ ]
60:     ifstream mFastaFileStream;
affxparser:src/fusion/calvin_files/parsers/src/GenericFileReader.h: [ ]
150: 	std::ifstream fileStream;
beachmat:inst/include/byteme/ZlibBufferReader.hpp: [ ]
27:     struct ZStream {
28:         ZStream(int mode) {
56:         ~ZStream() {
62:         ZStream(const ZStream&) = delete;
63:         ZStream(ZStream&&) = delete;
64:         ZStream& operator=(const ZStream&) = delete;
65:         ZStream& operator=(ZStream&&) = delete;
126:     ZStream zstr;
mzR:src/pwiz/utility/misc/SHA1CalculatorTest.cpp: [ ]
71: void testStream()
164:         testStream();
Rfastp:src/FASTP/writer.h: [ ]
39:     ofstream* mOutStream;
mzR:src/pwiz/data/msdata/MSDataFile.cpp: [ ]
147: void writeStream(ostream& os, const MSData& msd, const MSDataFile::WriteConfig& config,
237:             writeStream(*os, msd, config, iterationListenerRegistry);
251:     writeStream(os, msd, config2, iterationListenerRegistry);
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));
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 );
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`
mzR:src/pwiz/analysis/spectrum_processing/SpectrumList_MZRefiner.cpp: [ ]
1329:     shared_ptr<ofstream> statStream_;
1394:     statStream_ = openFilestreamIfWritable(statFilepath, fileExists);
1395:     if (!statStream_) statStream_ = openFilestreamIfWritable(statFilepath.filename(), fileExists);
1396:     if (!statStream_) statStream_ = openFilestreamIfWritable(bfs::temp_directory_path() / statFilepath.filename(), fileExists);
1397:     if (!statStream_) throw runtime_error("[SpectrumList_MZRefiner::configureShift] unable to open a writable mzRefinem...(17 bytes skipped)...
1401:         *statStream_ << "ThresholdScore\tThresholdValue\tExcluded (score)\tExcluded (mass error)"
2236:     *statStream_ << statsRow.str();
2237:     statStream_->close();
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;
HTSeqGenie:R/io.R: [ ]
102: FastQStreamer.init <- function(input_file, input_file2=NULL, chunk_size, subsample_nbreads=NULL, max_nbchunks=N...(6 bytes skipped)...
144:   FastQStreamer.lfqs <<- lfqs
145:   FastQStreamer.chunkid <<- 0
146:   FastQStreamer.subsampling_filter <<- subsampling_filter
148:   if (is.null(max_nbchunks)) FastQStreamer.max_nbchunks <<- Inf
160: FastQStreamer.getReads <- function() {
163:     FastQStreamer.lfqs <- NULL ## to avoid the 'no visible binding' R CMD check warning
164:     FastQStreamer.chunkid <- NULL ## to avoid the 'no visible binding' R CMD check warning
165:     FastQStreamer.max_nbchunks <- NULL ## to avoid the 'no visible binding' R CMD check warning
166:     FastQStreamer.subsampling_filter <- NULL ## to avoid the 'no visible binding' R CMD check warning
210: FastQStreamer.release <- function() {
213:     FastQStreamer.lfqs <- NULL ## to avoid the 'no visible binding' R CMD check warning
70: ##' @importMethodsFrom ShortRead FastqStreamer
75:   fqs <- FastqStreamer(con, n=1e6)
88: ##' Only one FastQStreamer object can be open at any time.
96: ##' @seealso FastQStreamer.getReads
112:     loginfo(paste("io.R/FastQStreamer.init: counting number of reads in file=", input_file))
125:       loginfo(paste("io.R/FastQStreamer.init: subsampling_filter set (subsampled reads=", subsample_nbreads,
128:       loginfo(paste("io.R/FastQStreamer.init: the requested number of subsampled reads=", subsample_nbreads,
139:     fqs <- FastqStreamer(con1, n=chunk_size)
140:     loginfo(paste("io.R/FastQStreamer.init: initialised FastQ streamer for filename=", filename))
149:   else FastQStreamer.max_nbchunks <<- as.integer(max_nbchunks)
157: ##' @seealso FastQStreamer.init
162:   if (!exists("FastQStreamer.lfqs")) {
167:     stop("io.R/FastQStreamer.getReads: FastQStreamer.init() has not been called")
171:   lfqs <- FastQStreamer.lfqs
177:       stop("io.R/FastQStreamer.getReads: input files must have the same number of reads")
181:   FastQStreamer.chunkid <<- FastQStreamer.chunkid + 1
182:   if (length(lreads[[1]])==0 || FastQStreamer.chunkid>FastQStreamer.max_nbchunks) lreads <- NULL
185:     if (!is.null(FastQStreamer.subsampling_filter)) {
188:         z <- FastQStreamer.subsampling_filter[1:len]
191:           FastQStreamer.subsampling_filter <<- FastQStreamer.subsampling_filter[-(1:len)]
193:        ##   stop("io.R/FastQStreamer.getReads: (known bug) the chunk is empty after subsampling. I won't process an empty chunk! Pleas...(69 bytes skipped)...
202: ##' Close the FastQStreamer 
204: ##' @title Close the FastQStreamer 
206: ##' @seealso FastQStreamer.init
212:   if (!exists("FastQStreamer.lfqs")) {
214:     stop("io.R/FastQStreamer.release: FastQStreamer.init() has not been called")
217:   invisible(lapply(FastQStreamer.lfqs, close))
382:     fqs <- FastqStreamer(con, n=nreads)
473: ##' Overloaded yield(...) method catching truncated exceptions for FastqStreamer
475: ##' @title Overloaded yield(...) method catching truncated exceptions for FastqStreamer
476: ##' @param fqs An instance from the FastqSampler or FastqStreamer class.
477: ##' @return Same as FastqStreamer::yield
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']] )
CNEr:src/ucsc/net.c: [ ]
27: static int netStreamSocket()
95: if ((sd = netStreamSocket()) < 0)
230: if ((sd = netStreamSocket()) < 0)
rtracklayer:src/ucsc/net.c: [ ]
30: static int netStreamSocket()
121: if ((sd = netStreamSocket()) < 0)
262: if ((sd = netStreamSocket()) < 0)
HTSeqGenie:inst/unitTests/runit.io.R: [ ]
16: test.FastQStreamer.getReads.pefq <- function() {
35: test.FastQStreamer.getReads.truncated <- function() {
54: test.FastQStreamer.getReads.pefq.subsample <- function() {
75: test.FastQStreamer.subsampler.isdeterministic <- function() {
88: test.FastQStreamer.getReads.segz <- function() {
21:                      testname="test.FastQStreamer.getReads.pefq")
23:   ## init FastQStreamer
24:   FastQStreamer.init(input_file=getConfig("input_file"), input_file2=getConfig("input_file2"),
28:   lreads <- FastQStreamer.getReads()
29:   checkEquals(length(lreads[[2]]), 10, "FastQStreamer.getReads() doesn't return 10 reads")
31:   ## release FastQStreamer
32:   FastQStreamer.release()
40:                      testname="test.FastQStreamer.getReads.truncated")
42:   ## init FastQStreamer
43:   FastQStreamer.init(input_file=getPackageFile("test-data/truncated.fastq.gz"),
47:   lreads <- try(FastQStreamer.getReads(), silent=TRUE)
50:   ## release FastQStreamer
51:   FastQStreamer.release()
59:                      testname="test.FastQStreamer.getReads.pefq.subsample")
61:   ## init FastQStreamer
62:   FastQStreamer.init(input_file=getConfig("input_file"), input_file2=getConfig("input_file2"),
67:   lreads <- FastQStreamer.getReads()
68:   checkEquals(length(lreads[[2]]), 17, "FastQStreamer.getReads() doesn't return 17 reads")
70:   ## release FastQStreamer
71:   FastQStreamer.release()
77:   lreads1 <- test.FastQStreamer.getReads.pefq.subsample()
78:   lreads2 <- test.FastQStreamer.getReads.pefq.subsample()
85:   checkEquals(reads1, reads2, "FastQStreamer is not deterministic")
93:                      testname="test.FastQStreamer.getReads.segz")
95:   ## init FastQStreamer
96:   FastQStreamer.init(input_file=getConfig("input_file"), input_file2=getConfig("input_file2"),
100:   lreads <- FastQStreamer.getReads()
101:   checkEquals(length(lreads[[1]]), 10, "FastQStreamer.getReads() doesn't return 10 reads")
103:   ## release FastQStreamer
104:   FastQStreamer.release()
seqbias:src/yaml-cpp/emitter.cpp: [ ]
660: 	void Emitter::PreWriteStreamable(std::stringstream& str)
673: 	void Emitter::PostWriteStreamable(const std::stringstream& str)
lpsymphony:src/SYMPHONY/Osi/src/OsiMsk/OsiMskSolverInterface.cpp: [ ]
99: void MSKAPI OsiMskStreamFuncLog(MSKuserhandle_t handle, MSKCONST char* str) {
110: void MSKAPI OsiMskStreamFuncWarning(MSKuserhandle_t handle, MSKCONST char* str) {
121: void MSKAPI OsiMskStreamFuncError(MSKuserhandle_t handle, MSKCONST char* str) {
4575:   MSK_linkfunctotaskstream(getMutableLpPtr(), MSK_STREAM_LOG, messageHandler(), OsiMskStreamFuncLog);
4576:   MSK_linkfunctotaskstream(getMutableLpPtr(), MSK_STREAM_ERR, messageHandler(), OsiMskStreamFuncWarning);
4577:   MSK_linkfunctotaskstream(getMutableLpPtr(), MSK_STREAM_WRN, messageHandler(), OsiMskStreamFuncError);
4941:     err = MSK_linkfunctotaskstream(task_, MSK_STREAM_LOG, messageHandler(), OsiMskStreamFuncLog);
4944:     err = MSK_linkfunctotaskstream(task_, MSK_STREAM_WRN, messageHandler(), OsiMskStreamFuncWarning);
4947:     err = MSK_linkfunctotaskstream(task_, MSK_STREAM_ERR, messageHandler(), OsiMskStreamFuncError);
rhdf5filters:src/blosc/lib/lz4-1.9.2/lz4hc.c: [ ]
951: LZ4_streamHC_t* LZ4_createStreamHC(void)
959: int LZ4_freeStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr)
968: LZ4_streamHC_t* LZ4_initStreamHC (void* buffer, size_t size)
992: void LZ4_resetStreamHC (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
998: void LZ4_resetStreamHC_fast (LZ4_streamHC_t* LZ4_streamHCPtr, int compressionLevel)
1166: int LZ4_sizeofStreamStateHC(void) { return LZ4_STREAMHCSIZE; }
1170: int LZ4_resetStreamStateHC(void* state, char* inputBuffer)
948: *  Streaming Functions
905:     LZ4_resetStreamHC_fast((LZ4_streamHC_t*)state, compressionLevel);
915:     LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
938:     LZ4_streamHC_t* const ctx = LZ4_initStreamHC(state, sizeof(*ctx));
955:     LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));  /* full initialization, malloc'ed buffer can be full...(14 bytes skipped)...
961:     DEBUGLOG(4, "LZ4_freeStreamHC(%p)", LZ4_streamHCPtr);
980:     DEBUGLOG(4, "LZ4_initStreamHC(%p, %u)", LZ4_streamHCPtr, (unsigned)size);
994:     LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
1000:     DEBUGLOG(4, "LZ4_resetStreamHC_fast(%p, %d)", LZ4_streamHCPtr, compressionLevel);
1002:         LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
1039:         LZ4_initStreamHC(LZ4_streamHCPtr, sizeof(*LZ4_streamHCPtr));
1172:     LZ4_streamHC_t* const hc4 = LZ4_initStreamHC(state, sizeof(*hc4));
1180:     LZ4_streamHC_t* const hc4 = LZ4_createStreamHC();
1207:     LZ4_resetStreamHC_fast(ctx, ctx->internal_donotuse.compressionLevel);
seqbias:src/yaml-cpp/emitter.h: [ ]
115: 	inline Emitter& Emitter::WriteStreamable(T value)
65: 		Emitter& WriteStreamable(T value);
69: 		void PreWriteStreamable(std::stringstream& str);
71: 		void PostWriteStreamable(const std::stringstream& str);
121: 		PreWriteStreamable(str);
123: 		PostWriteStreamable(str);
148: 	inline Emitter& operator << (Emitter& emitter, float v) { return emitter.WriteStreamable(v); }
149: 	inline Emitter& operator << (Emitter& emitter, double v) { return emitter.WriteStreamable(v); }
rtracklayer:src/ucsc/bbiWrite.c: [ ]
603: struct bbiSumOutStream *bbiSumOutStreamOpen(int allocCount, FILE *f, boolean doCompress)
615: void bbiSumOutStreamFlush(struct bbiSumOutStream *stream)
636: void bbiSumOutStreamClose(struct bbiSumOutStream **pStream)
648: void bbiSumOutStreamWrite(struct bbiSumOutStream *stream, struct bbiSummary *sum)
604: /* Allocate new bbiSumOutStream. */
606: struct bbiSumOutStream *stream;
637: /* Free up bbiSumOutStream */
639: struct bbiSumOutStream *stream = *pStream;
644:     freez(pStream);
671: 	struct bbiSumOutStream *stream)
642:     bbiSumOutStreamFlush(stream);
664:     bbiSumOutStreamFlush(stream);    
687: bbiSumOutStreamWrite(stream, sum);
ShortRead:R/AllClasses-Base.R: [ ]
370: .FastqStreamer_g <- setRefClass("FastqStreamer",
387: setClass("FastqStreamerList", contains="FastqFileList",
388:          prototype=prototype(elementType="FastqStreamer"))
ShortRead:inst/unitTests/test_ShortReadQ.R: [ ]
97: test_FastqStreamer <- function()
141: test_FastqStreamer_roundtrip <- function()
149: test_FastqStreamer_IRanges <- function()
101:     f <- FastqStreamer(fl, n=50)
112:     f <- FastqStreamer(fl, n=50)
118:     f <- FastqStreamer(fl, n=500)
130:     f <- FastqStreamer(fl, n=50, readerBlockSize=100)
145:     s <- FastqStreamer(out)
155:     f <- FastqStreamer(fl, rng)
164:     f <- FastqStreamer(fl, rng)
172:     f <- FastqStreamer(fl, rng)
179:     f <- FastqStreamer(fl, rng, readerBlockSize=10000)
185:     f <- FastqStreamer(fl, rng, readerBlockSize=10000)
192:     checkException(FastqStreamer(fl, rng), silent=TRUE)
194:     checkException(FastqStreamer(fl, rng), silent=TRUE)
velociraptor:man/plotVelocityStream.Rd: [ ]
76: Plot velocities embedded into low-dimensional space as a stream plot. Stream
2: % Please edit documentation in R/plotVelocityStream.R
3: \name{plotVelocityStream}
4: \alias{plotVelocityStream}
7: plotVelocityStream(
90:   Streamlines are computed by simple integration with a forward Euler method,
108: plotVelocityStream(out, em)
109: plotVelocityStream(out, em, color.streamlines = TRUE)
Streamer:man/Streamer-package.Rd: [ ]
21:   The central paradigm in this package is a \code{Stream} composed of a
26:   transformations on it. The \code{\link{Stream}} function is used to
45:   main types of stream components. Use \code{\link{Stream}} to connect
61: s <- Stream(RawToChar(), Rev(), b)
68: s <- Stream(RawToChar(), d, b)
</