source: trunk/FACT++/src/EventImp.cc @ 10423

Last change on this file since 10423 was 10423, checked in by tbretz, 9 years ago
Added boolean option to Print to suppress the SERVER name if any.
File size: 7.4 KB
Line 
1// **************************************************************************
2/** @class EventImp
3
4@brief A general base-class describing events issues in a state machine
5
6@section General purpose
7
8The general purpose of this class is to describe an event which can
9occur in one of our StateMachines. It provides pointers to data
10associated with the event, a target state and stores the states in which
11issuing this event is allowed. The target state might be negative to
12describe that no transition of the state is requested.
13
14Such an event canjust be a description of an event, but can also be
15an issued event which already contain data.
16
17The format can, but need not, contain the format of the data area.
18As a rule, it should follow the format also used in the DIM network.
19
20
21@section Assigning functions to an event
22
23To any event a function call can be assigned. Thanks to boost::bind there
24are various and different very powerful ways to do that.
25
26The function assigned with AssignFunction must return int. When it is
27executed it is given a const reference of the current event as an argument,
28i.e. if you want to get such a reference in your function, you can reference
29it using the placeholder _1. (Remark: it is allowe to omit the _1 placeholder
30if no reference to the EventImp object is needed)
31
32A few examples:
33
34\code
35   int function(const EventImp &evt, int i, const char *txt) { return i; }
36
37   EventImp evt;
38   evt.AssignFunction(boost::bind(function, _1, 7, "hallo"));
39   cout << evt.Exec() << endl;
40   // 7
41\endcode
42
43When the function is executed later via ExecFunc() in will get a reference
44to the executing EventImp as its first argument (indicated by '_1'), it will
45get 7 and "hallo" as second and third argument.
46
47\code
48   int function(int i, const char *txt, const EventImp &evt) { return i; }
49
50   EventImp evt;
51   evt.AssignFunction(boost::bind(function, 7, "hallo", _1));
52   cout << evt.Exec() << endl;
53   // 7
54\endcode
55
56Is the same example than the one above, but the arguments are in a different
57order.
58
59\code
60   class A
61   {
62      int function(const EventImp &evt, int i, const char *txt)
63      {
64         cout << this << endl; return i;
65      }
66   };
67
68   A a;
69
70   EventImp evt;
71   evt.AssignFunction(boost::bind(&A::function, &a, _1, 7, "hallo"));
72   cout << evt.Exec() << endl;
73   // &a
74   // 7
75\endcode
76
77The advanatge of boost::bind is that it also works for member functions
78of classes. In this case the first argument after the function-pointer
79\b must be a pointer to a valid class-object. This can also be \em this
80if called from within a class object.
81
82Also note that everything (as usual) which is not a reference is copied
83when the bind function is invoked. If you want to distribute a reference
84instead use ref(something), like
85
86\code
87   int function(int &i)  { return i; }
88
89   int j = 5;
90   EventImp evt;
91   evt.AssignFunction(bind(function, ref(j));
92   j = 7;
93   cout << evt.Exec() << endl;
94   // 7
95\endcode
96
97Note, that you are responsible for the validity, that means: Do not
98destroy your object (eg. reference to j) while bind might still be called
99later, or a pointer to \em this.
100
101@section References
102   - <A HREF="http://www.boost.org/doc/libs/1_45_0/libs/bind/bind.html">boost::bind (V1.45.0)</A>
103
104@todo
105   Add link to DIM format
106
107*/
108// **************************************************************************
109#include "EventImp.h"
110
111#include <sstream>
112
113#include "Time.h"
114#include "WindowLog.h"
115#include "Description.h"
116
117using namespace std;
118
119// --------------------------------------------------------------------------
120//
121//! Copy the contents of an EventImp (fTargetState, fAllowedStates and
122//!  fFunction)
123//
124EventImp::EventImp(const EventImp &cmd) :
125    fTargetState(cmd.fTargetState), fAllowedStates(cmd.fAllowedStates),
126    fFunction(cmd.fFunction)
127{
128}
129
130// --------------------------------------------------------------------------
131//
132//! If the state is 0 or positive add it to fAllowedStates
133//!
134//! @param state
135//!     The state which should be added
136//
137void EventImp::AddAllowedState(int state)
138{
139    if (state>=0)
140        fAllowedStates.push_back(state);
141}
142
143// --------------------------------------------------------------------------
144//
145//! Add all states in the string to fAllowedStates.
146//!
147//! @param states
148//!    A string containing the states. They can either be separated by
149//!    whitespaces or commas, e.g. "1 2 3 4" or "1, 7, 9, 10". Note that
150//!    no real consistency check is done.
151//
152void EventImp::AddAllowedStates(const char *states)
153{
154    stringstream stream(states);
155
156    const bool sep = stream.str().find(',')==string::npos;
157
158    string buffer;
159    while (getline(stream, buffer, sep ? ' ' : ','))
160        AddAllowedState(atoi(buffer.c_str()));
161}
162
163// --------------------------------------------------------------------------
164//
165//! Return whether the given state is in the list of allowed states.
166//!
167//! @param state
168//!    The state to look for in fAllowedStates
169//!
170//! @returns
171//!    If the given state is negative returns false. If the list of allowed
172//!    states is empty return true. Otherwise return whether the state
173//!    is found in fAllowedList or not.
174//
175bool EventImp::IsStateAllowed(int state) const
176{
177    // States with negative values are internal states and are
178    // never allowed
179    if (state<0)
180        return false;
181
182    // In case no allowed state is explicitly set
183    // all positive states are allowed
184    if (fAllowedStates.size()==0)
185        return true;
186
187    return find(fAllowedStates.begin(), fAllowedStates.end(), state)!=fAllowedStates.end();
188}
189
190// --------------------------------------------------------------------------
191//
192//! Print the contents of the event to the given stream.
193//!
194//! @param out
195//!    An ostream to which the output should be redirected.
196//!
197void EventImp::Print(ostream &out, bool strip) const
198{
199    out << " \xc2\xb7 ";
200
201    const string str = GetName();
202    if (!str.empty())
203        out << kBold << str.substr(strip?str.find_first_of('/')+1:0);
204
205    const string fmt = GetFormat();
206    if (!fmt.empty())
207        out << kBold << "[" << fmt << "]";
208
209    vector<Description> v = Description::SplitDescription(GetDescription());
210
211    if (!GetDescription().empty())
212    {
213        for (vector<Description>::const_iterator j=v.begin()+1;
214             j!=v.end(); j++)
215            out << " <" << j->name << ">";
216    }
217
218    out << kReset << ":";
219
220    for (unsigned int i=0; i<fAllowedStates.size(); i++)
221        out << " " << fAllowedStates[i];
222
223    if (fTargetState<0)
224        out << " [conf]";
225    else
226        out << " [trans->" << fTargetState << "]";
227
228    const Time tm = GetTime();
229
230    const bool t = tm!=Time::None && tm!=Time(1970,1,1);
231    const bool s = GetSize()>0;
232
233    if (s || t)
234        out << "(";
235    if (t)
236        out << tm.GetAsStr();
237    if (s && t)
238        out << "/";
239    if (s)
240        out << "size=" << GetSize();
241    if (s || t)
242        out << ")";
243    out << endl;
244
245    if (GetDescription().empty())
246        return;
247
248    out << "      " << v[0].comment << endl;
249
250    for (vector<Description>::const_iterator j=v.begin()+1;
251         j!=v.end(); j++)
252    {
253        out << "      " << kGreen << j->name;
254        if (!j->comment.empty())
255            out << kReset << ": " << kBlue << j->comment;
256        if (!j->unit.empty())
257            out << kYellow << " [" << j->unit << "]";
258        out << endl;
259    }
260}
261
262// --------------------------------------------------------------------------
263//
264//! Calls Print(std::cout)
265//
266void EventImp::Print(bool strip) const
267{
268    Print(cout, strip);
269}
Note: See TracBrowser for help on using the repository browser.