IOController.h

См. документацию.

/* This file is part of the UniSet project
 * Copyright (c) 2002 Free Software Foundation, Inc.
 * Copyright (c) 2002 Pavel Vainerman
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
// --------------------------------------------------------------------------
// -------------------------------------------------------------------------- 
#ifndef IOController_H_
#define IOController_H_
//---------------------------------------------------------------------------
#include <map>
#include <list>
#include <sigc++/sigc++.h>
#include "IOController_i.hh"
#include "UniSetTypes.h"
#include "UniSetManager.h"
#include "Configuration.h"
#include "Mutex.h"
//---------------------------------------------------------------------------
class IOController: 
        public UniSetManager,
        public POA_IOController_i
{
    public:

        IOController( const std::string& name, const std::string& section );
        IOController( const UniSetTypes::ObjectId id );
        ~IOController();

        virtual UniSetTypes::ObjectType getType() override { return UniSetTypes::ObjectType("IOController"); }

        virtual CORBA::Long getValue( UniSetTypes::ObjectId sid ) override;

//     -------------------- !!!!!!!!! ---------------------------------
//        Реализуются конкретным i/o контроллером
//        Не забывайте писать реализацию этих функций
        virtual void setValue( UniSetTypes::ObjectId sid, CORBA::Long value,
                                UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId ) override;

        virtual void fastSetValue( UniSetTypes::ObjectId sid, CORBA::Long value,
                                UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId ) override;

//     ----------------------------------------------------------------
        virtual void setUndefinedState( UniSetTypes::ObjectId sid,
                                        CORBA::Boolean undefined,
                                        UniSetTypes::ObjectId sup_id = UniSetTypes::DefaultObjectId ) override;


        virtual IOController_i::SensorInfoSeq* getSensorSeq( const UniSetTypes::IDSeq& lst ) override;
        virtual UniSetTypes::IDSeq* setOutputSeq( const IOController_i::OutSeq& lst, UniSetTypes::ObjectId sup_id ) override;

//     ----------------------------------------------------------------
        virtual UniversalIO::IOType getIOType( UniSetTypes::ObjectId sid ) override;

        virtual IOController_i::SensorInfoSeq* getSensorsMap() override;
        virtual IOController_i::SensorIOInfo getSensorIOInfo( UniSetTypes::ObjectId sid ) override;

        virtual CORBA::Long getRawValue( UniSetTypes::ObjectId sid ) override;
        virtual void calibrate( UniSetTypes::ObjectId sid,
                                    const IOController_i::CalibrateInfo& ci,
                                    UniSetTypes::ObjectId adminId ) override;

        IOController_i::CalibrateInfo getCalibrateInfo( UniSetTypes::ObjectId sid ) override;

        inline IOController_i::SensorInfo SensorInfo( const UniSetTypes::ObjectId sid,
                                const UniSetTypes::ObjectId node=UniSetTypes::uniset_conf()->getLocalNode())
        {
            IOController_i::SensorInfo si;
            si.id = sid;
            si.node = node;
            return si;
        };

        UniSetTypes::Message::Priority getPriority( const UniSetTypes::ObjectId id );

        virtual IOController_i::ShortIOInfo getChangedTime( const UniSetTypes::ObjectId id ) override;

        virtual IOController_i::ShortMapSeq* getSensors() override;

    public:

        // предварительное объявление, чтобы в структуре объявить итератор..
        struct USensorInfo;
        typedef std::map<UniSetTypes::ObjectId, USensorInfo> IOStateList;

        // ================== Достпуные сигналы =================
        typedef sigc::signal<void, IOStateList::iterator&, IOController*> ChangeSignal;
        typedef sigc::signal<void, IOStateList::iterator&, IOController*> ChangeUndefinedStateSignal;

        // signal по изменению определённого датчика
        ChangeSignal signal_change_value( UniSetTypes::ObjectId sid );

        // signal по изменению любого датчика
        ChangeSignal signal_change_value();

        // сигналы по изменению флага "неопределённое состояние" (обрыв датчика например)
        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); }
        inline int ioCount(){ return ioList.size(); }

        // доступ к элементам через итератор
        virtual void localSetValue( IOStateList::iterator& it, const UniSetTypes::ObjectId sid,
                                        CORBA::Long value, UniSetTypes::ObjectId sup_id );

        virtual long localGetValue( IOStateList::iterator& it, const UniSetTypes::ObjectId sid );


        virtual void localSetUndefinedState( IOStateList::iterator& it, bool undefined,
                                                const UniSetTypes::ObjectId sid );

    protected:
            // переопределяем для добавления вызова регистрации датчиков
            virtual bool deactivateObject() override;
            virtual bool activateObject() override;

            virtual void activateInit();

            virtual void sensorsRegistration(){};
            virtual void sensorsUnregistration();

            typedef sigc::signal<void, IOStateList::iterator&, IOController*> InitSignal;
            // signal по изменению определённого датчика
            inline InitSignal signal_init(){ return sigInit; }

            void ioRegistration( USensorInfo&&, bool force=false );

            void ioUnRegistration( const UniSetTypes::ObjectId sid );

            // ------------------------------
            inline IOController_i::SensorIOInfo
                SensorIOInfo(long v, UniversalIO::IOType t, const IOController_i::SensorInfo& si,
                                UniSetTypes::Message::Priority p = UniSetTypes::Message::Medium,
                                long defval=0, IOController_i::CalibrateInfo* ci=0 )
            {
                IOController_i::SensorIOInfo ai;
                ai.si = si;
                ai.type = t;
                ai.value = v;
                ai.priority = p;
                ai.default_val = defval;
                ai.real_value = v;
                ai.blocked = false;
                if( ci!=0 )
                    ai.ci = *ci;
                else
                {
                    ai.ci.minRaw = 0;
                    ai.ci.maxRaw = 0;
                    ai.ci.minCal = 0;
                    ai.ci.maxCal = 0;
                    ai.ci.precision = 0;
                }
                return ai;
            };

            virtual void logging( UniSetTypes::SensorMessage& sm );

            virtual void dumpToDB();

        IOController();

        // доступ к списку c изменением только для своих
        IOStateList::iterator myioBegin();
        IOStateList::iterator myioEnd();
        IOStateList::iterator myiofind( UniSetTypes::ObjectId id );
        // --------------------------
        // ФИЛЬТРОВАНИЕ
        //
        typedef sigc::slot<bool,const USensorInfo&, CORBA::Long, UniSetTypes::ObjectId> IOFilterSlot;
        typedef std::list<IOFilterSlot> IOFilterSlotList;

        /*
            Фильтрующая функция должна возвращать:
            TRUE - если значение 'нормальное'
            FALSE - если значение не подходит (отбрасывается)

            Пример использования:
                addIOFilter( sigc::mem_fun(my,&MyClass::my_filter) );
        */
        IOFilterSlotList::iterator addIOFilter( IOFilterSlot sl, bool push_front=false );
        void eraseIOFilter(IOFilterSlotList::iterator& it);

        // функии проверки текущего значения
        bool checkIOFilters( const USensorInfo& ai, CORBA::Long& newvalue, UniSetTypes::ObjectId sup_id );

        inline bool iofiltersEmpty(){ return iofilters.empty(); }
        inline int iodiltersSize(){ return iofilters.size(); }

    private:
        friend class NCRestorer;

        UniSetTypes::uniset_mutex siganyMutex;
        ChangeSignal sigAnyChange;

        UniSetTypes::uniset_mutex siganyundefMutex;
        ChangeSignal sigAnyUndefChange;
        InitSignal sigInit;

        IOStateList ioList;    
        UniSetTypes::uniset_rwmutex ioMutex; 
        bool isPingDBServer;    // флаг связи с DBServer-ом

        IOFilterSlotList iofilters; 
        UniSetTypes::uniset_rwmutex loggingMutex; 
};
// --------------------------------------------------------------------------
#endif
// --------------------------------------------------------------------------