Found 2549 results in 329 files, showing top 50 files (show more).
seqbias:src/yaml-cpp/stream.cpp: [ ]
180: 	Stream::Stream(std::istream& input)
224: 	Stream::~Stream()
311: 	void Stream::StreamInUtf8() const
320: 	void Stream::StreamInUtf16() const
426: 	void Stream::StreamInUtf32() const
149: 		// We are not allowed to queue the Stream::eof() codepoint, so
151: 		if (static_cast<unsigned long>(Stream::eof()) == ch)
229: 	char Stream::peek() const
233: 			return Stream::eof();
239: 	Stream::operator bool() const
241: 		return m_input.good() || (!m_readahead.empty() && m_readahead[0] != Stream::eof());
246: 	char Stream::get()
262: 	std::string Stream::get(int n)
273: 	void Stream::eat(int n)
279: 	void Stream::AdvanceCurrent()
290: 	bool Stream::_ReadAheadTo(size_t i) const
306: 			m_readahead.push_back(Stream::eof());
399: 	unsigned char Stream::GetNextByte() const
296: 			case utf8: StreamInUtf8(); break;
297: 			case utf16le: StreamInUtf16(); break;
298: 			case utf16be: StreamInUtf16(); break;
299: 			case utf32le: StreamInUtf32(); break;
300: 			case utf32be: StreamInUtf32(); break;
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))
chromstaR:src/logging.h: [ ]
101: inline FILE*& Output2FILE::Stream()
97:     static FILE*& Stream();
109:     FILE* pStream = Stream();
137:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
103:     static FILE* pStream = stderr;
104:     return pStream;
110:     if (!pStream)
112:     fprintf(pStream, "%s", msg.c_str());
113:     fflush(pStream);
AneuFinder:src/logging.h: [ ]
108: inline FILE*& Output2FILE::Stream()
104:     static FILE*& Stream();
116:     FILE* pStream = Stream();
144:     else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
110:     static FILE* pStream = stderr;
111:     return pStream;
117:     if (!pStream)
119:     fprintf(pStream, "%s", msg.c_str());
120:     fflush(pStream);
iBMQ:src/RngStream.c: [ ]
307: RngStream RngStream_CreateStream (const char name[])
337: void RngStream_DeleteStream (RngStream g)
348: void RngStream_ResetStartStream (RngStream g)
357: void RngStream_ResetNextSubstream (RngStream g)
368: void RngStream_ResetStartSubstream (RngStream g)
377: int RngStream_SetPackageSeed (unsigned long seed[6])
389: int RngStream_SetSeed (RngStream g, unsigned long seed[6])
401: void RngStream_AdvanceState (RngStream g, long e, long c)
432: void RngStream_GetState (RngStream g, unsigned long seed[6])
441: void RngStream_WriteState (RngStream g)
459: void RngStream_WriteStateFull (RngStream g)
491: void RngStream_IncreasedPrecis (RngStream g, int incp)
498: void RngStream_SetAntithetic (RngStream g, int a)
505: double RngStream_RandU01 (RngStream g)
515: int RngStream_RandInt (RngStream g, int i, int j)
3:  * File:           RngStream.c for multiple streams of Random Numbers
14: #include "RngStream.h"
213: static double U01 (RngStream g)
246: static double U01d (RngStream g)
310:    RngStream g;
313:    g = (RngStream) malloc (sizeof (struct RngStream_InfoState));
315:       Rprintf ("RngStream_CreateStream: No more memory\n\n");
316:       error("RngStream allocation failed. Exiting.");
464:    Rprintf ("The RngStream");
517:    return i + (int) ((j - i + 1.0) * RngStream_RandU01 (g));
velociraptor:R/plotVelocityStream.R: [ ]
81: plotVelocityStream <- function(sce, embedded, use.dimred = 1,
3: #' Plot velocities embedded into low-dimensional space as a stream plot. Stream
48: #'   Streamlines are computed by simple integration with a forward Euler method,
70: #' plotVelocityStream(out, em)
71: #' plotVelocityStream(out, em, color.streamlines = TRUE)
112:         stop("'plotVelocityStream' requires the package 'ggplot2'.")
iBMQ:src/RngStream.h: [ ]
19: typedef struct RngStream_InfoState * RngStream;
21: struct RngStream_InfoState {
2:    RngStream.h for ANSI C
29: int RngStream_SetPackageSeed (unsigned long seed[6]);
32: RngStream RngStream_CreateStream (const char name[]);
35: void RngStream_DeleteStream (RngStream g);
38: void RngStream_ResetStartStream (RngStream g);
41: void RngStream_ResetStartSubstream (RngStream g);
44: void RngStream_ResetNextSubstream (RngStream g);
47: void RngStream_SetAntithetic (RngStream g, int a);
50: void RngStream_IncreasedPrecis (RngStream g, int incp);
53: int RngStream_SetSeed (RngStream g, unsigned long seed[6]);
56: void RngStream_AdvanceState (RngStream g, long e, long c);
59: void RngStream_GetState (RngStream g, unsigned long seed[6]);
62: void RngStream_WriteState (RngStream g);
65: void RngStream_WriteStateFull (RngStream g);
68: double RngStream_RandU01 (RngStream g);
71: int RngStream_RandInt (RngStream g, int i, int j);
mzR:src/pwiz/data/common/BinaryIndexStream.cpp: [ ]
402: PWIZ_API_DECL BinaryIndexStream::BinaryIndexStream(shared_ptr<iostream> isPtr) : impl_(new Impl(isPtr)) {}
253:     typedef stream_vector_const_iterator<Entry, EntryReader> IndexStreamIterator;
264:             throw runtime_error("[BinaryIndexStream::ctor] Stream is null");
2: // $Id: BinaryIndexStream.cpp 2051 2010-06-15 18:39:13Z chambm $
25: #include "BinaryIndexStream.hpp"
215: class BinaryIndexStream::Impl
403: PWIZ_API_DECL void BinaryIndexStream::create(vector<Entry>& entries) {impl_->create(entries);}
404: PWIZ_API_DECL size_t BinaryIndexStream::size() const {return impl_->size();}
405: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(const string& id) const {return impl_->find(id);}
406: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(size_t index) const {return impl_->find(index);}
364:             IndexStreamIterator itr(isPtr_, entrySize_, entryReader_, indexBegin, indexEnd);
365:             itr = lower_bound(itr, IndexStreamIterator(), *entryPtr, EntryIdLessThan());
368:             if (itr == IndexStreamIterator())
netboost:src/mcupgma/clustering_round/myutils/StreamFromFileNameGenerator.hpp: [ ]
10: RCPtr<istream> InputStream(string const & filename) {
30: RCPtr<ostream> OutputStream(string const & filename) {
2: #define __StreamFromFileNameGenerator_hpp
1: #ifndef __StreamFromFileNameGenerator_hpp
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.cpp: [ ]
34: InFileStream::InFileStream() :
41: InFileStream::InFileStream(const char *filename) :
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
28: #include "InFileStream.h"
38:     //cout << "InFileStream() constructor 1" << endl;
44:     //cout << "InFileStream(f) constructor 2" << endl;
49: //- InFileStream::InFileStream(const InFileStream &copy) :
52: //-     cout << "InFileStream() constructor 3" << endl;
56: void InFileStream::open(const char *filename) 
67: void InFileStream::close() 
74: std::istream& InFileStream::getline(char *s, streamsize n) 
80: std::istream& InFileStream::getline(char *s, streamsize n, char delim) 
93:  * 09-02-07,Nigel Brown(EMBL): moved member into new InFileStream subclassed
95:  * that uses InFileStream in place of std::ifstream. Replaced if/then/else
98: char InFileStream::findDelimiter()
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.h: [ ]
22: class InFileStream : public std::ifstream
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
25:     InFileStream();
26:     InFileStream(const char *filename);
27:     //- InFileStream(const InFileStream &copy);
45:     InFileStream(const InFileStream &copy);
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;
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
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);
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) {
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()
Gviz:R/Gviz-methods.R: [ ]
4576:         isStream <- !is.null(defMap[[".stream"]]) && defMap[[".stream"]]
4578:         if (!isStream) {
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(); }
rtracklayer:src/ucsc/udc.c: [ ]
48: FILE *udcLogStream = NULL;
62:     udcLogStream = fp;
1093: if (udcLogStream)
1094:     fprintf(udcLogStream, "Open %s\n", url);
1229:     if (udcLogStream)
1231:         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)...
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;
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/AllClasses.R: [ ]
724:     isStream <- FALSE
971:     isStream <- FALSE
1605:     isStream <- FALSE
2393:     isStream <- FALSE
747:         isStream <- TRUE
760:         if (!isStream) {
1003:         isStream <- TRUE
1017:     if (!isStream) {
1615:         isStream <- TRUE
1649:     if (!isStream) {
2425:         isStream <- TRUE
2452:     if (!isStream) {
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)
affxparser:src/fusion/calvin_files/data/src/DataSet.cpp: [ ]
161: void DataSet::ReadDataSetUsingStream()
327: void DataSet::ClearStreamData()
71: 	fileStream = 0;
95: 	fileStream = &ifs;
129: 		ReadDataSetUsingStream();
170: 	fileStream->seekg(mapStart);
171: 	fileStream->read(data, mapLen);
444: 	fileStream->seekg(mapStart);
445: 	fileStream->read(data, mapLen);
182: 		ClearStreamData();
438: 	ClearStreamData();
RSeqAn:inst/include/seqan/stream/file_stream.h: [ ]
1138: class FileStream :
1143:     typedef typename BasicStream<TValue, TDirection>::Type  TBasicStream;
1147:     FileStream() :
1151:     FileStream(const char * fileName, int openMode = DefaultOpenMode<FileStream>::VALUE) :
1157:     ~FileStream()
1198:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
1215:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
804: struct FileStreamBuffer :
831:     FileStreamBuffer()
836:     ~FileStreamBuffer()
1142:     typedef FileStreamBuffer<TValue, TDirection, TSpec>     TStreamBuffer;
1115: class FileStream;
1119: close(FileStream<TValue, TDirection, TSpec> & stream);
1130: struct DefaultOpenMode<FileStream<TValue, TDirection, TSpec>, TDummy>:
1134: // Class FileStream
1139:     public BasicStream<TValue, TDirection>::Type
1148:         TBasicStream(&buffer)
1152:         TBasicStream(&buffer)
1188: struct Value<FileStream<TValue, TDirection, TSpec> >:
1199:     typedef typename TStream_::TFile TFile_;
1205: struct Position<FileStream<TValue, TDirection, TSpec> >:
1216:     typedef typename TStream_::TFile TFile_;
1222: struct Size<FileStream<TValue, TDirection, TSpec> >:
1230: SEQAN_CONCEPT_IMPL((FileStream<TValue, Input, TSpec>), (InputStreamConcept));
1233: SEQAN_CONCEPT_IMPL((FileStream<TValue, Output, TSpec>), (OutputStreamConcept));
1236: SEQAN_CONCEPT_IMPL((FileStream<TValue, Bidirectional, TSpec>), (BidirectionalStreamConcept));
1257: open(FileStream<TValue, TDirection, TSpec> & stream, const char * fileName, int openMode = DefaultOpenMode<FileStream<TValue, TDirection, TSpec> >::VALUE)
1301: close(FileStream<TValue, TDirection, TSpec> & stream)
800: // Class FileStreamBuffer
1099: clear(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
1145:     TStreamBuffer buffer;
1182: struct Value<FileStreamBuffer<TValue, TDirection, TSpec> >
1189:     Value<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1196: struct Position<FileStreamBuffer<TValue, TDirection, TSpec> >
1206:     Position<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1213: struct Size<FileStreamBuffer<TValue, TDirection, TSpec> >
1223:     Size<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1293: close(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
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
seqTools:src/dna_astream.h: [ ]
87: } daStream;
55: 	dfStream *dnaf;
95: static inline int dasEmpty(daStream *das) 		{ return das->r_iter == das->r_end; }
96: static inline int dasProcEmpty(daStream *das)	{ return das->p_iter == das->p_end; }
97: static inline int dasIsError(daStream *das)		{ return das->state & das_err; }
98: static inline int dasIsOpen(daStream *das)		{ return dfs_isOpen(das->dnaf); }
99: static inline int dasIsEof(daStream *das)		{ return dfs_stream_eof(das->dnaf); }
107: void das_destroy(daStream *das)
122: int das_fill(daStream *das)
176: daStream * das_init(const char* filename, unsigned das_size)
178: 	daStream *das = calloc(sizeof(daStream), 1);
Rfastp:src/FASTP/seprocessor.h: [ ]
68:     ofstream* mOutStream;
diffUTR:README.md: [ ]
3: ## Streamlining differential exon and 3' UTR usage analysis
BUSseq:src/rngstream.h: [ ]
8: class RngStream
12: RngStream (const char *name = "");
18: void ResetStartStream ();
CoGAPS:src/utils/Archive.h: [ ]
86:     std::fstream mStream;
24:     mStream(path.c_str(), std::ios::binary | flags)
43:         mStream.close();
49:         ar.mStream.write(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
56:         ar.mStream.read(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
mzR:src/pwiz/utility/misc/VendorReaderTestHarness.cpp: [ ]
179: string headStream(istream& is, size_t maxLength)
170:     stringstream diffStream;
171:     diffStream << diff;
172:     string diffString = diffStream.str();
324:             if (diff_mzXML && !os_) cerr << "mzXML:\n" << headStream(*serializedStreamPtr, 5000) << endl;
345:             if (diff_MGF && !os_) cerr << "MGF:\n" << headStream(*serializedStreamPtr, 5000) << endl;
278:         boost::shared_ptr<std::iostream> serializedStreamPtr(stringstreamPtr);
321:             serializer_mzXML.read(serializedStreamPtr, msd_mzXML);
341:             serializer_MGF.read(serializedStreamPtr, msd_MGF);
436:             boost::shared_ptr<std::iostream> serializedStreamPtr(stringstreamPtr);
chromDraw:src/libBoard/include/board/Tools.h: [ ]
57:   class MessageStream {
74:   MessageStream::MessageStream( std::ostream & out, const char * prefix )
60:     inline MessageStream( std::ostream & out, const char * prefix  );
63:     inline MessageStream operator<<( const T & v );
70:   extern MessageStream error;
71:   extern MessageStream warning;
72:   extern MessageStream notice;
81:   MessageStream MessageStream::operator<<( const T & v )
87:     return MessageStream( _out, 0 );
Streamer:R/stream-methods.R: [ ]
1: .Stream_set <- function(x, ..., verbose)
25:     .Stream$new(inputPipe=inputPipe, verbose=verbose)
28: setMethod(Stream, "Producer",
32:         .Stream_set(x, verbose=verbose)
34:         do.call(Stream, c(rev(list(..., verbose=verbose)), list(x)))
37: setMethod(Stream, "Consumer", .Stream_set)
3:     ## helper used to construct Streams
Streamer:R/Streamer-class.R: [ ]
1: .Streamer <- setRefClass("Streamer",
6: .Streamer$methods(
9:         "initialize 'Streamer'"
20:         "reset Streamer() -- noop"
21:         if (verbose) msg("Streamer$reset()")
27:         if (verbose) msg("Streamer$yield()")
33:         if (verbose) msg("Streamer$status()")
41: setMethod(reset, "Streamer", function(x, ...) x$reset())
43: setMethod(yield, "Streamer", function(x, ...) x$yield())
45: setMethod(status,"Streamer", function(x, ...) x$status())
msa:src/ClustalW/src/Makefile.in: [ ]
635: InFileStream.o: ./fileInput/InFileStream.cpp
642: InFileStream.obj: ./fileInput/InFileStream.cpp
61: 	InFileStream.$(OBJEXT) ClustalFileParser.$(OBJEXT) \
266:  ./fileInput/InFileStream.cpp \
269:  ./fileInput/InFileStream.h \
488: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/InFileStream.Po@am__quote@
636: ...(33 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.o -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
637: @am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
638: @AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='./fileInput/InFileStream.cpp' object='InFileStream.o' libtool=no @AMDEPBACKSLASH@
640: ...(36 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
643: ...(33 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.obj -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
644: @am__fastdepCXX_TRUE@	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
645: @AMDEP_TRUE@@am__fastdepCXX_FALSE@	source='./fileInput/InFileStream.cpp' object='InFileStream.obj' libtool=no @AMDEPBACKSLASH@
647: ...(36 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
msa:src/ClustalW/windows/src/Makefile: [ ]
635: InFileStream.o: ./fileInput/InFileStream.cpp
642: InFileStream.obj: ./fileInput/InFileStream.cpp
61: 	InFileStream.$(OBJEXT) ClustalFileParser.$(OBJEXT) \
266:  ./fileInput/InFileStream.cpp \
269:  ./fileInput/InFileStream.h \
488: # ./$(DEPDIR)/InFileStream.Po
636: ...(13 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.o -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
637: #	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
638: 	source='./fileInput/InFileStream.cpp' object='InFileStream.o' libtool=no \
640: ...(14 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
643: ...(13 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.obj -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
644: #	$(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
645: 	source='./fileInput/InFileStream.cpp' object='InFileStream.obj' libtool=no \
647: ...(14 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
Rfastp:src/FASTP/peprocessor.h: [ ]
74:     ofstream* mOutStream1;
75:     ofstream* mOutStream2;
rhdf5filters:src/blosc/lib/zstd-1.4.5/compress/zstd_compress_internal.h: [ ]
50: typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
1066: /*! ZSTD_initCStream_internal() :
1071: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
273:     ZSTD_cStreamStage streamStage;
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)
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)