Found 2896 results in 345 files, showing top 50 files (show more).
| seqbias:src/yaml-cpp/stream.cpp: [ ] |
|---|
180: Stream::Stream(std::istream& input)
|
224: Stream::~Stream()
|
311: void Stream::StreamInUtf8() const
|
320: void Stream::StreamInUtf16() const
|
426: void Stream::StreamInUtf32() const
|
149: // We are not allowed to queue the Stream::eof() codepoint, so
|
151: if (static_cast<unsigned long>(Stream::eof()) == ch)
|
229: char Stream::peek() const
|
233: return Stream::eof();
|
239: Stream::operator bool() const
|
241: return m_input.good() || (!m_readahead.empty() && m_readahead[0] != Stream::eof());
|
246: char Stream::get()
|
262: std::string Stream::get(int n)
|
273: void Stream::eat(int n)
|
279: void Stream::AdvanceCurrent()
|
290: bool Stream::_ReadAheadTo(size_t i) const
|
306: m_readahead.push_back(Stream::eof());
|
399: unsigned char Stream::GetNextByte() const
|
296: case utf8: StreamInUtf8(); break;
|
297: case utf16le: StreamInUtf16(); break;
|
298: case utf16be: StreamInUtf16(); break;
|
299: case utf32le: StreamInUtf32(); break;
|
300: case utf32be: StreamInUtf32(); break;
|
| MACPET:R/plot-methods.R: [ ] |
|---|
187: FDR = RegCount = X = Y = ymin = ymax = Dist = Tag = Stream = PeakID = NULL
|
310: xsub$end2), Dist = c(xsub$Dist, xsub$Dist), Stream = c(rep("Upper",
|
313: ymax = ymax, color = factor(Stream))) + ggplot2::geom_errorbar(width = 10) +
|
316: ggplot2::labs(color = "Stream") + ggplot2::theme(plot.title = ggplot2::element_text(hjust = 0.5))
|
| chromstaR:src/logging.h: [ ] |
|---|
101: inline FILE*& Output2FILE::Stream()
|
97: static FILE*& Stream();
|
109: FILE* pStream = Stream();
|
137: else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
|
103: static FILE* pStream = stderr;
|
104: return pStream;
|
110: if (!pStream)
|
112: fprintf(pStream, "%s", msg.c_str());
|
113: fflush(pStream);
|
| AneuFinder:src/logging.h: [ ] |
|---|
108: inline FILE*& Output2FILE::Stream()
|
104: static FILE*& Stream();
|
116: FILE* pStream = Stream();
|
144: else if (level > FILELog::ReportingLevel() || !Output2FILE::Stream()) ; \
|
110: static FILE* pStream = stderr;
|
111: return pStream;
|
117: if (!pStream)
|
119: fprintf(pStream, "%s", msg.c_str());
|
120: fflush(pStream);
|
| iBMQ:src/RngStream.c: [ ] |
|---|
307: RngStream RngStream_CreateStream (const char name[])
|
337: void RngStream_DeleteStream (RngStream g)
|
348: void RngStream_ResetStartStream (RngStream g)
|
357: void RngStream_ResetNextSubstream (RngStream g)
|
368: void RngStream_ResetStartSubstream (RngStream g)
|
377: int RngStream_SetPackageSeed (unsigned long seed[6])
|
389: int RngStream_SetSeed (RngStream g, unsigned long seed[6])
|
401: void RngStream_AdvanceState (RngStream g, long e, long c)
|
432: void RngStream_GetState (RngStream g, unsigned long seed[6])
|
441: void RngStream_WriteState (RngStream g)
|
459: void RngStream_WriteStateFull (RngStream g)
|
491: void RngStream_IncreasedPrecis (RngStream g, int incp)
|
498: void RngStream_SetAntithetic (RngStream g, int a)
|
505: double RngStream_RandU01 (RngStream g)
|
515: int RngStream_RandInt (RngStream g, int i, int j)
|
3: * File: RngStream.c for multiple streams of Random Numbers
|
14: #include "RngStream.h"
|
213: static double U01 (RngStream g)
|
246: static double U01d (RngStream g)
|
310: RngStream g;
|
313: g = (RngStream) malloc (sizeof (struct RngStream_InfoState));
|
315: Rprintf ("RngStream_CreateStream: No more memory\n\n");
|
316: error("RngStream allocation failed. Exiting.");
|
464: Rprintf ("The RngStream");
|
517: return i + (int) ((j - i + 1.0) * RngStream_RandU01 (g));
|
| velociraptor:R/plotVelocityStream.R: [ ] |
|---|
81: plotVelocityStream <- function(sce, embedded, use.dimred = 1,
|
3: #' Plot velocities embedded into low-dimensional space as a stream plot. Stream
|
48: #' Streamlines are computed by simple integration with a forward Euler method,
|
70: #' plotVelocityStream(out, em)
|
71: #' plotVelocityStream(out, em, color.streamlines = TRUE)
|
112: stop("'plotVelocityStream' requires the package 'ggplot2'.")
|
| iBMQ:src/RngStream.h: [ ] |
|---|
19: typedef struct RngStream_InfoState * RngStream;
|
21: struct RngStream_InfoState {
|
2: RngStream.h for ANSI C
|
29: int RngStream_SetPackageSeed (unsigned long seed[6]);
|
32: RngStream RngStream_CreateStream (const char name[]);
|
35: void RngStream_DeleteStream (RngStream g);
|
38: void RngStream_ResetStartStream (RngStream g);
|
41: void RngStream_ResetStartSubstream (RngStream g);
|
44: void RngStream_ResetNextSubstream (RngStream g);
|
47: void RngStream_SetAntithetic (RngStream g, int a);
|
50: void RngStream_IncreasedPrecis (RngStream g, int incp);
|
53: int RngStream_SetSeed (RngStream g, unsigned long seed[6]);
|
56: void RngStream_AdvanceState (RngStream g, long e, long c);
|
59: void RngStream_GetState (RngStream g, unsigned long seed[6]);
|
62: void RngStream_WriteState (RngStream g);
|
65: void RngStream_WriteStateFull (RngStream g);
|
68: double RngStream_RandU01 (RngStream g);
|
71: int RngStream_RandInt (RngStream g, int i, int j);
|
| netboost:src/mcupgma/clustering_round/myutils/StreamFromFileNameGenerator.hpp: [ ] |
|---|
10: RCPtr<istream> InputStream(string const & filename) {
|
30: RCPtr<ostream> OutputStream(string const & filename) {
|
2: #define __StreamFromFileNameGenerator_hpp
|
1: #ifndef __StreamFromFileNameGenerator_hpp
|
| enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.cpp: [ ] |
|---|
34: InFileStream::InFileStream() :
|
41: InFileStream::InFileStream(const char *filename) :
|
7: * InFileStream subclasses std::ifstream, adding a check for the end-of-line
|
28: #include "InFileStream.h"
|
38: //cout << "InFileStream() constructor 1" << endl;
|
44: //cout << "InFileStream(f) constructor 2" << endl;
|
49: //- InFileStream::InFileStream(const InFileStream ©) :
|
52: //- cout << "InFileStream() constructor 3" << endl;
|
56: void InFileStream::open(const char *filename)
|
67: void InFileStream::close()
|
74: std::istream& InFileStream::getline(char *s, streamsize n)
|
80: std::istream& InFileStream::getline(char *s, streamsize n, char delim)
|
93: * 09-02-07,Nigel Brown(EMBL): moved member into new InFileStream subclassed
|
95: * that uses InFileStream in place of std::ifstream. Replaced if/then/else
|
98: char InFileStream::findDelimiter()
|
| enhancerHomologSearch:src/ClustalW/fileInput/InFileStream.h: [ ] |
|---|
22: class InFileStream : public std::ifstream
|
7: * InFileStream subclasses std::ifstream, adding a check for the end-of-line
|
25: InFileStream();
|
26: InFileStream(const char *filename);
|
27: //- InFileStream(const InFileStream ©);
|
45: InFileStream(const InFileStream ©);
|
| Director:inst/www/js/d3.v3.js: [ ] |
|---|
4246: function d3_geo_pathProjectStream(project) {
|
3878: var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
|
3881: lower48Stream.point(x, y);
|
3886: lower48Stream.sphere();
|
3891: lower48Stream.lineStart();
|
3896: lower48Stream.lineEnd();
|
3901: lower48Stream.polygonStart();
|
3906: lower48Stream.polygonEnd();
|
3862: var point, pointStream = {
|
3882: alaskaStream.point(x, y);
|
3883: hawaiiStream.point(x, y);
|
3887: alaskaStream.sphere();
|
3888: hawaiiStream.sphere();
|
3892: alaskaStream.lineStart();
|
3893: hawaiiStream.lineStart();
|
3897: alaskaStream.lineEnd();
|
3898: hawaiiStream.lineEnd();
|
3902: alaskaStream.polygonStart();
|
3903: hawaiiStream.polygonStart();
|
3907: alaskaStream.polygonEnd();
|
3908: hawaiiStream.polygonEnd();
|
3929: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
|
3930: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
|
3931: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
|
4200: var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
|
4203: if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
|
4204: if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
|
4205: d3.geo.stream(object, cacheStream);
|
4207: return contextStream.result();
|
4211: d3.geo.stream(object, projectStream(d3_geo_pathArea));
|
4216: d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
|
4221: d3.geo.stream(object, projectStream(d3_geo_pathBounds));
|
4226: projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
|
4231: contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
|
4232: if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
|
4237: pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
|
4241: cacheStream = null;
|
| ChIC:R/privateFunctions.R: [ ] |
|---|
843: up_downStream <- 4020
|
755: ## f_one.point.scaling <- function(x, pos, strand=NULL,m=up_downStream/2,
|
847: estimated_bin_size_1P <- up_downStream/predefnum_bins_1P
|
860: settings$up_downStream <- up_downStream
|
1024: m = (settings$up_downStream / 2),
|
1032: m = (settings$up_downStream / 2),
|
1114: ## gdl=annotatedGenesPerChr,m=up_downStream, nbins=predefnum_bins_1P,
|
1177: ## m=up_downStream, nbins=predefnum_bins_1P,separate.strands=F,mc=1) {
|
| gdsfmt:src/CoreArray/dFile.cpp: [ ] |
|---|
278: static const char *ERR_GDSStream = "%s: GDSStream should not be NULL.";
|
427: void CdGDSObj::GetOwnBlockStream(vector<const CdBlockStream*> &Out) const
|
432: void CdGDSObj::GetOwnBlockStream(vector<CdStream*> &Out)
|
477: void CdGDSObj::SaveToBlockStream()
|
504: void CdGDSObj::_CheckGDSStream()
|
583: CdStream *fStream;
|
584: CLASS *fPStream;
|
616: CdStream *fStream;
|
617: CLASS *fPStream;
|
732: virtual void LoadStream(CdReader &Reader, TdVersion Version)
|
778: virtual void SaveStream(CdWriter &Writer)
|
1032: void CdPipeMgrItem::LoadStream(CdReader &Reader, TdVersion Version) { }
|
1034: void CdPipeMgrItem::SaveStream(CdWriter &Writer) { }
|
2493: void CdGDSStreamContainer::GetOwnBlockStream(vector<const CdBlockStream*> &Out) const
|
2499: void CdGDSStreamContainer::GetOwnBlockStream(vector<CdStream*> &Out)
|
2634: void CdGDSFile::LoadStream(CdStream *Stream, bool ReadOnly, bool AllowError)
|
2690: void CdGDSFile::SaveStream(CdStream *Stream)
|
679: virtual bool GetStreamInfo(CdBufStream *buf)
|
723: virtual void UpdateStreamInfo(CdStream &Stream)
|
1026: void CdPipeMgrItem::UpdateStreamSize()
|
1155: CdStreamPipeMgr CoreArray::dStreamPipeMgr;
|
1157: CdStreamPipeMgr::CdStreamPipeMgr(): CdAbstractManager()
|
1171: CdStreamPipeMgr::~CdStreamPipeMgr()
|
2231: CdGDSStreamContainer::CdGDSStreamContainer(): CdGDSObjPipe()
|
2241: CdGDSStreamContainer::~CdGDSStreamContainer()
|
543: // Stream Manage Pipe
|
590: fStream = BufStream->Stream();
|
624: fStream = BufStream->Stream();
|
670: return (dynamic_cast<CLASS*>(buf.Stream()) != NULL);
|
675: CLASS *s = dynamic_cast<CLASS*>(buf.Stream());
|
684: CLASS *s = dynamic_cast<CLASS*>(buf->Stream());
|
727: BYTE_LE<CdStream> S(Stream);
|
865: typedef CdWritePipe2<CdLZ4Encoder, CdBaseLZ4Stream::TLZ4Chunk> CdLZ4WritePipe;
|
875: public CdPipe<CdBaseLZ4Stream::bsLast, CdBaseLZ4Stream::bsDefault,
|
876: CdBaseLZ4Stream::TLZ4Chunk, CdLZ4Encoder, CdPipeLZ4>
|
2255: return "Stream";
|
2645: Stream->ReadData((void*)&buf[0], L);
|
2650: fVersion = Stream->R8b();
|
2651: fVersion |= Stream->R8b() << 8;
|
2660: BYTE_LE<CdStream>(Stream) >> Entry;
|
2663: CdBlockCollection::LoadStream(Stream, ReadOnly, AllowError, &Log());
|
2699: Stream->WriteData((void*)GDSFilePrefix(), L);
|
2702: Stream->W8b(fVersion & 0xFF);
|
2703: Stream->W8b(fVersion >> 8);
|
2705: SIZE64 _EntryPos = Stream->Position();
|
2706: BYTE_LE<CdStream>(Stream) << TdGDSBlockID(0);
|
2708: CdBlockCollection::WriteStream(Stream);
|
2711: SIZE64 _NewPos = Stream->Position();
|
2713: Stream->SetPosition(_EntryPos);
|
2714: BYTE_LE<CdStream>(Stream) << fRoot.fGDSStream->ID();
|
2715: Stream->SetPosition(_NewPos);
|
288: fGDSStream = NULL;
|
294: if (fGDSStream)
|
295: fGDSStream->Release();
|
393: if (fGDSStream && folder.GDSStream() && fFolder)
|
395: CdBlockCollection *n1 = &fGDSStream->Collection();
|
396: CdBlockCollection *n2 = &folder.GDSStream()->Collection();
|
424: SaveToBlockStream();
|
439: if (fGDSStream)
|
441: CdBlockCollection *collect = &fGDSStream->Collection();
|
479: _CheckGDSStream();
|
480: if (fGDSStream)
|
482: CdWriter Writer(fGDSStream, &GDSFile()->Log());
|
506: if (!fGDSStream)
|
507: throw ErrGDSObj(ERR_GDSStream, "CdGDSObj");
|
537: static_cast<CdGDSObj*>(Obj)->fGDSStream = (CdBlockStream*)Data;
|
552: static const CdRecodeStream::TLevel CompressionLevels[] =
|
554: CdRecodeStream::clMin,
|
555: CdRecodeStream::clFast,
|
556: CdRecodeStream::clDefault,
|
557: CdRecodeStream::clMax,
|
558: CdRecodeStream::clUltra, // ultra (LZMA 512MiB)
|
559: CdRecodeStream::clUltraMax, // ultra_max (LZMA 1536MiB)
|
560: CdRecodeStream::clDefault
|
575: CdWritePipe(CdRecodeStream::TLevel vLevel,
|
585: CdRecodeStream::TLevel fLevel;
|
588: virtual CdStream *InitPipe(CdBufStream *BufStream)
|
591: fPStream = new CLASS(*fStream, fLevel);
|
592: fPStream->PtrExtRec = &fRemainder;
|
593: return fPStream;
|
595: virtual CdStream *FreePipe()
|
597: if (fPStream) { fPStream->Release(); fPStream = NULL; }
|
598: return fStream;
|
607: CdWritePipe2(CdRecodeStream::TLevel vLevel, BSIZE bs,
|
618: CdRecodeStream::TLevel fLevel;
|
622: virtual CdStream *InitPipe(CdBufStream *BufStream)
|
625: fPStream = new CLASS(*fStream, fLevel, fBSize);
|
626: fPStream->PtrExtRec = &fRemainder;
|
627: return fPStream;
|
629: virtual CdStream *FreePipe()
|
631: if (fPStream) { fPStream->Release(); fPStream = NULL; }
|
632: return fStream;
|
648: fLevel = CdRecodeStream::clDefault;
|
663: virtual void PopPipe(CdBufStream &buf)
|
668: virtual bool WriteMode(CdBufStream &buf) const
|
673: virtual void ClosePipe(CdBufStream &buf)
|
703: CdRecodeStream::TLevel fLevel;
|
758: fLevel = (CdRecodeStream::TLevel)I;
|
760: fLevel = CdRecodeStream::clUnknown;
|
814: virtual void PushReadPipe(CdBufStream &buf)
|
816: virtual void PushWritePipe(CdBufStream &buf)
|
847: virtual void PushReadPipe(CdBufStream &buf)
|
849: virtual void PushWritePipe(CdBufStream &buf)
|
889: virtual void PushReadPipe(CdBufStream &buf)
|
891: virtual void PushWritePipe(CdBufStream &buf)
|
928: virtual void PushReadPipe(CdBufStream &buf)
|
930: virtual void PushWritePipe(CdBufStream &buf)
|
964: virtual void PushReadPipe(CdBufStream &buf)
|
966: virtual void PushWritePipe(CdBufStream &buf)
|
997: virtual void PushReadPipe(CdBufStream &buf)
|
999: virtual void PushWritePipe(CdBufStream &buf)
|
1250: fPipeInfo->LoadStream(Reader, Version);
|
1261: fPipeInfo->SaveStream(Writer);
|
1304: StreamID = 0;
|
1367: _CheckGDSStream();
|
1376: rv->fGDSStream = fGDSStream->Collection().NewBlockStream();
|
1377: rv->fGDSStream->AddRef();
|
1383: I.StreamID = rv->fGDSStream->ID();
|
1408: _CheckGDSStream();
|
1436: if (val->fGDSStream == NULL)
|
1438: val->fGDSStream = fGDSStream->Collection().NewBlockStream();
|
1439: val->fGDSStream->AddRef();
|
1440: I.StreamID = val->fGDSStream->ID();
|
1442: val->SaveToBlockStream();
|
1533: CdBlockStream *stream = it->Obj->fGDSStream;
|
1535: vector<const CdBlockStream*> BL;
|
1536: it->Obj->GetOwnBlockStream(BL);
|
1558: if (fGDSStream)
|
1561: fGDSStream->Collection().DeleteBlockStream(stream->ID());
|
1563: vector<const CdBlockStream*>::iterator it;
|
1566: fGDSStream->Collection().DeleteBlockStream((*it)->ID());
|
1749: Reader[VAR_DIR_ID] >> I.StreamID;
|
1777: Writer[VAR_DIR_ID] << it->StreamID;
|
1844: _CheckGDSStream();
|
1845: CdBlockStream *IStream = fGDSStream->Collection()[I.StreamID];
|
1846: CdReader Reader(IStream, &GDSFile()->Log());
|
1860: vObj->fGDSStream = IStream;
|
1861: IStream->AddRef();
|
1875: vObj->fGDSStream = IStream;
|
1876: IStream->AddRef();
|
1890: vObj->fGDSStream = IStream;
|
1891: IStream->AddRef();
|
1901: vObj->fGDSStream = IStream;
|
1902: IStream->AddRef();
|
1913: obj = fGDSStream->Collection().ClassMgr()->
|
1914: ToObj(Reader, _GDSObjInitProc, fGDSStream, false);
|
1928: I.Obj->fGDSStream = IStream;
|
1929: IStream->AddRef();
|
1943: SaveToBlockStream();
|
2233: fBufStream = new CdBufStream(new CdMemoryStream);
|
2234: fBufStream->AddRef();
|
2235: vAllocStream = NULL;
|
2244: if (fBufStream)
|
2245: fBufStream->Release();
|
2250: return "dStream";
|
2273: S->CopyTo(*BufStream());
|
2283: if (fGDSStream)
|
2289: if (fBufStream)
|
2290: fBufStream->Release();
|
2291: fBufStream = new CdBufStream(fGDSStream->Collection()[vAllocID]);
|
2292: fBufStream->AddRef();
|
2295: fPipeInfo->PushReadPipe(*fBufStream);
|
2297: throw ErrGDSStreamContainer(ERR_GDSStream, "CdGDSStreamContainer");
|
2305: if (fGDSStream)
|
2307: if (vAllocStream == NULL)
|
2309: _CheckGDSStream();
|
2310: vAllocStream = fGDSStream->Collection().NewBlockStream();
|
2312: if (fBufStream) fBufStream->Release();
|
2313: fBufStream = new CdBufStream(vAllocStream);
|
2314: fBufStream->AddRef();
|
2316: fPipeInfo->PushWritePipe(*fBufStream);
|
2318: TdGDSBlockID Entry = vAllocStream->ID();
|
2322: throw ErrGDSStreamContainer(ERR_GDSStream, "CdGDSStreamContainer");
|
2329: return fPipeInfo->StreamTotalIn();
|
2331: return fBufStream->GetSize();
|
2343: if (vAllocStream && fGDSStream && (vAllocStream->GetSize()>0))
|
2357: CdStream *TmpStream = new CdTempStream;
|
2358: TdAutoRef<CdBufStream> Output(new CdBufStream(TmpStream));
|
2371: vAllocStream->SetPosition(0);
|
2372: vAllocStream->SetSizeOnly(0);
|
2373: vAllocStream->CopyFrom(*TmpStream, 0, -1);
|
2376: vAllocStream->SetPosition(0);
|
2377: if (fBufStream)
|
2378: fBufStream->Release();
|
2379: fBufStream = new CdBufStream(vAllocStream);
|
2380: fBufStream->AddRef();
|
2382: fPipeInfo->PushReadPipe(*fBufStream);
|
2385: SaveToBlockStream();
|
2398: fBufStream->OnFlush.Clear();
|
2399: fBufStream->FlushWrite();
|
2400: if (fPipeInfo && vAllocStream)
|
2402: if (fPipeInfo->WriteMode(*fBufStream))
|
2404: fPipeInfo->ClosePipe(*fBufStream);
|
2405: if (_GetStreamPipeInfo(fBufStream, false))
|
2406: _UpdateStreamPipeInfo(*fGDSStream);
|
2408: if (fBufStream)
|
2409: fBufStream->Release();
|
2410: vAllocStream->SetPosition(0);
|
2411: fBufStream = new CdBufStream(vAllocStream);
|
2412: fBufStream->AddRef();
|
2414: fPipeInfo->PushReadPipe(*fBufStream);
|
2419: void CdGDSStreamContainer::CopyFromBuf(CdBufStream &Source, SIZE64 Count)
|
2432: fBufStream->WriteData((void*)Buffer, N);
|
2437: void CdGDSStreamContainer::CopyFrom(CdStream &Source, SIZE64 Count)
|
2450: fBufStream->WriteData((void*)Buffer, N);
|
2455: void CdGDSStreamContainer::CopyTo(CdBufStream &Dest, SIZE64 Count)
|
2461: fBufStream->SetPosition(0);
|
2468: fBufStream->ReadData((void*)Buffer, N);
|
2474: void CdGDSStreamContainer::CopyTo(CdStream &Dest, SIZE64 Count)
|
2480: fBufStream->SetPosition(0);
|
2487: fBufStream->ReadData((void*)Buffer, N);
|
2496: if (vAllocStream) Out.push_back(vAllocStream);
|
2502: if (vAllocStream) Out.push_back(vAllocStream);
|
2673: fRoot.fGDSStream = (*this)[Entry];
|
2674: fRoot.fGDSStream->AddRef();
|
2679: (double)fRoot.fGDSStream->Size());
|
2682: CdReader Reader(fRoot.fGDSStream, &Log());
|
2693: if (fStream != NULL)
|
2709: fRoot.fGDSStream = NewBlockStream();
|
2710: fRoot.fGDSStream->AddRef();
|
2717: fRoot.SaveToBlockStream();
|
2722: TdAutoRef<CdStream> F(new CdFileStream(RawText(fn).c_str(),
|
2723: ReadOnly ? CdFileStream::fmOpenRead : CdFileStream::fmOpenReadWrite));
|
2724: LoadStream(F.get(), ReadOnly, AllowError);
|
2730: TdAutoRef<CdStream> F(new CdFileStream(fn,
|
2731: ReadOnly ? CdFileStream::fmOpenRead : CdFileStream::fmOpenReadWrite));
|
2732: LoadStream(F.get(), ReadOnly, AllowError);
|
2738: TdAutoRef<CdStream> F(new CdForkFileStream(fn,
|
2739: ReadOnly ? CdFileStream::fmOpenRead : CdFileStream::fmOpenReadWrite));
|
2740: LoadStream(F.get(), ReadOnly, AllowError);
|
2746: if (fStream == NULL)
|
2753: TdAutoRef<CdStream> F(new CdFileStream(RawText(fn).c_str(),
|
2754: CdFileStream::fmCreate));
|
2756: SaveStream(F.get());
|
2761: TdAutoRef<CdStream> F(new CdFileStream(fn, CdFileStream::fmCreate));
|
2763: SaveStream(F.get());
|
2774: TdAutoRef<CdStream> F(new CdFileStream(RawText(fn).c_str(),
|
2775: CdFileStream::fmCreate));
|
2786: BYTE_LE<CdStream>(*F) << fRoot.fGDSStream->ID();
|
2793: CdBlockStream::TBlockInfo::HEAD_SIZE + bSize) |
|
2796: BYTE_LE<CdStream>(*F) <<
|
2810: if (fStream)
|
2818: if (fRoot.fGDSStream)
|
2821: fRoot.fGDSStream->Release();
|
2822: fRoot.fGDSStream = NULL;
|
2879: return (dynamic_cast<CdForkFileStream*>(fStream) != NULL);
|
572: class COREARRAY_DLL_DEFAULT CdWritePipe: public CdStreamPipe
|
577: CdStreamPipe(), fRemainder(vRemainder)
|
604: class COREARRAY_DLL_DEFAULT CdWritePipe2: public CdStreamPipe
|
609: CdStreamPipe(), fRemainder(vRemainder)
|
693: if ((in!=fStreamTotalIn) || (out!=fStreamTotalOut))
|
695: fStreamTotalIn = in;
|
696: fStreamTotalOut = out;
|
729: S << fStreamTotalIn << fStreamTotalOut;
|
740: fStreamTotalIn = Ary[0];
|
741: fStreamTotalOut = Ary[1];
|
744: fStreamTotalIn = fStreamTotalOut = -1;
|
780: UpdateStreamSize();
|
781: C_Int64 Ary[2] = { fStreamTotalIn, fStreamTotalOut };
|
798: typedef CdStreamPipe2<CdZDecoder> CdZIPReadPipe;
|
829: typedef CdStreamPipe2<CdZDecoder_RA> CdZRAReadPipe;
|
864: typedef CdStreamPipe2<CdLZ4Decoder> CdLZ4ReadPipe;
|
904: typedef CdStreamPipe2<CdLZ4Decoder_RA> CdLZ4RAReadPipe;
|
947: typedef CdStreamPipe2<CdXZDecoder> CdXZReadPipe;
|
979: typedef CdStreamPipe2<CdXZDecoder_RA> CdXZReadPipe_RA;
|
1021: fStreamTotalIn = fStreamTotalOut = -1;
|
1153: // CdStreamPipeMgr
|
1178: void CdStreamPipeMgr::Register(CdPipeMgrItem *vNewPipe)
|
1185: CdPipeMgrItem *CdStreamPipeMgr::Match(CdGDSObjPipe &Obj, const char *Mode)
|
1247: fPipeInfo = dStreamPipeMgr.Match(*this, RawText(Coder).c_str());
|
1429: } else if (dynamic_cast<CdGDSStreamContainer*>(val))
|
1896: CdGDSStreamContainer *vObj = new CdGDSStreamContainer;
|
2227: // CdGDSStreamContainer
|
2248: const char *CdGDSStreamContainer::dName()
|
2253: const char *CdGDSStreamContainer::dTraitName()
|
2258: CdGDSObj *CdGDSStreamContainer::NewObject()
|
2260: return (new CdGDSStreamContainer)->AssignPipe(*this);
|
2263: void CdGDSStreamContainer::Assign(CdGDSObj &Source, bool Full)
|
2265: if (dynamic_cast<CdGDSStreamContainer*>(&Source))
|
2271: CdGDSStreamContainer *S = static_cast<CdGDSStreamContainer*>(&Source);
|
2276: RaiseInvalidAssign("CdGDSStreamContainer", &Source);
|
2279: void CdGDSStreamContainer::Loading(CdReader &Reader, TdVersion Version)
|
2301: void CdGDSStreamContainer::Saving(CdWriter &Writer)
|
2326: SIZE64 CdGDSStreamContainer::GetSize()
|
2334: void CdGDSStreamContainer::SetPackedMode(const char *Mode)
|
2351: fPipeInfo = dStreamPipeMgr.Match(*this, Mode);
|
2353: throw ErrGDSStreamContainer(ERR_PACKED_MODE, Mode);
|
2367: fPipeInfo->GetStreamInfo(Output.get());
|
2389: fPipeInfo = dStreamPipeMgr.Match(*this, Mode);
|
2391: throw ErrGDSStreamContainer(ERR_PACKED_MODE, Mode);
|
2396: void CdGDSStreamContainer::CloseWriter()
|
2869: return fStreamSize;
|
| R453Plus1Toolbox:R/methods-AVASet.R: [ ] |
|---|
1078: upDownStream = max(width(dnaSet))
|
1088: seqType="gene_exon_intron", upstream=upDownStream, mart=ensembl)
|
1093: seqType="gene_exon_intron", downstream=upDownStream, mart=ensembl)
|
1122: pos[refName] = geneInfo$start_position[ind] - upDownStream + start(m) - 1
|
| Rmmquant:src/mmquant.h: [ ] |
|---|
644: std::ostream &getOutputStream () {
|
648: std::ostream &getStatsStream () {
|
1799: parameters.getOutputStream() << "# Program:mmquant v" << VERSION << "; Command:";
|
1801: parameters.getOutputStream() << " \"" << arg << "\"";
|
1803: parameters.getOutputStream() << "\nGeneid\tChr\tStart\tEnd\tStrand\tLength";
|
1806: parameters.getOutputStream() << "Gene";
|
1809: parameters.getOutputStream() << "\t" << sample;
|
1811: parameters.getOutputStream() << "\n";
|
1813: parameters.getOutputStream() << line.first;
|
1815: parameters.getOutputStream() << "\t" << i;
|
1817: parameters.getOutputStream() << "\n";
|
1908: dumpStats(parameters.getStatsStream(), parameters.names, stats);
|
| ChemmineR:R/AllClasses.R: [ ] |
|---|
2413: sdfStream <- function(input, output, append=FALSE, fct, Nlines=10000, startline=1, restartNlines=10000, silen...(15 bytes skipped)...
|
2406: ## (6.8) Streaming Through SD Files ##
|
2408: ## Streaming function to compute descriptors for large SD Files without consuming much memory.
|
2419: ## For restarting sdfStream at specific line assigned to startline argument. If assigned
|
2521: # sdfStream(input="test.sdf", output="matrix.xls", fct=desc, Nlines=1000)
|
2530: ## as character strings to APset or FPset objects (e.g. generated by sdfStream).
|
2561: ## Extracts specific molecules from SD File based on a line position index computed by the sdfStream function
|
2592: ## Usage: see sdfStream()
|
| affxparser:src/fusion/file/TsvFile/TsvFile.h: [ ] |
|---|
472: std::fstream m_fileStream;
|
579: int isFileOpen() { return (m_fileStream.is_open()? TSV_OK : TSV_ERR_FILEIO); }
|
581: bool is_open() { return m_fileStream.is_open(); }
|
582: bool good() { return m_fileStream.good(); }
|
| Gviz:R/DataTrack-class.R: [ ] |
|---|
356: isStream <- FALSE
|
366: isStream <- TRUE
|
400: if (!isStream) {
|
| rtracklayer:src/ucsc/udc.c: [ ] |
|---|
48: FILE *udcLogStream = NULL;
|
62: udcLogStream = fp;
|
1124: if (udcLogStream)
|
1125: fprintf(udcLogStream, "Open %s\n", url);
|
1264: if (udcLogStream)
|
1266: fprintf(udcLogStream, "Close %s %s %lld %lld bit %lld %lld %lld %lld %lld sparse %lld %lld %lld %lld %lld udc %lld %lld...(49 bytes skipped)...
|
| LACE:inst/htmlwidgets/lib/d3.v4.js: [ ] |
|---|
6898: function geoStream(object, stream) {
|
7424: function circleStream(stream, radius, delta, direction, t0, t1) {
|
8978: function TransformStream() {}
|
9343: point, pointStream = {point: function(x, y) { point = [x, y]; }};
|
6915: var areaStream = {
|
6921: areaStream.lineStart = areaRingStart;
|
6922: areaStream.lineEnd = areaRingEnd;
|
6935: areaStream.point = areaPointFirst;
|
6943: areaStream.point = areaPoint;
|
6972: geoStream(object, areaStream);
|
7020: var boundsStream = {
|
7025: boundsStream.point = boundsRingPoint;
|
7026: boundsStream.lineStart = boundsRingStart;
|
7027: boundsStream.lineEnd = boundsRingEnd;
|
7029: areaStream.polygonStart();
|
7032: areaStream.polygonEnd();
|
7033: boundsStream.point = boundsPoint;
|
7034: boundsStream.lineStart = boundsLineStart;
|
7035: boundsStream.lineEnd = boundsLineEnd;
|
7099: boundsStream.point = linePoint;
|
7104: boundsStream.point = boundsPoint;
|
7115: areaStream.point(lambda, phi);
|
7120: areaStream.lineStart();
|
7125: areaStream.lineEnd();
|
7151: geoStream(feature, boundsStream);
|
7200: var centroidStream = {
|
7206: centroidStream.lineStart = centroidRingStart;
|
7207: centroidStream.lineEnd = centroidRingEnd;
|
7210: centroidStream.lineStart = centroidLineStart;
|
7211: centroidStream.lineEnd = centroidLineEnd;
|
7230: centroidStream.point = centroidLinePointFirst;
|
7239: centroidStream.point = centroidLinePoint;
|
7258: centroidStream.point = centroidPoint;
|
7264: centroidStream.point = centroidRingPointFirst;
|
7269: centroidStream.point = centroidPoint;
|
7275: centroidStream.point = centroidRingPoint;
|
7310: geoStream(object, centroidStream);
|
7470: circleStream(stream, r, p, 1);
|
7906: circleStream(stream, radius, delta, direction, from, to);
|
8182: var activeStream = stream,
|
8183: bufferStream = clipBuffer(),
|
8192: var clipStream = {
|
8201: if (visible(x, y)) activeStream.point(x, y);
|
8220: activeStream = bufferStream, segments = [], polygon = [], clean = true;
|
8239: activeStream = stream, segments = polygon = ring = null;
|
8243: clipStream.point = linePoint;
|
8256: if (v__ && v_) bufferStream.rejoin();
|
8257: segments.push(bufferStream.result());
|
8259: clipStream.point = point;
|
8260: if (v_) activeStream.lineEnd();
|
8270: activeStream.lineStart();
|
8271: activeStream.point(x, y);
|
8274: if (v && v_) activeStream.point(x, y);
|
8280: activeStream.lineStart();
|
8281: activeStream.point(a[0], a[1]);
|
8283: activeStream.point(b[0], b[1]);
|
8284: if (!v) activeStream.lineEnd();
|
8287: activeStream.lineStart();
|
8288: activeStream.point(x, y);
|
8296: return clipStream;
|
8306: cacheStream,
|
8311: return cache && cacheStream === stream ? cache : cache = clipRectangle(x0, y0, x1, y1)(cacheStream = stream);
|
8314: ...(16 bytes skipped)...return arguments.length ? (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1], cache = cacheStream = null, clip) : [[x0, y0], [x1, y1]];
|
8324: var lengthStream = {
|
8334: lengthStream.point = lengthPointFirst;
|
8335: lengthStream.lineEnd = lengthLineEnd;
|
8339: lengthStream.point = lengthStream.lineEnd = noop$1;
|
8345: lengthStream.point = lengthPoint;
|
8364: geoStream(object, lengthStream);
|
8607: var areaStream$1 = {
|
8612: areaStream$1.lineStart = areaRingStart$1;
|
8613: areaStream$1.lineEnd = areaRingEnd$1;
|
8616: areaStream$1.lineStart = areaStream$1.lineEnd = areaStream$1.point = noop$1;
|
8628: areaStream$1.point = areaPointFirst$1;
|
8632: areaStream$1.point = areaPoint$1;
|
8650: var boundsStream$1 = {
|
8686: var centroidStream$1 = {
|
8691: centroidStream$1.lineStart = centroidRingStart$1;
|
8692: centroidStream$1.lineEnd = centroidRingEnd$1;
|
8695: centroidStream$1.point = centroidPoint$1;
|
8696: centroidStream$1.lineStart = centroidLineStart$1;
|
8697: centroidStream$1.lineEnd = centroidLineEnd$1;
|
8718: centroidStream$1.point = centroidPointFirstLine;
|
8722: centroidStream$1.point = centroidPointLine;
|
8735: centroidStream$1.point = centroidPoint$1;
|
8739: centroidStream$1.point = centroidPointFirstRing;
|
8747: centroidStream$1.point = centroidPointRing;
|
8817: var lengthStream$1 = {
|
8820: lengthStream$1.point = lengthPointFirst$1;
|
8824: lengthStream$1.point = noop$1;
|
8840: lengthStream$1.point = lengthPoint$1;
|
8912: projectionStream,
|
8913: contextStream;
|
8917: if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
|
8918: geoStream(object, projectionStream(contextStream));
|
8920: return contextStream.result();
|
8924: geoStream(object, projectionStream(areaStream$1));
|
8925: return areaStream$1.result();
|
8929: geoStream(object, projectionStream(lengthStream$1));
|
8930: return lengthStream$1.result();
|
8934: geoStream(object, projectionStream(boundsStream$1));
|
8935: return boundsStream$1.result();
|
8939: geoStream(object, projectionStream(centroidStream$1));
|
8940: return centroidStream$1.result();
|
8944: return arguments.length ? (projectionStream = _ == null ? (projection = null, identity$4) : (projection = _).stream, path) : projection;
|
8949: contextStream = _ == null ? (context = null, new PathString) : new PathContext(context = _);
|
8950: if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
|
8956: pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
|
8971: var s = new TransformStream;
|
8980: TransformStream.prototype = {
|
8981: constructor: TransformStream,
|
8994: geoStream(object, projection.stream(boundsStream$1));
|
8995: fitBounds(boundsStream$1.result());
|
9083: var resampleStream = {
|
9087: polygonStart: function() { stream.polygonStart(); resampleStream.lineStart = ringStart; },
|
9088: polygonEnd: function() { stream.polygonEnd(); resampleStream.lineStart = lineStart; }
|
9098: resampleStream.point = linePoint;
|
9109: resampleStream.point = point;
|
9115: resampleStream.point = ringPoint;
|
9116: resampleStream.lineEnd = ringEnd;
|
9121: resampleStream.point = linePoint;
|
9126: resampleStream.lineEnd = lineEnd;
|
9130: return resampleStream;
|
9163: cacheStream;
|
9180: return cache && cacheStream...(9 bytes skipped)...am ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
|
9244: cache = cacheStream = null;
|
9339: cacheStream,
|
9363: return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
|
9385: .stream(pointStream);
|
9390: .stream(pointStream);
|
9395: .stream(pointStream);
|
9417: cache = cacheStream = null;
|
9621: cacheStream,
|
9625: cache = cacheStream = null;
|
9631: return cache && cacheStream === stream ? cache : cache = transform$$1(postclip(cacheStream = stream));
|
16942: exports.geoStream = geoStream;
|
| rhdf5filters:src/blosc/lib/zstd-1.4.5/zstd.h: [ ] |
|---|
641: typedef ZSTD_CCtx ZSTD_CStream; /**< CCtx and CStream are now effectively same object (>= v1.3.0) */
|
761: typedef ZSTD_DCtx ZSTD_DStream; /**< DCtx and DStream are now effectively same object (>= v1.3.0) */
|
1308: * Note : if streaming is init with function ZSTD_init?Stream_usingDict(),
|
56: - unbounded multiple steps (described as Streaming compression)
|
240: * "sticky" parameters are applicable to `ZSTD_compress2()` and `ZSTD_compressStream*()` !
|
371: ...(8 bytes skipped)... * When nbWorkers >= 1, triggers asynchronous mode when used with ZSTD_compressStream*() :
|
372: * ZSTD_compressStream*() consumes input and flush output if possible, but immediately gives back control to caller,
|
374: ...(13 bytes skipped)... * (note : a strong exception to this rule is when first invocation of ZSTD_compressStream2() sets ZSTD_e_end :
|
375: * in which case, ZSTD_compressStream2() delegates to ZSTD_compress2(), which is always a blocking call).
|
459: * or invoking immediately ZSTD_compressStream2(,,,ZSTD_e_end),
|
509: * Note : This API is compatible with existing ZSTD_decompressDCtx() and ZSTD_decompressStream().
|
563: * Streaming
|
581: * Streaming compression - HowTo
|
583: * A ZSTD_CStream object is required to track streaming operation.
|
584: * Use ZSTD_createCStream() and ZSTD_freeCStream() to create/release resources.
|
585: * ZSTD_CStream objects can be reused multiple times on consecutive compression operations.
|
586: * It is recommended to re-use ZSTD_CStream since it will play nicer with system's memory, by re-using already allocated memory.
|
588: * For parallel execution, use one separate ZSTD_CStream per thread.
|
590: * note : since v1.3.0, ZSTD_CStream and ZSTD_CCtx are the same thing.
|
599: * Use ZSTD_compressStream2() with ZSTD_e_continue as many times as necessary to
|
616: * using ZSTD_compressStream2() with ZSTD_e_flush. `output->pos` will be updated.
|
618: * In which case, make some room to receive more compressed data, and call again ZSTD_compressStream2() with ZSTD_e_flush.
|
619: * You must continue calling ZSTD_compressStream2() with ZSTD_e_flush until it returns 0, at which point you can change the
|
627: * Calling ZSTD_compressStream2() with ZSTD_e_end instructs to finish a frame.
|
630: * flush operation is the same, and follows same rules as calling ZSTD_compressStream2() with ZSTD_e_flush.
|
631: * You must continue calling ZSTD_compressStream2() with ZSTD_e_end until it returns 0, at which point you are free to
|
643: /*===== ZSTD_CStream management functions =====*/
|
644: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream(void);
|
645: ZSTDLIB_API size_t ZSTD_freeCStream(ZSTD_CStream* zcs);
|
647: /*===== Streaming compression functions =====*/
|
661: /*! ZSTD_compressStream2() :
|
662: * Behaves about the same as ZSTD_compressStream, with additional control on end directive.
|
682: ZSTDLIB_API size_t ZSTD_compressStream2( ZSTD_CCtx* cctx,
|
689: * They are not required : ZSTD_compressStream*() happily accepts any buffer size, for both input and output.
|
690: * Respecting the recommended size just makes it a bit easier for ZSTD_compressStream*(),
|
707: * It can be replaced by ZSTD_CCtx_reset() and ZSTD_compressStream2().
|
720: ZSTDLIB_API size_t ZSTD_initCStream(ZSTD_CStream* zcs, int compressionLevel);
|
722: * Alternative for ZSTD_compressStream2(zcs, output, input, ZSTD_e_continue).
|
723: * NOTE: The return value is different. ZSTD_compressStream() returns a hint for
|
724: * the next read size (if non-zero and not an error). ZSTD_compressStream2()
|
727: ZSTDLIB_API size_t ZSTD_compressStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
|
728: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_flush). */
|
729: ZSTDLIB_API size_t ZSTD_flushStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
|
730: /*! Equivalent to ZSTD_compressStream2(zcs, output, &emptyInput, ZSTD_e_end). */
|
731: ZSTDLIB_API size_t ZSTD_endStream(ZSTD_CStream* zcs, ZSTD_outBuffer* output);
|
735: * Streaming decompression - HowTo
|
737: * A ZSTD_DStream object is required to track streaming operations.
|
738: * Use ZSTD_createDStream() and ZSTD_freeDStream() to create/release resources.
|
739: * ZSTD_DStream objects can be re-used multiple times.
|
741: * Use ZSTD_initDStream() to start a new decompression operation.
|
745: * Use ZSTD_decompressStream() repetitively to consume your input.
|
752: * In which case, call ZSTD_decompressStream() again to flush whatever remains in the buffer.
|
763: /*===== ZSTD_DStream management functions =====*/
|
764: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream(void);
|
765: ZSTDLIB_API size_t ZSTD_freeDStream(ZSTD_DStream* zds);
|
767: /*===== Streaming decompression functions =====*/
|
774: ZSTDLIB_API size_t ZSTD_initDStream(ZSTD_DStream* zds);
|
776: ZSTDLIB_API size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inBuffer* input);
|
898: * ZSTD_compressStream2(), and ZSTD_decompress(). Dictionaries are sticky, and
|
991: * End of frame is reached when ZSTD_decompressStream() returns 0.
|
996: * reached when ZSTD_decompressStream() returns 0.
|
1012: ZSTDLIB_API size_t ZSTD_sizeof_CStream(const ZSTD_CStream* zcs);
|
1013: ZSTDLIB_API size_t ZSTD_sizeof_DStream(const ZSTD_DStream* zds);
|
1304: * Note : CStream size estimation is only correct for single-threaded compression.
|
1305: * ZSTD_DStream memory budget depends on window Size.
|
1343: * ZSTD_CCtx_loadDictionary(), ZSTD_initCStream_usingDict() or ZSTD_initDStream_usingDict().
|
1348: ZSTDLIB_API ZSTD_CStream* ZSTD_initStaticCStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticCCtx() */
|
1351: ZSTDLIB_API ZSTD_DStream* ZSTD_initStaticDStream(void* workspace, size_t workspaceSize); /**< same as ZSTD_initStaticDCtx() */
|
1378: ZSTDLIB_API ZSTD_CStream* ZSTD_createCStream_advanced(ZSTD_customMem customMem);
|
1380: ZSTDLIB_API ZSTD_DStream* ZSTD_createDStream_advanced(ZSTD_customMem customMem);
|
1540: * - ZSTD_compressStream2() : Do compression using the CCtx.
|
1591: /*! ZSTD_compressStream2_simpleArgs() :
|
1592: * Same as ZSTD_compressStream2(),
|
1597: ZSTDLIB_API size_t ZSTD_compressStream2_simpleArgs (
|
1694: /*! ZSTD_decompressStream_simpleArgs() :
|
1695: * Same as ZSTD_decompressStream(),
|
1700: ZSTDLIB_API size_t ZSTD_decompressStream_simpleArgs (
|
1713: /*===== Advanced Streaming compression functions =====*/
|
1714: /**! ZSTD_initCStream_srcSize() :
|
1727: ZSTD_initCStream_srcSize(ZSTD_CStream* zcs,
|
1731: /**! ZSTD_initCStream_usingDict() :
|
1744: ZSTD_initCStream_usingDict(ZSTD_CStream* zcs,
|
1748: /**! ZSTD_initCStream_advanced() :
|
1764: ZSTD_initCStream_advanced(ZSTD_CStream* zcs,
|
1769: /**! ZSTD_initCStream_usingCDict() :
|
1777: ZSTDLIB_API size_t ZSTD_initCStream_usingCDict(ZSTD_CStream* zcs, const ZSTD_CDict* cdict);
|
1779: /**! ZSTD_initCStream_usingCDict_advanced() :
|
1789: * same as ZSTD_initCStream_usingCDict(), with control over frame parameters.
|
1795: ZSTD_initCStream_usingCDict_advanced(ZSTD_CStream* zcs,
|
1800: /*! ZSTD_resetCStream() :
|
1807: * Note that zcs must be init at least once before using ZSTD_resetCStream().
|
1815: ZSTDLIB_API size_t ZSTD_resetCStream(ZSTD_CStream* zcs, unsigned long long pledgedSrcSize);
|
1851: /*===== Advanced Streaming decompression functions =====*/
|
1861: ZSTDLIB_API size_t ZSTD_initDStream_usingDict(ZSTD_DStream* zds, const void* dict, size_t dictSize);
|
1872: ZSTDLIB_API size_t ZSTD_initDStream_usingDDict(ZSTD_DStream* zds, const ZSTD_DDict* ddict);
|
1882: ZSTDLIB_API size_t ZSTD_resetDStream(ZSTD_DStream* zds);
|
701: ZSTDLIB_API size_t ZSTD_CStreamInSize(void); /**< recommended size for input buffer */
|
702: ZSTDLIB_API size_t ZSTD_CStreamOutSize(void); /**< recommended size for output buffer. Guarantee to successfully flush at least o...(32 bytes skipped)...
|
778: ZSTDLIB_API size_t ZSTD_DStreamInSize(void); /*!< recommended size for input buffer */
|
779: ZSTDLIB_API size_t ZSTD_DStreamOutSize(void); /*!< recommended size for output buffer. Guarantee to successfully flush at least o...(42 bytes skipped)...
|
1276: * Note : Unlike ZSTD_estimateCStreamSize*(), this estimate
|
1298: /*! ZSTD_estimateCStreamSize() :
|
1299: * ZSTD_estimateCStreamSize() will provide a budget large enough for any compression level up to selected one.
|
1301: * If srcSize is known to always be small, ZSTD_estimateCStreamSize_usingCParams() can provide a tighter estimation.
|
1302: * ZSTD_estimateCStreamSize_usingCParams() can be used in tandem with ZSTD_getCParams() to create cParams from compressionL...(5 bytes skipped)...
|
1303: * ZSTD_estimateCStreamSize_usingCCtxParams() can be used in tandem with ZSTD_CCtxParams_setParameter(). Only single-thread...(97 bytes skipped)...
|
1306: * This information can be passed manually, using ZSTD_estimateDStreamSize,
|
1307: * or deducted from a valid frame Header, using ZSTD_estimateDStreamSize_fromFrame();
|
1311: ZSTDLIB_API size_t ZSTD_estimateCStreamSize(int compressionLevel);
|
1312: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCParams(ZSTD_compressionParameters cParams);
|
1313: ZSTDLIB_API size_t ZSTD_estimateCStreamSize_usingCCtxParams(const ZSTD_CCtx_params* params);
|
1314: ZSTDLIB_API size_t ZSTD_estimateDStreamSize(size_t windowSize);
|
1315: ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize);
|
| seqTools:src/dna_fasta_stream.h: [ ] |
|---|
52: } fafStream;
|
207: } faStream;
|
215: void faStream_destroy(faStream *fa)
|
275: faStream * faStream_init(const char* filename, unsigned k, unsigned mode)
|
135: // fasta Stream
|
54: static inline unsigned faf_isEof(fafStream *faf) { return faf->status & faf_file_eof; }
|
55: static inline unsigned faf_isOpen(fafStream *faf)
|
62: static fafStream* faf_stream_init(const char* filename, unsigned mode)
|
64: // Construct fafStream object from opened file
|
65: fafStream *faf = calloc(sizeof(fafStream), 1);
|
87: static void faf_destroy(fafStream *faf)
|
99: static size_t inline faf_read(fafStream *faf, char *dest, unsigned size)
|
187: fafStream *fasta;
|
230: int fas_fill(faStream *fa)
|
279: printf("[faStream_init] k > fas_size!\n");
|
283: faStream *fa = calloc(sizeof(faStream), 1);
|
292: printf("[faStream_init] Cannot open file '%s'!\n", filename);
|
293: faStream_destroy(fa);
|
308: printf("[faStream_init] Initial array filling failed!\n");
|
309: faStream_destroy(fa);
|
321: static inline int fas_fas_end(faStream *fa) { return fa->ffc == 0; }
|
322: static inline int fas_nuc_end(faStream *fa) { return fa->fnc == 0; }
|
333: static inline int fas_checkNewLine(faStream *fa)
|
343: static inline int fas_skipNewLine(faStream *fa)
|
366: static inline int fas_skipLine(faStream *fa)
|
386: static inline int fas_checkNewSeq(faStream *fa)
|
399: static inline int fas_skipSeqHeader(faStream *fa)
|
412: static inline int fas_checkComment(faStream *fa)
|
422: static inline int fas_skipComment(faStream *fa)
|
435: static inline int fas_checkN(faStream *fa)
|
445: static inline int fas_skipN(faStream *fa)
|
496: char * fas_getSeqName(faStream *fa)
|
551: int fas_initSeq(faStream *fa)
|
592: static inline int fas_returnFromTranfer(faStream *fa)
|
626: int fas_TransferNucArray(faStream *fa)
|
697: int fa_empty(faStream *fa) { return (fa->stream_state & fas_stream_empty); }
|
698: int fa_NucReady(faStream *fa) { return (fa->stream_state & fas_nuc_ready); }
|
699: int fa_K_Ready(faStream *fa) { return (fa->stream_state & fas_loc_kReady); }
|
700: int fa_NewSeq(faStream *fa) { return (fa->stream_state & fas_loc_newSeq); }
|
701: int fa_N_Nuc(faStream *fa) { return (ACGTN[(unsigned)*fa->iter] == nval); }
|
704: void fa_unsetNucReady(faStream *fa)
|
| interacCircos:inst/htmlwidgets/lib/d3.js: [ ] |
|---|
3639: function d3_geo_pathProjectStream(project) {
|
3271: var lower48Stream = lower48.stream(stream), alaskaStream = alaska.stream(stream), hawaiiStream = hawaii.stream(stream);
|
3274: lower48Stream.point(x, y);
|
3279: lower48Stream.sphere();
|
3284: lower48Stream.lineStart();
|
3289: lower48Stream.lineEnd();
|
3294: lower48Stream.polygonStart();
|
3299: lower48Stream.polygonEnd();
|
3255: var point, pointStream = {
|
3275: alaskaStream.point(x, y);
|
3276: hawaiiStream.point(x, y);
|
3280: alaskaStream.sphere();
|
3281: hawaiiStream.sphere();
|
3285: alaskaStream.lineStart();
|
3286: hawaiiStream.lineStart();
|
3290: alaskaStream.lineEnd();
|
3291: hawaiiStream.lineEnd();
|
3295: alaskaStream.polygonStart();
|
3296: hawaiiStream.polygonStart();
|
3300: alaskaStream.polygonEnd();
|
3301: hawaiiStream.polygonEnd();
|
3322: ...(33 bytes skipped)...slate(_).clipExtent([ [ x - .455 * k, y - .238 * k ], [ x + .455 * k, y + .238 * k ] ]).stream(pointStream).point;
|
3323: ...(79 bytes skipped)...([ [ x - .425 * k + ε, y + .12 * k + ε ], [ x - .214 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
|
3324: ...(80 bytes skipped)...[ [ x - .214 * k + ε, y + .166 * k + ε ], [ x - .115 * k - ε, y + .234 * k - ε ] ]).stream(pointStream).point;
|
3593: var pointRadius = 4.5, projection, context, projectStream, contextStream, cacheStream;
|
3596: if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
|
3597: if (!cacheStream || !cacheStream.valid) cacheStream = projectStream(contextStream);
|
3598: d3.geo.stream(object, cacheStream);
|
3600: return contextStream.result();
|
3604: d3.geo.stream(object, projectStream(d3_geo_pathArea));
|
3609: d3.geo.stream(object, projectStream(d3_geo_pathCentroid));
|
3614: d3.geo.stream(object, projectStream(d3_geo_pathBounds));
|
3619: projectStream = (projection = _) ? _.stream || d3_geo_pathProjectStream(_) : d3_identity;
|
3624: contextStream = (context = _) == null ? new d3_geo_pathBuffer() : new d3_geo_pathContext(_);
|
3625: if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
|
3630: pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
|
3634: cacheStream = null;
|
| Gviz:R/AnnotationTrack-class.R: [ ] |
|---|
327: isStream <- FALSE
|
350: isStream <- TRUE
|
363: if (!isStream) {
|
| rtracklayer:src/ucsc/bbiFile.h: [ ] |
|---|
299: struct bbiSumOutStream
|
309: struct bbiSumOutStream *bbiSumOutStreamOpen(int allocCount, FILE *f, boolean doCompress);
|
310: /* Open new bbiSumOutStream. */
|
312: void bbiSumOutStreamClose(struct bbiSumOutStream **pStream);
|
313: /* Free up bbiSumOutStream */
|
315: void bbiSumOutStreamWrite(struct bbiSumOutStream *stream, struct bbiSummary *sum);
|
322: struct bbiSumOutStream *stream);
|
| Cardinal:R/utils.R: [ ] |
|---|
401: getRNGStream <- function() {
|
410: setRNGStream <- function(seed = NULL) {
|
416: generateRNGStreams <- function(n = 1) {
|
418: s <- getRNGStream()
|
427: s <- nextRNGStream(seeds[[i - 1]])
|
| Glimma:inst/htmlwidgets/lib/datatables/JSZip-2.5.0/jszip.js: [ ] |
|---|
9127: function ZStream() {
|
9152: module.exports = ZStream;
|
| BUSseq:src/rngstream.cpp: [ ] |
|---|
303: RngStream::RngStream (const char *s) : name (s)
|
327: void RngStream::ResetStartStream ()
|
325: // Reset Stream to beginning of Stream.
|
335: // Reset Stream to beginning of SubStream.
|
345: // Reset Stream to NextSubStream.
|
3: * File: RngStream.cpp for multiple streams of Random Numbers
|
242: double RngStream::U01 ()
|
271: double RngStream::U01d ()
|
292: // declared RngStream, unless SetPackageSeed is called.
|
294: double RngStream::nextSeed[6] =
|
309: state of the stream, the starting state of the current SubStream, and the
|
313: will be the seed of the next declared RngStream. */
|
337: void RngStream::ResetStartSubstream ()
|
347: void RngStream::ResetNextSubstream ()
|
357: bool RngStream::SetPackageSeed (const unsigned long seed[6])
|
368: bool RngStream::SetSeed (const unsigned long seed[6])
|
384: void RngStream::AdvanceState (long e, long c)
|
415: void RngStream::GetState (unsigned long seed[6]) const
|
424: void RngStream::WriteState () const
|
439: void RngStream::WriteStateFull () const
|
443: cout << "The RngStream";
|
470: void RngStream::IncreasedPrecis (bool incp)
|
477: void RngStream::SetAntithetic (bool a)
|
486: double RngStream::RandU01 ()
|
498: int RngStream::RandInt (int low, int high)
|
| affxparser:src/fusion/calvin_files/data/src/DataSet.cpp: [ ] |
|---|
161: void DataSet::ReadDataSetUsingStream()
|
327: void DataSet::ClearStreamData()
|
71: fileStream = 0;
|
95: fileStream = &ifs;
|
129: ReadDataSetUsingStream();
|
170: fileStream->seekg(mapStart);
|
171: fileStream->read(data, mapLen);
|
444: fileStream->seekg(mapStart);
|
445: fileStream->read(data, mapLen);
|
182: ClearStreamData();
|
438: ClearStreamData();
|
| RProtoBufLib:src/GatingSet_pb_lib/GatingSet.pb.cc: [ ] |
|---|
1395: bool paramRange::MergePartialFromCodedStream(
|
1747: bool rangeGate::MergePartialFromCodedStream(
|
2025: bool paramPoly::MergePartialFromCodedStream(
|
2378: bool polygonGate::MergePartialFromCodedStream(
|
2685: bool coordinate::MergePartialFromCodedStream(
|
3030: bool ellipseGate::MergePartialFromCodedStream(
|
3432: bool BOOL_GATE_OP::MergePartialFromCodedStream(
|
3772: bool boolGate::MergePartialFromCodedStream(
|
4041: bool clusterGate::MergePartialFromCodedStream(
|
4330: bool quadGate::MergePartialFromCodedStream(
|
4795: bool gate::MergePartialFromCodedStream(
|
5341: bool POPSTATS::MergePartialFromCodedStream(
|
5740: bool calibrationTable::MergePartialFromCodedStream(
|
6391: bool biexpTrans::MergePartialFromCodedStream(
|
6814: bool fasinhTrans::MergePartialFromCodedStream(
|
7219: bool scaleTrans::MergePartialFromCodedStream(
|
7552: bool flinTrans::MergePartialFromCodedStream(
|
7869: bool logTrans::MergePartialFromCodedStream(
|
8234: bool logGML2Trans::MergePartialFromCodedStream(
|
8575: bool logicleTrans::MergePartialFromCodedStream(
|
9284: bool transformation::MergePartialFromCodedStream(
|
10062: bool trans_pair::MergePartialFromCodedStream(
|
10436: bool trans_local::MergePartialFromCodedStream(
|
10850: bool POPINDICES::MergePartialFromCodedStream(
|
11335: bool nodeProperties::MergePartialFromCodedStream(
|
11819: bool treeNodes::MergePartialFromCodedStream(
|
12116: bool populationTree::MergePartialFromCodedStream(
|
12488: bool COMP::MergePartialFromCodedStream(
|
13149: bool PARAM::MergePartialFromCodedStream(
|
13673: bool GatingHierarchy::MergePartialFromCodedStream(
|
14109: bool CytoFrame::MergePartialFromCodedStream(
|
14392: bool TRANS_TBL::MergePartialFromCodedStream(
|
14804: bool GatingSet::MergePartialFromCodedStream(
|
1396: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
1468: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
1748: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
1790: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
2026: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
2084: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
2379: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
2432: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
2686: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
2743: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
3031: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
3108: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
3433: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
3506: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
3773: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
3815: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
4042: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
4088: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
4331: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
4391: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
4796: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
4935: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
5342: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
5401: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
5741: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
5893: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
5982: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
5995: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6008: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6021: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6034: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
6392: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
6488: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
6815: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
6911: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
7220: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
7290: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
7553: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
7610: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
7870: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
7953: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
8235: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
8292: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
8576: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
8698: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
9285: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
9487: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
10063: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
10133: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
10437: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
10510: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
10583: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
10851: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
10936: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
10999: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
11336: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
11439: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
11820: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
11875: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
12117: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
12159: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
12489: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
12643: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
12811: target = ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream::WriteVarint32ToArray(
|
13150: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
13248: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
13674: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
13773: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
14110: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
14154: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
14393: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
14448: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
14805: ::PROTOBUF_NAMESPACE_ID::io::CodedInputStream* input) {
|
14960: ::PROTOBUF_NAMESPACE_ID::io::CodedOutputStream* output) const {
|
| RSeqAn:inst/include/seqan/stream/file_stream.h: [ ] |
|---|
1138: class FileStream :
|
1143: typedef typename BasicStream<TValue, TDirection>::Type TBasicStream;
|
1147: FileStream() :
|
1151: FileStream(const char * fileName, int openMode = DefaultOpenMode<FileStream>::VALUE) :
|
1157: ~FileStream()
|
1198: typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
|
1215: typedef FileStreamBuffer<TValue, TDirection, TSpec> TStream_;
|
804: struct FileStreamBuffer :
|
831: FileStreamBuffer()
|
836: ~FileStreamBuffer()
|
1142: typedef FileStreamBuffer<TValue, TDirection, TSpec> TStreamBuffer;
|
1115: class FileStream;
|
1119: close(FileStream<TValue, TDirection, TSpec> & stream);
|
1130: struct DefaultOpenMode<FileStream<TValue, TDirection, TSpec>, TDummy>:
|
1134: // Class FileStream
|
1139: public BasicStream<TValue, TDirection>::Type
|
1148: TBasicStream(&buffer)
|
1152: TBasicStream(&buffer)
|
1188: struct Value<FileStream<TValue, TDirection, TSpec> >:
|
1199: typedef typename TStream_::TFile TFile_;
|
1205: struct Position<FileStream<TValue, TDirection, TSpec> >:
|
1216: typedef typename TStream_::TFile TFile_;
|
1222: struct Size<FileStream<TValue, TDirection, TSpec> >:
|
1230: SEQAN_CONCEPT_IMPL((FileStream<TValue, Input, TSpec>), (InputStreamConcept));
|
1233: SEQAN_CONCEPT_IMPL((FileStream<TValue, Output, TSpec>), (OutputStreamConcept));
|
1236: SEQAN_CONCEPT_IMPL((FileStream<TValue, Bidirectional, TSpec>), (BidirectionalStreamConcept));
|
1257: open(FileStream<TValue, TDirection, TSpec> & stream, const char * fileName, int openMode = DefaultOpenMode<FileStream<TValue, TDirection, TSpec> >::VALUE)
|
1301: close(FileStream<TValue, TDirection, TSpec> & stream)
|
800: // Class FileStreamBuffer
|
1099: clear(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
|
1145: TStreamBuffer buffer;
|
1182: struct Value<FileStreamBuffer<TValue, TDirection, TSpec> >
|
1189: Value<FileStreamBuffer<TValue, TDirection, TSpec> >{};
|
1196: struct Position<FileStreamBuffer<TValue, TDirection, TSpec> >
|
1206: Position<FileStreamBuffer<TValue, TDirection, TSpec> >{};
|
1213: struct Size<FileStreamBuffer<TValue, TDirection, TSpec> >
|
1223: Size<FileStreamBuffer<TValue, TDirection, TSpec> >{};
|
1293: close(FileStreamBuffer<TValue, TDirection, TSpec> & buffer)
|
| RSeqAn:inst/include/seqan/basic/basic_stream.h: [ ] |
|---|
446: struct BasicStream :
|
47: struct StreamIterator;
|
56: inline void writeValue(Iter<TContainer, StreamIterator<Output> > &iter, TValue val);
|
94: // Concept StreamConcept
|
98: * @concept StreamConcept
|
103: * @signature concept StreamConcept;
|
107: * @mfn StreamConcept#Value
|
110: * @signature Value<TStream>::Type;
|
112: * @tparam TStream The stream type to query for its value type.
|
117: * @mfn StreamConcept#Size
|
120: * @signature Size<TStream>::Type;
|
122: * @tparam TStream The stream type to query for its size type.
|
127: * @mfn StreamConcept#Position
|
130: * @signature Position<TStream>::Type;
|
132: * @tparam TStream The stream type to query for its position type.
|
137: * @fn StreamConcept#position
|
143: * @return TPosition Current position in stream, see @link StreamConcept#Position Position @endlink.
|
147: * @fn StreamConcept#setPosition
|
157: * @fn StreamConcept#atEnd
|
166: SEQAN_CONCEPT(StreamConcept, (TStream))
|
174: * @concept InputStreamConcept Input StreamConcept
|
175: * @extends StreamConcept
|
178: * @signature concept InputStreamConcept : StreamConcept;
|
183: SEQAN_CONCEPT_REFINE(InputStreamConcept, (TStream), (StreamConcept))
|
185: typedef typename Value<TStream>::Type TValue;
|
186: typedef typename Size<TStream>::Type TSize;
|
187: typedef typename Position<TStream>::Type TPosition;
|
200: * @concept OutputStreamConcept Output StreamConcept
|
201: * @extends StreamConcept
|
204: * @signature concept OutputStreamConcept : StreamConcept;
|
209: SEQAN_CONCEPT_REFINE(OutputStreamConcept, (TStream), (StreamConcept))
|
211: typedef typename Value<TStream>::Type TValue;
|
212: typedef typename Size<TStream>::Type TSize;
|
213: typedef typename Position<TStream>::Type TPosition;
|
226: * @concept BidirectionalStreamConcept Bidirectional StreamConcept
|
227: * @extends StreamConcept
|
230: * @signature concept BidirectionalStreamConcept : StreamConcept;
|
235: SEQAN_CONCEPT_REFINE(BidirectionalStreamConcept, (TStream), (InputStreamConcept)(OutputStreamConcept))
|
402: * @mfn StreamConcept#DirectionIterator
|
405: * @signature DirectionIterator<TStream>::Type;
|
407: * @tparam TStream The stream to query for its direction iterator.
|
423: If<Is<StreamConcept<TObject> >,
|
424: Iter<TObject, StreamIterator<TDirection> >,
|
429: // Metafunction BasicStream
|
433: * @mfn BasicStream
|
437: * @signature BasicStream<TValue, TDirection[, TTraits]>::Type;
|
991: // NOTE(esiragusa): should it be defined for Streams and Containers?
|
1302: template <typename TStream, typename TIterator>
|
1303: inline TStream &
|
1304: operator<<(TStream & target,
|
1307: typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
|
1312: template <typename TStream, typename TValue>
|
1313: inline TStream &
|
1314: operator<<(TStream & target,
|
1317: typename DirectionIterator<TStream, Output>::Type it = directionIterator(target, Output());
|
170: // Concept InputStreamConcept
|
191: SEQAN_CONCEPT_USAGE(InputStreamConcept)
|
196: // Concept OutputStreamConcept
|
217: SEQAN_CONCEPT_USAGE(OutputStreamConcept)
|
222: // Concept BidirectionalStreamConcept
|
916: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
|
924: inline SEQAN_FUNC_ENABLE_IF(Is< OutputStreamConcept<TTarget> >, void)
|
994: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
|
1026: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
|
1041: //inline SEQAN_FUNC_ENABLE_IF(Or<Is<OutputStreamConcept<TTarget> >, Is<ContainerConcept<TTarget> > >, void)
|
| MACPET:R/Stage_0_FilteringLinkersFunctions.R: [ ] |
|---|
103: Streamfastq1 = ShortRead::FastqStreamer(con = S0_fastq1, n = S0_fastqStream)
|
104: Streamfastq2 = ShortRead::FastqStreamer(con = S0_fastq2, n = S0_fastqStream)
|
101: # Stream the fastq files:
|
8: S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_image, S0_fastqStream,
|
27: S0_LinkerOccurence = S0_LinkerOccurence, S0_fastqStream = S0_fastqStream,
|
98: S0_MinReadLength, S0_MaxReadLength, S0_LinkerOccurence, S0_fastqStream, S0_Totfastqreads,
|
128: fastq1yield = ShortRead::yield(Streamfastq1)
|
130: fastq2yield = ShortRead::yield(Streamfastq2)
|
216: close(Streamfastq1)
|
217: close(Streamfastq2)
|
1: #' @importFrom ShortRead FastqStreamer yield writeFastq
|
3: #' @importClassesFrom ShortRead FastqStreamer ShortReadQ SFastqQuality SRFilterResult
|
| mzR:src/boost/nowide/fstream.hpp: [ ] |
|---|
23: struct StreamTypeIn
|
32: struct StreamTypeOut
|
41: struct StreamTypeInOut
|
56: /// \tparam T_StreamType One of StreamType* above.
|
61: typename T_StreamType,
|
72: class basic_ifstream : public detail::fstream_impl<CharType, Traits, detail::StreamTypeIn>
|
74: using fstream_impl = detail::fstream_impl<CharType, Traits, detail::StreamTypeIn>;
|
123: class basic_ofstream : public detail::fstream_impl<CharType, Traits, detail::StreamTypeOut>
|
125: using fstream_impl = detail::fstream_impl<CharType, Traits, detail::StreamTypeOut>;
|
175: class basic_fstream : public detail::fstream_impl<CharType, Traits, detail::StreamTypeInOut>
|
177: using fstream_impl = detail::fstream_impl<CharType, Traits, detail::StreamTypeInOut>;
|
272: template<typename CharType, typename Traits, typename T_StreamType, int>
|
274: public T_StreamType::template stream_base<CharType, Traits>::type
|
278: using stream_base = typename T_StreamType::template stream_base<CharType, Traits>::type;
|
310: void open(const std::string& file_name, std::ios_base::openmode mode = T_StreamType::mode())
|
316: std::ios_base::openmode mode = T_StreamType::mode())
|
320: void open(const char* file_name, std::ios_base::openmode mode = T_StreamType::mode())
|
322: if(!rdbuf()->open(file_name, mode | T_StreamType::mode_modifier()))
|
328: void open(const wchar_t* file_name, std::ios_base::openmode mode = T_StreamType::mode())
|
330: if(!rdbuf()->open(file_name, mode | T_StreamType::mode_modifier()))
|
| seqTools:src/dna_astream.h: [ ] |
|---|
87: } daStream;
|
55: dfStream *dnaf;
|
95: static inline int dasEmpty(daStream *das) { return das->r_iter == das->r_end; }
|
96: static inline int dasProcEmpty(daStream *das) { return das->p_iter == das->p_end; }
|
97: static inline int dasIsError(daStream *das) { return das->state & das_err; }
|
98: static inline int dasIsOpen(daStream *das) { return dfs_isOpen(das->dnaf); }
|
99: static inline int dasIsEof(daStream *das) { return dfs_stream_eof(das->dnaf); }
|
107: void das_destroy(daStream *das)
|
122: int das_fill(daStream *das)
|
176: daStream * das_init(const char* filename, unsigned das_size)
|
178: daStream *das = calloc(sizeof(daStream), 1);
|
| Rfastp:src/FASTP/seprocessor.h: [ ] |
|---|
68: ofstream* mOutStream;
|
| diffUTR:README.md: [ ] |
|---|
3: ## Streamlining differential exon and 3' UTR usage analysis
|
| BUSseq:src/rngstream.h: [ ] |
|---|
8: class RngStream
|
12: RngStream (const char *name = "");
|
18: void ResetStartStream ();
|
| CoGAPS:src/utils/Archive.h: [ ] |
|---|
86: std::fstream mStream;
|
24: mStream(path.c_str(), std::ios::binary | flags)
|
43: mStream.close();
|
49: ar.mStream.write(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
|
56: ar.mStream.read(reinterpret_cast<char*>(&val), sizeof(T)); // NOLINT
|
| beachmat:inst/include/byteme/ZlibBufferReader.hpp: [ ] |
|---|
27: struct ZStream {
|
28: ZStream(int mode) {
|
56: ~ZStream() {
|
62: ZStream(const ZStream&) = delete;
|
63: ZStream(ZStream&&) = delete;
|
64: ZStream& operator=(const ZStream&) = delete;
|
65: ZStream& operator=(ZStream&&) = delete;
|
126: ZStream zstr;
|
| chromDraw:src/libBoard/include/board/Tools.h: [ ] |
|---|
57: class MessageStream {
|
74: MessageStream::MessageStream( std::ostream & out, const char * prefix )
|
60: inline MessageStream( std::ostream & out, const char * prefix );
|
63: inline MessageStream operator<<( const T & v );
|
70: extern MessageStream error;
|
71: extern MessageStream warning;
|
72: extern MessageStream notice;
|
81: MessageStream MessageStream::operator<<( const T & v )
|
87: return MessageStream( _out, 0 );
|
| Streamer:R/stream-methods.R: [ ] |
|---|
1: .Stream_set <- function(x, ..., verbose)
|
25: .Stream$new(inputPipe=inputPipe, verbose=verbose)
|
28: setMethod(Stream, "Producer",
|
32: .Stream_set(x, verbose=verbose)
|
34: do.call(Stream, c(rev(list(..., verbose=verbose)), list(x)))
|
37: setMethod(Stream, "Consumer", .Stream_set)
|
3: ## helper used to construct Streams
|
| Streamer:R/Streamer-class.R: [ ] |
|---|
1: .Streamer <- setRefClass("Streamer",
|
6: .Streamer$methods(
|
9: "initialize 'Streamer'"
|
20: "reset Streamer() -- noop"
|
21: if (verbose) msg("Streamer$reset()")
|
27: if (verbose) msg("Streamer$yield()")
|
33: if (verbose) msg("Streamer$status()")
|
41: setMethod(reset, "Streamer", function(x, ...) x$reset())
|
43: setMethod(yield, "Streamer", function(x, ...) x$yield())
|
45: setMethod(status,"Streamer", function(x, ...) x$status())
|
| msa:src/ClustalW/src/Makefile.in: [ ] |
|---|
635: InFileStream.o: ./fileInput/InFileStream.cpp
|
642: InFileStream.obj: ./fileInput/InFileStream.cpp
|
61: InFileStream.$(OBJEXT) ClustalFileParser.$(OBJEXT) \
|
266: ./fileInput/InFileStream.cpp \
|
269: ./fileInput/InFileStream.h \
|
488: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/InFileStream.Po@am__quote@
|
636: ...(33 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.o -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
|
637: @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
|
638: @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='./fileInput/InFileStream.cpp' object='InFileStream.o' libtool=no @AMDEPBACKSLASH@
|
640: ...(36 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
|
643: ...(33 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.obj -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
|
644: @am__fastdepCXX_TRUE@ $(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
|
645: @AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='./fileInput/InFileStream.cpp' object='InFileStream.obj' libtool=no @AMDEPBACKSLASH@
|
647: ...(36 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
|
| msa:src/ClustalW/windows/src/Makefile: [ ] |
|---|
635: InFileStream.o: ./fileInput/InFileStream.cpp
|
642: InFileStream.obj: ./fileInput/InFileStream.cpp
|
61: InFileStream.$(OBJEXT) ClustalFileParser.$(OBJEXT) \
|
266: ./fileInput/InFileStream.cpp \
|
269: ./fileInput/InFileStream.h \
|
488: # ./$(DEPDIR)/InFileStream.Po
|
636: ...(13 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.o -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
|
637: # $(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
|
638: source='./fileInput/InFileStream.cpp' object='InFileStream.o' libtool=no \
|
640: ...(14 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.o `test -f './fileInput/InFileStream.cpp' || echo '$(srcdir)/'`./fileInput/InFileStream.cpp
|
643: ...(13 bytes skipped)...FS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT InFileStream.obj -MD -MP -MF $(DEPDIR)/InFileStream.Tpo -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
|
644: # $(am__mv) $(DEPDIR)/InFileStream.Tpo $(DEPDIR)/InFileStream.Po
|
645: source='./fileInput/InFileStream.cpp' object='InFileStream.obj' libtool=no \
|
647: ...(14 bytes skipped)...) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o InFileStream.obj `if test -f './fileInput/InFileStream.cpp'; then $(CYGPATH_W) './fileInput/InFileStream.cpp'; else $(CYGPATH_W) '$(srcdir)/./fileInput/InFileStream.cpp'; fi`
|
| mzR:src/pwiz/analysis/spectrum_processing/SpectrumList_MZRefiner.cpp: [ ] |
|---|
1329: shared_ptr<ofstream> statStream_;
|
1394: statStream_ = openFilestreamIfWritable(statFilepath, fileExists);
|
1395: if (!statStream_) statStream_ = openFilestreamIfWritable(statFilepath.filename(), fileExists);
|
1396: if (!statStream_) statStream_ = openFilestreamIfWritable(bfs::temp_directory_path() / statFilepath.filename(), fileExists);
|
1397: if (!statStream_) throw runtime_error("[SpectrumList_MZRefiner::configureShift] unable to open a writable mzRefinem...(17 bytes skipped)...
|
1401: *statStream_ << "ThresholdScore\tThresholdValue\tExcluded (score)\tExcluded (mass error)"
|
2236: *statStream_ << statsRow.str();
|
2237: statStream_->close();
|
| Rfastp:src/FASTP/peprocessor.h: [ ] |
|---|
74: ofstream* mOutStream1;
|
75: ofstream* mOutStream2;
|
| rhdf5filters:src/blosc/lib/zstd-1.4.5/compress/zstd_compress_internal.h: [ ] |
|---|
50: typedef enum { zcss_init=0, zcss_load, zcss_flush } ZSTD_cStreamStage;
|
1066: /*! ZSTD_initCStream_internal() :
|
1071: size_t ZSTD_initCStream_internal(ZSTD_CStream* zcs,
|
273: ZSTD_cStreamStage streamStage;
|
| HTSeqGenie:R/io.R: [ ] |
|---|
102: FastQStreamer.init <- function(input_file, input_file2=NULL, chunk_size, subsample_nbreads=NULL, max_nbchunks=N...(6 bytes skipped)...
|
144: FastQStreamer.lfqs <<- lfqs
|
145: FastQStreamer.chunkid <<- 0
|
146: FastQStreamer.subsampling_filter <<- subsampling_filter
|
148: if (is.null(max_nbchunks)) FastQStreamer.max_nbchunks <<- Inf
|
160: FastQStreamer.getReads <- function() {
|
163: FastQStreamer.lfqs <- NULL ## to avoid the 'no visible binding' R CMD check warning
|
164: FastQStreamer.chunkid <- NULL ## to avoid the 'no visible binding' R CMD check warning
|
165: FastQStreamer.max_nbchunks <- NULL ## to avoid the 'no visible binding' R CMD check warning
|
166: FastQStreamer.subsampling_filter <- NULL ## to avoid the 'no visible binding' R CMD check warning
|
210: FastQStreamer.release <- function() {
|
213: FastQStreamer.lfqs <- NULL ## to avoid the 'no visible binding' R CMD check warning
|
70: ##' @importMethodsFrom ShortRead FastqStreamer
|
75: fqs <- FastqStreamer(con, n=1e6)
|
88: ##' Only one FastQStreamer object can be open at any time.
|
96: ##' @seealso FastQStreamer.getReads
|
112: loginfo(paste("io.R/FastQStreamer.init: counting number of reads in file=", input_file))
|
125: loginfo(paste("io.R/FastQStreamer.init: subsampling_filter set (subsampled reads=", subsample_nbreads,
|
128: loginfo(paste("io.R/FastQStreamer.init: the requested number of subsampled reads=", subsample_nbreads,
|
139: fqs <- FastqStreamer(con1, n=chunk_size)
|
140: loginfo(paste("io.R/FastQStreamer.init: initialised FastQ streamer for filename=", filename))
|
149: else FastQStreamer.max_nbchunks <<- as.integer(max_nbchunks)
|
157: ##' @seealso FastQStreamer.init
|
162: if (!exists("FastQStreamer.lfqs")) {
|
167: stop("io.R/FastQStreamer.getReads: FastQStreamer.init() has not been called")
|
171: lfqs <- FastQStreamer.lfqs
|
177: stop("io.R/FastQStreamer.getReads: input files must have the same number of reads")
|
181: FastQStreamer.chunkid <<- FastQStreamer.chunkid + 1
|
182: if (length(lreads[[1]])==0 || FastQStreamer.chunkid>FastQStreamer.max_nbchunks) lreads <- NULL
|
185: if (!is.null(FastQStreamer.subsampling_filter)) {
|
188: z <- FastQStreamer.subsampling_filter[1:len]
|
191: FastQStreamer.subsampling_filter <<- FastQStreamer.subsampling_filter[-(1:len)]
|
193: ## stop("io.R/FastQStreamer.getReads: (known bug) the chunk is empty after subsampling. I won't process an empty chunk! Pleas...(69 bytes skipped)...
|
202: ##' Close the FastQStreamer
|
204: ##' @title Close the FastQStreamer
|
206: ##' @seealso FastQStreamer.init
|
212: if (!exists("FastQStreamer.lfqs")) {
|
214: stop("io.R/FastQStreamer.release: FastQStreamer.init() has not been called")
|
217: invisible(lapply(FastQStreamer.lfqs, close))
|
382: fqs <- FastqStreamer(con, n=nreads)
|
473: ##' Overloaded yield(...) method catching truncated exceptions for FastqStreamer
|
475: ##' @title Overloaded yield(...) method catching truncated exceptions for FastqStreamer
|
476: ##' @param fqs An instance from the FastqSampler or FastqStreamer class.
|
477: ##' @return Same as FastqStreamer::yield
|
| DEsubs:R/subpathwayAnalysis.R: [ ] |
|---|
72: subStreamCases <- apply(cases, 1, function(x) {paste0(x, collapse='.')})
|
7: supportedMethods <- c( subTypes[['subStreamCases']],
|
89: 'subStreamCases'=subStreamCases,
|
167: if ( method %in% subTypes[['subStreamCases']] )
|