bool CBasicFastaWrapper::ReadFile(CNcbiIstream& iStream) { bool result = (iStream.good()); if (!result) { m_error = "Read Error: invalid stream.\n"; } else { CNcbiOstrstream oss; oss << iStream.rdbuf(); iStream.seekg(0); m_activeFastaString = CNcbiOstrstreamToString(oss); if (m_cacheRawFasta) m_rawFastaString = m_activeFastaString; // temporarily turn off warning messages (in case of '.' in *.a2m files) EDiagSev originalDiagSev = SetDiagPostLevel(eDiag_Error); try{ CStreamLineReader lineReader(iStream); CFastaReader fastaReader(lineReader, m_readFastaFlags); //CCounterManager counterMgr(reader.SetIDGenerator(), NULL); m_seqEntry = fastaReader.ReadSet(); // If there is only one sequence in the fasta, the Seq-entry returned is a Bioseq and not a Bioseq-set. // In that case, change the Bioseq to a Bioseq-set so caller doesn't have to manage multiple Seq-entry choices. if (m_seqEntry->IsSeq() && m_useBioseqSet) { CRef<CSeq_entry> bioseqFromFasta(new CSeq_entry); bioseqFromFasta->Assign(*m_seqEntry); m_seqEntry->Select(CSeq_entry::e_Set); m_seqEntry->SetSet().SetSeq_set().push_back(bioseqFromFasta); } } catch (...) { result = false; m_seqEntry.Reset(); } if (m_seqEntry.Empty()) { result = false; m_error = "Read Error: empty seq entry.\n"; } SetDiagPostLevel(originalDiagSev); } return result; }
// ---------------------------------------------------------------------------- void CMultiReaderApp::xProcessNewick( const CArgs& args, CNcbiIstream& istr, CNcbiOstream& ostr) // ---------------------------------------------------------------------------- { string strTree; char c = istr.get(); while (!istr.eof()) { strTree += c; if (c == ';') { CNcbiIstrstream istrstr(strTree.c_str()); auto_ptr<TPhyTreeNode> pTree(ReadNewickTree(istrstr) ); CRef<CBioTreeContainer> btc = MakeBioTreeContainer(pTree.get()); xWriteObject(*btc, ostr); strTree.clear(); } c = istr.get(); } }
/** **\brief Object constructor. ** **\param newInputStream input stream to read data from. **\param is_nucl true if the input is DNA, false if it is protein **\param parse_seqids false to disable parsing of deflines ** **/ CMaskFastaReader( CNcbiIstream & newInputStream, bool is_nucl = true, bool parse_seqids = false ) : CMaskReader( newInputStream ), is_nucleotide_(is_nucl), parse_seqids_(parse_seqids), fasta_reader_( newInputStream, CONST_FLAGS | (is_nucl ? objects::CFastaReader::fAssumeNuc : objects::CFastaReader::fAssumeProt) | (parse_seqids ? 0 : objects::CFastaReader::fNoParseID) ) { if( !newInputStream && !newInputStream.eof() ) { NCBI_THROW( Exception, eBadStream, "bad stream state at fasta mask reader initialization" ); } }
void CAlnMrgApp::LoadSeqEntry(CNcbiIstream& is) { string se_asn_type; {{ auto_ptr<CObjectIStream> obj_is (CObjectIStream::Open(eSerial_AsnText, is)); se_asn_type = obj_is->ReadFileHeader(); obj_is->Close(); is.seekg(0); }} auto_ptr<CObjectIStream> obj_is (CObjectIStream::Open(eSerial_AsnText, is)); if (se_asn_type == "Seq-entry") { CRef<CSeq_entry> se (new CSeq_entry); *obj_is >> *se; GetScope().AddTopLevelSeqEntry(*se); } else {
// Helper function for loading alignments. Returns number of alignments loaded // into the container. The expected format is: // <int-number-of-alignments> // <Seq-align>+ size_t LoadAligns(CNcbiIstream& in, CAlnContainer& aligns, size_t limit = 0) { size_t num_aligns = 0; while ( !in.eof() ) { try { CRef<CSeq_align> align(new CSeq_align); in >> MSerial_AsnText >> *align; align->Validate(true); aligns.insert(*align); num_aligns++; if (limit > 0 && num_aligns >= limit) break; } catch (CIOException e) { break; } } return num_aligns; }
/////////////////////////////////////////////////////// /// /// Read a string from a stream. The string is following /// by its size /// inline string ReadStringFromStream(CNcbiIstream& is) { string str; if (!is.good() || is.eof()) return str; size_t size; is >> size; if (!is.good() || is.eof()) return str; vector<char> buf(size+1, 0); is.read(&*buf.begin(), size+1); size_t count = is.gcount(); if (count > 0) str.append((&*buf.begin())+1, count-1); return str; }
void g_GZip_ScanForChunks(CNcbiIstream& is, IChunkHandler& handler) { typedef IChunkHandler::TPosition TPos; // Use our own total counters to avoid 4GB limit TPos in_total = 0; // Offset in input compressed data TPos out_total = 0; // Offset in output decompressed data z_stream strm; // Compressed stream structure int ret = Z_STREAM_END; // zlib return status bool initialized = false; // Default buffer size size_t in_size = kCompressionDefaultBufSize; size_t out_size = kCompressionDefaultBufSize * 2; // Allocate buffers AutoArray<unsigned char> in_buf_arr(in_size); unsigned char* in_buf = in_buf_arr.get(); if ( !in_buf ) { NCBI_THROW(CCoreException, eNullPtr, kEmptyStr); } AutoArray<unsigned char> out_buf_arr(out_size); unsigned char* out_buf = out_buf_arr.get(); if ( !out_buf ) { NCBI_THROW(CCoreException, eNullPtr, kEmptyStr); } try { IChunkHandler::EAction action = IChunkHandler::eAction_Continue; // Process all decompressed data in the input stream while ( is && action != IChunkHandler::eAction_Stop) { // Get some compressed data is.read((char*)in_buf, in_size); size_t nread = (size_t)is.gcount(); if ( !nread ) { break; } // Process all data in the buffer strm.next_in = in_buf; strm.avail_in = (unsigned int)nread; do { // Next gzip-file? if (ret == Z_STREAM_END) { // Save current position action = handler.OnChunk(in_total, out_total); if (action == IChunkHandler::eAction_Stop) { // Stop scanning break; } // (Re)Initialize inflate strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; ret = inflateInit2(&strm, 15+16 /* max windowbits + automatic gzip header decoding */); if (ret != Z_OK) { throw "inflateInit2() failed: " + string(zError(ret)); } initialized = true; } // We don't need uncompressed data -- discard it strm.next_out = out_buf; strm.avail_out = (unsigned int)out_size; // Decompress ret = inflate(&strm, Z_SYNC_FLUSH); if (ret != Z_OK && ret != Z_STREAM_END ) { // Error throw "inflate() failed: " + string(zError(ret)); } // Increase counters out_total += (out_size - strm.avail_out); in_total += (nread - strm.avail_in); nread = strm.avail_in; // If found end of compressed stream -- cleanup if (ret == Z_STREAM_END) { inflateEnd(&strm); initialized = false; } } while (strm.avail_in != 0); } if ( initialized ) { inflateEnd(&strm); } } // Cleanup catch (string& e) { if ( initialized ) { inflateEnd(&strm); } NCBI_THROW(CCompressionException, eCompression, e); } }