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;

187:     FDR = RegCount = X = Y = ymin = ymax = Dist = Tag = Stream = PeakID = NULL

310:                 xsub$end2), Dist = c(xsub$Dist, xsub$Dist), Stream = c(rep("Upper",

313:                 ymax = ymax, color = factor(Stream))) + ggplot2::geom_errorbar(width = 10) +

316:                 ggplot2::labs(color = "Stream") + ggplot2::theme(plot.title = ggplot2::element_text(hjust = 0.5))

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

402: PWIZ_API_DECL BinaryIndexStream::BinaryIndexStream(shared_ptr<iostream> isPtr) : impl_(new Impl(isPtr)) {}

253:     typedef stream_vector_const_iterator<Entry, EntryReader> IndexStreamIterator;

264:             throw runtime_error("[BinaryIndexStream::ctor] Stream is null");

2: // $Id: BinaryIndexStream.cpp 2051 2010-06-15 18:39:13Z chambm $

25: #include "BinaryIndexStream.hpp"

215: class BinaryIndexStream::Impl

403: PWIZ_API_DECL void BinaryIndexStream::create(vector<Entry>& entries) {impl_->create(entries);}

404: PWIZ_API_DECL size_t BinaryIndexStream::size() const {return impl_->size();}

405: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(const string& id) const {return impl_->find(id);}

406: PWIZ_API_DECL Index::EntryPtr BinaryIndexStream::find(size_t index) const {return impl_->find(index);}

364:             IndexStreamIterator itr(isPtr_, entrySize_, entryReader_, indexBegin, indexEnd);

365:             itr = lower_bound(itr, IndexStreamIterator(), *entryPtr, EntryIdLessThan());

368:             if (itr == IndexStreamIterator())

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

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;

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;

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

644:   std::ostream &getOutputStream () {

648:   std::ostream &getStatsStream () {

1799:         parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";

1801:           parameters.getOutputStream() << " \"" << arg << "\"";

1803:         parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";

1806:         parameters.getOutputStream() << "Gene";

1809:         parameters.getOutputStream() << "\t" << sample;

1811:       parameters.getOutputStream() << "\n";

1813:           parameters.getOutputStream() << line.first;

1815:               parameters.getOutputStream() << "\t" << i;

1817:           parameters.getOutputStream() << "\n";

1908:     dumpStats(parameters.getStatsStream(), parameters.names, stats);

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

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

4576:         isStream <- !is.null(defMap[[".stream"]]) && defMap[[".stream"]]

4578:         if (!isStream) {

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

48: FILE *udcLogStream = NULL;

62:     udcLogStream = fp;

1093: if (udcLogStream)

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

1229:     if (udcLogStream)

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

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;

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

724:     isStream <- FALSE

971:     isStream <- FALSE

1605:     isStream <- FALSE

2393:     isStream <- FALSE

747:         isStream <- TRUE

760:         if (!isStream) {

1003:         isStream <- TRUE

1017:     if (!isStream) {

1615:         isStream <- TRUE

1649:     if (!isStream) {

2425:         isStream <- TRUE

2452:     if (!isStream) {

401: getRNGStream <- function() {

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

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

418: 	s <- getRNGStream()

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

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)

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)

103:     Streamfastq1 = ShortRead::FastqStreamer(con = S0_fastq1, n = S0_fastqStream)

104:     Streamfastq2 = ShortRead::FastqStreamer(con = S0_fastq2, n = S0_fastqStream)

101:     # Stream the fastq files:

8:     S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_image, S0_fastqStream,

27:         S0_LinkerOccurence = S0_LinkerOccurence, S0_fastqStream = S0_fastqStream,

98:     S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_fastqStream, S0_Totfastqreads,

128:         fastq1yield = ShortRead::yield(Streamfastq1)

130:         fastq2yield = ShortRead::yield(Streamfastq2)

216:     close(Streamfastq1)

217:     close(Streamfastq2)

1: #' @importFrom ShortRead FastqStreamer yield writeFastq

3: #' @importClassesFrom ShortRead FastqStreamer ShortReadQ SFastqQuality SRFilterResult

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

68:     ofstream* mOutStream;

3: ## Streamlining differential exon and 3' UTR usage analysis

8: class RngStream

12: RngStream (const char *name = "");

18: void ResetStartStream ();

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

179: string headStream(istream& is, size_t maxLength)

170:     stringstream diffStream;

171:     diffStream << diff;

172:     string diffString = diffStream.str();

324:             if (diff_mzXML && !os_) cerr << "mzXML:\n" << headStream(*serializedStreamPtr, 5000) << endl;

345:             if (diff_MGF && !os_) cerr << "MGF:\n" << headStream(*serializedStreamPtr, 5000) << endl;

278:         boost::shared_ptr<std::iostream> serializedStreamPtr(stringstreamPtr);

321:             serializer_mzXML.read(serializedStreamPtr, msd_mzXML);

341:             serializer_MGF.read(serializedStreamPtr, msd_MGF);

436:             boost::shared_ptr<std::iostream> serializedStreamPtr(stringstreamPtr);

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

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

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

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`

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`

74:     ofstream* mOutStream1;

75:     ofstream* mOutStream2;

50: typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;

1066: /*! ZSTD_initCStream_internal() :

1071: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,

273:     ZSTD_cStreamStage streamStage;

102: FastQStreamer.init <- function(input_file, input_file2=NULL, chunk_size, subsample_nbreads=NULL, max_nbchunks=N...(6 bytes skipped)...

144:   FastQStreamer.lfqs <<- lfqs

145:   FastQStreamer.chunkid <<- 0

146:   FastQStreamer.subsampling_filter <<- subsampling_filter

148:   if (is.null(max_nbchunks)) FastQStreamer.max_nbchunks <<- Inf

160: FastQStreamer.getReads <- function() {

163:     FastQStreamer.lfqs <- NULL ## to avoid the 'no visible binding' R CMD check warning

164:     FastQStreamer.chunkid <- NULL ## to avoid the 'no visible binding' R CMD check warning

165:     FastQStreamer.max_nbchunks <- NULL ## to avoid the 'no visible binding' R CMD check warning

166:     FastQStreamer.subsampling_filter <- NULL ## to avoid the 'no visible binding' R CMD check warning

210: FastQStreamer.release <- function() {

213:     FastQStreamer.lfqs <- NULL ## to avoid the 'no visible binding' R CMD check warning

70: ##' @importMethodsFrom ShortRead FastqStreamer

75:   fqs <- FastqStreamer(con, n=1e6)

88: ##' Only one FastQStreamer object can be open at any time.

96: ##' @seealso FastQStreamer.getReads

112:     loginfo(paste("io.R/FastQStreamer.init: counting number of reads in file=", input_file))

125:       loginfo(paste("io.R/FastQStreamer.init: subsampling_filter set (subsampled reads=", subsample_nbreads,

128:       loginfo(paste("io.R/FastQStreamer.init: the requested number of subsampled reads=", subsample_nbreads,

139:     fqs <- FastqStreamer(con1, n=chunk_size)

140:     loginfo(paste("io.R/FastQStreamer.init: initialised FastQ streamer for filename=", filename))

149:   else FastQStreamer.max_nbchunks <<- as.integer(max_nbchunks)

157: ##' @seealso FastQStreamer.init

162:   if (!exists("FastQStreamer.lfqs")) {

167:     stop("io.R/FastQStreamer.getReads: FastQStreamer.init() has not been called")

171:   lfqs <- FastQStreamer.lfqs

177:       stop("io.R/FastQStreamer.getReads: input files must have the same number of reads")

181:   FastQStreamer.chunkid <<- FastQStreamer.chunkid + 1

182:   if (length(lreads[[1]])==0 || FastQStreamer.chunkid>FastQStreamer.max_nbchunks) lreads <- NULL

185:     if (!is.null(FastQStreamer.subsampling_filter)) {

188:         z <- FastQStreamer.subsampling_filter[1:len]

191:           FastQStreamer.subsampling_filter <<- FastQStreamer.subsampling_filter[-(1:len)]

193:        ##   stop("io.R/FastQStreamer.getReads: (known bug) the chunk is empty after subsampling. I won't process an empty chunk! Pleas...(69 bytes skipped)...

202: ##' Close the FastQStreamer 

204: ##' @title Close the FastQStreamer 

206: ##' @seealso FastQStreamer.init

212:   if (!exists("FastQStreamer.lfqs")) {

214:     stop("io.R/FastQStreamer.release: FastQStreamer.init() has not been called")

217:   invisible(lapply(FastQStreamer.lfqs, close))

382:     fqs <- FastqStreamer(con, n=nreads)

473: ##' Overloaded yield(...) method catching truncated exceptions for FastqStreamer

475: ##' @title Overloaded yield(...) method catching truncated exceptions for FastqStreamer

476: ##' @param fqs An instance from the FastqSampler or FastqStreamer class.

477: ##' @return Same as FastqStreamer::yield

72:     subStreamCases <- apply(cases, 1, function(x) {paste0(x, collapse='.')})

7:     supportedMethods <- c(  subTypes[['subStreamCases']], 

89:                 'subStreamCases'=subStreamCases,

167:     if ( method %in% subTypes[['subStreamCases']] )

27: static int netStreamSocket()

95: if ((sd = netStreamSocket()) < 0)

230: if ((sd = netStreamSocket()) < 0)

16: test.FastQStreamer.getReads.pefq <- function() {

35: test.FastQStreamer.getReads.truncated <- function() {

54: test.FastQStreamer.getReads.pefq.subsample <- function() {

75: test.FastQStreamer.subsampler.isdeterministic <- function() {

88: test.FastQStreamer.getReads.segz <- function() {

21:                      testname="test.FastQStreamer.getReads.pefq")