VirtualInstrumentInterval.hh
3.59 KB
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
/*
* VirtualInstrumentInterval.hh
*
* Created on: Jan 17, 2013
* Author: f.casimir
*/
#ifndef VIRTUALINSTRUMENTINTERVAL_HH_
#define VIRTUALINSTRUMENTINTERVAL_HH_
#include <string>
#include <map>
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include "Worker.hh"
#include "DD.hh"
#include "TimeInterval.hh"
namespace AMDA {
namespace DDServerInterface {
namespace VI {
class ParamFlow;
typedef boost::shared_ptr<ParamFlow> ParamFlowSPtr;
}
class VirtualInstrument;
/**
* @class VirtualInstrumentInterval
* @brief Class responsible to get data from a time interval for dispatch them into some DataFlow.
*/
class VirtualInstrumentInterval : public AMDA::Helpers::Worker {
typedef std::list<TimeTableCatalog::TimeInterval> TimeIntervalList;
public:
/**
* Constructor
*/
VirtualInstrumentInterval(VirtualInstrument& pVI, TimeIntervalList* pTimeIntervalList);
/**
* Destructor
*/
virtual ~VirtualInstrumentInterval();
// Getter methods
int getId() const { return _id; }
// Other methods
VI::ParamFlowSPtr getParamFlow(const std::string& pParamName);
/**
* @return nbData Available or 0 if no Data
* blocking operation
*/
boost::shared_future<unsigned int> getAsync() {
AMDA::Helpers::Task<unsigned int>* task = new AMDA::Helpers::Task<unsigned int>(
boost::bind(&VirtualInstrumentInterval::getOneDDDataBloc, this));
boost::shared_future<unsigned int> future(task->getFuture());
_taskList.push(task); // assuming internal_queue member
return future;
}
/**
* @brief Define if time interval was set to another one.
*/
bool isTimeIntToProcessChanged() { return _timeIntToProcessChanged; }
protected:
typedef boost::weak_ptr<VI::ParamFlow> ParamFlowWPtr;
typedef std::map<std::string,std::vector<ParamFlowWPtr> > ParamFlowList;
/**
* @details Close DD_Client and re-initialize _id.
*/
void ddClose();
/**
* set pointer for read data in DD_serveur
* @param synchronized if true, the interval time itimeInt must be updated with real start time
* @return true if the TimeInterval changed otherwise false if there is no more TimeInterval.
*/
bool setTimeDD();
/**
* @brief Call _step pointer function which is different in function of the program step.
*/
unsigned int getOneDDDataBloc();
private:
/**
* @brief Construct _paramList (it is the first step) and call writeData.
*/
unsigned int initAndWriteData();
/**
* @details It is the midle step.
* Call DDClient::getMultiParam and dispatch results to ParamFlow.
* When no more data set the _tep function pointer to writeEmptyData.
*/
unsigned int writeData();
/**
* @brief write NULL Packet.
*/
unsigned int writeEmptyData();
unsigned int writeNoData();
unsigned int (VirtualInstrumentInterval::*_step)();
VirtualInstrument& _vi; /*!< Reference an associated Virtual Instrument */
TimeIntervalList& _timeIntervalList;
TimeIntervalList::iterator _currentTimeIntToProcess;
/**
* @brief Define if data retrieving for a time interval changed.
*/
bool _timeIntToProcessChanged;
double _realTimeInt; /*!< Time interval to extract data */
int _id; /*!< id of param in DD_server */
char** _paramList; /*!< Need to call GetMultiData to DD_server */
std::string _paramNameListForLog; /*!< Need to display log */
DD_Client _ddClient; /*!< Connection DD_client for DD_Server */
ParamFlowList _paramFlowList; /*! List of ParamFlow => ObserverList */
char _strStartTime[TIMELENGTH];
char _strTimeInt[TIMELENGTH];
bool _nodata;
};
} /* namespace DDServerInterface */
} /* namespace AMDA */
#endif /* VIRTUALINSTRUMENTINTERVAL_HH_ */