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