Application of MFC message ing mechanism in Linux C ++ programming environment)

#IfndefMsg_constant_h
#DefineMsg_constant_h

#DefineMax_msg_parta_size 2048/* Message Parameter size */
#DefineMax_queue_length 3000/* Maximum queue length */

#DefineEventmsg_quit 100/* Exit */

# 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

#DefinePer_buff_length 1000/* Message input buffer size (entries )*/

/*!
*
* For macro definitions of items in the message ing segment, refer to the MFC message ing mechanism.
*/

/* When calling the message processing function, add this, which must be a member function of the message machine */
# Define Msg_map_fun ( Msg_code , Msg_action_fun ) Case Msg_code : This - > Msg_action_fun ( MSG ) ; Break ;

/* Implement the pointer to forward messages to other message processing objects, which are used in cases where messages need to be processed for a long time. The receiving object must be a subclass of msg_machine */
# Define Msg_map_obj ( Msg_code , Msg_action_obj ) Case Msg_code : Sendmessage ( MSG , Msg_action_obj ) ; Break ;

/*! Message ing macro
*
* Begin_msg_map is the macro that defines the start of the message ing segment.
* The message ing segment must appear in the class body, not the implementation part.
* The format is as follows:
* 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 ) \
{

/*!
*
* Macro that defines the end of the message ing segment
*/
# Define End_msg_map ( Base ) Default : \
Base : : Dispatch ( MSG) ; \
Break ; \
} \
}

#Endif

2. # Ifndef message_struct_h
4. # Define message_struct_h
6. # Ifdef _ cplusplus
8. Extern "C"
10. {
12. # Include <pthread. h>
14. # Include <semaphore. h>
16. # Include <stdio. h>
18. # Include <stdlib. h>
20. # Include <string. h>
22. # Include <ctype. h>
24. }
26. # Endif // _ cplusplus
28. # Include "msg_macro.h"
30. Typedef unsigned char u_char;
32. Struct msg
34. {
36. Unsigned int msg_code; // message code
38. U_char msg_para [max_msg_para_size]; // Message Parameter
40. };
42. Class msg_queue
44. {
46. Public:
48. Msg_queue () {initialized = false ;};
50. ~ Msg_queue ();
52. Int initialize ();
54. Int gethead (struct MSG * p_msg );
56. Int addtail (struct MSG * p_msg );
58. PRIVATE:
60. Pthread_mutex_t mutex_wr;
62. Bool initialized;
64. Int msg_count;
66. Int head;
68. Int tail;
70. Struct MSG msg_array [max_queue_length];
72. };
74. # Endif // message_struct_h

CopyCode

2. # Include "MSG. H"
4. Extern "C"
6. {
8. # Include <error. h>
10. # Include <errno. h>
12. }
14. Int msg_queue: Initialize ()
16. {
18. Int error;
22. If (initialized) return 0;
26. Error = pthread_mutex_init (& mutex_wr, null );
28. Switch (error ){
30. Case eagain: initialized = false; Return-1;
32. Case enomem: initialized = false; Return-2;
34. Case eperm: initialized = false; Return-3;
36. }
38. Initialized = true;
40. Msg_count = 0;
42. Head = 0;
44. Tail = 0;
46. Memset (msg_array, 0, sizeof (msg_array ));
48. Return 0;
50. }
52. Int msg_queue: gethead (struct MSG * p_msg)
54. {
56. Int result;
58. Int error;
60. If (! Initialized) return un_ini;
62. If (p_msg = NULL) return rw_error_que;
66. If (error = pthread_mutex_lock (& mutex_wr ))
68. Return-3; // lock retrieval failed
72. If (msg_count> 0)
74. {
76. Memcpy (void *) p_msg, (void *) & msg_array [head], sizeof (struct MSG ));
78. Memset (void *) & msg_array [head], 0, sizeof (struct MSG ));
80. Head ++;
82. If (Head = max_queue_length) Head = 0;
84. Msg_count --;
86. Result = rw_success;
88. }
90. Else
92. {
94. P_msg-> msg_code = empty_que;
96. Result = empty_que;
98. }
102. If (error = pthread_mutex_unlock (& mutex_wr ))
104. Return-4; // unlock failed
108. Return result;
112. }
114. Int msg_queue: addtail (struct MSG * p_msg)
116. {
118. Int ilock;
120. Int result;
122. Int error;
124. If (p_msg = NULL) return rw_error_que;
126. If (! Initialized) return un_ini;
128. If (error = pthread_mutex_lock (& mutex_wr ))
130. Return-3;
134. If (msg_count <max_queue_length)
136. {
138. Memcpy (void *) & msg_array [tail], (void *) p_msg, sizeof (struct MSG ));
140. Tail ++;
142. If (tail = max_queue_length)
144. Tail = 0;
146. Msg_count ++;
148. Result = rw_success;
150. }
152. Else
154. Result = full_que;
158. If (error = pthread_mutex_unlock (& mutex_wr ))
160. Result =-4;
164. Return result;
166. }
168. Msg_queue ::~ Msg_queue ()
170. {
172. Pthread_mutex_destroy (& mutex_wr );
174. }

Copy code

2. # Ifndef msgmachine_h
4. # Define msgmachine_h
6. # Include "MSG. H"
8. # Include "msg_macro.h"
10. # Include "msg_input_buf.h"
12. # Ifdef _ cplusplus
14. Extern "C"
16. {
18. # Include <stdio. h>
20. # Include <stdlib. h>
22. # Include <string. h>
24. # Include <ctype. h>
26. # Include <signal. h>
28. # Include <unistd. h>
30. }
32. # Endif // _ cplusplus
36. //-----------------------------------------------------------------------------
40. Class msgmachine
42. {
46. Public:
48. Bool cmd_run;
50. Msgmachine ();
52. Virtual ~ Msgmachine ();
54. Void msg_deal_loop ();
56. /* Read messages from each buffer zone to the message queue and asynchronously check whether a buffer zone is readable */
58. Int readinputbuf (inputbuff * pbuff );
60. /*!
62. * Start the message loop processing thread.
64. * If the word class is changed to execute, the execute of the parent class must be called to start the message processing cycle.
66. */
70. Virtual void dispatch (struct MSG)
72. {
74. Unsigned int msg_code;
76. Msg_code = msg. msg_code;
78. Switch (msg_code)
80. {
82. Default: break;
84. }
86. }
90. PRIVATE:
92. Bool detecteffective;
94. Msg_queue * pmsg_que;
98. };
102. # Endif // msgmachine_h

Copy code

2. # Include "msg_machine.h"
4. Msgmachine ::~ Msgmachine ()
6. {
8. Delete pmsg_que;
10. }
12. Msgmachine: msgmachine ()
14. {
16. Pmsg_que = new msg_queue;
18. If (pmsg_que-> initialize () =-1)
20. {
22. Delete pmsg_que;
24. // Printf ("initialize Message Queue error! \ N ");
26. // U_log ("initialize Message Queue error! \ N ");
28. Exit (-1 );
30. }
32. Detecteffective = true;
34. }
38. Void msgmachine: msg_deal_loop ()
40. {
42. Struct MSG;
44. While (cmd_run)
46. {
50. If (pmsg_que-> gethead (& MSG) = 0)
52. {
54. If (msg. msg_code = eventmsg_quit)
56. Break;
58. Dispatch (MSG );
60. }
62. Else
64. Continue;
66. }
68. }
70. Int msgmachine: readinputbuf (inputbuff * pbuff)
72. {
74. Struct MSG;
78. If (pbuff-> Read (& MSG) = 0)
80. {
82. If (pmsg_que-> addtail (& MSG) = rw_success)
84. {
86. Return 0;
88. }
90. Else
92. Return-1;
94. }
96. Else
98. {
100. Return-1;
102. }
104. }

Copy code

These are some of our projects (C ++ Development Implementation in RedHat Linux and interfaces based on UDP messages of a Portal Server ).
For more information about the daemon, see the message ing mechanism of MFC. Currently, the above Code has been implemented.