1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
|
<!-- $Id$ -->
<HTML>
<HEAD>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=iso-8859-1">
<META NAME="Author" CONTENT="James CE Johnson">
<TITLE>ACE Tutorial 012</TITLE>
</HEAD>
<BODY TEXT="#000000" BGCOLOR="#FFFFFF" LINK="#000FFF" VLINK="#FF0F0F">
<CENTER><B><FONT SIZE=+2>ACE Tutorial 012</FONT></B></CENTER>
<CENTER><B><FONT SIZE=+2>Passing classes through ACE_Message_Queue</FONT></B></CENTER>
<P>
<HR WIDTH="100%">
We normally start by looking at main() and work our way out from
there. This time, I want to start by showing you the ACE_Message_Block
derivative but before that, I have to introduce you to the Work object
and it's baseclass Unit_Of_Work
<P>
<HR WIDTH="100%">
<PRE>
<font color=red>// $Id$</font>
<font color=blue>#ifndef</font> <font color=purple>WORK_H</font>
<font color=blue>#define</font> <font color=purple>WORK_H</font>
<font color=blue>#include</font> "<A HREF="../../../ace/Message_Block.h">ace/Message_Block.h</A>"
<font color=blue>#if !defined</font> (<font color=purple>ACE_LACKS_PRAGMA_ONCE</font>)
<font color=blue># pragma</font> <font color=purple>once</font>
<font color=blue>#endif</font> <font color=red>/* ACE_LACKS_PRAGMA_ONCE */</font>
<font color=red>/*
We'll start by defining a basic unit of work that can be put into
the message queue. The threads in the pool will expect to find one
of these in each message block and will invoke a method or two.
*/</font>
class Unit_Of_Work
{
public:
Unit_Of_Work (void)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) Unit_Of_Work ctor 0x%x\n</font>", (void *) this));
}
virtual ~ Unit_Of_Work (void)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) Unit_Of_Work dtor 0x%x\n</font>", (void *) this));
}
void who_am_i (void)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) Unit_Of_Work instance 0x%x\n</font>", (void *) this));
}
virtual void what_am_i (void)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) I am a Unit_Of_Work object\n</font>"));
}
};
<font color=red>/*
Now, we specialize the Unit_Of_Work object to do something
different. By overriding the virtual methods, we can do whatever
"<font color=green>real work</font>" is needed but the thread pool doesn't have to know the specifics.
*/</font>
class Work : public Unit_Of_Work
{
public:
Work (void)
: message_ (-1)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) Work ctor 0x%x\n</font>", (void *) this));
}
Work (int message)
: message_ (message)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) Work ctor 0x%x for message %d\n</font>", (void *) this, message_));
}
virtual ~ Work (void)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) Work dtor 0x%x\n</font>", (void *) this));
}
void what_am_i (void)
{
ACE_DEBUG ((LM_DEBUG, "<font color=green>(%P|%t) I am a Work object for message %d\n</font>", message_));
}
protected:
int message_;
};
<font color=blue>#endif</font>
</PRE>
<HR WIDTH="100%">
<P>
This is basically the same as the <i>DataBase</i> in the previous
tutorial but I've changed the name to be more generic. The feeling is
that a <i>Data</i> object would be a C struct but an <i>Work</i>
object would be a class with methods.
<P>
Now that you know what we'll be putting into the queue, lets go to the
next page where I specialize the ACE_Message_Block.
<P>
<P><HR WIDTH="100%">
<CENTER>[<A HREF="../online-tutorials.html">Tutorial Index</A>] [<A HREF="page03.html">Continue This Tutorial</A>]</CENTER>
|
