zoukankan      html  css  js  c++  java

  • MFC消息映射机制在Linux C++编程环境下的应用(转)

    #ifndef MSG_CONSTANT_H
    #define MSG_CONSTANT_H

    #define MAX_MSG_PARA_SIZE 2048 /*消息参数大小*/
    #define MAX_QUEUE_LENGTH  3000 /*队列限制长度*/


    #define EVENTMSG_QUIT      100 /*退出*/

    #define RW_SUCCESS           0
    #define EMPTY_QUE            1
    #define RW_ERROR_QUE        -1
    #define FULL_QUE            -2
    #define LOCK_ERROR          -3
    #define UNLOCK_ERROR        -4
    #define REALESE_LOCK_ERROR  -5
    #define UN_INI                   -6

    #define PER_BUFF_LENGTH     1000 /*消息输入缓冲区大小（条）*/

    /*!
    *
    * 定义消息映射段内项目的宏 参考MFC 消息映射机制
    */

    /*消息处理函数调用时，加上this,必须是消息机的成员函数*/
    #define MSG_MAP_FUN(MSG_CODE,MSG_ACTION_FUN)  case MSG_CODE:this->MSG_ACTION_FUN(msg);break;
                
    /*实现消息转发到其他消息处理对象指针，用于某些消息需要长时间处理的情况，接受对象必须为msg_machine的子类*/            
    #define MSG_MAP_OBJ(MSG_CODE,MSG_ACTION_OBJ)  case MSG_CODE:SendMessage(msg,MSG_ACTION_OBJ);break;

    /*!消息映射宏
    *
    * BEGIN_MSG_MAP为定义消息映射段开始的宏
    * 消息映射段必须出现在类体内，不是实现部分
    *形式如下 
    *  BEGIN_MSG_MAP
    *    MSG_MAP_FUN(message code ,member function that must return void and have a Msg type parameter)
    *   MSG_MAP_OBJ(message code ,message machine class instance)
    *  END_MSG_MAP
    */                

    #define BEGIN_MSG_MAP   virtual void Dispatch(struct Msg msg) \
                   {                                      \
                                                    \
                    unsigned int msg_code;                  \
                    msg_code=msg.msg_code;                  \
                    switch(msg_code)                      \
                    {
                

    /*!
    *
    * 定义消息映射段结束的宏
    */                
    #define END_MSG_MAP(base) default:         \
                base::Dispatch(msg);        \
                break;     \
                }\
         }

    #endif

    1. #ifndef MESSAGE_STRUCT_H
    2. #define MESSAGE_STRUCT_H
    3. #ifdef _cplusplus
    4. extern "C"
    5. {
    6. #include <pthread.h>
    7. #include <semaphore.h>
    8. #include <stdio.h>
    9. #include <stdlib.h>
    10. #include <string.h>
    11. #include <ctype.h>
    12. }
    13. #endif //_cplusplus
    14. #include "msg_macro.h"
    15. typedef unsigned char u_char;
    16. struct Msg
    17. {
    18. unsigned int msg_code;     // Message Code
    19. u_char   msg_para[MAX_MSG_PARA_SIZE]; // Message Parameter
    20. };
    21. class Msg_queue
    22. {
    23. public:
    24. Msg_queue(){ initialized=false; };
    25. ~Msg_queue();
    26. int Initialize();
    27. int GetHead(struct Msg *p_msg);
    28. int AddTail(struct Msg *p_msg);
    29. private:
    30. pthread_mutex_t mutex_wr;
    31. bool initialized; 
    32.     int msg_count;
    33. int head;
    34.     int tail; 
    35. struct Msg   msg_array[MAX_QUEUE_LENGTH];
    36. };
    37. #endif // MESSAGE_STRUCT_H
    复制代码



    1. #include "msg.h"
    2. extern "C"
    3. {
    4. #include <error.h>
    5. #include <errno.h>
    6. }
    7. int  Msg_queue::Initialize()
    8. {
    9. int error;
    11. if(initialized)return 0;
    13. error=pthread_mutex_init(&mutex_wr,NULL);
    14. switch(error){
    15.   case EAGAIN: initialized=false; return -1;
    16.   case ENOMEM: initialized=false; return -2;
    17.   case EPERM:  initialized=false;  return -3;
    18. }
    19.   initialized=true;
    20. msg_count=0;
    21. head=0;
    22. tail=0;
    23. memset(msg_array,0,sizeof(msg_array));
    24. return 0;    
    25. }
    26. int  Msg_queue::GetHead(struct Msg *p_msg)
    27. {
    28. int result;
    29. int error;
    30. if(!initialized)return UN_INI;
    31. if(p_msg==NULL) return RW_ERROR_QUE;
    33. if(error=pthread_mutex_lock(&mutex_wr))
    34. return -3;//取锁失败
    36. if(msg_count>0)
    37. {
    38.   memcpy((void*)p_msg,(void*)&msg_array[head],sizeof(struct Msg));
    39.   memset((void*)&msg_array[head],0,sizeof(struct Msg));
    40.   head++;
    41.   if(head==MAX_QUEUE_LENGTH)head=0;
    42.   msg_count--;
    43.   result= RW_SUCCESS;
    44. }
    45. else
    46. {
    47.   p_msg->msg_code=EMPTY_QUE;
    48.   result=EMPTY_QUE; 
    49. }
    51. if(error=pthread_mutex_unlock(&mutex_wr))
    52. return -4;//解锁失败
    54. return result;
    56. }
    57. int Msg_queue::AddTail(struct Msg *p_msg)
    58. {
    59. int ilock;
    60. int result;
    61. int error;
    62. if(p_msg==NULL)return RW_ERROR_QUE;
    63. if(!initialized)return UN_INI;
    64. if(error=pthread_mutex_lock(&mutex_wr))
    65. return -3;
    67. if(msg_count<MAX_QUEUE_LENGTH)
    68. {
    69.   memcpy((void*)&msg_array[tail],(void*)p_msg,sizeof(struct Msg));
    70.   tail++;
    71.   if(tail==MAX_QUEUE_LENGTH)
    72.   tail=0;
    73.   msg_count++;
    74.   result=RW_SUCCESS;
    75. }
    76. else
    77. result=FULL_QUE;
    79. if(error=pthread_mutex_unlock(&mutex_wr))
    80. result=-4;
    82. return result;
    83. }
    84. Msg_queue::~Msg_queue()
    85. {
    86.   pthread_mutex_destroy(&mutex_wr);   
    87. }
    复制代码



    1. #ifndef  MSGMACHINE_H
    2. #define  MSGMACHINE_H
    3. #include "msg.h"
    4. #include "msg_macro.h"
    5. #include "msg_input_buf.h"
    6. #ifdef _cplusplus
    7. extern "C"
    8. {
    9. #include <stdio.h>
    10. #include <stdlib.h>
    11. #include <string.h>
    12. #include <ctype.h>
    13. #include <signal.h>
    14. #include <unistd.h>
    15. }
    16. #endif //_cplusplus
    18. //----------------------------------------------------------------------------- 
    19.         
    20. class MsgMachine
    21. {
    23. public:
    24. bool cmd_run;
    25. MsgMachine();
    26. virtual ~MsgMachine(); 
    27. void Msg_Deal_Loop();
    28. /*从各一缓冲区读消息到消息队列，异步检查某个缓冲区是否可读*/
    29. int ReadInputBuf(InputBuff *pbuff) ;
    30. /*!
    31. *启动消息循环处理线程
    32. *字类如果改写Execute,必须调用父类的Execute才能启动消息处理循环
    33. */
    35. virtual void Dispatch(struct Msg msg)
    36. {
    37.   unsigned int msg_code;      
    38.       msg_code=msg.msg_code;      
    39.          switch(msg_code)       
    40.          {
    41.       default:break;  
    42.          } 
    43. } 
    45. private: 
    46. bool DetectorActive;
    47. Msg_queue *pMsg_que;
    48.   
    49. };               
    50.                
    51. #endif // MSGMACHINE_H
    复制代码



    1. #include "msg_machine.h"
    2. MsgMachine::~MsgMachine()
    3. {
    4. delete pMsg_que;
    5. }
    6. MsgMachine::MsgMachine()
    7. {
    8. pMsg_que=new Msg_queue;
    9. if(pMsg_que->Initialize()==-1) 
    10. {
    11.   delete pMsg_que;
    12.   //printf("Initialize message queue error!\n");
    13.   //u_log("Initialize message queue error!\n");
    14.   exit(-1);
    15. }
    16. DetectorActive=true; 
    17. }
    19. void MsgMachine::Msg_Deal_Loop()
    20. {
    21. struct Msg msg;
    22. while(cmd_run)
    23. {
    24.   
    25.   if(pMsg_que->GetHead(&msg)==0)
    26.   {
    27.    if(msg.msg_code==EVENTMSG_QUIT)
    28.    break;
    29.    Dispatch(msg); 
    30.   }
    31.   else 
    32.    continue;
    33. }
    34. }
    35. int MsgMachine::ReadInputBuf(InputBuff  *pbuff)
    36. {
    37.   struct Msg msg;
    38.   
    39.   if(pbuff->Read(&msg)==0)
    40.   {
    41.    if(pMsg_que->AddTail(&msg)==RW_SUCCESS)
    42.    { 
    43.     return 0;
    44.    }
    45.    else 
    46.    return -1;
    47.   }
    48.   else
    49.   {
    50.     return -1;
    51.   }
    52. }
    复制代码



    以上是偶们的某个项目(Redhat Linux下C++开发实现与某Portal Server的基于UDP消息的接口
    的daemon，参考MFC的消息映射机制，目前已经实现，上述代码给大家参考，请多多指教
  • 相关阅读:
    SpringBoot自定义FailureAnalyzer
    Linux 系统目录结构
    Spring Boot实战：静态资源处理
    Activiti7整合SpringBoot(十二)
    Acvitivi网关(十一)
    为什么阿里巴巴要禁用Executors创建线程池？
    lqb 基础练习 数列排序 (sort的使用)
    lqb 入门训练 A+B问题
    lqb 入门训练 序列求和 （PS：用长整数做数据的输入输出）
    lqb 入门训练 圆的面积 (PS: PI的精确计算方法 atan(1.0) * 4)
  • 原文地址：https://www.cnblogs.com/qq78292959/p/2720998.html
Copyright © 2011-2022 走看看