Programmation Orientée Aspect en Qt

Question

J'essaie de me concentrer sur l'AOP et certains codes Qt seraient vraiment utiles.

De wikipedia voici quelques exemples de code (facile pour un Qt/C++ programmeur pour lire):

void transfer(Account fromAcc, Account toAcc, int amount, User user, Logger logger) 
    throws Exception { 
    logger.info("transferring money..."); 
    if (! checkUserPermission(user)){ 
    logger.info("User has no permission."); 
    throw new UnauthorizedUserException(); 
    } 
    if (fromAcc.getBalance() < amount) { 
    logger.info("Insufficient Funds, sorry :("); 
    throw new InsufficientFundsException(); 
    } 

    fromAcc.withdraw(amount); 
    toAcc.deposit(amount); 

    //get database connection 

    //save transactions 

    logger.info("Successful transaction. :) "); 
} 

Et puis "aspectized":

void transfer(Account fromAcc, Account toAcc, int amount) throws Exception { 


    if (fromAcc.getBalance() < amount) { 
    throw new InsufficientFundsException(); 
    } 

    fromAcc.withdraw(amount); 
    toAcc.deposit(amount); 
} 

aspect Logger 
{ 

    void Bank.transfer(Account fromAcc, Account toAcc, int amount, User user, Logger logger) 
    {
  
     logger.info("transferring money..."); 
    } 

    void Bank.getMoneyBack(User user, int transactionId, Logger logger) 
    { 
     logger.info("User requested money back"); 
    } 

    // other crosscutting code... 
} 

Qt a des signaux et des fentes pour découpler objets. Mais j'ai encore besoin d'émettre des signaux. Donc: Cela peut-il être fait avec Qt ou ai-je besoin de framework/préprocesseurs spéciaux comme référencé dans l'article wikipedia?

J'ai le sentiment qu'il doit y avoir un truc depuis Qt utilise le compilateur Meta Object et certaines fonctionnalités peut être « injecté » avec des méthodes dynamiques .... juste à la broche Balling ici;)

Modifier : Pour donner un meilleur contexte: j'aime vraiment les aspects dynamiques (puissance) du méta-objet Qt avec des signaux et des slots et je voudrais garder une sensation Qt. Ainsi, mon idée est d'utiliser des fentes (ou des signaux) comme coupes de points. Par exemple:

Si je définis slot Bank::transfer(...) puis signal Bank::OnBeforeTranfer() et signal Bank::OnAfterTransfer(). Si je les connecte ensuite à d'autres aspects, disons Security::transfer() et Logger::transfer() (tous les QObjects) je peux bloquer les appels (comme fail OnBeforeTransfer).

Mais, si l'on prend alors à la prochaine évolution pour obtenir moins et plus propre code, je voudrais vous débarrasser des OnXXXX signaux et connecter la fente Bank::transfer à fente Security::transfer et Logger::transfer. Quelque chose de dynamique dans Qt? : Comme ordre des créneaux d'appel et et empêcher l'appel suivant dans le "chaîne de fente"?

Tout ce contexte peut toujours être considéré comme un AOP? J'essaie de m'en tenir à des «coupures de points au niveau de la méthode» ou suis-je complètement à côté de ce point ici?

Answer 1

Dans quelle langue envisagez-vous d'utiliser Qt? J'ai récemment dû construire une interface graphique simple dans Qt autour d'un script python et utiliser le paquet python AOP Aspyct pour faire des choses rapides avant et après. Qt est la programmation événementielle, je dirais se familiariser avec les bases Qt, beaucoup de choses sont similaires aux opérations de style AOP et ensuite trouver des bibliothèques AOP pour la langue que vous prévoyez d'utiliser Qt.

Answer 2

Si vous voulez pour rester dans le cadre Qt, vous pouvez jeter un oeil à the State Machine Framework. (Et se débarrasser des exceptions :)

Ensuite, vous pouvez simplement connecter le Logger aux événements de changement d'état.

Answer 3

Une autre infrastructure AOP que vous pouvez utiliser est AspectC++. J'ai joué avec un peu et ça a l'air de bien fonctionner. Ils ont même un livre blanc sur le site qui décrit comment AspectC++ peut être utilisé avec Qt.