Небольшая оптимизация и правки документации

extensions/ModbusMaster/MBExchange.cc

@@ -31,15 +31,12 @@ prop_prefix(""),
 mb(0),
 pollActivated(false)
 {
-//    cout << "$ $" << endl;
-
     if( objId == DefaultObjectId )
         throw UniSetTypes::SystemError("(MBExchange): objId=-1?!! Use --" + prefix + "-name" );
 
     mutex_start.setName(myname + "_mutex_start");
 
-//    xmlNode* cnode = conf->getNode(myname);
-    string conf_name = conf->getArgParam("--" + prefix + "-confnode",myname);
+    string conf_name(conf->getArgParam("--" + prefix + "-confnode",myname));
 
     cnode = conf->getNode(conf_name);
     if( cnode == NULL )
@@ -86,7 +83,6 @@ pollActivated(false)
     force = conf->getArgInt("--" + prefix + "-force",it.getProp("force"));
     force_out = conf->getArgInt("--" + prefix + "-force-out",it.getProp("force_out"));
 
-
     // ********** HEARTBEAT *************
     string heart = conf->getArgParam("--" + prefix + "-heartbeat-id",it.getProp("heartbeat_id"));
     if( !heart.empty() )

extensions/SharedMemory/SharedMemory.cc

@@ -63,12 +63,12 @@ SharedMemory::SharedMemory( ObjectId id, string datafile, std::string confname )
     restorer = NULL;
     NCRestorer_XML* rxml = new NCRestorer_XML(datafile);
 
-    string s_field = conf->getArgParam("--s-filter-field");
-    string s_fvalue = conf->getArgParam("--s-filter-value");
-    string c_field = conf->getArgParam("--c-filter-field");
-    string c_fvalue = conf->getArgParam("--c-filter-value");
-    string t_field = conf->getArgParam("--t-filter-field");
-    string t_fvalue = conf->getArgParam("--t-filter-value");
+    string s_field(conf->getArgParam("--s-filter-field"));
+    string s_fvalue(conf->getArgParam("--s-filter-value"));
+    string c_field(conf->getArgParam("--c-filter-field"));
+    string c_fvalue(conf->getArgParam("--c-filter-value"));
+    string t_field(conf->getArgParam("--t-filter-field"));
+    string t_fvalue(conf->getArgParam("--t-filter-value"));
 
     heartbeat_node = conf->getArgParam("--heartbeat-node");
     if( heartbeat_node.empty() )

extensions/SharedMemory/SharedMemory.h

@@ -210,15 +210,15 @@
        id           - задаёт (внутренний) идентификатор "истории"
        fuse_id      - идентификатор датчика "детонатора"
        fuse_value   - значение срабатывания (для аналогового "детонатора")
-       fuse_invert  - ивертировать (для дискретный "детонаторов"). 
+       fuse_invert  - ивертировать (для дискретных "детонаторов").
                       Т.е. срабатвание на значение "0".
        
        size         - количество точек в хранимой истории
        filter       - поле используемое в качестве фильтра, определяющего датчики
-                      входящие в данную историю. 
+                      входящие в данную группу (историю).
     \endcode 
        
-       Каждый датчик может входить в любое количество историй.
+       Каждый датчик может входить в любое количество групп (историй).
        
        Механизм фукнционирует по следующей логике:
        
@@ -234,8 +234,8 @@
        
        Помимо этого в фукнциях изменения датчиков  (saveXXX, setXXX) отслеживается
        изменение состояния "детонаторов". Если срабатывает заданое условие для
-       "сброса" дампа инициируется сигнал, в который передаётся идентификатор истории
-       и текущая накопленная информация.
+       "сброса" дампа, инициируется сигнал, в который передаётся идентификатор истории
+       и текущая накопленная история.
        
        \section sec_SM_Pulsar "Мигание" специальным датчиком
        В SM реализован механизм позволяющий задать специальный дискретный датчик ("пульсар"),
@@ -250,7 +250,7 @@
        Для оптимизации, по умолчанию в SM отключено сохранение каждого изменения датчиков в БД
        (реализованное в базовом классе IONotifyController).
        Параметр командной строки \b --db-logging 1 позволяет включить этот механизм
-       (в свою очередь он требует отдельной настройки).
+       (в свою очередь работа с БД требует отдельной настройки).
    
 */
 class SharedMemory:

extensions/SharedMemory/start_fg.sh

@@ -4,7 +4,7 @@ export LD_LIBRARY_PATH="../../lib/.libs;../lib/.libs"
 
 ulimit -Sc 10000000000
 
-./uniset-start.sh -g ./uniset-smemory --smemory-id SharedMemory --pulsar-id DO_C --pulsar-iotype DO \
+./uniset-start.sh -f ./uniset-smemory --smemory-id SharedMemory --pulsar-id DO_C --pulsar-iotype DO \
 --confile test.xml --datfile test.xml \
 --unideb-add-levels info,crit,warn,level9,system \
 --dlog-add-levels info,crit,warn \

extensions/include/Calibration.h

@@ -80,7 +80,7 @@ class Calibration
             Получение сырого значения по калиброванному
             \param range=true вернуть крайнее значение в диаграмме
                 если cal<leftVal или cal>rightVal (т.е. выходит за диапазон)
-                            
+
             Если range=false, то может быть возвращено значение outOfRange.
         */
         long getRawValue( long cal, bool range=false );
@@ -110,7 +110,7 @@ class Calibration
         /*! преобразование типа для хранения 
             в тип для аналоговых датчиков
          */
-        inline long tRound( const TypeOfValue& val )
+        inline long tRound( const TypeOfValue& val ) const
         {
             return lround(val);
         }
@@ -118,8 +118,6 @@ class Calibration
         friend std::ostream& operator<<(std::ostream& os, Calibration& c );
         friend std::ostream& operator<<(std::ostream& os, Calibration* c );
 
-    protected:
-
         /*!    точка характеристики */
         struct Point
         {
@@ -129,7 +127,7 @@ class Calibration
             TypeOfValue x;
             TypeOfValue y;
 
-               inline bool operator < ( const Point& p ) const
+            inline bool operator < ( const Point& p ) const
             {
                 return ( x < p.x );
             }
@@ -139,47 +137,49 @@ class Calibration
         class Part
         {
             public:
-                Part( Point& pleft, Point& pright );
+                Part( const Point& pleft, const Point& pright );
                 ~Part(){};
 
                 /*!    находится ли точка на данном участке */
-                bool check( Point& p );
+                bool check( const Point& p ) const;
 
                 /*!    находится ли точка на данном участке по X */
-                bool checkX( TypeOfValue x );
+                bool checkX( const TypeOfValue& x ) const;
 
                 /*!    находится ли точка на данном участке по Y */
-                bool checkY( TypeOfValue y );
-                
+                bool checkY( const TypeOfValue& y ) const;
+
                 // функции могут вернуть OutOfRange
-                TypeOfValue getY( TypeOfValue x );         /*!< получить значение Y */
-                TypeOfValue getX( TypeOfValue y );        /*!< получить значение X */
+                TypeOfValue getY( const TypeOfValue& x ) const;         /*!< получить значение Y */
+                TypeOfValue getX( const TypeOfValue& y ) const;        /*!< получить значение X */
+
+                TypeOfValue calcY( const TypeOfValue& x ) const;     /*!< расчитать значение для x */
+                TypeOfValue calcX( const TypeOfValue& y ) const;     /*!< расчитать значение для y */
 
-                TypeOfValue calcY( TypeOfValue x );     /*!< расчитать значение для x */
-                TypeOfValue calcX( TypeOfValue y );     /*!< расчитать значение для y */
-                
-                   inline bool operator < ( const Part& p ) const
+                inline bool operator < ( const Part& p ) const
                 {
                     return (p_right < p.p_right);
                 }
-            
-                inline Point leftPoint(){ return p_left; }
-                inline Point rightPoint(){ return p_right; }
-                inline TypeOfValue getK(){ return k; }     /*!< получить коэффициент наклона */
-                inline TypeOfValue left_x(){ return p_left.x; }
-                inline TypeOfValue left_y(){ return p_left.y; }
-                inline TypeOfValue right_x(){ return p_right.x; }
-                inline TypeOfValue right_y(){ return p_right.y; }
+
+                inline Point leftPoint() const { return p_left; }
+                inline Point rightPoint() const { return p_right; }
+                inline TypeOfValue getK() const { return k; }     /*!< получить коэффициент наклона */
+                inline TypeOfValue left_x() const { return p_left.x; }
+                inline TypeOfValue left_y() const { return p_left.y; }
+                inline TypeOfValue right_x() const { return p_right.x; }
+                inline TypeOfValue right_y() const { return p_right.y; }
 
             protected:
                 Point p_left;     /*!< левый предел участка */
                 Point p_right;     /*!< правый предел участка */
                 TypeOfValue k;     /*!< коэффициент наклона */
         };
-        
+
+    protected:
+
         // список надо отсортировать по x!
         typedef std::list<Part> PartsList;
-        
+
         long minRaw, maxRaw, minVal, maxVal, rightVal, leftVal, rightRaw, leftRaw;
 
     private:

extensions/lib/Calibration.cc

 #include <sstream>
 #include <iostream>
+#include <algorithm>
 #include "UniXML.h"
 #include "Exceptions.h"
 #include "Calibration.h"
@@ -8,7 +9,7 @@ using namespace std;
 using namespace UniSetTypes;
 // ----------------------------------------------------------------------------
 
-Calibration::Part::Part( Point& pleft, Point& pright ):
+Calibration::Part::Part( const Point& pleft, const Point& pright ):
     p_left(pleft),
     p_right(pright),
     k(0)
@@ -28,19 +29,19 @@ Calibration::Part::Part( Point& pleft, Point& pright ):
         k = ( p_right.y - p_left.y ) / ( p_right.x - p_left.x );
 }
 // ----------------------------------------------------------------------------
-bool Calibration::Part::check( Point& p )
+bool Calibration::Part::check( const Point& p ) const
 {
     return ( checkX(p.x) && checkY(p.y) );
 }
 
-bool Calibration::Part::checkX( TypeOfValue x )
+bool Calibration::Part::checkX( const TypeOfValue& x ) const
 {
     if( x < p_left.x || x > p_right.x )
         return false;
     return true;
 }
 
-bool Calibration::Part::checkY( TypeOfValue y )
+bool Calibration::Part::checkY( const TypeOfValue& y ) const
 {
     if( y < p_left.y || y > p_right.y )
         return false;
@@ -49,41 +50,41 @@ bool Calibration::Part::checkY( TypeOfValue y )
 }
 
 // ----------------------------------------------------------------------------
-Calibration::TypeOfValue Calibration::Part::getY( TypeOfValue x )
+Calibration::TypeOfValue Calibration::Part::getY( const TypeOfValue& x ) const
 {
     if( !checkX(x) )
         return Calibration::outOfRange;
 
     if( x == left_x() )
         return left_y();
-    
+
     if( x == right_x() )
         return right_y();
-    
+
     return calcY(x);
 }
 // ----------------------------------------------------------------------------
-Calibration::TypeOfValue Calibration::Part::getX( TypeOfValue y )
+Calibration::TypeOfValue Calibration::Part::getX( const TypeOfValue& y ) const
 {
     if( !checkY(y) )
         return Calibration::outOfRange;
-    
+
     if( y == left_y() )
         return left_x();
-    
+
     if( y == right_y() )
         return right_x();
-    
+
     return calcX(y);
 }
 // ----------------------------------------------------------------------------
-Calibration::TypeOfValue Calibration::Part::calcY( TypeOfValue x )
+Calibration::TypeOfValue Calibration::Part::calcY( const TypeOfValue& x ) const
 {
     // y = y0 + kx
     return k*(x-p_left.x)+p_left.y;
 }
 // ----------------------------------------------------------------------------
-Calibration::TypeOfValue Calibration::Part::calcX( TypeOfValue y )
+Calibration::TypeOfValue Calibration::Part::calcX( const TypeOfValue& y ) const
 {
     // x = (y - y0) / k
     if( k == 0 )
@@ -220,17 +221,14 @@ void Calibration::build( const string& name, const string& confile, xmlNode* roo
 // ----------------------------------------------------------------------------
 long Calibration::getValue( long raw, bool crop_raw )
 {
-    if( crop_raw )
-    {
-        // если x левее первого отрезка то берём первую точку...
-        if( raw < leftRaw )
-            return leftVal;
-        
-        // если x правее последнего то берём крайнюю точку...
-        if( raw > rightRaw )
-            return rightVal;
-    }
-    
+    // если x левее первого отрезка то берём первую точку...
+    if( raw < leftRaw )
+        return (crop_raw ? leftVal : outOfRange);
+
+    // если x правее последнего то берём крайнюю точку...
+    if( raw > rightRaw )
+        return (crop_raw ? rightVal : outOfRange);
+
     for( PartsList::iterator it=plist.begin(); it!=plist.end(); ++it )
     {
         TypeOfValue q = it->getY(raw);
@@ -254,7 +252,7 @@ long Calibration::getRawValue( long cal, bool range )
     {
         if( cal < leftVal )
             return leftRaw;
-        
+
         if( cal > rightVal )
             return rightRaw;
     }