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;

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);

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);

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));

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'.")

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);

10: RCPtr<istream> InputStream(string const & filename) {

30: RCPtr<ostream> OutputStream(string const & filename) {

2: #define __StreamFromFileNameGenerator_hpp

1: #ifndef __StreamFromFileNameGenerator_hpp

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()

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);

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

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);

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;

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()

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;

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) {

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(); }

356:     isStream <- FALSE

366:         isStream <- TRUE

400:     if (!isStream) {

48: FILE *udcLogStream = NULL;

62:     udcLogStream = fp;

1124: if (udcLogStream)

1125:     fprintf(udcLogStream, "Open %s\n", url);

1264:     if (udcLogStream)

1266:         fprintf(udcLogStream, "Close %s %s %lld %lld bit %lld %lld %lld %lld %lld sparse %lld %lld %lld %lld %lld udc  %lld %lld...(49 bytes skipped)...

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;

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);

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)

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;

327:     isStream <- FALSE

350:         isStream <- TRUE

363:         if (!isStream) {

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);

370: getRNGStream <- function() {

379: setRNGStream <- function(seed = NULL) {

385: generateRNGStreams <- function(n = 1) {

387: 	s <- getRNGStream()

396: 			s <- nextRNGStream(seeds[[i - 1]])

9127: function ZStream() {

9152: module.exports = ZStream;

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)

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();

1395: bool paramRange::MergePartialFromCodedStream(

1747: bool rangeGate::MergePartialFromCodedStream(

2025: bool paramPoly::MergePartialFromCodedStream(

2378: bool polygonGate::MergePartialFromCodedStream(

2685: bool coordinate::MergePartialFromCodedStream(

3030: bool ellipseGate::MergePartialFromCodedStream(

3432: bool BOOL_GATE_OP::MergePartialFromCodedStream(

3772: bool boolGate::MergePartialFromCodedStream(

4041: bool clusterGate::MergePartialFromCodedStream(

4330: bool quadGate::MergePartialFromCodedStream(

4795: bool gate::MergePartialFromCodedStream(

5341: bool POPSTATS::MergePartialFromCodedStream(

5740: bool calibrationTable::MergePartialFromCodedStream(

6391: bool biexpTrans::MergePartialFromCodedStream(

6814: bool fasinhTrans::MergePartialFromCodedStream(

7219: bool scaleTrans::MergePartialFromCodedStream(

7552: bool flinTrans::MergePartialFromCodedStream(

7869: bool logTrans::MergePartialFromCodedStream(

8234: bool logGML2Trans::MergePartialFromCodedStream(

8575: bool logicleTrans::MergePartialFromCodedStream(

9284: bool transformation::MergePartialFromCodedStream(

10062: bool trans_pair::MergePartialFromCodedStream(

10436: bool trans_local::MergePartialFromCodedStream(

10850: bool POPINDICES::MergePartialFromCodedStream(

11335: bool nodeProperties::MergePartialFromCodedStream(

11819: bool treeNodes::MergePartialFromCodedStream(

12116: bool populationTree::MergePartialFromCodedStream(

12488: bool COMP::MergePartialFromCodedStream(

13149: bool PARAM::MergePartialFromCodedStream(

13673: bool GatingHierarchy::MergePartialFromCodedStream(

14109: bool CytoFrame::MergePartialFromCodedStream(

14392: bool TRANS_TBL::MergePartialFromCodedStream(

14804: bool GatingSet::MergePartialFromCodedStream(

1396:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

1468:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

1748:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

1790:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

2026:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

2084:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

2379:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

2432:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

2686:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

2743:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

3031:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

3108:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

3433:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

3506:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

3773:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

3815:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

4042:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

4088:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

4331:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

4391:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

4796:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

4935:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

5342:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

5401:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

5741:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

5893:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

5982:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

5995:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6008:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6021:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6034:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

6392:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

6488:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

6815:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

6911:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

7220:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

7290:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

7553:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

7610:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

7870:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

7953:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

8235:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

8292:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

8576:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

8698:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

9285:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

9487:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

10063:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

10133:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

10437:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

10510:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

10583:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

10851:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

10936:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

10999:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

11336:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

11439:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

11820:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

11875:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

12117:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

12159:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

12489:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

12643:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

12811:     target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(

13150:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

13248:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

13674:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

13773:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

14110:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

14154:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

14393:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

14448:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

14805:     ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {

14960:     ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {

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)

43:     class CytoStream : public std::ostream {

46:         CytoStream() : std::ostream(&cytobuf){}

54: extern CytoML::CytoStream  cytocout;

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;