Skip to content

U
uniset2
Commit d28a8a9c authored by Pavel Vainerman's avatar Pavel Vainerman
Browse files
Options

Глобальный переход на unordered_map везде где возможно.

parent 95eb3b75
Hide whitespace changes
Inline Side-by-side
Showing with 426 additions and 358 deletions
extensions/LogicProcessor/Schema.h
View file @ d28a8a9c
#ifndef Schema_H_
#define Schema_H_
// --------------------------------------------------------------------------
#include <map>
#include <unordered_map>
#include "Element.h"
#include "Schema.h"
// --------------------------------------------------------------------------
......@@ -59,7 +59,7 @@ class Schema
void setIn( Element::ElementID ID, int inNum, bool state );
bool getOut( Element::ElementID ID );
typedef std::map<Element::ElementID,Element*> ElementMap;
typedef std::unordered_map<Element::ElementID,Element*> ElementMap;
typedef std::list<INLink> InternalList;
typedef std::list<EXTLink> ExternalList;
typedef std::list<EXTOut> OutputsList;
......
extensions/ModbusSlave/MBSlave.cc
View file @ d28a8a9c
......@@ -689,7 +689,6 @@ void MBSlave::askSensors( UniversalIO::UIOCommand cmd )
if( force )
return;
for( auto &it: iomap )
{
IOProperty* p(&it.second);
......@@ -697,7 +696,7 @@ void MBSlave::askSensors( UniversalIO::UIOCommand cmd )
{
shm->askSensor(p->si.id,cmd);
}
catch( UniSetTypes::Exception& ex )
catch( const UniSetTypes::Exception& ex )
{
dwarn << myname << "(askSensors): " << ex << std::endl;
}
......
extensions/ModbusSlave/MBSlave.h
View file @ d28a8a9c
......@@ -6,6 +6,7 @@
#include <string>
#include <memory>
#include <map>
#include <unordered_map>
#include <vector>
#include "UniSetObject_LT.h"
#include "modbus/ModbusTypes.h"
......@@ -253,6 +254,17 @@
*/
// -----------------------------------------------------------------------------
namespace std {
template<>
class hash<ModbusRTU::mbErrCode> {
public:
size_t operator()(const ModbusRTU::mbErrCode &e) const
{
return std::hash<int>()((int)e);
}
};
}
// -----------------------------------------------------------------------------
/*! Реализация slave-интерфейса */
class MBSlave:
public UniSetObject_LT
......@@ -383,6 +395,8 @@ class MBSlave:
virtual ModbusRTU::mbErrCode checkRegister( ModbusRTU::ModbusData reg, ModbusRTU::ModbusData& val )
{ return ModbusRTU::erNoError; }
// т.к. в функциях (much_real_read,nuch_real_write) рассчёт на отсортированность IOMap
// то использовать unordered_map нельзя
typedef std::map<ModbusRTU::ModbusData,IOProperty> IOMap;
IOMap iomap; /*!< список входов/выходов */
......@@ -449,7 +463,7 @@ class MBSlave:
PassiveTimer ptTimeout;
long askCount;
typedef std::map<ModbusRTU::mbErrCode,unsigned int> ExchangeErrorMap;
typedef std::unordered_map<ModbusRTU::mbErrCode,unsigned int> ExchangeErrorMap;
ExchangeErrorMap errmap; /*!< статистика обмена */
std::atomic_bool activated;
......@@ -461,7 +475,7 @@ class MBSlave:
bool mbregFromID;
typedef std::map<int,std::string> FileList;
typedef std::unordered_map<int,std::string> FileList;
FileList flist;
std::string prefix;
std::string prop_prefix;
......@@ -471,9 +485,9 @@ class MBSlave:
// данные для ответа на запрос 0x2B(43)/0x0E(14)
// 'MEI' - modbus encapsulated interface
// 'RDI' - read device identification
typedef std::map<int,std::string> MEIValMap;
typedef std::map<int,MEIValMap> MEIObjIDMap;
typedef std::map<int,MEIObjIDMap> MEIDevIDMap;
typedef std::unordered_map<int,std::string> MEIValMap;
typedef std::unordered_map<int,MEIValMap> MEIObjIDMap;
typedef std::unordered_map<int,MEIObjIDMap> MEIDevIDMap;
MEIDevIDMap meidev;
};
......
extensions/ModbusSlave/MBTCPMultiSlave.h
View file @ d28a8a9c
......@@ -2,7 +2,7 @@
#ifndef _MBTCPMultiSlave_H_
#define _MBTCPMultiSlave_H_
// -----------------------------------------------------------------------------
#include <map>
#include <unordered_map>
#include "MBSlave.h"
#include "modbus/ModbusTCPServer.h"
// -----------------------------------------------------------------------------
......@@ -67,7 +67,7 @@ class MBTCPMultiSlave:
}
};
typedef std::map<const std::string,ClientInfo> ClientsMap;
typedef std::unordered_map<std::string,ClientInfo> ClientsMap;
ClientsMap cmap;
......
extensions/RRDServer/RRDServer.h
View file @ d28a8a9c
#ifndef _RRDServer_H_
#define _RRDServer_H_
// -----------------------------------------------------------------------------
#include <unordered_map>
#include <memory>
#include "UObject_SK.h"
#include "SMInterface.h"
......@@ -93,7 +94,7 @@ class RRDServer:
dsname(dsname),value(defval){}
};
typedef std::map<UniSetTypes::ObjectId,DSInfo> DSMap;
typedef std::unordered_map<UniSetTypes::ObjectId,DSInfo> DSMap;
struct RRDInfo
{
......
extensions/SharedMemory/SharedMemory.cc
View file @ d28a8a9c
......@@ -649,12 +649,12 @@ void SharedMemory::saveHistory()
}
}
// -----------------------------------------------------------------------------
void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
void SharedMemory::updateHistory( std::shared_ptr<USensorInfo>& s_it, IOController* )
{
if( hist.empty() )
return;
auto i = histmap.find(s_it->second.si.id);
auto i = histmap.find(s_it->si.id);
if( i == histmap.end() )
return;
......@@ -662,14 +662,14 @@ void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
long sm_tv_sec = 0;
long sm_tv_usec = 0;
{
uniset_rwmutex_rlock lock(s_it->second.val_lock);
value = s_it->second.value;
sm_tv_sec = s_it->second.tv_sec;
sm_tv_usec = s_it->second.tv_usec;
uniset_rwmutex_rlock lock(s_it->val_lock);
value = s_it->value;
sm_tv_sec = s_it->tv_sec;
sm_tv_usec = s_it->tv_usec;
}
dinfo << myname << "(updateHistory): "
<< " sid=" << s_it->second.si.id
<< " sid=" << s_it->si.id
<< " value=" << value
<< endl;
......@@ -677,8 +677,8 @@ void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
{
History::iterator it = it1;
if( s_it->second.type == UniversalIO::DI ||
s_it->second.type == UniversalIO::DO )
if( s_it->type == UniversalIO::DI ||
s_it->type == UniversalIO::DO )
{
bool st = (bool)value;
......@@ -694,8 +694,8 @@ void SharedMemory::updateHistory( IOStateList::iterator& s_it, IOController* )
m_historySignal.emit( (*it) );
}
}
else if( s_it->second.type == UniversalIO::AI ||
s_it->second.type == UniversalIO::AO )
else if( s_it->type == UniversalIO::AI ||
s_it->type == UniversalIO::AO )
{
if( !it->fuse_use_val )
{
......
extensions/SharedMemory/SharedMemory.h
View file @ d28a8a9c
......@@ -2,6 +2,7 @@
#ifndef SharedMemory_H_
#define SharedMemory_H_
// -----------------------------------------------------------------------------
#include <unordered_map>
#include <string>
#include <memory>
#include <deque>
......@@ -341,7 +342,7 @@ class SharedMemory:
// вводим не просто map, а "map списка историй".
// точнее итераторов-историй.
typedef std::list<History::iterator> HistoryItList;
typedef std::map<UniSetTypes::ObjectId,HistoryItList> HistoryFuseMap;
typedef std::unordered_map<UniSetTypes::ObjectId,HistoryItList> HistoryFuseMap;
typedef sigc::signal<void, const HistoryInfo&> HistorySlot;
HistorySlot signal_history(); /*!< сигнал о срабатывании условий "сброса" дампа истории */
......@@ -428,7 +429,7 @@ class SharedMemory:
History hist;
HistoryFuseMap histmap; /*!< map для оптимизации поиска */
virtual void updateHistory( IOStateList::iterator& it, IOController* );
virtual void updateHistory( std::shared_ptr<IOController::USensorInfo>& it, IOController* );
virtual void saveHistory();
void buildHistoryList( xmlNode* cnode );
......
include/IOController.h
View file @ d28a8a9c
......@@ -25,7 +25,7 @@
#ifndef IOController_H_
#define IOController_H_
//---------------------------------------------------------------------------
#include <map>
#include <unordered_map>
#include <list>
#include <sigc++/sigc++.h>
#include "IOController_i.hh"
......@@ -97,18 +97,18 @@ class IOController:
public:
// предварительное объявление, чтобы в структуре объявить итератор..
// предварительное объявление..
struct USensorInfo;
typedef std::map<UniSetTypes::ObjectId, USensorInfo> IOStateList;
typedef std::unordered_map<UniSetTypes::ObjectId, std::shared_ptr<USensorInfo>> IOStateList;
// ================== Достпуные сигналы =================
/*!
// \warning В сигнале напрямую передаётся итератор (т.е. по сути указатель на внутреннюю структуру!)
// \warning В сигнале напрямую передаётся указатель на внутреннюю структуру!
// Это не очень хорошо, с точки зрения "архитектуры", но оптимальнее по быстродействию!
// необходимо в обработчике не забывать использовать uniset_rwmutex_wrlock(val_lock) или uniset_rwmutex_rlock(val_lock)
*/
typedef sigc::signal<void, IOStateList::iterator&, IOController*> ChangeSignal;
typedef sigc::signal<void, IOStateList::iterator&, IOController*> ChangeUndefinedStateSignal;
typedef sigc::signal<void, std::shared_ptr<USensorInfo>&, IOController*> ChangeSignal;
typedef sigc::signal<void, std::shared_ptr<USensorInfo>&, IOController*> ChangeUndefinedStateSignal;
// signal по изменению определённого датчика
ChangeSignal signal_change_value( UniSetTypes::ObjectId sid );
......@@ -120,59 +120,6 @@ class IOController:
ChangeUndefinedStateSignal signal_change_undefined_state( UniSetTypes::ObjectId sid );
ChangeUndefinedStateSignal signal_change_undefined_state();
// -----------------------------------------------------------------------------------------
struct USensorInfo:
public IOController_i::SensorIOInfo
{
USensorInfo( const USensorInfo& ) = delete;
const USensorInfo& operator=(const USensorInfo& ) = delete;
USensorInfo( USensorInfo&& ) = default;
USensorInfo& operator=(USensorInfo&& ) = default;
USensorInfo():any(0),d_value(0),d_off_value(0)
{
d_si.id = UniSetTypes::DefaultObjectId;
d_si.node = UniSetTypes::DefaultObjectId;
value = default_val;
real_value = default_val;
dbignore = false;
undefined = false;
blocked = false;
}
virtual ~USensorInfo(){}
USensorInfo(IOController_i::SensorIOInfo& r);
USensorInfo(IOController_i::SensorIOInfo* r);
USensorInfo(const IOController_i::SensorIOInfo& r);
USensorInfo& operator=(IOController_i::SensorIOInfo& r);
const USensorInfo& operator=(const IOController_i::SensorIOInfo& r);
USensorInfo& operator=(IOController_i::SensorIOInfo* r);
// Дополнительные (вспомогательные поля)
UniSetTypes::uniset_rwmutex val_lock; /*!< флаг блокирующий работу со значением */
IOStateList::iterator it;
void* any; /*!< расширение для возможности хранения своей информации */
// сигнал для реализации механизма зависимостией..
// (все зависимые датчики подключаются к нему (см. NCRestorer::init_depends_signals)
UniSetTypes::uniset_rwmutex changeMutex;
ChangeSignal sigChange;
UniSetTypes::uniset_rwmutex undefMutex;
ChangeUndefinedStateSignal sigUndefChange;
IOController_i::SensorInfo d_si; /*!< идентификатор датчика, от которого зависит данный */
long d_value; /*!< разрешающее работу значение датчика от которого зависит данный */
long d_off_value; /*!< блокирующее значение */
// функция обработки информации об изменении состояния датчика, от которого зависит данный
void checkDepend( IOStateList::iterator& it, IOController* );
};
inline IOStateList::iterator ioBegin(){ return ioList.begin(); }
inline IOStateList::iterator ioEnd(){ return ioList.end(); }
inline IOStateList::iterator find(UniSetTypes::KeyType k){ return ioList.find(k); }
......@@ -184,6 +131,12 @@ class IOController:
virtual long localGetValue( IOStateList::iterator& it, const UniSetTypes::ObjectId sid );
// вариант с указателем
void localSetValue( std::shared_ptr<USensorInfo>& usi, UniSetTypes::ObjectId sid,
CORBA::Long value, UniSetTypes::ObjectId sup_id );
long localGetValue( std::shared_ptr<USensorInfo>& it, const UniSetTypes::ObjectId sid );
/*! функция выставления признака неопределённого состояния для аналоговых датчиков
// для дискретных датчиков необходимости для подобной функции нет.
......@@ -212,7 +165,7 @@ class IOController:
/*! регистрация датчика
force=true - не проверять на дублирование (оптимизация)
*/
void ioRegistration( USensorInfo&&, bool force=false );
void ioRegistration( std::shared_ptr<USensorInfo>&, bool force=false );
/*! разрегистрация датчика */
void ioUnRegistration( const UniSetTypes::ObjectId sid );
......@@ -259,7 +212,7 @@ class IOController:
// --------------------------
// ФИЛЬТРОВАНИЕ
//
typedef sigc::slot<bool,const USensorInfo&, CORBA::Long, UniSetTypes::ObjectId> IOFilterSlot;
typedef sigc::slot<bool,std::shared_ptr<USensorInfo>&, CORBA::Long, UniSetTypes::ObjectId> IOFilterSlot;
typedef std::list<IOFilterSlot> IOFilterSlotList;
/*
......@@ -274,7 +227,7 @@ class IOController:
void eraseIOFilter(IOFilterSlotList::iterator& it);
// функии проверки текущего значения
bool checkIOFilters( const USensorInfo& ai, CORBA::Long& newvalue, UniSetTypes::ObjectId sup_id );
bool checkIOFilters( std::shared_ptr<USensorInfo>& ai, CORBA::Long& newvalue, UniSetTypes::ObjectId sup_id );
inline bool iofiltersEmpty(){ return iofilters.empty(); }
inline int iodiltersSize(){ return iofilters.size(); }
......@@ -297,6 +250,60 @@ class IOController:
IOFilterSlotList iofilters; /*!< список фильтров для аналоговых значений */
UniSetTypes::uniset_rwmutex loggingMutex; /*!< logging info mutex */
public:
struct USensorInfo:
public IOController_i::SensorIOInfo
{
USensorInfo( const USensorInfo& ) = delete;
const USensorInfo& operator=(const USensorInfo& ) = delete;
USensorInfo( USensorInfo&& ) = default;
USensorInfo& operator=(USensorInfo&& ) = default;
USensorInfo():any(0),d_value(0),d_off_value(0)
{
d_si.id = UniSetTypes::DefaultObjectId;
d_si.node = UniSetTypes::DefaultObjectId;
value = default_val;
real_value = default_val;
dbignore = false;
undefined = false;
blocked = false;
}
virtual ~USensorInfo(){}
USensorInfo(IOController_i::SensorIOInfo& r);
USensorInfo(IOController_i::SensorIOInfo* r);
USensorInfo(const IOController_i::SensorIOInfo& r);
USensorInfo& operator=(IOController_i::SensorIOInfo& r);
const USensorInfo& operator=(const IOController_i::SensorIOInfo& r);
USensorInfo& operator=(IOController_i::SensorIOInfo* r);
// Дополнительные (вспомогательные поля)
UniSetTypes::uniset_rwmutex val_lock; /*!< флаг блокирующий работу со значением */
// IOStateList::iterator it;
std::shared_ptr<USensorInfo> it;
void* any; /*!< расширение для возможности хранения своей информации */
// сигнал для реализации механизма зависимостией..
// (все зависимые датчики подключаются к нему (см. NCRestorer::init_depends_signals)
UniSetTypes::uniset_rwmutex changeMutex;
ChangeSignal sigChange;
UniSetTypes::uniset_rwmutex undefMutex;
ChangeUndefinedStateSignal sigUndefChange;
IOController_i::SensorInfo d_si; /*!< идентификатор датчика, от которого зависит данный */
long d_value; /*!< разрешающее работу значение датчика от которого зависит данный */
long d_off_value; /*!< блокирующее значение */
// функция обработки информации об изменении состояния датчика, от которого зависит данный
void checkDepend( std::shared_ptr<USensorInfo>& it, IOController* );
};
};
// --------------------------------------------------------------------------
#endif
......
include/IONotifyController.h
View file @ d28a8a9c
......@@ -25,7 +25,7 @@
#ifndef IONotifyController_H_
#define IONotifyController_H_
//---------------------------------------------------------------------------
#include <map>
#include <unordered_map>
#include <list>
#include <string>
......@@ -193,7 +193,7 @@ class IONotifyController:
};
/*! словарь: датчик -> список потребителей */
typedef std::map<UniSetTypes::KeyType,ConsumerListInfo> AskMap;
typedef std::unordered_map<UniSetTypes::KeyType,ConsumerListInfo> AskMap;
/*! Информация о пороговом значении */
......@@ -261,13 +261,13 @@ class IONotifyController:
UniSetTypes::uniset_rwmutex mut;
IOController_i::SensorInfo si; /*!< аналоговый датчик */
IOStateList::iterator ait;
std::shared_ptr<USensorInfo> ait;
UniversalIO::IOType type;
ThresholdExtList list; /*!< список порогов по данному аналоговому датчику */
};
/*! словарь: аналоговый датчик --> список порогов по нему */
typedef std::map<UniSetTypes::KeyType,ThresholdsListInfo> AskThresholdMap;
typedef std::unordered_map<UniSetTypes::KeyType,ThresholdsListInfo> AskThresholdMap;
protected:
IONotifyController();
......@@ -275,7 +275,7 @@ class IONotifyController:
virtual void initItem( IOStateList::iterator& it, IOController* ic );
// ФИЛЬТРЫ
bool myIOFilter(const USensorInfo& ai, CORBA::Long newvalue, UniSetTypes::ObjectId sup_id);
bool myIOFilter(std::shared_ptr<USensorInfo>& ai, CORBA::Long newvalue, UniSetTypes::ObjectId sup_id);
//! посылка информации об изменении состояния датчика
virtual void send( ConsumerListInfo& lst, UniSetTypes::SensorMessage& sm );
......@@ -304,7 +304,7 @@ class IONotifyController:
NCRestorer* restorer;
void onChangeUndefinedState( IOStateList::iterator& it, IOController* ic );
void onChangeUndefinedState( std::shared_ptr<USensorInfo>& it, IOController* ic );
private:
friend class NCRestorer;
......
include/LogAgregator.h
View file @ d28a8a9c
......@@ -3,7 +3,7 @@
// -------------------------------------------------------------------------
#include <string>
#include <memory>
#include <map>
#include <unordered_map>
#include "DebugStream.h"
#include "LogServerTypes.h"
// -------------------------------------------------------------------------
......@@ -44,7 +44,7 @@ class LogAgregator:
private:
typedef std::map<std::string, LogInfo> LogMap;
typedef std::unordered_map<std::string, LogInfo> LogMap;
LogMap lmap;
};
// -------------------------------------------------------------------------
......
include/NCRestorer.h
View file @ d28a8a9c
......@@ -25,6 +25,7 @@
#ifndef NCRestorer_H_
#define NCRestorer_H_
// ------------------------------------------------------------------------------------------
#include <memory>
#include <sigc++/sigc++.h>
#include <string>
#include "UniXML.h"
......@@ -69,24 +70,25 @@ class NCRestorer
this->default_val = 0;
}
SInfo &operator=(IOController_i::SensorIOInfo& inf);
SInfo &operator=(const IOController_i::SensorIOInfo& inf);
SInfo( const IOController_i::SensorIOInfo& inf );
};
virtual void read( IONotifyController* ic, const std::string& fn="" )=0;
virtual void dump(const IONotifyController* ic, SInfo& inf, const IONotifyController::ConsumerListInfo& lst)=0;
virtual void dumpThreshold(const IONotifyController* ic, SInfo& inf, const IONotifyController::ThresholdExtList& lst)=0;
virtual void dump(const IONotifyController* ic, std::shared_ptr<SInfo>& inf, const IONotifyController::ConsumerListInfo& lst)=0;
virtual void dumpThreshold(const IONotifyController* ic, std::shared_ptr<SInfo>& inf, const IONotifyController::ThresholdExtList& lst)=0;
protected:
// добавление списка заказчиков
static void addlist( IONotifyController* ic, SInfo&& inf, IONotifyController::ConsumerListInfo&& lst, bool force=false );
static void addlist( IONotifyController* ic, std::shared_ptr<IOController::USensorInfo>& inf, IONotifyController::ConsumerListInfo&& lst, bool force=false );
// добавление списка порогов и заказчиков
static void addthresholdlist( IONotifyController* ic, SInfo&& inf, IONotifyController::ThresholdExtList&& lst, bool force=false );
static void addthresholdlist( IONotifyController* ic, std::shared_ptr<IOController::USensorInfo>& inf, IONotifyController::ThresholdExtList&& lst, bool force=false );
static inline void ioRegistration( IONotifyController* ic, IOController::USensorInfo&& inf, bool force=false )
static inline void ioRegistration( IONotifyController* ic, std::shared_ptr<IOController::USensorInfo>& inf, bool force=false )
{
ic->ioRegistration( std::move(inf),force);
ic->ioRegistration(inf,force);
}
static inline IOController::IOStateList::iterator ioFind( IONotifyController* ic, UniSetTypes::KeyType k )
......@@ -149,26 +151,26 @@ class NCRestorer_XML:
*/
void setReadThresholdItem( ReaderSlot sl );
typedef sigc::slot<bool,const std::shared_ptr<UniXML>&,UniXML::iterator&,xmlNode*,SInfo&> NCReaderSlot;
typedef sigc::slot<bool,const std::shared_ptr<UniXML>&,UniXML::iterator&,xmlNode*,std::shared_ptr<IOController::USensorInfo>&> NCReaderSlot;
void setNCReadItem( NCReaderSlot sl );
virtual void read( IONotifyController* ic, const std::string& filename="" );
virtual void read( IONotifyController* ic, const std::shared_ptr<UniXML>& xml );
virtual void dump(const IONotifyController* ic, SInfo& inf, const IONotifyController::ConsumerListInfo& lst);
virtual void dumpThreshold(const IONotifyController* ic, SInfo& inf, const IONotifyController::ThresholdExtList& lst);
virtual void dump(const IONotifyController* ic, std::shared_ptr<NCRestorer::SInfo>& inf, const IONotifyController::ConsumerListInfo& lst) override;
virtual void dumpThreshold(const IONotifyController* ic, std::shared_ptr<NCRestorer::SInfo>& inf, const IONotifyController::ThresholdExtList& lst) override;
protected:
bool check_thresholds_item( UniXML::iterator& it );
void read_consumers( const std::shared_ptr<UniXML>& xml, xmlNode* node, NCRestorer_XML::SInfo&& inf, IONotifyController* ic );
void read_consumers( const std::shared_ptr<UniXML>& xml, xmlNode* node, std::shared_ptr<NCRestorer_XML::SInfo>& inf, IONotifyController* ic );
void read_list( const std::shared_ptr<UniXML>& xml, xmlNode* node, IONotifyController* ic);
void read_thresholds( const std::shared_ptr<UniXML>& xml, xmlNode* node, IONotifyController* ic);
void init( const std::string& fname );
bool getBaseInfo( const std::shared_ptr<UniXML>& xml, xmlNode* it, IOController_i::SensorInfo& si );
bool getSensorInfo( const std::shared_ptr<UniXML>& xml, xmlNode* snode, SInfo& si );
bool getSensorInfo( const std::shared_ptr<UniXML>& xml, xmlNode* snode, std::shared_ptr<NCRestorer_XML::SInfo>& si );
bool getConsumerList( const std::shared_ptr<UniXML>& xml,xmlNode* node, IONotifyController::ConsumerListInfo& lst);
bool getThresholdInfo(const std::shared_ptr<UniXML>& xml,xmlNode* tnode, IONotifyController::ThresholdInfoExt& ti);
......
include/ObjectIndex_Array.h
View file @ d28a8a9c
......@@ -24,7 +24,7 @@
#define ObjectIndex_Array_H_
// --------------------------------------------------------------------------
#include <string>
#include <map>
#include <unordered_map>
#include <ostream>
#include "UniSetTypes.h"
#include "Exceptions.h"
......@@ -56,7 +56,7 @@ class ObjectIndex_Array:
private:
int numOfObject;
typedef std::map<std::string, ObjectId> MapObjectKey;
typedef std::unordered_map<std::string, ObjectId> MapObjectKey;
MapObjectKey::iterator MapObjectKeyIterator;
MapObjectKey mok;
const ObjectInfo *objectInfo;
......
include/ObjectIndex_XML.h
View file @ d28a8a9c
......@@ -23,7 +23,7 @@
#ifndef ObjectIndex_XML_H_
#define ObjectIndex_XML_H_
// --------------------------------------------------------------------------
#include <map>
#include <unordered_map>
#include <memory>
#include <vector>
#include <string>
......@@ -57,7 +57,7 @@ class ObjectIndex_XML:
unsigned int read_nodes( const std::shared_ptr<UniXML>& xml, const std::string& sec, unsigned int ind );
private:
typedef std::map<std::string, ObjectId> MapObjectKey;
typedef std::unordered_map<std::string, ObjectId> MapObjectKey;
MapObjectKey mok; // для обратного писка
std::vector<ObjectInfo> omap; // для прямого поиска
};
......
include/ObjectIndex_idXML.h
View file @ d28a8a9c
......@@ -2,7 +2,7 @@
#ifndef ObjectIndex_idXML_H_
#define ObjectIndex_idXML_H_
// --------------------------------------------------------------------------
#include <map>
#include <unordered_map>
#include <string>
#include "ObjectIndex.h"
#include "UniXML.h"
......@@ -30,10 +30,10 @@ class ObjectIndex_idXML:
void read_nodes( const std::shared_ptr<UniXML>& xml, const std::string& sec );
private:
typedef std::map<UniSetTypes::ObjectId, UniSetTypes::ObjectInfo> MapObjects;
typedef std::unordered_map<UniSetTypes::ObjectId, UniSetTypes::ObjectInfo> MapObjects;
MapObjects omap;
typedef std::map<std::string, UniSetTypes::ObjectId> MapObjectKey;
typedef std::unordered_map<std::string, UniSetTypes::ObjectId> MapObjectKey;
MapObjectKey mok; // для обратного писка
};
// -----------------------------------------------------------------------------------------
......
include/ProxyManager.h
View file @ d28a8a9c
......@@ -24,7 +24,7 @@
#ifndef ProxyManager_H_
#define ProxyManager_H_
//---------------------------------------------------------------------------
#include <map>
#include <unordered_map>
#include <memory>
#include "UniSetObject.h"
......@@ -57,7 +57,7 @@ class ProxyManager:
virtual bool deactivateObject();
private:
typedef std::map<UniSetTypes::ObjectId, PassiveObject*> PObjectMap;
typedef std::unordered_map<UniSetTypes::ObjectId, PassiveObject*> PObjectMap;
PObjectMap omap;
};
//----------------------------------------------------------------------------------------
......
include/TriggerAND.h
View file @ d28a8a9c
......@@ -26,7 +26,7 @@
#ifndef TRIGGER_AND_H_
#define TRIGGER_AND_H_
//---------------------------------------------------------------------------
#include <map>
#include <unordered_map>
//---------------------------------------------------------------------------
/*!
Триггер \b "И", со множеством входов.
......@@ -94,7 +94,7 @@ class TriggerAND
void add(InputType in, bool state);
void remove(InputType in);
typedef std::map<InputType, bool> InputMap;
typedef std::unordered_map<InputType, bool> InputMap;
inline typename InputMap::const_iterator begin()
{
......
include/TriggerOR.h
View file @ d28a8a9c
......@@ -25,7 +25,7 @@
#ifndef TRIGGER_OR_H_
#define TRIGGER_OR_H_
//---------------------------------------------------------------------------
#include <map>
#include <unordered_map>
//---------------------------------------------------------------------------
/*!
Триггер \b "ИЛИ", со множеством входов.
......@@ -92,7 +92,7 @@ class TriggerOR
void add(InputType in, bool state);
void remove(InputType in);
typedef std::map<InputType, bool> InputMap;
typedef std::unordered_map<InputType, bool> InputMap;
inline typename InputMap::const_iterator begin()
{
......
include/TriggerOUT.h
View file @ d28a8a9c
......@@ -25,7 +25,7 @@
#ifndef TriggerOUT_H_
#define TriggerOUT_H_
//---------------------------------------------------------------------------
#include <map>
#include <unordered_map>
//---------------------------------------------------------------------------
/*!
\par Описание
......@@ -120,7 +120,7 @@ class TriggerOUT
protected:
void resetOuts( OutIdType outIgnore );
typedef std::map<OutIdType, ValueType> OutList;
typedef std::unordered_map<OutIdType, ValueType> OutList;
OutList outs; // список выходов
Caller* cal;
......
include/UInterface.h
View file @ d28a8a9c
......@@ -28,7 +28,7 @@
#include <memory>
#include <string>
#include <sstream>
#include <map>
#include <unordered_map>
#include <functional>
#include <omniORB4/CORBA.h>
#include "Exceptions.h"
......@@ -281,7 +281,7 @@ class UInterface
}
};
typedef std::map<int, Info> CacheMap;
typedef std::unordered_map<int, Info> CacheMap;
mutable CacheMap mcache;
mutable UniSetTypes::uniset_rwmutex cmutex;
unsigned int MaxSize; /*!< максимальный размер кэша */
......
src/ObjectRepository/UniSetObject.cc
View file @ d28a8a9c
......@@ -21,6 +21,8 @@
* \author Pavel Vainerman
*/
// --------------------------------------------------------------------------
#include <unordered_map>
#include <map>
#include <unistd.h>
#include <signal.h>
#include <iomanip>
......@@ -477,10 +479,10 @@ struct tmpConsumerInfo
{
tmpConsumerInfo(){}
map<UniSetTypes::KeyType,VoidMessage> smap;
map<int,VoidMessage> tmap;
map<int,VoidMessage> sysmap;
map<CInfo,VoidMessage> cmap;
unordered_map<UniSetTypes::KeyType,VoidMessage> smap;
unordered_map<int,VoidMessage> tmap;
unordered_map<int,VoidMessage> sysmap;
std::map<CInfo,VoidMessage> cmap;
list<VoidMessage> lstOther;
};
......@@ -492,7 +494,7 @@ void UniSetObject::cleanMsgQueue( MessagesQueue& q )
// проходим по всем известным нам типам(базовым)
// ищем все совпадающие сообщения и оставляем только последние...
VoidMessage m;
map<UniSetTypes::ObjectId,tmpConsumerInfo> consumermap;
unordered_map<UniSetTypes::ObjectId,tmpConsumerInfo> consumermap;
// while( receiveMessage(vm) );
// while нельзя использовать потому-что, из параллельного потока
......
src/Processes/IOController.cc
View file @ d28a8a9c
......@@ -84,7 +84,7 @@ void IOController::sensorsUnregistration()
{
try
{
ioUnRegistration( li.second.si.id );
ioUnRegistration( li.second->si.id );
}
catch( const Exception& ex )
{
......@@ -100,14 +100,14 @@ void IOController::activateInit()
{
try
{
USensorInfo& s(li->second);
auto s = li->second;
// Проверка зависимостей
if( s.d_si.id != DefaultObjectId )
if( s->d_si.id != DefaultObjectId )
{
auto d_it = myiofind(s.d_si.id);
auto d_it = myiofind(s->d_si.id);
if( d_it != ioEnd() )
s.checkDepend(d_it, this);
s->checkDepend( d_it->second, this);
}
sigInit.emit(li,this);
......@@ -131,18 +131,30 @@ long IOController::localGetValue( IOController::IOStateList::iterator& li, const
li = ioList.find(sid);
if( li!=ioList.end() )
{
uniset_rwmutex_rlock lock(li->second.val_lock);
return localGetValue(li->second,sid);
// -------------
ostringstream err;
err << myname << "(localGetValue): Not found sensor (" << sid << ") "
<< uniset_conf()->oind->getNameById(sid);
if( li->second.undefined )
uinfo << err.str() << endl;
throw IOController_i::NameNotFound(err.str().c_str());
}
// ------------------------------------------------------------------------------------------
long IOController::localGetValue( std::shared_ptr<USensorInfo>& li, const UniSetTypes::ObjectId sid )
{
if( li )
{
uniset_rwmutex_rlock lock(li->val_lock);
if( li->undefined )
throw IOController_i::Undefined();
return li->second.value;
return li->value;
}
// -------------
ostringstream err;
err << myname << "(localGetValue): Not found sensor (" << sid << ") "
err << myname << "(localGetValue): Not found sensor (" << sid << ") "
<< uniset_conf()->oind->getNameById(sid);
uinfo << err.str() << endl;
......@@ -172,9 +184,9 @@ void IOController::localSetUndefinedState( IOStateList::iterator& li,
bool changed = false;
{ // lock
uniset_rwmutex_wrlock lock(li->second.val_lock);
changed = (li->second.undefined != undefined);
li->second.undefined = undefined;
uniset_rwmutex_wrlock lock(li->second->val_lock);
changed = (li->second->undefined != undefined);
li->second->undefined = undefined;
} // unlock
// сперва локальные события...
......@@ -182,8 +194,8 @@ void IOController::localSetUndefinedState( IOStateList::iterator& li,
{
if( changed )
{
uniset_rwmutex_wrlock l(li->second.undefMutex);
li->second.sigUndefChange.emit(li, this);
uniset_rwmutex_wrlock l(li->second->undefMutex);
li->second->sigUndefChange.emit( li->second, this);
}
}
catch(...){}
......@@ -194,7 +206,7 @@ void IOController::localSetUndefinedState( IOStateList::iterator& li,
if( changed )
{
uniset_mutex_lock l(siganyundefMutex);
sigAnyUndefChange.emit(li, this);
sigAnyUndefChange.emit(li->second, this);
}
}
catch(...){}
......@@ -204,8 +216,8 @@ void IOController::localSetUndefinedState( IOStateList::iterator& li,
{
if( changed )
{
uniset_rwmutex_wrlock(li->second.changeMutex);
li->second.sigChange.emit(li, this);
uniset_rwmutex_wrlock(li->second->changeMutex);
li->second->sigChange.emit(li->second, this);
}
}
catch(...){}
......@@ -216,7 +228,7 @@ void IOController::localSetUndefinedState( IOStateList::iterator& li,
if( changed )
{
uniset_mutex_lock l(siganyMutex);
sigAnyChange.emit(li, this);
sigAnyChange.emit(li->second, this);
}
}
catch(...){}
......@@ -257,35 +269,42 @@ void IOController::localSetValue( IOController::IOStateList::iterator& li,
throw IOController_i::NameNotFound(err.str().c_str());
}
localSetValue(li->second,sid,value,sup_id);
}
// ------------------------------------------------------------------------------------------
void IOController::localSetValue( std::shared_ptr<USensorInfo>& usi,
UniSetTypes::ObjectId sid,
CORBA::Long value, UniSetTypes::ObjectId sup_id )
{
bool changed = false;
{ // lock
uniset_rwmutex_wrlock lock(li->second.val_lock);
uniset_rwmutex_wrlock lock(usi->val_lock);
// фильтрам может потребоваться измениять исходное значение (например для усреднения)
// поэтому передаём (и затем сохраняем) напрямую(ссылку) value (а не const value)
bool blocked = ( li->second.blocked || li->second.undefined );
bool blocked = ( usi->blocked || usi->undefined );
if( checkIOFilters(li->second,value,sup_id) || blocked )
if( checkIOFilters(usi,value,sup_id) || blocked )
{
uinfo << myname << ": save sensor value (" << sid << ")"
<< " name: " << uniset_conf()->oind->getNameById(sid)
<< " value="<< value << endl;
long prev = li->second.value;
long prev = usi->value;
if( blocked )
{
li->second.real_value = value;
li->second.value = li->second.d_off_value;
usi->real_value = value;
usi->value = usi->d_off_value;
}
else
{
li->second.value = value;
li->second.real_value = value;
usi->value = value;
usi->real_value = value;
}
changed = ( prev != li->second.value );
changed = ( prev != usi->value );
// запоминаем время изменения
struct timeval tm;
......@@ -293,8 +312,8 @@ void IOController::localSetValue( IOController::IOStateList::iterator& li,
tm.tv_sec = 0;
tm.tv_usec = 0;
gettimeofday(&tm,&tz);
li->second.tv_sec = tm.tv_sec;
li->second.tv_usec = tm.tv_usec;
usi->tv_sec = tm.tv_sec;
usi->tv_usec = tm.tv_usec;
}
} // unlock
......@@ -302,8 +321,8 @@ void IOController::localSetValue( IOController::IOStateList::iterator& li,
{
if( changed )
{
uniset_rwmutex_wrlock l(li->second.changeMutex);
li->second.sigChange.emit(li, this);
uniset_rwmutex_wrlock l(usi->changeMutex);
usi->sigChange.emit(usi, this);
}
}
catch(...){}
......@@ -313,7 +332,7 @@ void IOController::localSetValue( IOController::IOStateList::iterator& li,
if( changed )
{
uniset_mutex_lock l(siganyMutex);
sigAnyChange.emit(li, this);
sigAnyChange.emit(usi, this);
}
}
catch(...){}
......@@ -323,14 +342,14 @@ IOType IOController::getIOType( UniSetTypes::ObjectId sid )
{
auto ali = ioList.find(sid);
if( ali!=ioList.end() )
return ali->second.type;
return ali->second->type;
ostringstream err;
err << myname << "(getIOType): датчик имя: " << uniset_conf()->oind->getNameById(sid) << " не найден";
throw IOController_i::NameNotFound(err.str().c_str());
}
// ---------------------------------------------------------------------------
void IOController::ioRegistration( USensorInfo&& ainf, bool force )
void IOController::ioRegistration( std::shared_ptr<USensorInfo>& ainf, bool force )
{
// проверка задан ли контроллеру идентификатор
if( getId() == DefaultObjectId )
......@@ -345,29 +364,29 @@ void IOController::ioRegistration( USensorInfo&& ainf, bool force )
uniset_rwmutex_wrlock lock(ioMutex);
if( !force )
{
auto li = ioList.find(ainf.si.id);
auto li = ioList.find(ainf->si.id);
if( li!=ioList.end() )
{
ostringstream err;
err << "Попытка повторной регистрации датчика("<< ainf.si.id << "). имя: "
<< uniset_conf()->oind->getNameById(ainf.si.id);
err << "Попытка повторной регистрации датчика("<< ainf->si.id << "). имя: "
<< uniset_conf()->oind->getNameById(ainf->si.id);
throw ObjectNameAlready(err.str().c_str());
}
}
IOStateList::mapped_type ai( std::move(ainf) );
IOStateList::mapped_type ai = ainf;
// запоминаем начальное время
struct timeval tm;
struct timezone tz;
tm.tv_sec = 0;
tm.tv_usec = 0;
gettimeofday(&tm,&tz);
ai.tv_sec = tm.tv_sec;
ai.tv_usec = tm.tv_usec;
ai.value = ai.default_val;
ai->tv_sec = tm.tv_sec;
ai->tv_usec = tm.tv_usec;
ai->value = ai->default_val;
// более оптимальный способ(при условии вставки первый раз)
ioList.insert( IOStateList::value_type(ainf.si.id, std::move(ai) ));
ioList.insert( IOStateList::value_type(ainf->si.id, std::move(ai) ));
}
try
......@@ -378,15 +397,15 @@ void IOController::ioRegistration( USensorInfo&& ainf, bool force )
{
uinfo << myname
<< "(ioRegistration): регистрирую "
<< uniset_conf()->oind->getNameById(ainf.si.id) << endl;
<< uniset_conf()->oind->getNameById(ainf->si.id) << endl;
ui->registered( ainf.si.id, getRef(), true );
ui->registered( ainf->si.id, getRef(), true );
return;
}
catch( const ObjectNameAlready& ex )
{
uwarn << myname << "(asRegistration): ЗАМЕНЯЮ СУЩЕСТВУЮЩИЙ ОБЪЕКТ (ObjectNameAlready)" << endl;
ui->unregister(ainf.si.id);
ui->unregister(ainf->si.id);
}
}
}
......@@ -438,18 +457,18 @@ void IOController::dumpToDB()
// uniset_mutex_lock lock(ioMutex, 100);
for( auto li = ioList.begin(); li!=ioList.end(); ++li )
{
uniset_rwmutex_rlock lock(li->second.val_lock);
uniset_rwmutex_rlock lock(li->second->val_lock);
SensorMessage sm;
sm.id = li->second.si.id;
sm.node = li->second.si.node;
sm.sensor_type = li->second.type;
sm.value = li->second.value;
sm.undefined = li->second.undefined;
sm.priority = (Message::Priority)li->second.priority;
sm.sm_tv_sec = li->second.tv_sec;
sm.sm_tv_usec = li->second.tv_usec;
sm.ci = li->second.ci;
if ( !li->second.dbignore )
sm.id = li->second->si.id;
sm.node = li->second->si.node;
sm.sensor_type = li->second->type;
sm.value = li->second->value;
sm.undefined = li->second->undefined;
sm.priority = (Message::Priority)li->second->priority;
sm.sm_tv_sec = li->second->tv_sec;
sm.sm_tv_usec = li->second->tv_usec;
sm.ci = li->second->ci;
if ( !li->second->dbignore )
logging(sm);
}
} // unlock
......@@ -465,8 +484,8 @@ IOController_i::SensorInfoSeq* IOController::getSensorsMap()
unsigned int i=0;
for( auto &it: ioList )
{
uniset_rwmutex_rlock lock(it.second.val_lock);
(*res)[i] = it.second;
uniset_rwmutex_rlock lock(it.second->val_lock);
(*res)[i] = *(it.second.get());
i++;
}
......@@ -477,7 +496,7 @@ UniSetTypes::Message::Priority IOController::getPriority( const UniSetTypes::Obj
{
auto it = ioList.find(sid);
if( it!=ioList.end() )
return (UniSetTypes::Message::Priority)it->second.priority;
return (UniSetTypes::Message::Priority)it->second->priority;
return UniSetTypes::Message::Medium; // ??
}
......@@ -487,8 +506,8 @@ IOController_i::SensorIOInfo IOController::getSensorIOInfo( const UniSetTypes::O
auto it = ioList.find(sid);
if( it!=ioList.end() )
{
uniset_rwmutex_rlock lock(it->second.val_lock);
return it->second;
uniset_rwmutex_rlock lock(it->second->val_lock);
return *(it->second.get());
}
// -------------
......@@ -513,18 +532,18 @@ CORBA::Long IOController::getRawValue( UniSetTypes::ObjectId sid )
}
// ??? получаем raw из калиброванного значения ???
IOController_i::CalibrateInfo& ci(it->second.ci);
IOController_i::CalibrateInfo& ci(it->second->ci);
if( ci.maxCal!=0 && ci.maxCal!=ci.minCal )
{
if( it->second.type == UniversalIO::AI )
return UniSetTypes::lcalibrate(it->second.value,ci.minRaw,ci.maxRaw,ci.minCal,ci.maxCal,true);
if( it->second->type == UniversalIO::AI )
return UniSetTypes::lcalibrate(it->second->value,ci.minRaw,ci.maxRaw,ci.minCal,ci.maxCal,true);
if( it->second.type == UniversalIO::AO )
return UniSetTypes::lcalibrate(it->second.value,ci.minCal,ci.maxCal,ci.minRaw,ci.maxRaw,true);
if( it->second->type == UniversalIO::AO )
return UniSetTypes::lcalibrate(it->second->value,ci.minCal,ci.maxCal,ci.minRaw,ci.maxRaw,true);
}
return it->second.value;
return it->second->value;
}
// --------------------------------------------------------------------------------------------------------------
void IOController::calibrate( UniSetTypes::ObjectId sid,
......@@ -542,7 +561,7 @@ void IOController::calibrate( UniSetTypes::ObjectId sid,
uinfo << myname <<"(calibrate): from " << uniset_conf()->oind->getNameById(adminId) << endl;
it->second.ci = ci;
it->second->ci = ci;
}
// --------------------------------------------------------------------------------------------------------------
IOController_i::CalibrateInfo IOController::getCalibrateInfo( UniSetTypes::ObjectId sid )
......@@ -555,7 +574,7 @@ IOController_i::CalibrateInfo IOController::getCalibrateInfo( UniSetTypes::Objec
<< uniset_conf()->oind->getNameById(sid);
throw IOController_i::NameNotFound(err.str().c_str());
}
return it->second.ci;
return it->second->ci;
}
// --------------------------------------------------------------------------------------------------------------
IOController::USensorInfo::USensorInfo( IOController_i::SensorIOInfo& ai ):
......@@ -599,7 +618,7 @@ const IOController::USensorInfo&
}
// ----------------------------------------------------------------------------------------
bool IOController::checkIOFilters( const USensorInfo& ai, CORBA::Long& newvalue,
bool IOController::checkIOFilters( std::shared_ptr<USensorInfo>& ai, CORBA::Long& newvalue,
UniSetTypes::ObjectId sup_id )
{
for( auto &it: iofilters )
......@@ -655,8 +674,8 @@ IOController_i::SensorInfoSeq* IOController::getSensorSeq( const IDSeq& lst )
auto it = ioList.find(lst[i]);
if( it!=ioList.end() )
{
uniset_rwmutex_rlock lock(it->second.val_lock);
(*res)[i] = it->second;
uniset_rwmutex_rlock lock(it->second->val_lock);
(*res)[i] = *(it->second.get());
continue;
}
......@@ -701,10 +720,10 @@ IOController_i::ShortIOInfo IOController::getChangedTime( UniSetTypes::ObjectId
if( ait!=ioList.end() )
{
IOController_i::ShortIOInfo i;
uniset_rwmutex_rlock lock(ait->second.val_lock);
i.value = ait->second.value;
i.tv_sec = ait->second.tv_sec;
i.tv_usec = ait->second.tv_usec;
uniset_rwmutex_rlock lock(ait->second->val_lock);
i.value = ait->second->value;
i.tv_sec = ait->second->tv_sec;
i.tv_usec = ait->second->tv_usec;
return i;
}
......@@ -729,10 +748,10 @@ IOController_i::ShortMapSeq* IOController::getSensors()
{
IOController_i::ShortMap m;
{
uniset_rwmutex_rlock lock(it.second.val_lock);
m.id = it.second.si.id;
m.value = it.second.value;
m.type = it.second.type;
uniset_rwmutex_rlock lock(it.second->val_lock);
m.id = it.second->si.id;
m.value = it.second->value;
m.type = it.second->type;
}
(*res)[i++] = m;
}
......@@ -753,8 +772,8 @@ IOController::ChangeSignal IOController::signal_change_value( UniSetTypes::Objec
throw IOController_i::NameNotFound(err.str().c_str());
}
uniset_rwmutex_rlock lock(it->second.val_lock);
return it->second.sigChange;
uniset_rwmutex_rlock lock(it->second->val_lock);
return it->second->sigChange;
}
// -----------------------------------------------------------------------------
IOController::ChangeSignal IOController::signal_change_value()
......@@ -776,8 +795,8 @@ IOController::ChangeUndefinedStateSignal IOController::signal_change_undefined_s
throw IOController_i::NameNotFound(err.str().c_str());
}
uniset_rwmutex_rlock lock(it->second.val_lock);
return it->second.sigUndefChange;
uniset_rwmutex_rlock lock(it->second->val_lock);
return it->second->sigUndefChange;
}
// -----------------------------------------------------------------------------
IOController::ChangeUndefinedStateSignal IOController::signal_change_undefined_state()
......@@ -785,14 +804,14 @@ IOController::ChangeUndefinedStateSignal IOController::signal_change_undefined_s
return sigAnyUndefChange;
}
// -----------------------------------------------------------------------------
void IOController::USensorInfo::checkDepend( IOStateList::iterator& d_it, IOController* ic )
void IOController::USensorInfo::checkDepend( std::shared_ptr<USensorInfo>& d_it, IOController* ic )
{
bool changed = false;
{
uniset_rwmutex_wrlock lock(val_lock);
bool prev = blocked;
uniset_rwmutex_rlock dlock(d_it->second.val_lock);
blocked = ( d_it->second.value == d_value ) ? false : true;
uniset_rwmutex_rlock dlock(d_it->val_lock);
blocked = ( d_it->value == d_value ) ? false : true;
changed = ( prev != blocked );
}
......
src/Processes/IONotifyController.cc
View file @ d28a8a9c
......@@ -129,7 +129,7 @@ bool IONotifyController::removeConsumer( ConsumerListInfo& lst, const ConsumerIn
/*!
* \param si - информация о датчике
* \param ci - информация о заказчике
* \param cmd - команда см. UniversalIO::UIOCommand
* \param cmd - команда см. UniversalIO::UIOCommand
*/
void IONotifyController::askSensor(const UniSetTypes::ObjectId sid,
const UniSetTypes::ConsumerInfo& ci, UniversalIO::UIOCommand cmd )
......@@ -154,24 +154,24 @@ void IONotifyController::askSensor(const UniSetTypes::ObjectId sid,
} // unlock
// посылка первый раз состояния
if( cmd==UniversalIO::UIONotify || (cmd==UIONotifyFirstNotNull && li->second.value) )
if( cmd==UniversalIO::UIONotify || (cmd==UIONotifyFirstNotNull && li->second->value) )
{
SensorMessage smsg;
smsg.id = sid;
smsg.node = uniset_conf()->getLocalNode();
smsg.consumer = ci.id;
smsg.supplier = getId();
smsg.sensor_type = li->second.type;
smsg.priority = (Message::Priority)li->second.priority;
smsg.sm_tv_sec = li->second.tv_sec;
smsg.sm_tv_usec = li->second.tv_usec;
smsg.ci = li->second.ci;
smsg.sensor_type = li->second->type;
smsg.priority = (Message::Priority)li->second->priority;
smsg.sm_tv_sec = li->second->tv_sec;
smsg.sm_tv_usec = li->second->tv_usec;
smsg.ci = li->second->ci;
{
uniset_rwmutex_rlock lock(li->second.val_lock);
smsg.value = li->second.value;
smsg.undefined = li->second.undefined;
smsg.sm_tv_sec = li->second.tv_sec;
smsg.sm_tv_usec = li->second.tv_usec;
uniset_rwmutex_rlock lock(li->second->val_lock);
smsg.value = li->second->value;
smsg.undefined = li->second->undefined;
smsg.sm_tv_sec = li->second->tv_sec;
smsg.sm_tv_usec = li->second->tv_usec;
}
try
......@@ -278,10 +278,10 @@ void IONotifyController::ask( AskMap& askLst, const UniSetTypes::ObjectId sid,
}
}
// ------------------------------------------------------------------------------------------
bool IONotifyController::myIOFilter( const USensorInfo& ai,
bool IONotifyController::myIOFilter( std::shared_ptr<USensorInfo>& ai,
CORBA::Long newvalue, UniSetTypes::ObjectId sup_id )
{
if( ai.value == newvalue )
if( ai->value == newvalue )
return false;
return true;
......@@ -318,32 +318,32 @@ void IONotifyController::localSetValue( IOController::IOStateList::iterator& li,
IOController::localSetValue(li, sid, value, sup_id);
// сравниваем именно с li->second.value
// сравниваем именно с li->second->value
// т.к. фактическое сохранённое значение может быть изменено
// фильтрами или блокировками..
SensorMessage sm(sid,li->second.value);
SensorMessage sm(sid,li->second->value);
{ // lock
uniset_rwmutex_rlock lock(li->second.val_lock);
uniset_rwmutex_rlock lock(li->second->val_lock);
if( prevValue == li->second.value )
if( prevValue == li->second->value )
return;
// Рассылаем уведомления только в слуае изменения значения
sm.id = sid;
sm.node = uniset_conf()->getLocalNode();
sm.value = li->second.value;
sm.undefined = li->second.undefined;
sm.priority = (Message::Priority)li->second.priority;
sm.value = li->second->value;
sm.undefined = li->second->undefined;
sm.priority = (Message::Priority)li->second->priority;
sm.supplier = sup_id;
sm.sensor_type = li->second.type;
sm.sm_tv_sec = li->second.tv_sec;
sm.sm_tv_usec = li->second.tv_usec;
sm.ci = li->second.ci;
sm.sensor_type = li->second->type;
sm.sm_tv_sec = li->second->tv_sec;
sm.sm_tv_usec = li->second->tv_usec;
sm.ci = li->second->ci;
} // unlock
try
{
if( !li->second.dbignore )
if( !li->second->dbignore )
loggingInfo(sm);
}
catch(...){}
......@@ -456,10 +456,10 @@ void IONotifyController::readDump()
// --------------------------------------------------------------------------------------------------------------
void IONotifyController::initItem( IOStateList::iterator& li, IOController* ic )
{
USensorInfo& s(li->second);
auto s = li->second;
if( s.type == UniversalIO::AI || s.type == UniversalIO::AO )
checkThreshold( li, s.si.id, false );
if( s->type == UniversalIO::AI || s->type == UniversalIO::AO )
checkThreshold( li, s->si.id, false );
}
// ------------------------------------------------------------------------------------------
void IONotifyController::dumpOrdersList( const UniSetTypes::ObjectId sid,
......@@ -470,10 +470,10 @@ void IONotifyController::dumpOrdersList( const UniSetTypes::ObjectId sid,
try
{
NCRestorer::SInfo inf;
IOController_i::SensorIOInfo ainf( getSensorIOInfo(sid) );
inf=ainf;
restorer->dump(this,inf,lst);
NCRestorer::SInfo tmp = ainf;
std::shared_ptr<NCRestorer::SInfo> sinf = make_shared<NCRestorer::SInfo>( std::move(tmp) );
restorer->dump(this,sinf,lst);
}
catch( const Exception& ex )
{
......@@ -489,10 +489,9 @@ void IONotifyController::dumpThresholdList( const UniSetTypes::ObjectId sid, con
try
{
NCRestorer::SInfo inf;
IOController_i::SensorIOInfo ainf(getSensorIOInfo(sid));
inf=ainf;
restorer->dumpThreshold(this,inf,lst);
shared_ptr<NCRestorer::SInfo> sinf = make_shared<NCRestorer::SInfo>(ainf);
restorer->dumpThreshold(this,sinf,lst);
}
catch( const Exception& ex )
{
......@@ -540,8 +539,7 @@ void IONotifyController::askThreshold(UniSetTypes::ObjectId sid, const UniSetTyp
tli.si.id = sid;
tli.si.node = uniset_conf()->getLocalNode();
tli.list = std::move(lst);
tli.type = li->second.type;
tli.ait = myioEnd();
tli.type = li->second->type;
// после этого вызова ti использовать нельзя
addThreshold(tli.list,std::move(ti),ci);
......@@ -582,12 +580,12 @@ void IONotifyController::askThreshold(UniSetTypes::ObjectId sid, const UniSetTyp
sm.id = sid;
sm.node = uniset_conf()->getLocalNode();
sm.value = val;
sm.undefined = li->second.undefined;
sm.sensor_type = li->second.type;
sm.priority = (Message::Priority)li->second.priority;
sm.undefined = li->second->undefined;
sm.sensor_type = li->second->type;
sm.priority = (Message::Priority)li->second->priority;
sm.consumer = ci.id;
sm.tid = tid;
sm.ci = li->second.ci;
sm.ci = li->second->ci;
// Проверка нижнего предела
if( val <= lowLimit )
......@@ -700,7 +698,7 @@ void IONotifyController::checkThreshold( IOStateList::iterator& li,
bool send_msg )
{
// поиск списка порогов
auto lst = askTMap.end();
AskThresholdMap::iterator lst = askTMap.end();
{
uniset_rwmutex_rlock lock(trshMutex);
......@@ -721,15 +719,15 @@ void IONotifyController::checkThreshold( IOStateList::iterator& li,
SensorMessage sm;
sm.id = sid;
sm.node = uniset_conf()->getLocalNode();
sm.sensor_type = li->second.type;
sm.priority = (Message::Priority)li->second.priority;
sm.ci = li->second.ci;
sm.sensor_type = li->second->type;
sm.priority = (Message::Priority)li->second->priority;
sm.ci = li->second->ci;
{
uniset_rwmutex_rlock lock(li->second.val_lock);
sm.value = li->second.value;
sm.undefined = li->second.undefined;
sm.sm_tv_sec = li->second.tv_sec;
sm.sm_tv_usec = li->second.tv_usec;
uniset_rwmutex_rlock lock(li->second->val_lock);
sm.value = li->second->value;
sm.undefined = li->second->undefined;
sm.sm_tv_sec = li->second->tv_sec;
sm.sm_tv_usec = li->second->tv_usec;
}
// текущее время
......@@ -740,10 +738,10 @@ void IONotifyController::checkThreshold( IOStateList::iterator& li,
{
uniset_rwmutex_rlock l(lst->second.mut);
for( auto it=lst->second.list.begin(); it!=lst->second.list.end(); ++it )
for( auto it=lst->second.list.begin(); it!=lst->second.list.end(); ++it )
{
// Используем здесь значение скопированное в sm.value
// чтобы не делать ещё раз lock на li->second.value
// чтобы не делать ещё раз lock на li->second->value
IONotifyController_i::ThresholdState state = it->state;
if( !it->invert )
......@@ -945,38 +943,36 @@ IONotifyController_i::ThresholdsListSeq* IONotifyController::getThresholdsList()
return res;
}
// -----------------------------------------------------------------------------
void IONotifyController::onChangeUndefinedState( IOStateList::iterator& lit, IOController* ic )
void IONotifyController::onChangeUndefinedState( std::shared_ptr<USensorInfo>& it, IOController* ic )
{
USensorInfo& it(lit->second);
SensorMessage sm;
// эти поля можно копировать без lock, т.к. они не меняются
sm.id = it.si.id;
sm.node = it.si.node;
sm.undefined = it.undefined;
sm.priority = (Message::Priority)it.priority;
sm.sensor_type = it.type;
sm.id = it->si.id;
sm.node = it->si.node;
sm.undefined = it->undefined;
sm.priority = (Message::Priority)it->priority;
sm.sensor_type = it->type;
sm.supplier = DefaultObjectId;
{ // lock
uniset_rwmutex_rlock lock(it.val_lock);
sm.value = it.value;
sm.sm_tv_sec = it.tv_sec;
sm.sm_tv_usec = it.tv_usec;
sm.ci = it.ci;
uniset_rwmutex_rlock lock(it->val_lock);
sm.value = it->value;
sm.sm_tv_sec = it->tv_sec;
sm.sm_tv_usec = it->tv_usec;
sm.ci = it->ci;
} // unlock
try
{
if( !it.dbignore )
if( !it->dbignore )
loggingInfo(sm);
}
catch(...){}
{ // lock
uniset_rwmutex_rlock lock(askIOMutex);
auto it1 = askIOList.find(it.si.id);
auto it1 = askIOList.find(it->si.id);
if( it1!=askIOList.end() )
send(it1->second, sm);
} // unlock
......
src/Processes/NCRestorer.cc
View file @ d28a8a9c
......@@ -40,7 +40,7 @@ NCRestorer::~NCRestorer()
{
}
// ------------------------------------------------------------------------------------------
void NCRestorer::addlist( IONotifyController* ic, SInfo&& inf, IONotifyController::ConsumerListInfo&& lst, bool force )
void NCRestorer::addlist( IONotifyController* ic, std::shared_ptr<IOController::USensorInfo>& inf, IONotifyController::ConsumerListInfo&& lst, bool force )
{
// Проверка зарегистрирован-ли данный датчик
// если такого дискретного датчика нет, то здесь сработает исключение...
......@@ -48,23 +48,23 @@ void NCRestorer::addlist( IONotifyController* ic, SInfo&& inf, IONotifyControlle
{
try
{
ic->getIOType(inf.si.id);
ic->getIOType(inf->si.id);
}
catch(...)
{
// Регистрируем (если не найден)
switch(inf.type)
switch(inf->type)
{
case UniversalIO::DI:
case UniversalIO::DO:
case UniversalIO::AI:
case UniversalIO::AO:
ic->ioRegistration( std::move(inf) );
ic->ioRegistration(inf);
break;
default:
ucrit << ic->getName() << "(askDumper::addlist): НЕИЗВЕСТНЫЙ ТИП ДАТЧИКА! -> "
<< uniset_conf()->oind->getNameById(inf.si.id) << endl;
<< uniset_conf()->oind->getNameById(inf->si.id) << endl;
return;
break;
......@@ -72,23 +72,23 @@ void NCRestorer::addlist( IONotifyController* ic, SInfo&& inf, IONotifyControlle
}
}
switch(inf.type)
switch(inf->type)
{
case UniversalIO::DI:
case UniversalIO::AI:
case UniversalIO::DO:
case UniversalIO::AO:
ic->askIOList[inf.si.id]=std::move(lst);
ic->askIOList[inf->si.id]=std::move(lst);
break;
default:
ucrit << ic->getName() << "(NCRestorer::addlist): НЕИЗВЕСТНЫЙ ТИП ДАТЧИКА!-> "
<< uniset_conf()->oind->getNameById(inf.si.id) << endl;
<< uniset_conf()->oind->getNameById(inf->si.id) << endl;
break;
}
}
// ------------------------------------------------------------------------------------------
void NCRestorer::addthresholdlist( IONotifyController* ic, SInfo&& inf, IONotifyController::ThresholdExtList&& lst, bool force )
void NCRestorer::addthresholdlist( IONotifyController* ic, std::shared_ptr<IOController::USensorInfo>& inf, IONotifyController::ThresholdExtList&& lst, bool force )
{
// Проверка зарегистрирован-ли данный датчик
// если такого дискретного датчика нет сдесь сработает исключение...
......@@ -96,18 +96,18 @@ void NCRestorer::addthresholdlist( IONotifyController* ic, SInfo&& inf, IONotify
{
try
{
ic->getIOType(inf.si.id);
ic->getIOType(inf->si.id);
}
catch(...)
{
// Регистрируем (если не найден)
switch(inf.type)
switch(inf->type)
{
case UniversalIO::DI:
case UniversalIO::DO:
case UniversalIO::AI:
case UniversalIO::AO:
ic->ioRegistration( std::move(inf) );
ic->ioRegistration(inf);
break;
default:
......@@ -120,17 +120,21 @@ void NCRestorer::addthresholdlist( IONotifyController* ic, SInfo&& inf, IONotify
for( auto &it: lst )
it.sit = ic->myioEnd();
ic->askTMap[inf.si.id].si = inf.si;
ic->askTMap[inf.si.id].type = inf.type;
ic->askTMap[inf.si.id].list = std::move(lst);
ic->askTMap[inf.si.id].ait = ic->myioEnd();
ic->askTMap[inf->si.id].si = inf->si;
ic->askTMap[inf->si.id].type = inf->type;
ic->askTMap[inf->si.id].list = std::move(lst);
}
// ------------------------------------------------------------------------------------------
NCRestorer::SInfo& NCRestorer::SInfo::operator=( IOController_i::SensorIOInfo& inf )
NCRestorer::SInfo::SInfo( const IOController_i::SensorIOInfo& inf )
{
this->si = inf.si;
this->type = inf.type;
this->priority = inf.priority;
(*this) = inf;
}
// ------------------------------------------------------------------------------------------
NCRestorer::SInfo& NCRestorer::SInfo::operator=( const IOController_i::SensorIOInfo& inf )
{
this->si = inf.si;
this->type = inf.type;
this->priority = inf.priority;
this->default_val = inf.default_val;
this->real_value = inf.real_value;
this->ci = inf.ci;
......@@ -139,27 +143,41 @@ NCRestorer::SInfo& NCRestorer::SInfo::operator=( IOController_i::SensorIOInfo& i
this->dbignore = inf.dbignore;
this->any = 0;
return *this;
// CalibrateInfo ci;
// long tv_sec;
// long v_usec;
}
// ------------------------------------------------------------------------------------------
#if 0
NCRestorer::SInfo& NCRestorer::SInfo::operator=( const std::shared_ptr<IOController_i::SensorIOInfo>& inf )
{
this->si = inf->si;
this->type = inf->type;
this->priority = inf->priority;
this->default_val = inf->default_val;
this->real_value = inf->real_value;
this->ci = inf->ci;
this->undefined = inf->undefined;
this->blocked = inf->blocked;
this->dbignore = inf->dbignore;
this->any = 0;
return *this;
}
#endif
// ------------------------------------------------------------------------------------------
void NCRestorer::init_depends_signals( IONotifyController* ic )
{
for( auto it=ic->ioList.begin(); it!=ic->ioList.end(); ++it )
{
// обновляем итераторы...
it->second.it = it;
it->second->it = it->second;
if( it->second.d_si.id == DefaultObjectId )
if( it->second->d_si.id == DefaultObjectId )
continue;
uinfo << ic->getName() << "(NCRestorer::init_depends_signals): "
<< " init depend: '" << uniset_conf()->oind->getMapName(it->second.si.id) << "'"
<< " dep_name=(" << it->second.d_si.id << ")'" << uniset_conf()->oind->getMapName(it->second.d_si.id) << "'"
<< " init depend: '" << uniset_conf()->oind->getMapName(it->second->si.id) << "'"
<< " dep_name=(" << it->second->d_si.id << ")'" << uniset_conf()->oind->getMapName(it->second->d_si.id) << "'"
<< endl;
ic->signal_change_value(it->second.d_si.id).connect( sigc::mem_fun( &it->second, &IOController::USensorInfo::checkDepend) );
ic->signal_change_value(it->second->d_si.id).connect( sigc::mem_fun( it->second.get(), &IOController::USensorInfo::checkDepend) );
}
}
// -----------------------------------------------------------------------------
src/Processes/NCRestorer_XML.cc
View file @ d28a8a9c
......@@ -104,13 +104,13 @@ void NCRestorer_XML::init( const std::string& xmlfile )
}
}
// ------------------------------------------------------------------------------------------
void NCRestorer_XML::dump(const IONotifyController* ic, SInfo& inf,
void NCRestorer_XML::dump(const IONotifyController* ic, std::shared_ptr<SInfo>& inf,
const IONotifyController::ConsumerListInfo& lst)
{
uwarn << "NCRestorer_XML::dump NOT SUPPORT!!!!" << endl;
}
// ------------------------------------------------------------------------------------------
void NCRestorer_XML::dumpThreshold(const IONotifyController* ic, SInfo& inf,
void NCRestorer_XML::dumpThreshold(const IONotifyController* ic, std::shared_ptr<SInfo>& inf,
const IONotifyController::ThresholdExtList& lst)
{
uwarn << "NCRestorer_XML::dumpThreshold NOT SUPPORT!!!!" << endl;
......@@ -127,7 +127,7 @@ void NCRestorer_XML::read_list( const std::shared_ptr<UniXML>& xml, xmlNode* nod
if( !check_list_item(it) )
continue;
NCRestorer_XML::SInfo inf;
std::shared_ptr<NCRestorer_XML::SInfo> inf = make_shared<NCRestorer_XML::SInfo>();
if( !getSensorInfo(xml,it,inf) )
{
......@@ -135,14 +135,16 @@ void NCRestorer_XML::read_list( const std::shared_ptr<UniXML>& xml, xmlNode* nod
continue;
}
inf.undefined = false;
inf->undefined = false;
// т.к. в функции может обновится inf
// вызываем перед регистрацией
// (потому-что в xxRegistration inf будет скопирована
ncrslot(xml,it,node,inf);
std::shared_ptr<IOController::USensorInfo> uinf = std::static_pointer_cast<IOController::USensorInfo>(inf);
switch(inf.type)
ncrslot(xml,it,node,uinf);
switch(inf->type)
{
case UniversalIO::DO:
case UniversalIO::DI:
......@@ -151,7 +153,9 @@ void NCRestorer_XML::read_list( const std::shared_ptr<UniXML>& xml, xmlNode* nod
{
try
{
ioRegistration(ic, std::move(inf), true);
ioRegistration(ic,uinf,true);
}
catch( const Exception& ex )
{
......@@ -165,7 +169,7 @@ void NCRestorer_XML::read_list( const std::shared_ptr<UniXML>& xml, xmlNode* nod
}
rslot(xml,it,node);
read_consumers(xml, it, std::move(inf), ic);
read_consumers(xml, it, inf, ic);
}
}
// ------------------------------------------------------------------------------------------
......@@ -264,26 +268,26 @@ bool NCRestorer_XML::getBaseInfo( const std::shared_ptr<UniXML>& xml, xmlNode* i
return true;
}
// ------------------------------------------------------------------------------------------
bool NCRestorer_XML::getSensorInfo( const std::shared_ptr<UniXML>& xml, xmlNode* it, SInfo& inf )
bool NCRestorer_XML::getSensorInfo( const std::shared_ptr<UniXML>& xml, xmlNode* it, std::shared_ptr<NCRestorer_XML::SInfo>& inf )
{
if( !getBaseInfo(xml,it,inf.si) )
if( !getBaseInfo(xml,it,inf->si) )
return false;
inf.priority = Message::Medium;
inf->priority = Message::Medium;
string prior(xml->getProp(it,"priority"));
if( prior == "Low" )
inf.priority = Message::Low;
inf->priority = Message::Low;
else if( prior == "Medium" )
inf.priority = Message::Medium;
inf->priority = Message::Medium;
else if( prior == "High" )
inf.priority = Message::High;
inf->priority = Message::High;
else if( prior == "Super" )
inf.priority = Message::Super;
inf->priority = Message::Super;
else
inf.priority = Message::Medium;
inf->priority = Message::Medium;
inf.type = UniSetTypes::getIOType(xml->getProp(it,"iotype"));
if( inf.type == UniversalIO::UnknownIOType )
inf->type = UniSetTypes::getIOType(xml->getProp(it,"iotype"));
if( inf->type == UniversalIO::UnknownIOType )
{
ucrit << "(NCRestorer_XML:getSensorInfo): unknown iotype=" << xml->getProp(it,"iotype")
<< " for " << xml->getProp(it,"name") << endl;
......@@ -291,34 +295,34 @@ bool NCRestorer_XML::getSensorInfo( const std::shared_ptr<UniXML>& xml, xmlNode*
}
// калибровка
if( inf.type == UniversalIO::AI || inf.type == UniversalIO::AO )
if( inf->type == UniversalIO::AI || inf->type == UniversalIO::AO )
{
inf.ci.minRaw = xml->getIntProp(it,"rmin");
inf.ci.maxRaw = xml->getIntProp(it,"rmax");
inf.ci.minCal = xml->getIntProp(it,"cmin");
inf.ci.maxCal = xml->getIntProp(it,"cmax");
inf.ci.precision = xml->getIntProp(it,"precision");
inf->ci.minRaw = xml->getIntProp(it,"rmin");
inf->ci.maxRaw = xml->getIntProp(it,"rmax");
inf->ci.minCal = xml->getIntProp(it,"cmin");
inf->ci.maxCal = xml->getIntProp(it,"cmax");
inf->ci.precision = xml->getIntProp(it,"precision");
}
else
{
inf.ci.minRaw = 0;
inf.ci.maxRaw = 0;
inf.ci.minCal = 0;
inf.ci.maxCal = 0;
inf.ci.precision = 0;
inf->ci.minRaw = 0;
inf->ci.maxRaw = 0;
inf->ci.minCal = 0;
inf->ci.maxCal = 0;
inf->ci.precision = 0;
}
inf.default_val = xml->getIntProp(it,"default");
inf.dbignore = xml->getIntProp(it,"dbignore");
inf.value = inf.default_val;
inf.undefined = false;
inf.real_value = inf.value;
inf->default_val = xml->getIntProp(it,"default");
inf->dbignore = xml->getIntProp(it,"dbignore");
inf->value = inf->default_val;
inf->undefined = false;
inf->real_value = inf->value;
string d_txt( xml->getProp(it, "depend") );
if( !d_txt.empty() )
{
inf.d_si.id = uniset_conf()->getSensorID(d_txt);
if( inf.d_si.id == UniSetTypes::DefaultObjectId )
inf->d_si.id = uniset_conf()->getSensorID(d_txt);
if( inf->d_si.id == UniSetTypes::DefaultObjectId )
{
ucrit << "(NCRestorer_XML:getSensorInfo): sensor='"
<< xml->getProp(it,"name") << "' err: "
......@@ -327,11 +331,11 @@ bool NCRestorer_XML::getSensorInfo( const std::shared_ptr<UniXML>& xml, xmlNode*
return false;
}
inf.d_si.node = uniset_conf()->getLocalNode();
inf->d_si.node = uniset_conf()->getLocalNode();
// по умолчанию срабатывание на "1"
inf.d_value = xml->getProp(it,"depend_value").empty() ? 1 : xml->getIntProp(it,"depend_value");
inf.d_off_value = xml->getPIntProp(it,"depend_off_value",0);
inf->d_value = xml->getProp(it,"depend_value").empty() ? 1 : xml->getIntProp(it,"depend_value");
inf->d_off_value = xml->getPIntProp(it,"depend_off_value",0);
}
return true;
......@@ -348,7 +352,8 @@ void NCRestorer_XML::read_thresholds( const std::shared_ptr<UniXML>& xml, xmlNod
if( !check_thresholds_item(it) )
continue;
NCRestorer_XML::SInfo inf;
std::shared_ptr<NCRestorer_XML::SInfo> inf = make_shared<NCRestorer_XML::SInfo>();
if( !getSensorInfo(xml,it.getCurrent(),inf) )
{
uwarn << ic->getName()
......@@ -371,7 +376,7 @@ void NCRestorer_XML::read_thresholds( const std::shared_ptr<UniXML>& xml, xmlNod
uwarn << ic->getName()
<< "(read_thresholds): не смог получить информацию о пороге"
<< " для датчика "
<< uniset_conf()->oind->getNameById(inf.si.id) << endl;
<< uniset_conf()->oind->getNameById(inf->si.id) << endl;
continue;
}
......@@ -392,7 +397,7 @@ void NCRestorer_XML::read_thresholds( const std::shared_ptr<UniXML>& xml, xmlNod
uwarn << ic->getName()
<< "(read_thresholds): не смог получить список заказчиков"
<< " для порога " << ti.id
<< " датчика " << uniset_conf()->oind->getNameById(inf.si.id) << endl;
<< " датчика " << uniset_conf()->oind->getNameById(inf->si.id) << endl;
}
}
}
......@@ -402,13 +407,14 @@ void NCRestorer_XML::read_thresholds( const std::shared_ptr<UniXML>& xml, xmlNod
rtslot(xml,tit,it);
}
addthresholdlist(ic, std::move(inf), std::move(tlst) );
std::shared_ptr<IOController::USensorInfo> uinf = std::static_pointer_cast<IOController::USensorInfo>(inf);
addthresholdlist(ic, uinf, std::move(tlst) );
}
}
// ------------------------------------------------------------------------------------------
void NCRestorer_XML::read_consumers( const std::shared_ptr<UniXML>& xml, xmlNode* it,
NCRestorer_XML::SInfo&& inf, IONotifyController* ic )
std::shared_ptr<NCRestorer_XML::SInfo>& inf, IONotifyController* ic )
{
// в новых ask-файлах список выделен <consumers>...</consumers>,
xmlNode* cnode = find_node(xml,it,"consumers","");
......@@ -419,7 +425,10 @@ void NCRestorer_XML::read_consumers( const std::shared_ptr<UniXML>& xml, xmlNode
{
IONotifyController::ConsumerListInfo lst;
if( getConsumerList(xml,cit,lst) )
addlist(ic,std::move(inf),std::move(lst),true);
{
std::shared_ptr<IOController::USensorInfo> uinf = std::static_pointer_cast<IOController::USensorInfo>(inf);
addlist(ic,uinf,std::move(lst),true);
}
}
}
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment