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的訊息映射機制，目前已經實現，上述代碼給大家參考，請多多指教