bool _i2cAvailableData(InputStream* inputStream) {
fillI2CInputInternalBuffer(inputStream);
Buffer* buffer = _i2cMasterInputStreamGetBuffer(inputStream);
bool result = !isBufferEmpty(buffer);
return result;
}
char bufferGetFirstChar(Buffer* buffer) {
int isEmpty = isBufferEmpty(buffer);
if (!isEmpty) {
char* sPointer = (char*) buffer->s;
// Shift to the right cell index
sPointer += buffer->readIndex;
char result = *sPointer;
return result;
} else {
// We must log the problem
writeError(IO_BUFFER_EMPTY);
}
return 0;
}
int SocketReader::bufferData() {
if (isBufferEmpty()) {
const int ReadAmount = ::read(_MySocket, _BufferedData, BufferSize);
const int ReadError = errno;
if (ReadAmount > 0U) {
_BufferIndex = ReadAmount;
_BufferReadIndex = 0U;
}
return ReadAmount;
} else {
return 0;
}
}
uint32_t SocketReader::getAvailableData(uint8_t * dataOut,
const uint32_t MaxOut) throw (int) {
if (isBufferEmpty()) {
const int bufferResult = bufferData();
if (bufferResult < 0 && _BufferIndex == 0U) {
throw bufferResult;
} else if (_BufferIndex == 0U) {
throw 0;
}
}
const uint32_t BytesToTake = MIN(_BufferIndex - _BufferReadIndex, MaxOut);
memcpy(dataOut, &_BufferedData[_BufferReadIndex], BytesToTake);
_BufferReadIndex += BytesToTake;
return BytesToTake;
}
// Arbitrary-size pop function
unsigned int popFromBuffer(buffer_t *b, void *d, unsigned int l){
unsigned int elementIndex, byteIndex;
for (elementIndex = 0; elementIndex < l; elementIndex++) {
for (byteIndex = 0; byteIndex < b->width; byteIndex++) {
if (!isBufferEmpty(b)){
// Stacks swap bytes of multi-byte elements, so swap back
// on pop operation
if (b->behavior.bits.stack){
*( (unsigned char*)(d + ((elementIndex + 1) * b->width) - 1 - byteIndex) ) = popByte(b);
}
// Queue does not swap bytes, so no need to swap on pop
else {
*( (unsigned char*)(d + (elementIndex * b->width) + byteIndex) ) = popByte(b);
}
}
else {
// Push any bytes back to buffer that form an incomplete element
// -Ideally this should never run, but added just in case
unsigned int failedbytes;
for (failedbytes=byteIndex; failedbytes > 0; failedbytes--){
// Careful not to swap bytes here...
pushByte(b, *( (unsigned char*)(d + elementIndex * b->width + failedbytes ) ));
}
// Return a count of failed pop operations
// -Include partial pops in counter
return l - elementIndex;
}
}
}
return 0;
}
void printBuffer(OutputStream* outputStream, Buffer* buffer) {
while(!isBufferEmpty(buffer)) {
unsigned char c = bufferReadChar(buffer);
append(outputStream, c);
}
}
/**
* Definition of a function which is able to return if there is character to read.
*/
BOOL _bufferAvailableData(InputStream* inputStream) {
Buffer* buffer = (Buffer*) inputStream->object;
BOOL result = !isBufferEmpty(buffer);
return result;
}
