Status::Result Max6675::update() {
performRead();
if (sample_log_array) {
// logging
if (sample_log_idx < sample_log_size) {
Max6675::SampleLog * s = (Max6675::SampleLog *)(sample_log_array);
(s[sample_log_idx++]) = last_sample.data.init;
}
// don't use an 'else' here, but
// split this in two, so we return logfull
// as soon as it is true.
if (sample_log_idx >= sample_log_size) {
last_status = Status::LogFull;
return last_status;
}
}
last_status =
last_sample.data.thermo.isFault() ? this->determineError() : Status::OK;
return last_status;
}
void ListenerSocketConnection::readMessages() {
String key = getInstance();
try {
continueRead = true;
while( continueRead )
performRead();
}
catch ( RuntimeException& e ) {
logger.logError( "readMessages: connection=" + key + " - exception caught:" );
logger.printStack( e );
}
catch ( ... ) {
logger.printStack();
logger.logError( "readMessages: connection=" + key + " - unknown exception in read" );
}
try {
stopConnection();
}
catch ( ... ) {
logger.printStack();
logger.logError( "readMessages: connection=" + key + " - unknown exception in stop" );
}
}
void PollingBuffer::performTransimission(uint32_t event) {
if (event & EPOLLOUT && m_outputData.size() != 0) {
std::cout << "#Writing data" << std::endl;
performWrite();
}
pushMessages();
popMessages();
if (m_ballance == 0 && (event & EPOLLIN)) {
std::cout << "#Reading data" << std::endl;
performRead();
}
}
BufferRef SourceFile::loadBuffer()
{
seek( 0 );
BufferRef result = make_shared<Buffer>( mNumFrames, getNumChannels() );
if( mConverter ) {
// TODO: need BufferView's in order to reduce number of copies
Buffer converterDestBuffer( mConverter->getDestMaxFramesPerBlock(), getNumChannels() );
size_t readCount = 0;
while( true ) {
size_t framesNeeded = min( getMaxFramesPerRead(), mFileNumFrames - readCount );
if( framesNeeded == 0 )
break;
// make sourceBuffer num frames match outNumFrames so that Converter doesn't think it has more
if( framesNeeded != mConverterReadBuffer.getNumFrames() )
mConverterReadBuffer.setNumFrames( framesNeeded );
size_t outNumFrames = performRead( &mConverterReadBuffer, 0, framesNeeded );
CI_ASSERT( outNumFrames == framesNeeded );
pair<size_t, size_t> count = mConverter->convert( &mConverterReadBuffer, &converterDestBuffer );
result->copyOffset( converterDestBuffer, count.second, mReadPos, 0 );
readCount += outNumFrames;
mReadPos += count.second;
}
}
else {
size_t readCount = performRead( result.get(), 0, mNumFrames );
mReadPos = readCount;
}
return result;
}
size_t SourceFile::read( Buffer *buffer )
{
CI_ASSERT( buffer->getNumChannels() == getNumChannels() );
CI_ASSERT( mReadPos < mNumFrames );
size_t numRead;
if( mConverter ) {
size_t sourceBufFrames = size_t( buffer->getNumFrames() * (float)getSampleRateNative() / (float)getSampleRate() );
size_t numFramesNeeded = std::min( mFileNumFrames - mReadPos, std::min( getMaxFramesPerRead(), sourceBufFrames ) );
mConverterReadBuffer.setNumFrames( numFramesNeeded );
performRead( &mConverterReadBuffer, 0, numFramesNeeded );
pair<size_t, size_t> count = mConverter->convert( &mConverterReadBuffer, buffer );
numRead = count.second;
}
else {
size_t numFramesNeeded = std::min( mNumFrames - mReadPos, std::min( getMaxFramesPerRead(), buffer->getNumFrames() ) );
numRead = performRead( buffer, 0, numFramesNeeded );
}
mReadPos += numRead;
return numRead;
}
int main() {
Solution sln;
performRead(sln, 1);
performRead(sln, 2);
}
void PipeBase::processEvents()
{
DWORD dwWait = WaitForMultipleObjects(getNumEvents(), m_hEventsArr, FALSE, 500);
if (isStopped())
return;
if (dwWait == WAIT_TIMEOUT)
return;
if (dwWait == WAIT_FAILED)
{
DWORD lErr = GetLastError();
return;
}
// dwWait shows which pipe completed the operation.
size_t i = dwWait - WAIT_OBJECT_0; // determines which pipe
if (i < 0 || i > (getNumEvents() - 1))
{
printf("Index out of range.\n");
return;
}
PipeData* data = getData(i);
DWORD cbRet = 0;
#ifdef IPC_DEBUG
if (fh)
{
fprintf(fh, "Triggered event %d\n", i);
fflush(fh);
}
#endif
//printf("Event %d, P: %d\n", i, data->fPendingIO);
// Get the result if the operation was pending.
if (data->fPendingIO)
{
BOOL fSuccess = GetOverlappedResult(data->hPipe, &data->oOverlap, &cbRet, FALSE);
//printf("Pending S: %d A: %d P: %d\n", fSuccess, cbRet, data->pendingConnection);
if (data->pendingConnection)
{
if (!fSuccess)
throw gcException(ERR_PIPE, GetLastError(), gcString("Error {0}.\n", GetLastError()));
data->pendingConnection = false;
data->fPendingIO = FALSE;
}
else
{
DWORD err = GetLastError();
//Buffer is full. Wait for space
if (err == ERROR_IO_INCOMPLETE)
fSuccess = GetOverlappedResult(data->hPipe, &data->oOverlap, &cbRet, TRUE);
if (!fSuccess || (cbRet == 0 && data->sender == false)) // || (cbRet != data->size && data->sender == true)
{
disconnectAndReconnect(i);
ResetEvent(m_hEventsArr[i]);
printf("Disconnect pending!\n");
return;
}
if (!data->sender)
{
data->size = cbRet;
finishRead(data, getManager(i));
}
}
}
bool res = false;
// The pipe state determines which operation to do next.
if (data->sender)
res = performWrite(data, getManager(i));
else
res = performRead(data, getManager(i));
if (res)
ResetEvent(m_hEventsArr[i]);
}
