C++ SeekableReadStream::read方法代码示例

void FoxPro::loadRecords(SeekableReadStream &dbf, uint32 recordSize, uint32 recordCount) {
	_pool.push_back(new byte[recordSize * recordCount]);
	byte *recordData = _pool.back();

	if (dbf.read(recordData, recordSize * recordCount) != (recordSize * recordCount))
		throw Exception(kReadError);

	if (dbf.readByte() != 0x1A)
		throw Exception("Record end marker missing");

	uint32 fieldCount = _fields.size();

	// Create the records array
	_records.resize(recordCount);
	for (uint32 i = 0; i < recordCount; i++) {
		Record &record = _records[i];
		const byte *data = recordData + i * recordSize;

		char status = *data++;
		if ((status != ' ') && (status != '*'))
			throw Exception("Unknown record status '%c'", status);

		record.deleted = status == '*';

		record.fields.resize(fieldCount);
		for (uint32 j = 0; j < fieldCount; j++) {
			record.fields[j] = data;
			data += _fields[j].size;
		}
	}
}

size_t ZipFile::findCentralDirectoryEnd(SeekableReadStream &zip) {
	const size_t uSizeFile = zip.size();
	const size_t uMaxBack  = MIN<size_t>(0xFFFF, uSizeFile); // Maximum size of global comment

	byte buf[BUFREADCOMMENT + 4];

	size_t uPosFound = 0;
	size_t uBackRead = 4;
	while ((uPosFound == 0) && (uBackRead < uMaxBack)) {
		uBackRead = MIN<size_t>(uMaxBack, uBackRead + BUFREADCOMMENT);

		const size_t uReadPos  = uSizeFile - uBackRead;
		const size_t uReadSize = MIN<size_t>(BUFREADCOMMENT + 4, uSizeFile - uReadPos);

		try {
			zip.seek(uReadPos);
		} catch (...) {
			return 0;
		}

		if (zip.read(buf, uReadSize) != uReadSize) {
			uPosFound = 0;
			break;
		}

		for (size_t i = (uReadSize - 3); i-- > 0; )
			if (READ_LE_UINT32(buf + i) == 0x06054B50) {
				uPosFound = uReadPos + i;
				break;
			}

	}

	return uPosFound;
}

UString readStringFixed(SeekableReadStream &stream, Encoding encoding, size_t length) {
	std::vector<byte> output;
	output.resize(length);

	length = stream.read(&output[0], length);
	output.resize(length);

	return createString(output, encoding);
}

void printDataHex(SeekableReadStream &stream, size_t size) {
	size_t pos = stream.pos();

	size = MIN<size_t>(stream.size() - pos, size);

	if (size == 0)
		return;

	uint32 offset = 0;
	byte rowData[16];

	while (size > 0) {
		// At max 16 bytes printed per row
		uint32 n = MIN<size_t>(size, 16);
		if (stream.read(rowData, n) != n)
			throw Exception(kReadError);

		// Print an offset
		std::fprintf(stderr, "%08X  ", offset);

		// 2 "blobs" of each 8 bytes per row
		for (uint32 i = 0; i < 2; i++) {
			for (uint32 j = 0; j < 8; j++) {
				uint32 m = i * 8 + j;

				if (m < n)
					// Print the data
					std::fprintf(stderr, "%02X ", rowData[m]);
				else
					// Last row, data count not aligned to 16
					std::fprintf(stderr, "   ");
			}

			// Separate the blobs by an extra space
			std::fprintf(stderr, " ");
		}

		std::fprintf(stderr, "|");

		// If the data byte is a printable character, print it. If not, substitute a '.'
		for (uint32 i = 0; i < n; i++)
			std::fprintf(stderr, "%c", std::isprint(rowData[i]) ? rowData[i] : '.');

		std::fprintf(stderr, "|\n");

		size   -= n;
		offset += n;
	}

	// Seek back
	stream.seek(pos);
}

static uint32 readFakeChar(SeekableReadStream &stream, Encoding encoding) {
	byte data[2];

	switch (encoding) {
		case kEncodingASCII:
		case kEncodingLatin9:
		case kEncodingUTF8:
		case kEncodingCP1250:
		case kEncodingCP1251:
		case kEncodingCP1252:
		case kEncodingCP932:
		case kEncodingCP936:
		case kEncodingCP949:
		case kEncodingCP950:
			if (stream.read(data, 1) != 1)
				return 0;

			return data[0];

		case kEncodingUTF16LE:
			if (stream.read(data, 2) != 2)
				return 0;

			return READ_LE_UINT16(data);

		case kEncodingUTF16BE:
			if (stream.read(data, 2) != 2)
				return 0;

			return READ_BE_UINT16(data);

		default:
			break;
	}

	return 0;
}

void FoxPro::loadMemos(SeekableReadStream &fpt) {
	fpt.skip(4); // Next free block
	fpt.skip(2); // Unused

	_memoBlockSize = fpt.readUint16BE();
	if (_memoBlockSize < 33)
		_memoBlockSize *= 1024;

	fpt.skip(504); // Unused

	while (!fpt.eos()) {
		_memos.push_back(new byte[_memoBlockSize]);
		byte *data = _memos.back();

		fpt.read(data, _memoBlockSize);
	}
}

size_t searchBackwards(SeekableReadStream &haystack, const byte *needle, size_t needleSize,
                       size_t maxReadBack) {

	if (needleSize == 0 || maxReadBack == 0)
		return SIZE_MAX;

	assert(maxReadBack >= needleSize);

	static const size_t kReadBufferSize = 0x400;

	const size_t sizeFile = haystack.size();
	const size_t maxBack  = MIN<size_t>(maxReadBack, sizeFile);

	ScopedArray<byte> buf(new byte[kReadBufferSize + needleSize]);

	size_t backRead = needleSize;
	while (backRead < maxBack) {
		backRead = MIN<size_t>(maxBack, backRead + kReadBufferSize);

		const size_t readPos  = sizeFile - backRead;
		const size_t readSize = MIN<size_t>(kReadBufferSize + needleSize, sizeFile - readPos);

		try {
			haystack.seek(readPos);
		} catch (...) {
			break;
		}

		if (haystack.read(buf.get(), readSize) != readSize)
			break;

		for (size_t i = (readSize - (needleSize - 1)); i-- > 0; )
			if (!memcmp(buf.get() + i, needle, needleSize))
				return readPos + i;
	}

	return SIZE_MAX;
}