Main Page
Related Pages
Modules
Namespaces
Classes
Files
Examples
File List
File Members
rtt
base
CoreRunnableInterface.cpp
Go to the documentation of this file.
1
/***************************************************************************
2
tag: Peter Soetens Wed Jan 18 14:11:39 CET 2006 CoreRunnableInterface.cxx
3
4
CoreRunnableInterface.cxx - description
5
-------------------
6
begin : Wed January 18 2006
7
copyright : (C) 2006 Peter Soetens
8
email : peter.soetens@mech.kuleuven.be
9
10
***************************************************************************
11
* This library is free software; you can redistribute it and/or *
12
* modify it under the terms of the GNU General Public *
13
* License as published by the Free Software Foundation; *
14
* version 2 of the License. *
15
* *
16
* As a special exception, you may use this file as part of a free *
17
* software library without restriction. Specifically, if other files *
18
* instantiate templates or use macros or inline functions from this *
19
* file, or you compile this file and link it with other files to *
20
* produce an executable, this file does not by itself cause the *
21
* resulting executable to be covered by the GNU General Public *
22
* License. This exception does not however invalidate any other *
23
* reasons why the executable file might be covered by the GNU General *
24
* Public License. *
25
* *
26
* This library is distributed in the hope that it will be useful, *
27
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
28
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
29
* Lesser General Public License for more details. *
30
* *
31
* You should have received a copy of the GNU General Public *
32
* License along with this library; if not, write to the Free Software *
33
* Foundation, Inc., 59 Temple Place, *
34
* Suite 330, Boston, MA 02111-1307 USA *
35
* *
36
***************************************************************************/
37
38
39
40
#include "
RunnableInterface.hpp
"
41
#include "../Logger.hpp"
42
#include <cassert>
43
44
namespace
RTT
{
45
using namespace
base
;
46
47
RunnableInterface::~RunnableInterface
() {
48
if
( this->
owner_act
&& this->
owner_act
->
isRunning
() ) {
49
Logger::In
in(
"~RunnableInterface()"
);
50
log
(
Critical
)
51
<<
"Activity still running, but RunnableInterface destroyed! Stop the task"
52
" before deleting this object. Crash may be imminent."
<<
endlog
();
53
}
54
if
( this->
owner_act
)
55
this->
owner_act
->
disableRun
(
this
);
56
}
57
58
RunnableInterface::RunnableInterface
() :
owner_act
(0) {}
59
60
void
RunnableInterface::loop
() {
61
this->
step
();
62
}
63
64
bool
RunnableInterface::breakLoop
() {
return
false
; }
65
66
67
bool
RunnableInterface::hasWork
() {
68
return
false
;
69
}
70
71
void
RunnableInterface::work
(
WorkReason
reason) {}
72
73
void
RunnableInterface::setActivity
(
ActivityInterface
* task ) {
74
if
(
owner_act
) {
75
// notify old owner he's out.
76
owner_act
->
disableRun
(
this
);
77
}
78
79
owner_act
= task;
80
}
81
82
os::ThreadInterface
*
RunnableInterface::getThread
()
const
{
83
if
(
owner_act
)
84
return
owner_act
->
thread
();
85
return
0;
86
}
87
88
}
RTT::base::RunnableInterface::work
virtual void work(WorkReason reason)
Definition:
CoreRunnableInterface.cpp:71
RTT::base::RunnableInterface::getThread
virtual os::ThreadInterface * getThread() const
Definition:
CoreRunnableInterface.cpp:82
RTT::base::RunnableInterface::owner_act
ActivityInterface * owner_act
Definition:
RunnableInterface.hpp:74
RTT::base::RunnableInterface::RunnableInterface
RunnableInterface()
Definition:
CoreRunnableInterface.cpp:58
RTT::base::RunnableInterface::loop
virtual void loop()
Definition:
CoreRunnableInterface.cpp:60
RTT::base::ActivityInterface::isRunning
virtual bool isRunning() const =0
RTT::base::RunnableInterface::WorkReason
WorkReason
Definition:
RunnableInterface.hpp:76
RTT::base::RunnableInterface::step
virtual void step()=0
RTT::Critical
Definition:
Logger.hpp:345
RTT::os::ThreadInterface
Definition:
ThreadInterface.hpp:56
RunnableInterface.hpp
RTT::base::RunnableInterface::setActivity
virtual void setActivity(ActivityInterface *task)
Set the task this interface is run in.
Definition:
CoreRunnableInterface.cpp:73
RTT::base::ActivityInterface
Interface to start/stop and query a Activity.
Definition:
ActivityInterface.hpp:62
RTT::base::RunnableInterface::breakLoop
virtual bool breakLoop()
Definition:
CoreRunnableInterface.cpp:64
base
RTT::base::RunnableInterface::~RunnableInterface
virtual ~RunnableInterface()
Definition:
CoreRunnableInterface.cpp:47
RTT::base::ActivityInterface::thread
virtual os::ThreadInterface * thread()=0
RTT::Logger::In
Definition:
Logger.hpp:159
RTT
Contains TaskContext, Activity, OperationCaller, Operation, Property, InputPort, OutputPort, Attribute.
Definition:
Activity.cpp:53
RTT::log
static Logger & log()
Definition:
Logger.hpp:350
RTT::base::RunnableInterface::hasWork
virtual bool hasWork()
Definition:
CoreRunnableInterface.cpp:67
RTT::endlog
static Logger::LogFunction endlog()
Definition:
Logger.hpp:362
RTT::base::ActivityInterface::disableRun
void disableRun(RunnableInterface *caller)
Definition:
ActivityInterface.hpp:73
rtt
Author(s): RTT Developers
autogenerated on Tue Jun 25 2019 19:33:23