add UI interruption

nut-code-monkey · nut-code-monkey · commit 11921b4c5b39 · 2013-07-05T18:12:40.000+03:00
diff --git a/dispatch.xcodeproj/project.xcworkspace/xcuserdata/max.xcuserdatad/UserInterfaceState.xcuserstate b/dispatch.xcodeproj/project.xcworkspace/xcuserdata/max.xcuserdatad/UserInterfaceState.xcuserstate
diff --git a/dispatch/dispatch.cpp b/dispatch/dispatch.cpp
@@ -21,18 +21,21 @@ namespace dispatch
 {
 #pragma mark - TaskPriority
     
-    struct TaskPriority{
+    struct TaskPriority
+    {
         TaskPriority(QUEUE_PRIORITY priority, Functor task) : priority(priority), task(task), timestamp(std::clock()){}
 
         QUEUE_PRIORITY priority;
         Functor task;
         std::clock_t timestamp;
     };
+
 #pragma mark - Queue
     
     typedef std::function<void (Functor)> AppendTask;
     
-    struct QueueImpl {
+    struct QueueImpl
+    {
         QUEUE_PRIORITY priority;
         AppendTask append_task;
 
@@ -47,7 +50,8 @@ namespace dispatch
     
 #pragma mark - ThreadPool
     
-    class ThreadPool {
+    class ThreadPool
+    {
     public:
         ThreadPool(size_t);
         static ThreadPool* instance();
@@ -64,6 +68,7 @@ namespace dispatch
         std::mutex main_mutex;
         std::condition_variable main_condition;
         
+        Functor main_loop_need_update;
     private:
         friend class QueueImpl;
 
@@ -73,7 +78,8 @@ namespace dispatch
     
 #pragma mark - Task comparator
     
-    bool operator<(const QueueImpl::Task& firsTask, const QueueImpl::Task& secondTask) {
+    bool operator<(const QueueImpl::Task& firsTask, const QueueImpl::Task& secondTask)
+    {
         if ( firsTask->priority == secondTask->priority )
             return firsTask->timestamp > secondTask->timestamp;
         else
@@ -82,10 +88,13 @@ namespace dispatch
     
 #pragma mark - ThreadPool
     
-    void ThreadPool::add_worker(){
-        workers.push_back(std::thread([&]{
+    void ThreadPool::add_worker()
+    {
+        workers.push_back(std::thread([&]
+        {
             QueueImpl::Task task;
-            while(true){
+            while(true)
+            {
                 {
                     std::unique_lock<std::mutex> lock(this->queue_mutex);
 
@@ -103,24 +112,27 @@ namespace dispatch
         }));
     }
     
-    ThreadPool::ThreadPool(size_t threads) : stop(false){
+    ThreadPool::ThreadPool(size_t threads) : stop(false)
+    {
         for (int i = 0; i < threads; ++i)
             add_worker();
     }
     
-    ThreadPool::~ThreadPool(){
+    ThreadPool::~ThreadPool()
+    {
         stop = true;
         condition.notify_all();
-        
-        // the destructor joins all threads
+
         for(size_t i = 0;i<workers.size();++i)
             workers[i].join();
     }
     
-    ThreadPool* ThreadPool::instance(){
+    ThreadPool* ThreadPool::instance()
+    {
         static std::once_flag flag;
         static ThreadPool* instance = nullptr;
-        std::call_once(flag, [](){
+        std::call_once(flag, []()
+                       {
                            int default_not_computable_value = 5;
                            int number_of_threads = std::thread::hardware_concurrency();
                            instance = new ThreadPool(number_of_threads?: default_not_computable_value);
@@ -130,47 +142,63 @@ namespace dispatch
     
 #pragma mark -
     
-    Queue get_main_queue(){
-        return std::make_shared<QueueImpl>([](Functor task) {
+    Queue get_main_queue()
+    {
+        return std::make_shared<QueueImpl>([](Functor task)
+        {
             std::unique_lock<std::mutex> lock(ThreadPool::instance()->main_mutex);
             ThreadPool::instance()->main_queue.push(std::make_shared<TaskPriority>(QUEUE_PRIORITY::HIGH, task));
+            if (ThreadPool::instance()->main_loop_need_update != nullptr)
+                ThreadPool::instance()->main_loop_need_update();
         });
     }
     
-    void process_main_loop(){
+    Queue get_queue_with_priority(QUEUE_PRIORITY priority)
+    {
+        return std::make_shared<QueueImpl>(priority, [=](Functor task)
+                                           {
+                                               {
+                                                   std::unique_lock<std::mutex> lock(ThreadPool::instance()->queue_mutex);
+                                                   ThreadPool::instance()->tasks.push(std::make_shared<TaskPriority>(priority, task));
+                                               }
+                                               ThreadPool::instance()->condition.notify_one();
+                                           });
+    }
+    
+    void process_main_loop()
+    {
         ThreadPool* pool = ThreadPool::instance();
         std::unique_lock<std::mutex> lock(pool->main_mutex);
-        while (!pool->main_queue.empty()){
+        while (!pool->main_queue.empty())
+        {
             QueueImpl::Task task = pool->main_queue.front();
             pool->main_queue.pop();
             task->task();
         }
     }
 
-    void main_loop(Functor function){
+    void main_loop(Functor function)
+    {
         Queue main_queue = get_main_queue();
-        while (!ThreadPool::instance()->stop){
+        while (!ThreadPool::instance()->stop)
+        {
             async(main_queue, function);
             process_main_loop();
         }
     }
 
-    void async(Queue queue, Functor function){
+    void async(Queue queue, Functor function)
+    {
         queue->append_task(function);
     }
     
-    void exit(){
+    void exit()
+    {
         ThreadPool::instance()->stop = true;
     }
     
-    Queue get_queue_with_priority(QUEUE_PRIORITY priority){
-        return std::make_shared<QueueImpl>(priority, [=](Functor task) {
-            {
-                std::unique_lock<std::mutex> lock(ThreadPool::instance()->queue_mutex);
-                ThreadPool::instance()->tasks.push(std::make_shared<TaskPriority>(priority, task));
-            }
-
-            ThreadPool::instance()->condition.notify_one();
-        });
+    void set_main_loop_process_callback(Functor update_callback)
+    {
+        ThreadPool::instance()->main_loop_need_update = update_callback;
     }
 }
diff --git a/dispatch/dispatch.h b/dispatch/dispatch.h
@@ -23,17 +23,19 @@ namespace dispatch
     } QUEUE_PRIORITY;
 
     typedef std::function<void ()> Functor;
-    
+
     class QueueImpl;
     typedef std::shared_ptr<QueueImpl> Queue;
     
     Queue get_main_queue();
     Queue get_queue_with_priority(QUEUE_PRIORITY priority);
 
-    void process_main_loop();
-    void main_loop(Functor function);
     void async(Queue queue, Functor function);
+    
     void exit();
+    void main_loop(Functor function);
+    void process_main_loop();
+    void set_main_loop_process_callback(Functor functor);
 }
 
 #endif
diff --git a/dispatch/main.cpp b/dispatch/main.cpp
@@ -42,7 +42,7 @@ int main(int argc, const char * argv[])
     dispatch::main_loop([]{
         std::cout << ".";
     });
-    
+
     return 0;
 }
 
diff --git a/ios/ios.xcodeproj/project.xcworkspace/xcuserdata/max.xcuserdatad/UserInterfaceState.xcuserstate b/ios/ios.xcodeproj/project.xcworkspace/xcuserdata/max.xcuserdatad/UserInterfaceState.xcuserstate
diff --git a/ios/ios/AppDelegate.mm b/ios/ios/AppDelegate.mm
@@ -19,50 +19,16 @@ @implementation AppDelegate
 
 @synthesize runLoopObserver;
 
-static void onRunLoop(CFRunLoopObserverRef observer, CFRunLoopActivity activity, void* info)
+-(void)dispatchMainThread
 {
     dispatch::process_main_loop();
 }
 
-- (void)attachObservers
-{
-    if (runLoopObserver != NULL)
-        return;
-
-    CFRunLoopObserverContext context =
-    {
-        0,    // Version of this structure. Must be zero.
-        (__bridge void*)self, // Info pointer: a reference to this UpdateTimer.
-        NULL, // Retain callback for info pointer.
-        NULL, // Release callback for info pointer.
-        NULL  // Copy description.
-    };
-
-    runLoopObserver = CFRunLoopObserverCreate(NULL,
-                                              kCFRunLoopBeforeWaiting | kCFRunLoopExit, // Observe when the run loop is waiting and just before it exits.
-                                              true, // Repeats.
-                                              0, // Priority index. Use zero because there's currently no reason to do otherwise.
-                                              onRunLoop,
-                                              &context); // Copied by CFRunLoopObserverCreate, no need to pass a heap pointer.
-
-    CFRunLoopAddObserver(CFRunLoopGetCurrent(), runLoopObserver, kCFRunLoopCommonModes);
-}
-
-- (void)detachObservers
-{
-    if (runLoopObserver == NULL)
-        return;
-
-    CFRunLoopObserverInvalidate(runLoopObserver);
-    CFRelease(runLoopObserver);
-    runLoopObserver = NULL;
-}
-
 - (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
 {
-    [self attachObservers];
-    
-    // Override point for customization after application launch.
+    dispatch::set_main_loop_process_callback([=]{
+        [self performSelectorOnMainThread:@selector(dispatchMainThread) withObject:nil waitUntilDone:NO];
+    });
     return YES;
 }
 							
@@ -91,7 +57,6 @@ - (void)applicationDidBecomeActive:(UIApplication *)application
 
 - (void)applicationWillTerminate:(UIApplication *)application
 {
-    [self detachObservers];
     
     // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
 }
diff --git a/ios/ios/ViewController.h b/ios/ios/ViewController.h
@@ -10,6 +10,8 @@
 
 @interface ViewController : UIViewController
 
-- (IBAction)onRunButtonClick:(id)sender;
+-(IBAction)onRunButtonClick:(id)sender;
+
+@property (strong, nonatomic) IBOutlet UITableView *tableView;
 
 @end
diff --git a/ios/ios/ViewController.mm b/ios/ios/ViewController.mm
@@ -7,35 +7,32 @@
 //
 
 #import "ViewController.h"
+
 #import "dispatch.h"
+
 #import <string>
 #import <iostream>
 
-@interface ViewController ()
-
-@end
-
 @implementation ViewController
 
 - (IBAction)onRunButtonClick:(id)sender
 {
-    dispatch::Queue queue = dispatch::get_queue_with_priority(dispatch::QUEUE_PRIORITY::HIGH);
-    
-    dispatch::Queue main_queue = dispatch::get_main_queue();
     for (int i = 0; i < 20; ++i)
     {
-        dispatch::async(queue, [=](){
+        dispatch::async(dispatch::get_queue_with_priority(dispatch::QUEUE_PRIORITY::HIGH), [=](){
             
             std::string first_string = std::to_string(i);
             
-            dispatch::async(main_queue, [=]{
-                
+            dispatch::async(dispatch::get_main_queue(), [=]{
+
                 std::string second_string = std::to_string(i+1);
                 
                 std::cout << first_string << " -> " << second_string << std::endl;
+                
+                [self.tableView reloadData];
             });
         });
     }
-    
 }
+
 @end
diff --git a/ios/ios/en.lproj/MainStoryboard.storyboard b/ios/ios/en.lproj/MainStoryboard.storyboard
@@ -25,14 +25,24 @@
                                     <action selector="onRunButtonClick:" destination="2" eventType="touchUpInside" id="cS2-Dv-cjl"/>
                                 </connections>
                             </button>
+                            <tableView clipsSubviews="YES" contentMode="scaleToFill" alwaysBounceVertical="YES" dataMode="prototypes" style="plain" rowHeight="44" sectionHeaderHeight="22" sectionFooterHeight="22" translatesAutoresizingMaskIntoConstraints="NO" id="Wx2-He-U1k">
+                                <color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
+                            </tableView>
                         </subviews>
                         <color key="backgroundColor" white="1" alpha="1" colorSpace="custom" customColorSpace="calibratedWhite"/>
                         <constraints>
+                            <constraint firstItem="Wx2-He-U1k" firstAttribute="top" secondItem="TKA-PP-F8H" secondAttribute="bottom" constant="8" symbolic="YES" type="default" id="6YF-Gd-xpU"/>
+                            <constraint firstAttribute="bottom" secondItem="Wx2-He-U1k" secondAttribute="bottom" constant="20" symbolic="YES" type="default" id="DQH-53-iv0"/>
                             <constraint firstAttribute="trailing" secondItem="TKA-PP-F8H" secondAttribute="trailing" constant="20" symbolic="YES" type="default" id="IQh-zZ-mLE"/>
                             <constraint firstItem="TKA-PP-F8H" firstAttribute="top" secondItem="3" secondAttribute="top" constant="20" symbolic="YES" type="default" id="IfE-4Y-rwZ"/>
                             <constraint firstItem="TKA-PP-F8H" firstAttribute="leading" secondItem="3" secondAttribute="leading" constant="20" symbolic="YES" type="default" id="Qeg-9b-CS5"/>
+                            <constraint firstAttribute="trailing" secondItem="Wx2-He-U1k" secondAttribute="trailing" constant="20" symbolic="YES" type="default" id="Zp0-Kg-1nn"/>
+                            <constraint firstItem="Wx2-He-U1k" firstAttribute="leading" secondItem="3" secondAttribute="leading" constant="20" symbolic="YES" type="default" id="gT3-od-ZKD"/>
                         </constraints>
                     </view>
+                    <connections>
+                        <outlet property="tableView" destination="Wx2-He-U1k" id="FrQ-7q-UIQ"/>
+                    </connections>
                 </viewController>
                 <placeholder placeholderIdentifier="IBFirstResponder" id="4" sceneMemberID="firstResponder"/>
             </objects>
@@ -46,6 +56,7 @@
             <source key="sourceIdentifier" type="project" relativePath="./Classes/ViewController.h"/>
             <relationships>
                 <relationship kind="action" name="onRunButtonClick:"/>
+                <relationship kind="outlet" name="tableView" candidateClass="UITableView"/>
             </relationships>
         </class>
     </classes>

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ int main(int argc, const char * argv[])`
`42`	`42`	`dispatch::main_loop([]{`
`43`	`43`	`std::cout << ".";`
`44`	`44`	`});`
`45`		`-`
	`45`	`+`
`46`	`46`	`return 0;`
`47`	`47`	`}`
`48`	`48`