Ho una classe wrapper di template attorno al contenitore std::priority_queue che supporta il multithreading. Di seguito la versione breve. In questa classe uso la funzione IsReady() che controlla se l'elemento è pronto per essere scoppiato o meno. L'implementazione di IsReady() dipende dal tipo T .
All'inizio ho reso IsReady() un membro della classe di PriorityQueue e ho creato un metodo specializzato per i modelli per vari tipi T . Tuttavia, sembra un'idea errata inquinare questa generica classe PriorityQueue con tali specializzazioni.
#include <queue>
#include "pthread.h"
enum RV {
SUCCESS = 0,
ERROR = 1,
};
template <class T>
class PriorityQueue {
private:
std::priority_queue<T> __priorityQueue;
pthread_mutex_t __mutex;
pthread_cond_t __condition;
public:
PriorityQueue();
void Push(T element);
RV TryPop(T * element);
};
template <class T>
PriorityQueue<T>::PriorityQueue() {
pthread_mutex_init(&__mutex, NULL);
pthread_cond_init(&__condition, NULL);
}
template <class T>
void PriorityQueue<T>::Push(T element) {
pthread_mutex_lock(&__mutex);
__priorityQueue.push(element);
pthread_cond_signal(&__condition);
pthread_mutex_unlock(&__mutex);
}
template <class T>
RV PriorityQueue<T>::TryPop(T * element) {
pthread_mutex_lock(&__mutex);
if (__priorityQueue.empty()) {
pthread_mutex_unlock(&__mutex);
return ERROR;
}
*element = __priorityQueue.top();
if (!IsReady(*element)) {
pthread_mutex_unlock(&__mutex);
return ERROR;
}
__priorityQueue.pop();
pthread_mutex_unlock(&__mutex);
return SUCCESS;
}
Domande:
1) Va bene, in generale, avere qualcosa come IsReady() metodi in classi generiche come PriorityQueue ?
2) Qual è l'opzione migliore per iniettare il metodo IsReady() in questa classe (specializzazione del template, passaggio del puntatore alla funzione del costruttore di PriorityQueue etc)?
Grazie per il tuo aiuto in anticipo!