Les blocs et libdispatch sont-ils disponibles sur Linux?

Question

J'adorerais essayer la grande distribution centrale, mais tout ce que j'ai à développer est un poste de travail Ubuntu. Est libdispatch, et l'extension de blocs à c/obj-c etc ... disponible sur Linux? Si oui, comment puis-je les obtenir?

Answer 1

Vous devrez peut-être utiliser le compilateur LLVM Clang (available on Ubuntu) pour obtenir des blocs en ce moment (je ne pense pas que ce soit disponible dans gcc, mais je n'ai pas suivi gcc, donc je peux me tromper).

Des efforts sont en cours pour porter le port libdispatch (home for the open source libdispatch) vers Linux. La plupart des efforts semblent être sur Debian jusqu'à présent, mais aussi sur d'autres distributions. Voir ces fils de discussion:

• linux + libdispatch + clang + blocks
• libdispatch porting status update
• Grand Central Dispatch available for Debian

Answer 2

Je l'ai fait un peu de travail pour obtenir la version OS X Lion Montagne de libdispatch travaillant sur Linux; le résultat est à Github: http://nickhutchinson.me/libdispatch/.

Answer 3

Plutôt que d'utiliser des blocs, utilisez C++ lambdas. Ils jouent mieux avec C++ et il y a moins de magie cachée.

je le fais comme ceci:

/// Dispatch a function object to a queue. 
template<class F> 
static void dispatch_async_function(dispatch_queue_t queue, F f) { 
    struct context_t { 
     using function_type = F; 

     context_t(function_type&& f) noexcept 
     : _f(std::move(f)) 
     {} 

     static void execute(void* p) noexcept { 
      auto context = reinterpret_cast<context_t*>(p); 
      if (context) { 
       try { 
        context->_f(); 
       } 
       catch(...) { 
        // error processing here 
       } 
       delete context; 
      } 
     } 

    private: 
     function_type _f; 
    }; 

    dispatch_async_f(queue, new context_t<F>(std::move(f)), &context_t<F>::execute); 
} 

Et si vous devez vous assurer que certaines ressources partagées existe avant que l'appel a lieu (comme un rappel sur un objet qui est maintenu en vie par un pointeur partagé) :

/// Dispatch a function object to a queue. Only execute the function if the tie 
/// locks successfully. 
template<class F> 
static void dispatch_async_tied_function(dispatch_queue_t queue, std::weak_ptr<void> tie, F f) { 
    struct context_t { 
     using function_type = F; 

     context_t(function_type&& f) noexcept 
     : _f(std::move(f)) 
     {} 

     static void execute(void* p) noexcept { 
      auto context = reinterpret_cast<context_t*>(p); 
      auto lock = _tie.lock(); 
      if (context && tie) { 
       try { 
        context->_f(); 
       } 
       catch(...) { 
        // error processing here 
       } 
       delete context; 
      } 
     } 

    private: 
     function_type _f; 
     std::weak_ptr<void> _tie; 
    }; 

    dispatch_async_f(queue, new context_t<F>(std::move(f)), &context_t<F>::execute); 
} 

les appellent comme ça

dispatch_function(queue, []() { something(); }); 

ou ...

dispatch_tied_function(_myQueue, shared_from_this(), [this]() { somethingOnThis(); }); 

Answer 4

Utiliser clang-3.4.

• sudo apt-get install libdispatch-dev
• sudo apt-get install libblocks-exécution-dev
• Compile avec -fblocks
• Lien avec -lBlocksRuntime -ldispatch