Changeset 2495 for branches/vtkvis_threaded/ResponseQueue.cpp

Timestamp:

Sep 8, 2011, 8:03:53 PM (13 years ago)

Author:

ldelgass

Message:

A few mostly style changes to make more consistent with style in vtkvis. Also
fix queueTGA -- no need to copy one scanline at a time and bytes per pixel can
be 3 or 4).

File:

• branches/vtkvis_threaded/ResponseQueue.cpp (modified) (1 diff)

branches/vtkvis_threaded/ResponseQueue.cpp

@@ -1 @@
-
-#ifdef USE_THREADS
+/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+/*
+ * Copyright (C) 2011, Purdue Research Foundation
+ *
+ * Author: George A. Howlett <gah@purdue.edu>
+ */
 
 #include <pthread.h>
 #include <semaphore.h>
-#include <errno.h>
-#include <list>
-#include <stdlib.h>
-#include <errno.h>
+#include <cerrno>
 #include <cstring>
 #include <cstdlib>
+#include <list>
+
 #include "Trace.h"
 #include "ResponseQueue.h"
 
-ResponseQueue::ResponseQueue(void *clientData) 
+using namespace Rappture::VtkVis;
+
+ResponseQueue::ResponseQueue(void *clientData)  :
+    _clientData(clientData)
 {
     pthread_mutex_init(&_idle, NULL);
     if (sem_init(&_ready, 0, 0) < 0) {
-        ERROR("can't initialize semaphore: %s", strerror(errno));
+        ERROR("can't initialize semaphore: %s", strerror(errno));
     }
-    _clientData = clientData;
 }
 
-ResponseQueue::~ResponseQueue(void) 
+ResponseQueue::~ResponseQueue() 
 {
     pthread_mutex_destroy(&_idle);
     if (sem_destroy(&_ready) < 0) {
-        ERROR("can't destroy semaphore: %s", strerror(errno));
+        ERROR("can't destroy semaphore: %s", strerror(errno));
     }
 }
 
 void
-ResponseQueue::Enqueue(Response *responsePtr)
+ResponseQueue::enqueue(Response *response)
 {
     if (pthread_mutex_lock(&_idle) != 0) {
-        ERROR("can't lock mutex: %s", strerror(errno));
+        ERROR("can't lock mutex: %s", strerror(errno));
     }   
     /* Examine the list and remove any queued responses of the same type. */
     INFO("before # of elements is %d\n", _list.size());
-    std::list<Response *>::iterator iter;
-    for (iter = _list.begin(); iter != _list.end(); iter++) {
-        /* Remove any responses of the same type. There should be no more than
-         * one. */
-        if ((*iter)->Type() == responsePtr->Type()) {
-            _list.erase(iter);
-        }
+    for (std::list<Response *>::iterator itr = _list.begin();
+         itr != _list.end(); ++itr) {
+        /* Remove any responses of the same type. There should be no more than
+         * one. */
+        if ((*itr)->type() == response->type()) {
+            _list.erase(itr);
+        }
     }
     /* Add the new response to the end of the list. */
-    _list.push_back(responsePtr);
+    _list.push_back(response);
     if (sem_post(&_ready) < 0) {
-        ERROR("can't post semaphore: %s", strerror(errno));
+        ERROR("can't post semaphore: %s", strerror(errno));
     }
     if (pthread_mutex_unlock(&_idle) != 0) {
-        ERROR("can't unlock mutex: %s", strerror(errno));
+        ERROR("can't unlock mutex: %s", strerror(errno));
     }   
 }
 
 Response *
-ResponseQueue::Dequeue(void)
+ResponseQueue::dequeue()
 {
-    Response *responsePtr;
+    Response *response;
 
     if (sem_wait(&_ready) < 0) {
-        ERROR("can't wait on semaphore: %s", strerror(errno));
+        ERROR("can't wait on semaphore: %s", strerror(errno));
     }
     if (pthread_mutex_lock(&_idle) != 0) {
-        ERROR("can't lock mutex: %s", strerror(errno));
+        ERROR("can't lock mutex: %s", strerror(errno));
     }   
-    responsePtr = _list.front();
+    response = _list.front();
     _list.pop_front();
     if (pthread_mutex_unlock(&_idle) != 0) {
-        ERROR("can't unlock mutex: %s", strerror(errno));
+        ERROR("can't unlock mutex: %s", strerror(errno));
     }   
-    return responsePtr;
+    return response;
 }
-
-#endif /*USE_THREADS*/