Example #1
0
ssize_t
Stream::Read(void *dst, size_t size)
{
	off_t curPos = Position();
	ssize_t read = ReadAt(curPos, dst, size);
	if (read > 0)
		Seek(read, SEEK_CUR);
	return read;
}
Example #2
0
// Read
ssize_t
BPositionIO::Read(void *buffer, size_t size)
{
	off_t curPos = Position();
	ssize_t result = ReadAt(curPos, buffer, size);
	if (result > 0)
		Seek(result, SEEK_CUR);

	return result;
}
Example #3
0
	virtual	ssize_t	ReadAt(off_t position, void* buffer,
		size_t size)
	{
		if (position == Position()) {
			ssize_t ret = fDataIO->Read(buffer, size);
			fDataInputAdapter->Write(buffer, ret);
			return ret;
		}

		off_t totalSize = 0;
		if (GetSize(&totalSize) != B_OK)
			return B_UNSUPPORTED;

		if (position+size < (size_t)totalSize)
			return ReadAt(position, buffer, size);

		return B_NOT_SUPPORTED;
	}
Example #4
0
 bool DataReader::Read( double& v )
 {
     return ReadAt( currentIndex++, v );
 }
Example #5
0
 bool DataReader::Read( long long& v )
 {
     return ReadAt( currentIndex++, v );
 }
Example #6
0
 bool DataReader::Read( int& v )
 {
     return ReadAt( currentIndex++, v );
 }
Example #7
0
 std::string DataReader::ReadString()
 {
     std::string v;
     ReadAt( currentIndex++, v );
     return v;
 }
Example #8
0
	virtual size_t Read(size_t bytes, void *data) override {
		return ReadAt(filepos_, bytes, data);
	}
Example #9
0
void Device::Warmup() {
	ReadAt(M, M);
}
Example #10
0
 long long DataReader::ReadInt64At( int columnIndex )
 {
     long long v = 0;
     ReadAt( columnIndex, v );
     return v;
 }
Example #11
0
 int DataReader::ReadInt32At( int columnIndex )
 {
     int v = 0;
     ReadAt( columnIndex, v );
     return v;
 }
Example #12
0
 std::string DataReader::ReadStringAt( int columnIndex )
 {
     std::string v;
     ReadAt( columnIndex, v );
     return v;
 }
Example #13
0
 char const* DataReader::ReadCStringAt( int columnIndex )
 {
     char const* v = nullptr;
     ReadAt( columnIndex, v );
     return v;
 }
Example #14
0
 double DataReader::ReadDouble()
 {
     double v = 0;
     ReadAt( currentIndex++, v );
     return v;
 }
Example #15
0
 long long DataReader::ReadInt64()
 {
     long long v = 0;
     ReadAt( currentIndex++, v );
     return v;
 }
Example #16
0
 int DataReader::ReadInt32()
 {
     int v = 0;
     ReadAt( currentIndex++, v );
     return v;
 }
Example #17
0
 double DataReader::ReadDoubleAt( int columnIndex )
 {
     double v = 0;
     ReadAt( columnIndex, v );
     return v;
 }
Example #18
0
 bool DataReader::Read( char const*& v )
 {
     return ReadAt( currentIndex++, v );
 }
Example #19
0
/*virtual*/ bool
BufferStream::CachedReadAt(int64_t aOffset, void* aData, size_t aLength,
                           size_t* aBytesRead)
{
  return ReadAt(aOffset, aData, aLength, aBytesRead);
}
Example #20
0
 bool DataReader::Read( std::string & v )
 {
     return ReadAt( currentIndex++, v );
 }
Example #21
0
	virtual size_t ReadAt(s64 absolutePos, size_t bytes, size_t count, void *data) override {
		return ReadAt(absolutePos, bytes * count, data) / bytes;
	}
Example #22
0
 char const* DataReader::ReadCString()
 {
     char const* v = nullptr;
     ReadAt( currentIndex++, v );
     return v;
 }