#define DEMO_MAIN_LOOP_H_
+#if !defined (COMMONAPI_INTERNAL_COMPILATION)
+#define COMMONAPI_INTERNAL_COMPILATION
+#endif
#include <CommonAPI/MainLoopContext.h>
+#undef COMMONAPI_INTERNAL_COMPILATION
#include <vector>
#include <set>
}
/**
- * The given timeout will be overridden if a timeout-event is present that defines an earlier ready time.
+ * \brief Runs the mainloop indefinitely until stop() is called.
+ *
+ * Runs the mainloop indefinitely until stop() is called. The given timeout (milliseconds)
+ * will be overridden if a timeout-event is present that defines an earlier ready time.
*/
void run(const int64_t& timeoutInterval = TIMEOUT_INFINITE) {
running_ = true;
(*fileDescriptor).revents = 0;
}
- auto numReadyFileDescriptors = ::poll(&(managedFileDescriptors_[0]), managedFileDescriptors_.size(), currentMinimalTimeoutInterval_);
+ size_t numReadyFileDescriptors = ::poll(&(managedFileDescriptors_[0]), managedFileDescriptors_.size(), currentMinimalTimeoutInterval_);
// If no FileDescriptors are ready, poll returned because of a timeout that has expired.
// The only case in which this is not the reason is when the timeout handed in "prepare"
bool check() {
//The first file descriptor always is the loop's wakeup-descriptor. All others need to be linked to a watch.
for (auto fileDescriptor = managedFileDescriptors_.begin() + 1; fileDescriptor != managedFileDescriptors_.end(); ++fileDescriptor) {
- for(auto registeredWatchIterator = registeredWatches_.begin();
+ for (auto registeredWatchIterator = registeredWatches_.begin();
registeredWatchIterator != registeredWatches_.end();
registeredWatchIterator++) {
const auto& correspondingWatchPriority = registeredWatchIterator->first;
const auto& correspondingWatchPair = registeredWatchIterator->second;
if (std::get<0>(correspondingWatchPair) == fileDescriptor->fd && fileDescriptor->revents) {
- watchesToDispatch_.insert( { correspondingWatchPriority, {std::get<1>(correspondingWatchPair), fileDescriptor->revents} } );
+ watchesToDispatch_.insert( { correspondingWatchPriority, {std::get<1>(correspondingWatchPair)} } );
}
}
}
for (auto watchIterator = watchesToDispatch_.begin();
watchIterator != watchesToDispatch_.end();
watchIterator++) {
- Watch* watch = std::get<0>(watchIterator->second);
- const unsigned int flags = std::get<1>(watchIterator->second);
- const auto& dependentSources = watch->getDependentDispatchSources();
+ Watch* watch = watchIterator->second;
+ const unsigned int flags = 7;
watch->dispatch(flags);
-
- for (auto dependentSourceIterator = dependentSources.begin();
- dependentSourceIterator != dependentSources.end();
- dependentSourceIterator++) {
- if((*dependentSourceIterator)->check()) {
- sourcesToDispatch_.insert( {watchIterator->first, *dependentSourceIterator} );
- }
- }
}
breakLoop_ = false;
watchIterator != registeredWatches_.end();
watchIterator++) {
- if(watchIterator->second.first == watch->getAssociatedFileDescriptor().fd) {
+ if(watchIterator->second.second == watch) {
registeredWatches_.erase(watchIterator);
break;
}
std::multimap<DispatchPriority, Timeout*> registeredTimeouts_;
std::set<std::pair<DispatchPriority, DispatchSource*>> sourcesToDispatch_;
- std::set<std::pair<DispatchPriority, std::pair<Watch*, unsigned short>>> watchesToDispatch_;
+ std::set<std::pair<DispatchPriority, Watch*>> watchesToDispatch_;
std::set<std::pair<DispatchPriority, Timeout*>> timeoutsToDispatch_;
DispatchSourceListenerSubscription dispatchSourceListenerSubscription_;