source: flair-src/trunk/lib/FlairCore/src/IODevice.h@ 2

Last change on this file since 2 was 2, checked in by Sanahuja Guillaume, 6 years ago

flaircore

File size: 5.1 KB
Line 
1// %flair:license{
2// This file is part of the Flair framework distributed under the
3// CECILL-C License, Version 1.0.
4// %flair:license}
5/*!
6 * \file IODevice.h
7 * \brief Abstract class for input/ouput system
8 * \author Guillaume Sanahuja, Copyright Heudiasyc UMR UTC/CNRS 7253
9 * \date 2011/05/01
10 * \version 4.0
11 */
12
13#ifndef IO_DEVICE_H
14#define IO_DEVICE_H
15
16#include <Object.h>
17
18class IODevice_impl;
19class Thread_impl;
20class FrameworkManager_impl;
21
22namespace flair { namespace core {
23
24 class io_data;
25 class DataType;
26
27 /*! \class IODevice
28 *
29 * \brief Abstract class for input/ouput system
30 *
31 * An input/output system is generally used to describe a sensor, an actuator or a filter. \n
32 * These systems can be linked (for exemple a sensor with a filter), when an IODevice
33 * is created with a parent of type IODevice.
34 * In this case, an update of the parent's data will call an update
35 * of the child's data (for exemple when a sensor gets new datas, a filter is automatically called). \n
36 * Output of this object can also be sent to a shared memory using the OutputToShMem method; in order to use it with an
37 * external program.
38 */
39 class IODevice: public Object {
40 friend class ::IODevice_impl;
41 friend class ::Thread_impl;
42 friend class ::FrameworkManager_impl;
43
44 public:
45 /*!
46 * \brief Constructor
47 *
48 * Construct an IODevice of Object's type "IODevice" (see Object::ObjectType). \n
49 * If parent's Object::ObjectType is also "IODevice", this IODevice will be linked to its parent
50 * (see ProcessUpdate()).
51 *
52 * \param parent parent
53 * \param name name
54 */
55 IODevice(const Object* parent,std::string name);
56
57 /*!
58 * \brief Destructor
59 *
60 */
61 virtual ~IODevice();
62
63 /*!
64 * \brief Add an IODevice to the logs
65 *
66 * The IODevice will be automatically logged among this IODevice logs,
67 * if logging is enabled (see SetDataToLog(), FrameworkManager::StartLog
68 * and FrameworkManager::AddDeviceToLog). \n
69 * Logging happens when ProcessUpdate() is called. \n
70 * Note that when an IODevice is just added for logs (ie. no parent/child
71 * link between the two IODevice),
72 * UpdateFrom() is not automatically called.
73 *
74 * \param device IODevice to log
75 */
76 void AddDeviceToLog(const IODevice* device);
77
78 /*!
79 * \brief Add an io_data to the log
80 *
81 * The io_data will be automatically logged if enabled (see FrameworkManager::StartLog
82 * and FrameworkManager::AddDeviceToLog),
83 * during call to ProcessUpdate().
84 *
85 * \param data data to log
86 */
87 void AddDataToLog(const io_data* data);
88
89 /*!
90 * \brief Send the output to a shared memory
91 *
92 * Use this method to output log datas to a shared memory.
93 * This can be usefull to get datas from an external progam. \n
94 * Output happens when ProcessUpdate() is called. \n
95 * The name and the structure of the shared memory will be displayed when
96 * this method is called with true as argument. \n
97 * By default it is not enabled.
98 *
99 *
100 * \param enabled true to enable the output, false otherwise
101 */
102 void OutputToShMem(bool enabled);
103
104 //TODO: these 2 method should be pure virtual
105 virtual DataType const &GetInputDataType() const;
106 virtual DataType const &GetOutputDataType() const;
107
108 protected:
109 /*!
110 * \brief Process the childs of type IODevice, and log if needed
111 *
112 * This method must be called after computing datas;
113 * generally at the end of the reimplemented UpdateFrom or after acquiring datas in case of a sensor. \n
114 * It will call UpdateFrom methods of each child of type IODevice,
115 * and log all datas (this IODevice and its childs)
116 * if logging is enabled (see SetDataToLog(), AddDeviceToLog(),
117 * FrameworkManager::StartLog and FrameworkManager::AddDeviceToLog). \n
118 * If a thread is waiting on this IODevice (see Thread::WaitUpdate), it will be resumed.
119 *
120 * \param data data to process
121 */
122 void ProcessUpdate(io_data* data);
123
124 private:
125 /*!
126 * \brief Update using provided datas
127 *
128 * This method is automatically called by ProcessUpdate()
129 * of the Object::Parent's if its Object::ObjectType is "IODevice". \n
130 * This method must be reimplemented, in order to process the data from the parent.
131 *
132 * \param data data from the parent to process
133 */
134 virtual void UpdateFrom(const io_data *data)=0;
135
136 class IODevice_impl* pimpl_;
137 };
138
139} // end namespace core
140} // end namespace flair
141
142#endif // IO_DEVICE_H
Note: See TracBrowser for help on using the repository browser.