Found 2665 results in 306 files, showing top 50 files (show more).
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);
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);
netboost:src/mcupgma/clustering_round/myutils/StreamFromFileNameGenerator.hpp: [ ]
10: RCPtr<istream> InputStream(string const & filename) {
30: RCPtr<ostream> OutputStream(string const & filename) {
2: #define __StreamFromFileNameGenerator_hpp
1: #ifndef __StreamFromFileNameGenerator_hpp
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.cpp: [ ]
34: InFileStream::InFileStream() :
41: InFileStream::InFileStream(const char *filename) :
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
28: #include "InFileStream.h"
38:     //Rcpp::Rcout << "InFileStream() constructor 1" << endl;
44:     //Rcpp::Rcout << "InFileStream(f) constructor 2" << endl;
49: //- InFileStream::InFileStream(const InFileStream &copy) :
52: //-     Rcpp::Rcout << "InFileStream() constructor 3" << endl;
56: void InFileStream::open(const char *filename)
67: void InFileStream::close()
74: std::istream& InFileStream::getline(char *s, streamsize n)
80: std::istream& InFileStream::getline(char *s, streamsize n, char delim)
93:  * 09-02-07,Nigel Brown(EMBL): moved member into new InFileStream subclassed
95:  * that uses InFileStream in place of std::ifstream. Replaced if/then/else
98: char InFileStream::findDelimiter()
enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.h: [ ]
22: class InFileStream : public std::ifstream
7:  * InFileStream subclasses std::ifstream, adding a check for the end-of-line
25:     InFileStream();
26:     InFileStream(const char *filename);
27:     //- InFileStream(const InFileStream &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;
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: [ ]
2427: sdfStream <- function(input, output, append=FALSE, fct, Nlines=10000, startline=1, restartNlines=10000, silen...(15 bytes skipped)...
2420: ## (6.8) Streaming Through SD Files ##
2422: ## Streaming function to compute descriptors for large SD Files without consuming much memory.
2433: 	## For restarting sdfStream at specific line assigned to startline argument. If assigned
2535: # sdfStream(input="test.sdf", output="matrix.xls", fct=desc, Nlines=1000)
2544: ## as character strings to APset or FPset objects (e.g. generated by sdfStream).
2575: ## Extracts specific molecules from SD File based on a line position index computed by the sdfStream function
2606: ## Usage: see sdfStream()
Director:inst/www/js/d3.v3.js: [ ]
4246:   function d3_geo_pathProjectStream(project) {
3878:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3881:           lower48Stream.point(x, y);
3886:           lower48Stream.sphere();
3891:           lower48Stream.lineStart();
3896:           lower48Stream.lineEnd();
3901:           lower48Stream.polygonStart();
3906:           lower48Stream.polygonEnd();
3862:     var point, pointStream = {
3882:           alaskaStream.point(x, y);
3883:           hawaiiStream.point(x, y);
3887:           alaskaStream.sphere();
3888:           hawaiiStream.sphere();
3892:           alaskaStream.lineStart();
3893:           hawaiiStream.lineStart();
3897:           alaskaStream.lineEnd();
3898:           hawaiiStream.lineEnd();
3902:           alaskaStream.polygonStart();
3903:           hawaiiStream.polygonStart();
3907:           alaskaStream.polygonEnd();
3908:           hawaiiStream.polygonEnd();
3929: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3930: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3931: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
4200:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
4203:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
4204:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
4205:         d3.geo.stream(object, cacheStream);
4207:       return contextStream.result();
4211:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
4216:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
4221:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
4226:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
4231:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
4232:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
4237:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
4241:       cacheStream = null;
Rmmquant:src/mmquant.h: [ ]
658:   std::ostream &getOutputStream () {
662:   std::ostream &getStatsStream () {
1814:         parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";
1816:           parameters.getOutputStream() << " \"" << arg << "\"";
1818:         parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";
1821:         parameters.getOutputStream() << "Gene";
1824:         parameters.getOutputStream() << "\t" << sample;
1826:       parameters.getOutputStream() << "\n";
1828:           parameters.getOutputStream() << line.first;
1830:               parameters.getOutputStream() << "\t" << i;
1832:           parameters.getOutputStream() << "\n";
1923:     dumpStats(parameters.getStatsStream(), parameters.names, stats);
Rarr:src/compression_tools/zstd/compress/zstd_compress.c: [ ]
213: size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs)
5687: ZSTD_CStream* ZSTD_createCStream(void)
5693: ZSTD_CStream* ZSTD_initStaticCStream(void *workspace, size_t workspaceSize)
5703: size_t ZSTD_freeCStream(ZSTD_CStream* zcs)
5729: size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pss)
5837: size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel)
6060: size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input)
6846: size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
6854: size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output)
5698: ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem)
5746: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
5768: size_t ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
5782: size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict)
5795: size_t ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
5813: size_t ZSTD_initCStream_usingDict(ZSTD_CStream* zcs, const void* dict, size_t dictSize, int compressionLevel)
5822: size_t ZSTD_initCStream_srcSize(ZSTD_CStream* zcs, int compressionLevel, unsigned long long pss)
5863: static size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
6103: static size_t ZSTD_CCtx_init_compressStream2(ZSTD_CCtx* cctx,
6201: size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
6300: size_t ZSTD_compressStream2_simpleArgs (
1755: size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params)
1775: size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams)
1792: static size_t ZSTD_estimateCStreamSize_internal(int compressionLevel)
1798: size_t ZSTD_estimateCStreamSize(int compressionLevel)
5712: size_t ZSTD_CStreamInSize(void)  { return ZSTD_BLOCKSIZE_MAX; }
5714: size_t ZSTD_CStreamOutSize(void)
3679:     U32 singleStream = litSize < 256;
3688:             if (!singleStream) cLitSizeEstimate += 6; /* multi-stream huffman uses 6-byte jump table */
5684: *  Streaming
5689:     DEBUGLOG(3, "ZSTD_createCStream");
5690:     return ZSTD_createCStream_advanced(ZSTD_defaultCMem);
5699: {   /* CStream and CCtx are now same object */
5727: /* ZSTD_resetCStream():
5736:     DEBUGLOG(4, "ZSTD_resetCStream: pledgedSrcSize = %u", (unsigned)pledgedSrcSize);
5742: /*! ZSTD_initCStream_internal() :
5751:     DEBUGLOG(4, "ZSTD_initCStream_internal");
5766: /* ZSTD_initCStream_usingCDict_advanced() :
5767:  * same as ZSTD_initCStream_usingCDict(), with control over frame parameters */
5773:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict_advanced");
5784:     DEBUGLOG(4, "ZSTD_initCStream_usingCDict");
5791: /* ZSTD_initCStream_advanced() :
5804:     DEBUGLOG(4, "ZSTD_initCStream_advanced");
5815:     DEBUGLOG(4, "ZSTD_initCStream_usingDict");
5829:     DEBUGLOG(4, "ZSTD_initCStream_srcSize");
5839:     DEBUGLOG(4, "ZSTD_initCStream");
5860: /** ZSTD_compressStream_generic():
5861:  *  internal function for all *compressStream*() variants
5877:     DEBUGLOG(5, "ZSTD_compressStream_generic, flush=%i, srcSize = %zu", (int)flushMode, input->size - input->pos);
5903:             RETURN_ERROR(init_missing, "call ZSTD_initCStream() first!");
6062:     FORWARD_IF_ERROR( ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue) , "");
6119:     DEBUGLOG(4, "ZSTD_compressStream2 : transparent init stage");
6155:             DEBUGLOG(4, "ZSTD_compressStream2: creating new mtctx for nbWorkers=%u",
6161:         DEBUGLOG(4, "call ZSTDMT_initCStream_internal as nbWorkers=%u", params.nbWorkers);
6162:         FORWARD_IF_ERROR( ZSTDMT_initCStream_internal(
6206:     DEBUGLOG(5, "ZSTD_compressStream2, endOp=%u ", (unsigned)endOp);
6234:         FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, endOp, totalInputSize), "compressStream2 initialization failed");
6258:             flushMin = ZSTDMT_compressStream_generic(cctx->mtctx, output, input, endOp);
6267:             FORWARD_IF_ERROR(flushMin, "ZSTDMT_compressStream_generic failed");
6285:         DEBUGLOG(5, "completed ZSTD_compressStream2 delegating to ZSTDMT_compressStream_generic");
6294:     FORWARD_IF_ERROR( ZSTD_compressStream_generic(cctx, output, input, endOp) , "");
6295:     DEBUGLOG(5, "completed ZSTD_compressStream2");
6314:     /* ZSTD_compressStream2() will check validity of dstPos and srcPos */
6315:     {   size_t const cErr = ZSTD_compressStream2(cctx, &output, &input, endOp);
6335:         size_t const result = ZSTD_compressStream2_simpleArgs(cctx,
6343:         FORWARD_IF_ERROR(result, "ZSTD_compressStream2_simpleArgs failed");
6802:     /* Transparent initialization stage, same as compressStream2() */
6805:     FORWARD_IF_ERROR(ZSTD_CCtx_init_compressStream2(cctx, ZSTD_e_end, srcSize), "CCtx initialization failed");
6837: static ZSTD_inBuffer inBuffer_forEndFlush(const ZSTD_CStream* zcs)
6844: /*! ZSTD_flushStream() :
6850:     return ZSTD_compressStream2(zcs, output, &input, ZSTD_e_flush);
6857:     size_t const remainingToFlush = ZSTD_compressStream2(zcs, output, &input, ZSTD_e_end);
6858:     FORWARD_IF_ERROR(remainingToFlush , "ZSTD_compressStream2(,,ZSTD_e_end) failed");
6864:         DEBUGLOG(4, "ZSTD_endStream : remaining to flush : %u", (unsigned)toFlush);
1783:         noRowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
1785:         rowCCtxSize = ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
1788:         return ZSTD_estimateCStreamSize_usingCCtxParams(&initialParams);
1795:     return ZSTD_estimateCStreamSize_usingCParams(cParams);
1803:         size_t const newMB = ZSTD_estimateCStreamSize_internal(level);
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(); }
LACE:inst/htmlwidgets/lib/d3.v4.js: [ ]
6898:     function geoStream(object, stream) {
7424:     function circleStream(stream, radius, delta, direction, t0, t1) {
8978:     function TransformStream() {}
9343:             point, pointStream = {point: function(x, y) { point = [x, y]; }};
6915:     var areaStream = {
6921:             areaStream.lineStart = areaRingStart;
6922:             areaStream.lineEnd = areaRingEnd;
6935:         areaStream.point = areaPointFirst;
6943:         areaStream.point = areaPoint;
6972:         geoStream(object, areaStream);
7020:     var boundsStream = {
7025:             boundsStream.point = boundsRingPoint;
7026:             boundsStream.lineStart = boundsRingStart;
7027:             boundsStream.lineEnd = boundsRingEnd;
7029:             areaStream.polygonStart();
7032:             areaStream.polygonEnd();
7033:             boundsStream.point = boundsPoint;
7034:             boundsStream.lineStart = boundsLineStart;
7035:             boundsStream.lineEnd = boundsLineEnd;
7099:         boundsStream.point = linePoint;
7104:         boundsStream.point = boundsPoint;
7115:         areaStream.point(lambda, phi);
7120:         areaStream.lineStart();
7125:         areaStream.lineEnd();
7151:         geoStream(feature, boundsStream);
7200:     var centroidStream = {
7206:             centroidStream.lineStart = centroidRingStart;
7207:             centroidStream.lineEnd = centroidRingEnd;
7210:             centroidStream.lineStart = centroidLineStart;
7211:             centroidStream.lineEnd = centroidLineEnd;
7230:         centroidStream.point = centroidLinePointFirst;
7239:         centroidStream.point = centroidLinePoint;
7258:         centroidStream.point = centroidPoint;
7264:         centroidStream.point = centroidRingPointFirst;
7269:         centroidStream.point = centroidPoint;
7275:         centroidStream.point = centroidRingPoint;
7310:         geoStream(object, centroidStream);
7470:             circleStream(stream, r, p, 1);
7906:             circleStream(stream, radius, delta, direction, from, to);
8182:             var activeStream = stream,
8183:                 bufferStream = clipBuffer(),
8192:             var clipStream = {
8201:                 if (visible(x, y)) activeStream.point(x, y);
8220:                 activeStream = bufferStream, segments = [], polygon = [], clean = true;
8239:                 activeStream = stream, segments = polygon = ring = null;
8243:                 clipStream.point = linePoint;
8256:                     if (v__ && v_) bufferStream.rejoin();
8257:                     segments.push(bufferStream.result());
8259:                 clipStream.point = point;
8260:                 if (v_) activeStream.lineEnd();
8270:                         activeStream.lineStart();
8271:                         activeStream.point(x, y);
8274:                     if (v && v_) activeStream.point(x, y);
8280:                                 activeStream.lineStart();
8281:                                 activeStream.point(a[0], a[1]);
8283:                             activeStream.point(b[0], b[1]);
8284:                             if (!v) activeStream.lineEnd();
8287:                             activeStream.lineStart();
8288:                             activeStream.point(x, y);
8296:             return clipStream;
8306:             cacheStream,
8311:                 return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream);
8314: ...(16 bytes skipped)...return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];
8324:     var lengthStream = {
8334:         lengthStream.point = lengthPointFirst;
8335:         lengthStream.lineEnd = lengthLineEnd;
8339:         lengthStream.point = lengthStream.lineEnd = noop$1;
8345:         lengthStream.point = lengthPoint;
8364:         geoStream(object, lengthStream);
8607:     var areaStream$1 = {
8612:             areaStream$1.lineStart = areaRingStart$1;
8613:             areaStream$1.lineEnd = areaRingEnd$1;
8616:             areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;
8628:         areaStream$1.point = areaPointFirst$1;
8632:         areaStream$1.point = areaPoint$1;
8650:     var boundsStream$1 = {
8686:     var centroidStream$1 = {
8691:             centroidStream$1.lineStart = centroidRingStart$1;
8692:             centroidStream$1.lineEnd = centroidRingEnd$1;
8695:             centroidStream$1.point = centroidPoint$1;
8696:             centroidStream$1.lineStart = centroidLineStart$1;
8697:             centroidStream$1.lineEnd = centroidLineEnd$1;
8718:         centroidStream$1.point = centroidPointFirstLine;
8722:         centroidStream$1.point = centroidPointLine;
8735:         centroidStream$1.point = centroidPoint$1;
8739:         centroidStream$1.point = centroidPointFirstRing;
8747:         centroidStream$1.point = centroidPointRing;
8817:     var lengthStream$1 = {
8820:             lengthStream$1.point = lengthPointFirst$1;
8824:             lengthStream$1.point = noop$1;
8840:         lengthStream$1.point = lengthPoint$1;
8912:             projectionStream,
8913:             contextStream;
8917:                 if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
8918:                 geoStream(object, projectionStream(contextStream));
8920:             return contextStream.result();
8924:             geoStream(object, projectionStream(areaStream$1));
8925:             return areaStream$1.result();
8929:             geoStream(object, projectionStream(lengthStream$1));
8930:             return lengthStream$1.result();
8934:             geoStream(object, projectionStream(boundsStream$1));
8935:             return boundsStream$1.result();
8939:             geoStream(object, projectionStream(centroidStream$1));
8940:             return centroidStream$1.result();
8944:             return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;
8949:             contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);
8950:             if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
8956:             pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
8971:             var s = new TransformStream;
8980:     TransformStream.prototype = {
8981:         constructor: TransformStream,
8994:         geoStream(object, projection.stream(boundsStream$1));
8995:         fitBounds(boundsStream$1.result());
9083:             var resampleStream = {
9087:                 polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },
9088:                 polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }
9098:                 resampleStream.point = linePoint;
9109:                 resampleStream.point = point;
9115:                 resampleStream.point = ringPoint;
9116:                 resampleStream.lineEnd = ringEnd;
9121:                 resampleStream.point = linePoint;
9126:                 resampleStream.lineEnd = lineEnd;
9130:             return resampleStream;
9163:             cacheStream;
9180:             return cache && cacheStream...(9 bytes skipped)...am ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
9244:             cache = cacheStream = null;
9339:             cacheStream,
9363:             return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
9385:                 .stream(pointStream);
9390:                 .stream(pointStream);
9395:                 .stream(pointStream);
9417:             cache = cacheStream = null;
9621:             cacheStream,
9625:             cache = cacheStream = null;
9631:                 return cache && cacheStream === stream ? cache : cache = transform$$1(postclip(cacheStream = stream));
16942:     exports.geoStream = geoStream;
seqTools:src/dna_fasta_stream.h: [ ]
52: } fafStream;
207: } faStream;
215: void faStream_destroy(faStream *fa)
275: faStream * faStream_init(const char* filename, unsigned k, unsigned mode)
135: // fasta Stream
54: static inline unsigned faf_isEof(fafStream *faf) { return faf->status & faf_file_eof; }
55: static inline unsigned faf_isOpen(fafStream *faf)
62: static fafStream* faf_stream_init(const char* filename, unsigned mode)
64: 	// Construct fafStream object from opened file
65: 	fafStream *faf = calloc(sizeof(fafStream), 1);
87: static void faf_destroy(fafStream *faf)
99: static size_t inline faf_read(fafStream *faf, char *dest, unsigned size)
187: 	fafStream *fasta;
230: int fas_fill(faStream *fa)
279: 		printf("[faStream_init] k > fas_size!\n");
283: 	faStream *fa = calloc(sizeof(faStream), 1);
292: 		printf("[faStream_init] Cannot open file '%s'!\n", filename);
293: 		faStream_destroy(fa);
308: 		printf("[faStream_init] Initial array filling failed!\n");
309: 		faStream_destroy(fa);
321: static inline int fas_fas_end(faStream *fa)		{ return fa->ffc == 0; }
322: static inline int fas_nuc_end(faStream *fa)		{ return fa->fnc == 0; }
333: static inline int fas_checkNewLine(faStream *fa)
343: static inline int fas_skipNewLine(faStream *fa)
366: static inline int fas_skipLine(faStream *fa)
386: static inline int fas_checkNewSeq(faStream *fa)
399: static inline int fas_skipSeqHeader(faStream *fa)
412: static inline int fas_checkComment(faStream *fa)
422: static inline int fas_skipComment(faStream *fa)
435: static inline int fas_checkN(faStream *fa)
445: static inline int fas_skipN(faStream *fa)
496: char * fas_getSeqName(faStream *fa)
551: int fas_initSeq(faStream *fa)
592: static inline int fas_returnFromTranfer(faStream *fa)
626: int fas_TransferNucArray(faStream *fa)
697: int fa_empty(faStream *fa)    { return (fa->stream_state & fas_stream_empty); }
698: int fa_NucReady(faStream *fa) { return (fa->stream_state & fas_nuc_ready);    }
699: int fa_K_Ready(faStream *fa)  { return (fa->stream_state & fas_loc_kReady);   }
700: int fa_NewSeq(faStream *fa)   { return (fa->stream_state & fas_loc_newSeq);   }
701: int fa_N_Nuc(faStream *fa)    { return (ACGTN[(unsigned)*fa->iter] == nval);  }
704: void fa_unsetNucReady(faStream *fa)
interacCircos:inst/htmlwidgets/lib/d3.js: [ ]
3639:   function d3_geo_pathProjectStream(project) {
3271:       var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
3274:           lower48Stream.point(x, y);
3279:           lower48Stream.sphere();
3284:           lower48Stream.lineStart();
3289:           lower48Stream.lineEnd();
3294:           lower48Stream.polygonStart();
3299:           lower48Stream.polygonEnd();
3255:     var point, pointStream = {
3275:           alaskaStream.point(x, y);
3276:           hawaiiStream.point(x, y);
3280:           alaskaStream.sphere();
3281:           hawaiiStream.sphere();
3285:           alaskaStream.lineStart();
3286:           hawaiiStream.lineStart();
3290:           alaskaStream.lineEnd();
3291:           hawaiiStream.lineEnd();
3295:           alaskaStream.polygonStart();
3296:           hawaiiStream.polygonStart();
3300:           alaskaStream.polygonEnd();
3301:           hawaiiStream.polygonEnd();
3322: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
3323: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3324: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
3593:     var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
3596:         if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
3597:         if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
3598:         d3.geo.stream(object, cacheStream);
3600:       return contextStream.result();
3604:       d3.geo.stream(object, projectStream(d3_geo_pathArea));
3609:       d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
3614:       d3.geo.stream(object, projectStream(d3_geo_pathBounds));
3619:       projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
3624:       contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
3625:       if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
3630:       pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
3634:       cacheStream = null;
Cardinal:R/utils.R: [ ]
370: getRNGStream <- function() {
379: setRNGStream <- function(seed = NULL) {
385: generateRNGStreams <- function(n = 1) {
387: 	s <- getRNGStream()
396: 			s <- nextRNGStream(seeds[[i - 1]])
BUSseq:src/rngstream.cpp: [ ]
303: RngStream::RngStream (const char *s) : name (s)
327: void RngStream::ResetStartStream ()
325: // Reset Stream to beginning of Stream.
335: // Reset Stream to beginning of SubStream.
345: // Reset Stream to NextSubStream.
3:  * File:           RngStream.cpp for multiple streams of Random Numbers
242: double RngStream::U01 ()
271: double RngStream::U01d ()
292: // declared RngStream, unless SetPackageSeed is called.
294: double RngStream::nextSeed[6] =
309:    state of the stream, the starting state of the current SubStream, and the
313:    will be the seed of the next declared RngStream. */
337: void RngStream::ResetStartSubstream ()
347: void RngStream::ResetNextSubstream ()
357: bool RngStream::SetPackageSeed (const unsigned long seed[6])
368: bool RngStream::SetSeed (const unsigned long seed[6])
384: void RngStream::AdvanceState (long e, long c)
415: void RngStream::GetState (unsigned long seed[6]) const
424: void RngStream::WriteState () const
439: void RngStream::WriteStateFull () const
443:     cout << "The RngStream";
470: void RngStream::IncreasedPrecis (bool incp)
477: void RngStream::SetAntithetic (bool a)
486: double RngStream::RandU01 ()
498: int RngStream::RandInt (int low, int high)
RProtoBufLib:src/GatingSet_pb_lib/GatingSet.pb.cc: [ ]
1460: bool paramRange::MergePartialFromCodedStream(
1810: bool Range::MergePartialFromCodedStream(
2113: bool rangeGate::MergePartialFromCodedStream(
2391: bool MultiRangeGate::MergePartialFromCodedStream(
2724: bool paramPoly::MergePartialFromCodedStream(
3077: bool polygonGate::MergePartialFromCodedStream(
3384: bool coordinate::MergePartialFromCodedStream(
3729: bool ellipseGate::MergePartialFromCodedStream(
4131: bool BOOL_GATE_OP::MergePartialFromCodedStream(
4471: bool boolGate::MergePartialFromCodedStream(
4740: bool clusterGate::MergePartialFromCodedStream(
5029: bool quadGate::MergePartialFromCodedStream(
5519: bool gate::MergePartialFromCodedStream(
6100: bool POPSTATS::MergePartialFromCodedStream(
6499: bool calibrationTable::MergePartialFromCodedStream(
7150: bool biexpTrans::MergePartialFromCodedStream(
7573: bool fasinhTrans::MergePartialFromCodedStream(
7978: bool scaleTrans::MergePartialFromCodedStream(
8311: bool flinTrans::MergePartialFromCodedStream(
8628: bool logTrans::MergePartialFromCodedStream(
8993: bool logGML2Trans::MergePartialFromCodedStream(
9334: bool logicleTrans::MergePartialFromCodedStream(
10043: bool transformation::MergePartialFromCodedStream(
10821: bool trans_pair::MergePartialFromCodedStream(
11195: bool trans_local::MergePartialFromCodedStream(
11609: bool POPINDICES::MergePartialFromCodedStream(
12094: bool nodeProperties::MergePartialFromCodedStream(
12578: bool treeNodes::MergePartialFromCodedStream(
12875: bool populationTree::MergePartialFromCodedStream(
13247: bool COMP::MergePartialFromCodedStream(
13908: bool PARAM::MergePartialFromCodedStream(
14432: bool GatingHierarchy::MergePartialFromCodedStream(
14868: bool CytoFrame::MergePartialFromCodedStream(
15151: bool TRANS_TBL::MergePartialFromCodedStream(
15563: bool GatingSet::MergePartialFromCodedStream(
1461:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
1533:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
1811:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
1868:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
2114:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
2156:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
2392:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
2449:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
2725:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
2783:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
3078:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
3131:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
3385:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
3442:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
3730:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
3807:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
4132:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
4205:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
4472:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
4514:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
4741:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
4787:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
5030:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
5090:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
5520:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
5670:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
6101:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
6160:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
6500:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
6652:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
6741:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6754:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6767:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6780:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
6793:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
7151:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
7247:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
7574:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
7670:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
7979:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
8049:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
8312:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
8369:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
8629:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
8712:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
8994:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
9051:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
9335:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
9457:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
10044:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
10246:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
10822:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
10892:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
11196:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
11269:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
11342:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
11610:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
11695:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
11758:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
12095:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
12198:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
12579:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
12634:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
12876:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
12918:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
13248:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
13402:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
13570:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
13909:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
14007:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
14433:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
14532:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
14869:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
14913:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
15152:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
15207:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
15564:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
15719:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
affxparser:src/fusion/calvin_files/data/src/DataSet.cpp: [ ]
161: void DataSet::ReadDataSetUsingStream()
327: void DataSet::ClearStreamData()
71: 	fileStream = 0;
95: 	fileStream = &ifs;
129: 		ReadDataSetUsingStream();
170: 	fileStream->seekg(mapStart);
171: 	fileStream->read(data, mapLen);
444: 	fileStream->seekg(mapStart);
445: 	fileStream->read(data, mapLen);
182: 		ClearStreamData();
438: 	ClearStreamData();
RSeqAn:inst/include/seqan/stream/file_stream.h: [ ]
1138: class FileStream :
1143:     typedef typename BasicStream<TValue, TDirection>::Type  TBasicStream;
1147:     FileStream() :
1151:     FileStream(const char * fileName, int openMode = DefaultOpenMode<FileStream>::VALUE) :
1157:     ~FileStream()
1198:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
1215:     typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
804: struct FileStreamBuffer :
831:     FileStreamBuffer()
836:     ~FileStreamBuffer()
1142:     typedef FileStreamBuffer<TValue, TDirection, TSpec>     TStreamBuffer;
1115: class FileStream;
1119: close(FileStream<TValue, TDirection, TSpec> & stream);
1130: struct DefaultOpenMode<FileStream<TValue, TDirection, TSpec>, TDummy>:
1134: // Class FileStream
1139:     public BasicStream<TValue, TDirection>::Type
1148:         TBasicStream(&buffer)
1152:         TBasicStream(&buffer)
1188: struct Value<FileStream<TValue, TDirection, TSpec> >:
1199:     typedef typename TStream_::TFile TFile_;
1205: struct Position<FileStream<TValue, TDirection, TSpec> >:
1216:     typedef typename TStream_::TFile TFile_;
1222: struct Size<FileStream<TValue, TDirection, TSpec> >:
1230: SEQAN_CONCEPT_IMPL((FileStream<TValue, Input, TSpec>), (InputStreamConcept));
1233: SEQAN_CONCEPT_IMPL((FileStream<TValue, Output, TSpec>), (OutputStreamConcept));
1236: SEQAN_CONCEPT_IMPL((FileStream<TValue, Bidirectional, TSpec>), (BidirectionalStreamConcept));
1257: open(FileStream<TValue, TDirection, TSpec> & stream, const char * fileName, int openMode = DefaultOpenMode<FileStream<TValue, TDirection, TSpec> >::VALUE)
1301: close(FileStream<TValue, TDirection, TSpec> & stream)
800: // Class FileStreamBuffer
1099: clear(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
1145:     TStreamBuffer buffer;
1182: struct Value<FileStreamBuffer<TValue, TDirection, TSpec> >
1189:     Value<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1196: struct Position<FileStreamBuffer<TValue, TDirection, TSpec> >
1206:     Position<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1213: struct Size<FileStreamBuffer<TValue, TDirection, TSpec> >
1223:     Size<FileStreamBuffer<TValue, TDirection, TSpec> >{};
1293: close(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
CytoML:inst/include/CytoML/wsNode.hpp: [ ]
43:     class CytoStream : public std::ostream {
46:         CytoStream() : std::ostream(&cytobuf){}
54: extern CytoML::CytoStream  cytocout;
RSeqAn:inst/include/seqan/basic/basic_stream.h: [ ]
446: struct BasicStream :
47: struct StreamIterator;
56: inline void writeValue(Iter<TContainer, StreamIterator<Output> > &iter, TValue val);
94: // Concept StreamConcept
98:  * @concept StreamConcept
103:  * @signature concept StreamConcept;
107:  * @mfn StreamConcept#Value
110:  * @signature Value<TStream>::Type;
112:  * @tparam TStream The stream type to query for its value type.
117:  * @mfn StreamConcept#Size
120:  * @signature Size<TStream>::Type;
122:  * @tparam TStream The stream type to query for its size type.
127:  * @mfn StreamConcept#Position
130:  * @signature Position<TStream>::Type;
132:  * @tparam TStream The stream type to query for its position type.
137:  * @fn StreamConcept#position
143:  * @return TPosition Current position in stream, see @link StreamConcept#Position Position @endlink.
147:  * @fn StreamConcept#setPosition
157:  * @fn StreamConcept#atEnd
166: SEQAN_CONCEPT(StreamConcept, (TStream))
174:  * @concept InputStreamConcept Input StreamConcept
175:  * @extends StreamConcept
178:  * @signature concept InputStreamConcept : StreamConcept;
183: SEQAN_CONCEPT_REFINE(InputStreamConcept, (TStream), (StreamConcept))
185:     typedef typename Value<TStream>::Type       TValue;
186:     typedef typename Size<TStream>::Type        TSize;
187:     typedef typename Position<TStream>::Type    TPosition;
200:  * @concept OutputStreamConcept Output StreamConcept
201:  * @extends StreamConcept
204:  * @signature concept OutputStreamConcept : StreamConcept;
209: SEQAN_CONCEPT_REFINE(OutputStreamConcept, (TStream), (StreamConcept))
211:     typedef typename Value<TStream>::Type       TValue;
212:     typedef typename Size<TStream>::Type        TSize;
213:     typedef typename Position<TStream>::Type    TPosition;
226:  * @concept BidirectionalStreamConcept Bidirectional StreamConcept
227:  * @extends StreamConcept
230:  * @signature concept BidirectionalStreamConcept : StreamConcept;
235: SEQAN_CONCEPT_REFINE(BidirectionalStreamConcept, (TStream), (InputStreamConcept)(OutputStreamConcept))
402:  * @mfn StreamConcept#DirectionIterator
405:  * @signature DirectionIterator<TStream>::Type;
407:  * @tparam TStream The stream to query for its direction iterator.
423:     If<Is<StreamConcept<TObject> >,
424:        Iter<TObject, StreamIterator<TDirection> >,
429: // Metafunction BasicStream
433:  * @mfn BasicStream
437:  * @signature BasicStream<TValue, TDirection[, TTraits]>::Type;
991: // NOTE(esiragusa): should it be defined for Streams and Containers?
1302: template <typename TStream, typename TIterator>
1303: inline TStream &
1304: operator<<(TStream & target,
1307:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
1312: template <typename TStream, typename TValue>
1313: inline TStream &
1314: operator<<(TStream & target,
1317:     typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
170: // Concept InputStreamConcept
191:     SEQAN_CONCEPT_USAGE(InputStreamConcept)
196: // Concept OutputStreamConcept
217:     SEQAN_CONCEPT_USAGE(OutputStreamConcept)
222: // Concept BidirectionalStreamConcept
916: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
924: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
994: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
1026: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
1041: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
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);
beachmat:inst/include/tatami/utils/Oracles.hpp: [ ]
90: struct OracleStream {
99:     OracleStream(std::unique_ptr<Oracle<Index_> > o) : oracle(std::move(o)) {}
78:  * @brief Stream predictions from the oracle.
84:  * The `OracleStream` is primarily intended for `Matrix` developers to use within subclass implementations that can expl...(25 bytes skipped)...
85:  * Users should not have to construct `OracleStream` instances.
94:     OracleStream() = default;
diffUTR:README.md: [ ]
3: ## Streamlining differential exon and 3' UTR usage analysis
CoGAPS:src/utils/Archive.h: [ ]
86:     std::fstream mStream;
24:     mStream(path.c_str(), std::ios::binary | flags)
43:         mStream.close();
49:         ar.mStream.write(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
56:         ar.mStream.read(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
BUSseq:src/rngstream.h: [ ]
8: class RngStream
12: RngStream (const char *name = "");
18: void ResetStartStream ();
beachmat:inst/include/byteme/ZlibBufferReader.hpp: [ ]
27:     struct ZStream {
28:         ZStream(int mode) {
58:         ~ZStream() {
64:         ZStream(const ZStream&) = delete;
65:         ZStream(ZStream&&) = delete;
66:         ZStream& operator=(const ZStream&) = delete;
67:         ZStream& operator=(ZStream&&) = delete;
133:     ZStream zstr;
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`
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();
Rarr:src/compression_tools/zstd/compress/zstd_compress_internal.h: [ ]
50: typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
1421: /*! ZSTD_initCStream_internal() :
1426: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
456:     ZSTD_cStreamStage streamStage;
DEsubs:R/subpathwayAnalysis.R: [ ]
72:     subStreamCases <- apply(cases, 1, function(x) {paste0(x, collapse='.')})
7:     supportedMethods <- c(  subTypes[['subStreamCases']], 
89:                 'subStreamCases'=subStreamCases,
167:     if ( method %in% subTypes[['subStreamCases']] )
CNEr:src/ucsc/net.c: [ ]
27: static int netStreamSocket()
95: if ((sd = netStreamSocket()) < 0)
230: if ((sd = netStreamSocket()) < 0)
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);
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)
OncoSimulR:src/UnityOncoSimul/exprtk.h: [ ]
39336:          template <typename Stream, typename Ptr>
39339:             Stream* stream = reinterpret_cast<Stream*>(p);
CancerInSilico:src/Tests/catch.h: [ ]
639:     class Stream;
667:     Stream createStream( std::string const& streamName );
488:     //    >> +StreamEndStop
490:     //    >> stuff +StreamEndStop
491:     struct StreamEndStop {
497:     T const& operator + ( T const& value, StreamEndStop ) {
1200:     struct CopyableStream {
1201:         CopyableStream() {}
1202:         CopyableStream( CopyableStream const& other ) {
1205:         CopyableStream& operator=( CopyableStream const& other ) {
1262:         CopyableStream &stream()
1264:             if(!m_usedStream)
1266:                 m_usedStream = true;
1272:         static CopyableStream &m_stream()
1274:             static CopyableStream s;
1281:         bool m_usedStream;
2232:             __catchResult << __VA_ARGS__ + ::Catch::StreamEndStop(); \
2240:             __catchResult << log + ::Catch::StreamEndStop(); \
3832:     class StreamBufBase : public std::streambuf {
3834:         virtual ~StreamBufBase() CATCH_NOEXCEPT;
3849:     struct IStream {
3850:         virtual ~IStream() CATCH_NOEXCEPT;
3854:     class FileStream : public IStream {
3857:         FileStream( std::string const& filename );
3858:         virtual ~FileStream() CATCH_NOEXCEPT;
3859:     public: // IStream
3863:     class CoutStream : public IStream {
3866:         CoutStream();
3867:         virtual ~CoutStream() CATCH_NOEXCEPT;
3869:     public: // IStream
3873:     class DebugOutStream : public IStream {
3874:         CATCH_AUTO_PTR( StreamBufBase ) m_streamBuf;
3877:         DebugOutStream();
3878:         virtual ~DebugOutStream() CATCH_NOEXCEPT;
3880:     public: // IStream
3966:             m_stream( openStream() )
4013:         IStream const* openStream() {
4015:                 return new CoutStream();
4018:                     return new DebugOutStream();
4023:                 return new FileStream( m_data.outputFilename );
4027:         CATCH_AUTO_PTR( IStream const ) m_stream;
6537:     class StreamRedirect {
6540:         StreamRedirect( std::ostream& stream, std::string& targetString )
6548:         ~StreamRedirect() {
6562:     // order of writes and cannot use StreamRedirect on its own
6839:                     StreamRedirect coutRedir( Catch::cout(), redirectedCout );
7632:     class StreamBufImpl : public StreamBufBase {
7637:         StreamBufImpl() {
7641:         ~StreamBufImpl() CATCH_NOEXCEPT {
7669:     FileStream::FileStream( std::string const& filename ) {
7678:     std::ostream& FileStream::stream() const {
7689:     DebugOutStream::DebugOutStream()
7690:     :   m_streamBuf( new StreamBufImpl<OutputDebugWriter>() ),
7694:     std::ostream& DebugOutStream::stream() const {
7700:     CoutStream::CoutStream()
7704:     std::ostream& CoutStream::stream() const {
9108:         m_usedStream( false )
9231:         if(m_usedStream)
9565:     struct StreamingReporterBase : SharedImpl<IStreamingReporter> {
9567:         StreamingReporterBase( ReporterConfig const& _config )
9578:         virtual ~StreamingReporterBase() CATCH_OVERRIDE;
9794:     struct TestEventListenerBase : StreamingReporterBase {
9796:         :   StreamingReporterBase( _config )
10132:     class XmlReporter : public StreamingReporterBase {
10135:         :   StreamingReporterBase( _config ),
10158:     public: // StreamingReporterBase
10161:             StreamingReporterBase::noMatchingTestCases( s );
10165:             StreamingReporterBase::testRunStarting( testInfo );
10175:             StreamingReporterBase::testGroupStarting( groupInfo );
10181:             StreamingReporterBase::testCaseStarting(testInfo);
10195:             StreamingReporterBase::sectionStarting( sectionInfo );
10284:             StreamingReporterBase::sectionEnded( sectionStats );
10299:             StreamingReporterBase::testCaseEnded( testCaseStats );
10315:             StreamingReporterBase::testGroupEnded( testGroupStats );
10325:             StreamingReporterBase::testRunEnded( testRunStats );
10595:     struct ConsoleReporter : StreamingReporterBase {
10597:         :   StreamingReporterBase( _config ),
10632:             StreamingReporterBase::sectionStarting( _sectionInfo );
10650:             StreamingReporterBase::sectionEnded( _sectionStats );
10654:             StreamingReporterBase::testCaseEnded( _testCaseStats );
10664:             StreamingReporterBase::testGroupEnded( _testGroupStats );
10670:             StreamingReporterBase::testRunEnded( _testRunStats );
11025:     struct CompactReporter : StreamingReporterBase {
11028:         : StreamingReporterBase( _config )
11077:             StreamingReporterBase::testRunEnded( _testRunStats );
11318:     IStream::~IStream() CATCH_NOEXCEPT {}
11319:     FileStream::~FileStream() CATCH_NOEXCEPT {}
11320:     CoutStream::~CoutStream() CATCH_NOEXCEPT {}
11321:     DebugOutStream::~DebugOutStream() CATCH_NOEXCEPT {}
11322:     StreamBufBase::~StreamBufBase() CATCH_NOEXCEPT {}
11343:     StreamingReporterBase::~StreamingReporterBase() {}
1542:     TrueType& testStreamable( std::ostream& );
1543:     FalseType testStreamable( FalseType );
1548:     struct IsStreamInsertable {
1551:         enum { value = sizeof( testStreamable(s << t) ) == sizeof( TrueType ) };
1555:     class IsStreamInsertable {
1623:     Detail::StringMakerBase<Detail::IsStreamInsertable<T>::value> {};
5737:     struct IStreamingReporter : IShared {
5738:         virtual ~IStreamingReporter();
5770:         virtual IStreamingReporter* create( ReporterConfig const& config ) const = 0;
5779:         virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const = 0;
5784:     Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter );
6592:         explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
6904:         Ptr<IStreamingReporter> m_reporter;
6959:     Ptr<IStreamingReporter> createReporter( std::string const& reporterName, Ptr<Config> const& config ) {
6960:         Ptr<IStreamingReporter> reporter = getRegistryHub().getReporterRegistry().create( reporterName, config.get() );...(1 bytes skipped)...
6973:     Ptr<IStreamingReporter> makeReporter( Ptr<Config> const& config ) {
6978:         Ptr<IStreamingReporter> reporter;
6985:     Ptr<IStreamingReporter> addListeners( Ptr<IConfig const> const& config, Ptr<IStreamingReporter> reporters ) {
6998:         Ptr<IStreamingReporter> reporter = makeReporter( config );
7414:         virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig const> const& config ) const CATCH_OVERRID...(4 bytes skipped)...
8470:     class LegacyReporterAdapter : public SharedImpl<IStreamingReporter>
9399: class MultipleReporters : public SharedImpl<IStreamingReporter> {
9400:     typedef std::vector<Ptr<IStreamingReporter> > Reporters;
9404:     void add( Ptr<IStreamingReporter> const& reporter ) {
9408: public: // IStreamingReporter
9507: Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
9508:     Ptr<IStreamingReporter> resultingReporter;
9514:             resultingReporter = Ptr<IStreamingReporter>( multi );
9627:     struct CumulativeReporterBase : SharedImpl<IStreamingReporter> {
9816:             virtual IStreamingReporter* create( ReporterConfig const& config ) const {
9840:             // to IStreamingReporter. The "legacy" interface, IReporter, is still supported via
9848:             virtual IStreamingReporter* create( ReporterConfig const& config ) const {
9869:             virtual IStreamingReporter* create( ReporterConfig const& config ) const {
11334:     IStreamingReporter::~IStreamingReporter() {}
rhdf5filters:src/vbz/third_party/gsl/gsl-lite.hpp: [ ]
4781: // Stream output for string_span types
4786: template< class Stream >
4787: void write_padding( Stream & os, std::streamsize n )
4793: template< class Stream, class Span >
4794: Stream & write_to_stream( Stream & os, Span const & spn )
4796:     typename Stream::sentry sentry( os );
chopsticks:src/deflate.h: [ ]
58: /* Stream status */