void Simulation::checkpoint (istream& stream, int checkpointNum) { util::checkpoint::header (stream); util::CommandLine::staticCheckpoint (stream); Population::staticCheckpoint (stream); Surveys & stream; Global::simulationTime & stream; Global::timeStep & stream; simPeriodEnd & stream; totalSimDuration & stream; phase & stream; (*_population) & stream; // read last, because other loads may use random numbers: util::random::checkpoint (stream, checkpointNum); // Check scenario.xml and checkpoint files correspond: int oldWUID(workUnitIdentifier); util::Checksum oldCksum(cksum); workUnitIdentifier & stream; cksum & stream; if (workUnitIdentifier != oldWUID || cksum != oldCksum) throw util::checkpoint_error ("mismatched checkpoint"); stream.ignore (numeric_limits<streamsize>::max()-1); // skip to end of file if (stream.gcount () != 0) { ostringstream msg; msg << "Checkpointing file has " << stream.gcount() << " bytes remaining." << endl; throw util::checkpoint_error (msg.str()); } else if (stream.fail()) throw util::checkpoint_error ("stream read error"); }
bool OggDecoder::read_page(istream& stream, ogg_sync_state* state, ogg_page* page) { int ret = 0; // If we've hit end of file we still need to continue processing // any remaining pages that we've got buffered. if (!stream.good()) return ogg_sync_pageout(state, page) == 1; while((ret = ogg_sync_pageout(state, page)) != 1) { // Returns a buffer that can be written too // with the given size. This buffer is stored // in the ogg synchronisation structure. char* buffer = ogg_sync_buffer(state, 4096); assert(buffer); // Read from the file into the buffer stream.read(buffer, 4096); int bytes = stream.gcount(); if (bytes == 0) { // End of file. continue; } // Update the synchronisation layer with the number // of bytes written to the buffer ret = ogg_sync_wrote(state, bytes); assert(ret == 0); } return true; }
int dynv_xml_deserialize(struct dynvSystem* dynv_system, istream& in){ XML_Parser p = XML_ParserCreate("UTF-8"); XML_SetElementHandler(p, (XML_StartElementHandler)start_element_handler, (XML_EndElementHandler)end_element_handler); XML_SetCharacterDataHandler(p, (XML_CharacterDataHandler)character_data_handler); XmlCtx ctx; ctx.entity.push(new XmlEntity(0, dynv_system, false)); ctx.handler_map = dynv_system_get_handler_map(dynv_system); XML_SetUserData(p, &ctx); for (;;){ void *buffer = XML_GetBuffer(p, 4096); in.read((char*)buffer, 4096); size_t bytes_read = in.gcount(); if (!XML_ParseBuffer(p, bytes_read, bytes_read==0)) { } if (bytes_read == 0) break; } XML_ParserFree(p); return 0; }
void binary2source(ostream &os,istream &is) { os.setf(ios::hex,ios::basefield); os << '{' << endl; bool begin = true; while (is.good() && !is.eof()) { unsigned char buffer[16]; is.read((char *) buffer,16); int size = is.gcount(); if (size>0 && !begin) { os << ','; os << endl; } begin = false; for (int i=0; i<size;i++) { os << "0x" << setw(2) << setfill('0') << (unsigned int)buffer[i]; if (i<size-1) os << ','; } } os << endl << "};" << endl; }
void run(exploder & e, istream& in) { // any larger, and we may try to write to a multi_frame that never has enough space static const int BUF_SIZE = multi_frame::MAX_SIZE - frame::FRAME_SIZE; scoped_array<char> buffer(new char[BUF_SIZE]); ios::sync_with_stdio(false); // makes a big difference on buffered i/o for (int line = 1; !in.eof(); ++line) { in.getline(buffer.get(), BUF_SIZE - 1); // leave 1 for us to inject back the newline if (buffer[0] == '\0') continue; if (in.fail()) // line was too long? { cerr << "Skipping line <" << line << ">: line is probably too long" << endl; in.clear(); // clear state in.ignore(numeric_limits<streamsize>::max(), '\n'); continue; } buffer[in.gcount() - 1] = '\n'; // inject back the newline buffer[in.gcount()] = '\0'; e << buffer.get(); } }
streamsize cb::transfer(istream &in, ostream &out, streamsize length, SmartPointer<TransferCallback> callback) { char buffer[BUFFER_SIZE]; streamsize total = 0; while (!in.fail() && !out.fail()) { in.read(buffer, length ? min(length, BUFFER_SIZE) : BUFFER_SIZE); streamsize bytes = in.gcount(); out.write(buffer, bytes); total += bytes; if (!callback.isNull() && !callback->transferCallback(bytes)) break; if (length) { length -= bytes; if (!length) break; } } out.flush(); if (out.fail() || length) THROW("Transfer failed"); return total; }
string getSLine(istream &str) { char line[1024]; str.getline(line, 1024); if (str.gcount()==1024-1) raiseError("line too long"); return line; }
//extends fstream::getline with check on exceeding the buffer size std::streamsize getLineExt(istream& fin, char* buf) { fin.getline(buf, LINE_LEN); std::streamsize bufLen = fin.gcount(); if(bufLen == LINE_LEN - 1) throw LONG_LINE_ERR; return bufLen; }
/** * Parses the given input stream and returns a DOM Document. * A NULL pointer will be returned if errors occurred */ nsresult txDriver::parse(istream& aInputStream, const nsAString& aUri) { mErrorString.Truncate(); if (!aInputStream) { mErrorString.AppendLiteral("unable to parse xml: invalid or unopen stream encountered."); return NS_ERROR_FAILURE; } static const XML_Memory_Handling_Suite memsuite = { (void *(*)(size_t))PR_Malloc, (void *(*)(void *, size_t))PR_Realloc, PR_Free }; static const PRUnichar expatSeparator = kExpatSeparatorChar; mExpatParser = XML_ParserCreate_MM(nsnull, &memsuite, &expatSeparator); if (!mExpatParser) { return NS_ERROR_OUT_OF_MEMORY; } XML_SetReturnNSTriplet(mExpatParser, XML_TRUE); XML_SetUserData(mExpatParser, this); XML_SetElementHandler(mExpatParser, startElement, endElement); XML_SetCharacterDataHandler(mExpatParser, charData); #ifdef XML_DTD XML_SetParamEntityParsing(mExpatParser, XML_PARAM_ENTITY_PARSING_ALWAYS); #endif XML_SetExternalEntityRefHandler(mExpatParser, externalEntityRefHandler); XML_SetExternalEntityRefHandlerArg(mExpatParser, this); XML_SetBase(mExpatParser, (const XML_Char*)(PromiseFlatString(aUri).get())); const int bufferSize = 1024; char buf[bufferSize]; PRBool done; int success; mRV = NS_OK; do { aInputStream.read(buf, bufferSize); done = aInputStream.eof(); success = XML_Parse(mExpatParser, buf, aInputStream.gcount(), done); // mRV is set in onDoneCompiling in case of an error if (!success || NS_FAILED(mRV)) { createErrorString(); done = MB_TRUE; } } while (!done); aInputStream.clear(); // clean up XML_ParserFree(mExpatParser); mCompiler->doneLoading(); if (!success) { return NS_ERROR_FAILURE; } return mRV; }
void operator& (string& x, istream& stream) { size_t len; len & stream; validateListSize (len); x.resize (len); stream.read (&x[0], x.length()); if (!stream || stream.gcount() != streamsize(len)) throw checkpoint_error ("stream read error string"); }
void GLibXMLAdapter::read(istream &stream) { typedef void (*start_element_func_t)(GMarkupParseContext *, const gchar *, const gchar **, const gchar **, gpointer data, GError **error); typedef void (*end_element_func_t)(GMarkupParseContext *, const gchar *, gpointer, GError **); typedef void (*text_func_t)(GMarkupParseContext *, const gchar *, gsize, gpointer, GError **); GMarkupParser parser = { (start_element_func_t)&GLibXMLAdapter::startElement, (end_element_func_t)&GLibXMLAdapter::endElement, (text_func_t)&GLibXMLAdapter::text, 0, // passthrough 0, // error }; GMarkupParseContext *context = g_markup_parse_context_new(&parser, (GMarkupParseFlags)0, (void *)this, 0); if (!context) THROW("Failed to create XML parser."); try { while (!stream.eof() && !stream.fail()) { char buf[BUFFER_SIZE]; stream.read(buf, BUFFER_SIZE); streamsize count = stream.gcount(); GError *gerror = 0; if (count) { g_markup_parse_context_parse(context, buf, count, &gerror); if (error.get()) { Exception e(*error); error = 0; throw; } if (gerror) THROW("Parse failed " << g_quark_to_string(gerror->domain) << ": " << gerror->code << ": " << gerror->message); } } } catch (const Exception &e) { int line; int column; g_markup_parse_context_get_position(context, &line, &column); g_free(context); throw Exception(e.getMessage(), FileLocation(getFilename(), line - 1, column), e); } }
std::string readline(istream &is) { std::string out; char c=0; while (!is.eof() && c!='\n') { is.read(&c, 1); if (is.gcount()) out+=c; } return out; }
FrFILETYPE FrFileType(istream &in) { char buf[BUFFER_SIZE] ; long pos = in.tellg() ; in.seekg(0) ; (void)in.read(buf,sizeof(buf)) ; FrFILETYPE type = check_type(buf,in.gcount()) ; in.seekg(pos) ; return type ; }
/** * Read a specified number of characters from file. * * @param aIS Input stream. * @param aNChar Number of characters in the description. * @return read string. */ string IO:: ReadCharacters(istream &aIS,int aNChar) { char *buffer=new char[aNChar+1]; aIS.read(buffer,aNChar); buffer[aIS.gcount()] = '\0'; string str = buffer; delete[] buffer; return str; }
/** * Add new file to ZIP container. The file is actually archived to ZIP container after <code>save()</code> * method is called. * * @param containerPath file path inside ZIP file. * @param path full path of the file that should be added to ZIP file. * @see create() * @see save() */ void ZipSerialize::addFile(const string& containerPath, istream &is, const Properties &prop, Flags flags) { if(!d->create) THROW("Zip file is not open"); DEBUG("ZipSerialize::addFile(%s)", containerPath.c_str()); zip_fileinfo info = { { uInt(prop.time.tm_sec), uInt(prop.time.tm_min), uInt(prop.time.tm_hour), uInt(prop.time.tm_mday), uInt(prop.time.tm_mon), uInt(prop.time.tm_year) }, 0, 0, 0 }; // Create new file inside ZIP container. int method = flags & DontCompress ? Z_NULL : Z_DEFLATED; int level = flags & DontCompress ? Z_NO_COMPRESSION : Z_DEFAULT_COMPRESSION; uLong UTF8_encoding = 1 << 11; // general purpose bit 11 for unicode int zipResult = zipOpenNewFileInZip4(d->create, containerPath.c_str(), &info, nullptr, 0, nullptr, 0, prop.comment.c_str(), method, level, 0, -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, nullptr, 0, 0, UTF8_encoding); if(zipResult != ZIP_OK) THROW("Failed to create new file inside ZIP container. ZLib error: %d", zipResult); is.clear(); is.seekg(0); char buf[10240]; while( is ) { is.read(buf, 10240); if(is.gcount() <= 0) break; zipResult = zipWriteInFileInZip(d->create, buf, unsigned(is.gcount())); if(zipResult != ZIP_OK) { zipCloseFileInZip(d->create); THROW("Failed to write bytes to current file inside ZIP container. ZLib error: %d", zipResult); } } zipResult = zipCloseFileInZip(d->create); if(zipResult != ZIP_OK) THROW("Failed to close current file inside ZIP container. ZLib error: %d", zipResult); }
void read_all(istream& in, vector<char>& data) { static const size_t c_buffer_size = 1024; data.clear(); while (in) { size_t pre_size = data.size(); data.resize(pre_size + c_buffer_size); in.read(data.data() + pre_size, c_buffer_size); data.resize(pre_size + in.gcount()); } }
static void readToString(istream& aIstream, nsACString& aString) { static char buffer[1024]; int read = 0; do { aIstream.read(buffer, 1024); read = aIstream.gcount(); aString.Append(Substring(buffer, buffer + read)); } while (!aIstream.eof()); }
void readImageData( istream& is, cv::Mat_<cv::Vec3b>& cimg, cv::Mat_<cv::Vec3f>& points, cv::Mat_<float>& dimg) { string ln; getline( is, ln); istringstream iss(ln); cv::Size imgSz; iss >> imgSz.height >> imgSz.width; cimg = cv::Mat_<cv::Vec3b>( imgSz); points = cv::Mat_<cv::Vec3f>( imgSz); dimg = cv::Mat_<float>( imgSz); const int sz = imgSz.width * imgSz.height; const int pxlChunk = 3*sizeof(float) + 3*sizeof(byte); const int totalBytes = sz * pxlChunk; char* buff = (char*)malloc( totalBytes); int readBytes = 0; while ( readBytes < totalBytes) { is.read( &buff[readBytes], totalBytes-readBytes); const int numBytesRead = is.gcount(); if ( numBytesRead <= 0) break; readBytes += numBytesRead; } // end while assert( readBytes == totalBytes); for ( int i = 0; i < sz; ++i) { int j = i * pxlChunk; // Offset into read in buffer // Read in points (with respect to origin) cv::Vec3f p( *(float*)&buff[j], // X *(float*)&buff[j+sizeof(float)], // Y *(float*)&buff[j+2*sizeof(float)]); // Z (depth) j += 3*sizeof(float); // Skip to colour bytes cv::Vec3b c( (byte)buff[j], (byte)buff[j+1], (byte)buff[j+2]); const int row = i / imgSz.width; // Integer division const int col = i % imgSz.width; cimg.at<cv::Vec3b>(row,col) = c; points.at<cv::Vec3f>(row,col) = p; dimg.at<float>(row,col) = p[2]; // Depth is just the Z value } // end for free(buff); getline( is, ln); // Read end of line } // end readImageData
PWIZ_API_DECL string SHA1Calculator::hash(istream& is) { CSHA1 sha1; is.clear(); is.seekg(0); unsigned char buffer[65535]; while (is && is.read(reinterpret_cast<char*>(buffer), 65535)) sha1.Update(buffer, 65535u); sha1.Update(buffer, is.gcount()); sha1.Final(); return formatHash(sha1); }
//-------------------------------------------------- bool ofBuffer::set(istream & stream){ clear(); if( stream.bad() ) return false; char aux_buffer[1024]; std::streamsize size = 0; stream.read(aux_buffer, 1024); std::streamsize n = stream.gcount(); while( n > 0 ){ // we resize to size+1 initialized to 0 to have a 0 at the end for strings buffer.resize(size+n+1,0); memcpy(&(buffer[0])+size,aux_buffer,n); size += n; if( stream ){ stream.read(aux_buffer, 1024); n = stream.gcount(); } else n = 0; } return true; }
int MessageProcessHelper::ProcessMessageStream( istream& istrm ) { PackageHajackStream hajack; int ret; unsigned have; z_stream strm; unsigned char in[CHUNK]; unsigned char out[CHUNK]; /* 初始化压缩状态 */ strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; strm.avail_in = 0; strm.next_in = Z_NULL; ret = inflateInit(&strm); if (ret != Z_OK) return ret; /* 解压,直到流的结尾 */ do { istrm.read((char*)in,CHUNK); strm.avail_in = istrm.gcount(); if (strm.avail_in == 0) break; strm.next_in = in; do { strm.avail_out = CHUNK; strm.next_out = out; ret = inflate(&strm, Z_NO_FLUSH); switch (ret) { case Z_NEED_DICT: ret = Z_DATA_ERROR; /* and fall through */ case Z_DATA_ERROR: case Z_MEM_ERROR: (void)inflateEnd(&strm); return ret; } have = CHUNK - strm.avail_out; if(!hajack.WriteBlock((const char*)out,have,0)) { (void)inflateEnd(&strm); return Z_ERRNO; } } while (strm.avail_out == 0); } while (ret != Z_STREAM_END); (void)inflateEnd(&strm); return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR; }
void IceXML::Parser::parse(istream& in, Handler& handler) { XML_Parser parser = XML_ParserCreate(NULL); CallbackData cb; cb.parser = parser; cb.handler = &handler; XML_SetUserData(parser, &cb); XML_SetElementHandler(parser, startElementHandler, endElementHandler); XML_SetCharacterDataHandler(parser, characterDataHandler); try { char buff[1024]; int isFinal = 0; while(!isFinal) { in.read(buff, 1024); if(in.gcount() < 1024) { isFinal = 1; } if(XML_Parse(parser, buff, static_cast<int>(in.gcount()), isFinal) != 1) { handler.error(XML_ErrorString(XML_GetErrorCode(parser)), static_cast<int>(XML_GetCurrentLineNumber(parser)), static_cast<int>(XML_GetCurrentColumnNumber(parser))); return; } } } catch(...) { XML_ParserFree(parser); throw; } XML_ParserFree(parser); }
const char* LgScriptReader::read(State&, size_t *sz) { if (extraline) { extraline = false; *sz = 1; return "\n"; } if (infile->eof()) return NULL; infile->read(buff, sizeof(buff)); *sz = infile->gcount(); return buff; }
void LineBuffer::read(istream &stream) { while (true) { streamsize space = bufferSize - fill; stream.read(buffer + fill, space); streamsize bytes = stream.gcount(); if (!bytes) break; fill += bytes; extractLines(); if (bytes < space) break; } }
bool CanberraCnfDataSet::check(istream &f, string*) { int acq_offset = 0; f.ignore(112); int pos = 112; char buf[48]; while (!f.eof()) { f.read(buf, 48); if (f.gcount() != 48) return false; if ((buf[1] != 0x20 || buf[2] != 0x01) && buf[1] != 0 && buf[2] != 0) return false; pos += 48; if (buf[0] == 0) { acq_offset = from_le<uint32_t>(buf+10); break; } } if (acq_offset <= pos) return false; f.ignore(acq_offset - pos); f.read(buf, 48); return (!f.eof() && f.gcount() == 48 && buf[0] == 0 && buf[1] == 0x20); }
void CCryptMgr::Encrypt(istream& is, ostream& os) #endif // VC7 { int n = 0; char buf[8]; while (!is.eof()) { memset(buf, 0, 8); is.read(buf, 8); n = is.gcount(); Blowfish_encipher((UWORD_32bits*)buf, (UWORD_32bits*)&buf[4]); os.write(buf, 8); } os.put((char)n); }
//-------------------------------------------------- bool ofBuffer::set(istream & stream){ if(stream.bad()){ clear(); return false; }else{ buffer.clear(); } vector<char> aux_buffer(ioSize); while(stream.good()){ stream.read(&aux_buffer[0], ioSize); buffer.insert(buffer.end(),aux_buffer.begin(),aux_buffer.begin()+stream.gcount()); } buffer.push_back(0); return true; }
bool ftpClient::put(string filename, istream& f) { if (!sys::isRegularFile(filename)) { cout << "File not present." << endl; return false; } sendRequest(ftpRequest(string("TYPE"), string("I"))); ftpResponse response = recvResponse(); cout << response.getMessage() << endl; stringstream clientInfo; clientInfo << m_control_socket.getSrcHostname() << ":" << m_data_port; sendRequest(ftpRequest(string("PORT"), clientInfo.str())); tcpSocket cur_data_socket = m_data_socket.accept(); response = recvResponse(); cout << response.getMessage() << endl; if(response.getCode() != 200) return false; sendRequest(ftpRequest(string("STOR"), filename)); response = recvResponse(); cout << response.getMessage() << endl; if(response.getCode() != 150) return false; string s; char buffer[FILE_BLOCK_SIZE]; while(!f.eof()) { f.read(buffer, FILE_BLOCK_SIZE); cur_data_socket.sendData(buffer, f.gcount()); } cur_data_socket.close(); response = recvResponse(); cout << response.getMessage() << endl; return true; }
void DataFile::Load(istream &in) { vector<char> data; static const size_t BLOCK = 4096; while(in) { size_t currentSize = data.size(); data.resize(currentSize + BLOCK); in.read(&*data.begin() + currentSize, BLOCK); data.resize(currentSize + in.gcount()); } // As a sentinel, make sure the file always ends in a newline. if(data.back() != '\n') data.push_back('\n'); Load(&*data.begin(), &*data.end()); }
bool AbstractXMLParser::Parse(const std::string &strDesc, istream &in, bool bUser) { if (!in.good()) return false; //we'll be re-entrant (i.e. allow nested calls), as it's not difficult here... const bool bOldUser = m_bUser; const string strOldDesc = m_strDesc; m_bUser = bUser; m_strDesc = strDesc; XML_Parser Parser = XML_ParserCreate(NULL); // Members passed as callbacks must be static, so don't have a "this" pointer. // We give them one through horrible casting so they can effect changes. XML_SetUserData(Parser, this); XML_SetElementHandler(Parser, XML_StartElement, XML_EndElement); XML_SetCharacterDataHandler(Parser, XML_CharacterData); bool bRes(true); char Buffer[1024]; int Done; do { in.read(Buffer, sizeof(Buffer)); size_t len = in.gcount(); Done = len < sizeof(Buffer); if(XML_Parse(Parser, Buffer, len, Done) == XML_STATUS_ERROR) { bRes=false; if (m_pMsgs) { const XML_LChar *xmle=XML_ErrorString(XML_GetErrorCode(Parser)); //think XML_LChar==char, depends on preprocessor variables... ///TRANSLATORS: the first string is the error message from the XML Parser; /// the second is the URL of the file we're trying to read. m_pMsgs->FormatMessageWith2Strings(_("XML Error %s in file %s "), xmle, m_strDesc.c_str()); #ifdef DEBUG std::cout << "Error in: " << string(Buffer,len) << std::endl; #endif } break; } } while (!Done); XML_ParserFree(Parser); m_bUser = bOldUser; m_strDesc = strOldDesc; return bRes; }