C++ istream::readsome方法代码示例

void dc_buffered_stream_send_expqueue2::send_data(procid_t target, 
                unsigned char packet_type_mask,
                std::istream &istrm,
                size_t len) {
  if (len != size_t(-1)) {
    char cbuffer[len];
    while(len > 0 && istrm.good()) {
      size_t l = istrm.readsome(cbuffer, len);
      len -= l;
    }
    send_data(target, packet_type_mask, cbuffer, len);
  }
  else {
    // annoying. we have to compute the length of the stream
    // allocate a 128byte block first.
    // \todo: This can be optimized. Though, I don't think this
    //        code path is even used.
    size_t len = 0;
    size_t cursize = 128;
    char* data = (char*)malloc(128);
    // while the stream is good. read stuff
    // len is the current length of the contents
    // cursize is the max length of the array
    // when we run out of space in the array, we double the size.
    while (istrm.good()) {
      len += istrm.readsome(data+len, cursize-len);
      if (cursize - len == 0) {
        cursize *= 2;
        data = (char*)realloc(data, cursize);
      }
    }
    send_data(target, packet_type_mask, data, len);
    free(data);
  }
}

bool Configurator::readString (std::istream &stream, std::string &value)
{
	std::uint8_t size;
	char buffer[255];
	if (stream.readsome(reinterpret_cast<char *>(&size), sizeof(size)) != sizeof(size) || !stream.good())
		return false;

	if (stream.readsome(buffer, size) != size || !stream.good())
		return false;

	value.assign(buffer, size);
	return true;
}

bool Configurator::readBoolean (std::istream &stream, bool &value)
{
	std::uint8_t buffer;
	if (stream.readsome(reinterpret_cast<char *>(&buffer), sizeof(buffer)) != sizeof(buffer) || !stream.good())
		return false;
	value = (buffer != 0);
	return true;
}

bool Configurator::readInt (std::istream &stream, int &value)
{
	std::uint32_t buffer;
	if (stream.readsome(reinterpret_cast<char *>(&buffer), sizeof(buffer)) != sizeof(buffer) || !stream.good())
		return false;
	value = (int)ntohl(buffer);
	return true;
}

void StreamBuffer::load(std::istream &is){
	clear();
	for(;;){
		AUTO_REF(back, pushBackPooled(m_chunks));
		back.writePos = is.readsome(back.data, sizeof(back.data));
		if(back.writePos == 0){
			break;
		}
	}
}

	bool
	TraceLog::load(std::istream& i_stream)
	{
		// *** Header ***
		
		int version_high = Serializer::deserialize<int>(i_stream);
		int version_low = Serializer::deserialize<int>(i_stream);
		
		
		
		int tile_number = Serializer::deserialize<int>(i_stream);
		mlog(MLog::debug, "TraceLog::load") << "Reading "
			<< tile_number << " tiles.\n";
			
		for (int i = 0; i<tile_number; ++i)
		{
			Tile* tile = new Tile(Serializer::deserialize<Tile>(i_stream));
			_tile_cache.insert(tile->get_id(), tile);
		}		
		
		// *** Commands	***
		// Read data
		char buffer[4096];
		std::streamsize read_bytes;
		_command_string = "";
		
		while(read_bytes = i_stream.readsome(buffer, 4096))
			_command_string.append(buffer, read_bytes);
			
		_command_stream.str(_command_string);
		_command_stream.seekg(0);
		
		// Parse for command positions
		while(_command_stream.peek() != EOF)
		{
			int command_length = Serializer::deserialize<int>(_command_stream);
			_command_positions.push_back((int)_command_stream.tellg());
			_command_stream.ignore(command_length);
		}
		
		_command_stream.flush();
		
		mlog(MLog::debug, "TraceLog::load") << "Read "
			<< _command_positions.size() << " commands.\n";
		
		if (_command_positions.size())		
			_current_position = 0;
		else
			_current_position = -1;
	}

	BlobPtr Blob::fromJson(std::istream& is) {
		int next_ch = skipWhitespace(is);
		if (next_ch != '=')
			throw runtime_error(
			"Invalid input: Expected '=', got: '" +
			to_string(static_cast<char>(next_ch)) + "'");
		readChar(is);
		unique_ptr<BlobValue> pv{ new BlobValue() };
		B64::decode([&is](){ char ch; return is.readsome(&ch, 1) ? ch : -1; },
			[&pv](uint8_t x){ pv.get()->push_back(x); });
		// Read away trailing '=':
		while (is.peek() == '=')
			readChar(is);
		return Blob::make(pv);
	}

bool Configurator::readIp (std::istream &stream, IpAddress &address)
{
	int family;
	if (!readInt(stream, family))
		return false;

	unsigned int size = IpAddress::familySize(family);
	if (size > 0)
	{
		std::uint8_t *buffer = new std::uint8_t[size];
		if (stream.readsome(reinterpret_cast<char *>(buffer), size) != size || !stream.good())
		{
			delete[] buffer;
			return false;
		}

		address = IpAddress(buffer, family);
		delete[] buffer;
	}
	else
		address = IpAddress();

	return true;
}

bool ReaderWriterCURL::read(std::istream& fin, std::string& destination) const
{
    #define CHUNK 16384

    int ret;
    unsigned have;
    z_stream strm;
    unsigned char in[CHUNK];
    unsigned char out[CHUNK];

    /* allocate inflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit2(&strm,
                       15 + 32 // autodected zlib or gzip header
                       );
    if (ret != Z_OK)
        return false;

    /* decompress until deflate stream ends or end of file */
    do {

        strm.avail_in = fin.readsome((char*)in, CHUNK);

        if (fin.fail())
        {
            (void)inflateEnd(&strm);
            return false;
        }
        if (strm.avail_in == 0)
            break;
        strm.next_in = in;

        /* run inflate() on input until output buffer not full */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = inflate(&strm, Z_NO_FLUSH);

            switch (ret) {
            case Z_NEED_DICT:
            case Z_DATA_ERROR:
            case Z_MEM_ERROR:
                (void)inflateEnd(&strm);
                return false;
            }
            have = CHUNK - strm.avail_out;

            destination.append((char*)out, have);

        } while (strm.avail_out == 0);

        /* done when inflate() says it's done */
    } while (ret != Z_STREAM_END);

    /* clean up and return */
    (void)inflateEnd(&strm);
    return ret == Z_STREAM_END ? true : false;
}

void decompressZlib(std::istream &is, std::ostream &os)
{
	z_stream z;
	const s32 bufsize = 16384;
	char input_buffer[bufsize];
	char output_buffer[bufsize];
	int status = 0;
	int ret;
	int bytes_read = 0;
	int input_buffer_len = 0;

	z.zalloc = Z_NULL;
	z.zfree = Z_NULL;
	z.opaque = Z_NULL;

	ret = inflateInit(&z);
	if(ret != Z_OK)
		throw SerializationError("dcompressZlib: inflateInit failed");
	
	z.avail_in = 0;
	
	//dstream<<"initial fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;

	for(;;)
	{
		z.next_out = (Bytef*)output_buffer;
		z.avail_out = bufsize;

		if(z.avail_in == 0)
		{
			z.next_in = (Bytef*)input_buffer;
			input_buffer_len = is.readsome(input_buffer, bufsize);
			z.avail_in = input_buffer_len;
			//dstream<<"read fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
		}
		if(z.avail_in == 0)
		{
			//dstream<<"z.avail_in == 0"<<std::endl;
			break;
		}
			
		//dstream<<"1 z.avail_in="<<z.avail_in<<std::endl;
		status = inflate(&z, Z_NO_FLUSH);
		//dstream<<"2 z.avail_in="<<z.avail_in<<std::endl;
		bytes_read += is.gcount() - z.avail_in;
		//dstream<<"bytes_read="<<bytes_read<<std::endl;

		if(status == Z_NEED_DICT || status == Z_DATA_ERROR
				|| status == Z_MEM_ERROR)
		{
			zerr(status);
			throw SerializationError("decompressZlib: inflate failed");
		}
		int count = bufsize - z.avail_out;
		//dstream<<"count="<<count<<std::endl;
		if(count)
			os.write(output_buffer, count);
		if(status == Z_STREAM_END)
		{
			//dstream<<"Z_STREAM_END"<<std::endl;
			
			//dstream<<"z.avail_in="<<z.avail_in<<std::endl;
			//dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
			// Unget all the data that inflate didn't take
			for(u32 i=0; i < z.avail_in; i++)
			{
				is.unget();
				if(is.fail() || is.bad())
				{
					dstream<<"unget #"<<i<<" failed"<<std::endl;
					dstream<<"fail="<<is.fail()<<" bad="<<is.bad()<<std::endl;
					throw SerializationError("decompressZlib: unget failed");
				}
			}
			
			break;
		}
	}

	inflateEnd(&z);
}

	void addFile(const std::string& name, std::istream& file)
	{
		util::log("TarArchive") << " Adding file '" + name +
			"' to archive '" + _path + "'\n";
		
		auto entry = TarLibrary::archive_entry_new();
		 
		if(entry == nullptr)
		{
			throw std::runtime_error("Failed to create archive entry.");
		}

		util::log("TarArchive") << "  Creating entry in archive...\n";
		
		size_t size = getSize(file);
		
		TarLibrary::archive_entry_set_uid(entry, 0);
		TarLibrary::archive_entry_set_uname(entry, "root");
		TarLibrary::archive_entry_set_gid(entry, 0);
		TarLibrary::archive_entry_set_gname(entry, "wheel");
		TarLibrary::archive_entry_set_filetype(entry, TarLibrary::RegularFile);
		TarLibrary::archive_entry_set_perm(entry, 0644);
		TarLibrary::archive_entry_set_size(entry, size);
		TarLibrary::archive_entry_set_pathname(entry, name.c_str());
		
		if(TarLibrary::archive_write_header(_archive, entry) !=
			TarLibrary::OK)
		{
			TarLibrary::archive_entry_free(entry);
			
			throw std::runtime_error("Failed to write entry to archive. "
				"Message: " + TarLibrary::archive_error_string(_archive));
		}

		util::log("TarArchive") << "  Writing data (" << size
			<< " bytes) to archive...\n";
		
		char buffer[1024];
		
		while(size > 0)
		{
			int count = file.readsome(buffer, 1024);
		
			size -= count;
		
			if(TarLibrary::archive_write_data(_archive, buffer, count) != count)
			{
				throw std::runtime_error("Failed to write data to archive."
					"Message: " + TarLibrary::archive_error_string(_archive));
			}
		}

		if(TarLibrary::archive_write_finish_entry(_archive) != TarLibrary::OK)
		{
			throw std::runtime_error("Failed to finish "
				"writing data to archive.");
		}

		TarLibrary::archive_entry_free(entry);

		util::log("TarArchive") << "  File added successfully...\n";
	}

void
read_istream(
    std::istream& is,
    basic_flat_buffer<Allocator>& buffer,
    message<isRequest, Body, fields>& msg,
    error_code& ec)
{
    // Create the message parser
    //
    // Arguments passed to the parser's constructor are
    // forwarded to the message constructor. Here, we use
    // a move construction in case the caller has constructed
    // their message in a non-default way.
    //
    parser<isRequest, Body> p{std::move(msg)};

    do
    {
        // Extract whatever characters are presently available in the istream
        if(is.rdbuf()->in_avail() > 0)
        {
            // Get a mutable buffer sequence for writing
            auto const mb = buffer.prepare(
                static_cast<std::size_t>(is.rdbuf()->in_avail()));

            // Now get everything we can from the istream
            buffer.commit(static_cast<std::size_t>(is.readsome(
                boost::asio::buffer_cast<char*>(mb),
                boost::asio::buffer_size(mb))));
        }
        else if(buffer.size() == 0)
        {
            // Our buffer is empty and we need more characters, 
            // see if we've reached the end of file on the istream
            if(! is.eof())
            {
                // Get a mutable buffer sequence for writing
                auto const mb = buffer.prepare(1024);

                // Try to get more from the istream. This might block.
                is.read(
                    boost::asio::buffer_cast<char*>(mb),
                    boost::asio::buffer_size(mb));

                // If an error occurs on the istream then return it to the caller.
                if(is.fail() && ! is.eof())
                {
                    // We'll just re-use io_error since std::istream has no error_code interface.
                    ec = make_error_code(errc::io_error);
                    return;
                }

                // Commit the characters we got to the buffer.
                buffer.commit(static_cast<std::size_t>(is.gcount()));
            }
            else
            {
                // Inform the parser that we've reached the end of the istream.
                p.put_eof(ec);
                if(ec)
                    return;
                break;
            }
        }

        // Write the data to the parser
        auto const bytes_used = p.put(buffer.data(), ec);

        // This error means that the parser needs additional octets.
        if(ec == error::need_more)
            ec = {};
        if(ec)
            return;

        // Consume the buffer octets that were actually parsed.
        buffer.consume(bytes_used);
    }
    while(! p.is_done());

    // Transfer ownership of the message container in the parser to the caller.
    msg = p.release();
}

	int VirtualMachine::readProgram(std::istream & input)
	{
		qvm_header_t qvminfo;
		int i, n;
		uint1_t x[4];
		word w;

		DEBUGTRACE("Loading file...\n");
		qvminfo.magic = readInt(input); /* magic. */
		if (qvminfo.magic != QVM_MAGIC)
		{
			DEBUGTRACE("Invalid magic");
			throw InvalidProgramException();
			//q3vm_error("Does not appear to be a QVM file.");
			/* XXX: option to force continue. */
			return 0;
		}
		DEBUGTRACE("Magic OK\n");
		/* variable-length instructions mean instruction count != code length */
		qvminfo.inscount = readInt(input);
		qvminfo.codeoff = readInt(input);
		qvminfo.codelen = readInt(input);
		qvminfo.dataoff = readInt(input);
		qvminfo.datalen = readInt(input);
		qvminfo.litlen = readInt(input);
		qvminfo.bsslen = readInt(input);

		/* Code segment should follow... */
		/* XXX: use fseek with SEEK_CUR? */
		DEBUGTRACE("Searching for .code @ %d from %d\n", qvminfo.codeoff, input.tellg());

		//  rom = (q3vm_rom_t*)(hunk);  /* ROM-in-hunk */
		rom = (Instruction*)calloc(qvminfo.inscount, sizeof(rom[0]));
		while (input.tellg() < qvminfo.codeoff)
			readByte(input);
		while (romSize < qvminfo.inscount)
		{
			n = readByte(input);
			w.int4 = 0;
			if ((i = opcodeParameterSize(n)))
			{
				x[0] = x[1] = x[2] = x[3] = 0;
				input.readsome((char*)x, i);
				w.uint4 = (x[0]) | (x[1] << 8) | (x[2] << 16) | (x[3] << 24);
			}
			rom[romSize].Operation = n;
			rom[romSize].Parameter = w;
			romSize++;
		}
		DEBUGTRACE("After loading code: at %d, should be %d\n", input.tellg(), qvminfo.codeoff + qvminfo.codelen);

		/* Then data segment. */
		//  ram = hunk + ((romlen + 3) & ~3);  /* RAM-in-hunk */
		ram = hunk;
		DEBUGTRACE("Searching for .data @ %d from %d\n", qvminfo.dataoff, input.tellg());
		while (input.tellg() < qvminfo.dataoff)
			readByte(input);
		for (n = 0; n < (qvminfo.datalen / sizeof(uint1_t)); n++)
		{
			i = input.readsome((char*)x, sizeof(x));
			w.uint4 = (x[0]) | (x[1] << 8) | (x[2] << 16) | (x[3] << 24);
			*((word*)(ram + ramSize)) = w;
			ramSize += sizeof(word);
		}
	
		/* lit segment follows data segment. */
		/* Assembler should have already padded properly. */
		DEBUGTRACE("Loading .lit\n");
		for (n = 0; n < (qvminfo.litlen / sizeof(uint1_t)); n++)
		{
			i = input.readsome((char*)x, sizeof(x));
			memcpy(&(w.uint1), &x, sizeof(x));  /* no byte-swapping. */
			*((word*)(ram + ramSize)) = w;
			ramSize += sizeof(word);
		}
		/* bss segment. */
		DEBUGTRACE("Allocating .bss %d (%X) bytes\n", qvminfo.bsslen, qvminfo.bsslen);
		/* huge empty chunk. */
		ramSize += qvminfo.bsslen;

		hunkFree = hunkSize - ((ramSize * sizeof(uint1_t)) + 4);

		DEBUGTRACE("VM hunk has %d of %d bytes free (RAM = %d B).\n", hunkFree, hunkSize, ramSize);
		if (ramSize > hunkSize)
		{
			throw OutOfMemoryException();
			return 0;
		}

		/* set up stack. */
		{
			int stacksize = 0x10000;
			dataStack = ramSize - (stacksize / 2);
			returnStack = ramSize;
			//returnStack = dataStack+4;
			RP = returnStack;
			DP = dataStack;
		}

		/* set up PC for return-to-termination. */
//.........这里部分代码省略.........