IOController.h

/*
 * Copyright (c) 2015 Pavel Vainerman.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, version 2.1.
 *
 * 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
 * Lesser General Lesser Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
// --------------------------------------------------------------------------
// --------------------------------------------------------------------------
#ifndef IOController_H_
#define IOController_H_
//---------------------------------------------------------------------------
#include <unordered_map>
#include <list>
#include <sigc++/sigc++.h>
#include "IOController_i.hh"
#include "UniSetTypes.h"
#include "UniSetManager.h"
#include "Configuration.h"
#include "Mutex.h"
//---------------------------------------------------------------------------
namespace uniset
{
class IOController:
    public UniSetManager,
    public POA_IOController_i
{
    public:

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

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

        virtual uniset::SimpleInfo* getInfo( const char* userparam = "" ) override;

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

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

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


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

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

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

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

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

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

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

        virtual IOController_i::ShortIOInfo getTimeChange( const uniset::ObjectId id ) override;

        virtual IOController_i::ShortMapSeq* getSensors() override;

#ifndef DISABLE_REST_API
        // http API
        virtual Poco::JSON::Object::Ptr httpHelp( const Poco::URI::QueryParameters& p ) override;
        virtual Poco::JSON::Object::Ptr httpRequest( const std::string& req, const Poco::URI::QueryParameters& p ) override;
#endif

    public:

        // предварительное объявление..
        struct USensorInfo;
        typedef std::unordered_map<uniset::ObjectId, std::shared_ptr<USensorInfo>> IOStateList;

        // ================== Достпуные сигналы =================
        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( uniset::ObjectId sid );

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

        // сигналы по изменению флага "неопределённое состояние" (обрыв датчика например)
        ChangeUndefinedStateSignal signal_change_undefined_state( uniset::ObjectId sid );
        ChangeUndefinedStateSignal signal_change_undefined_state();
        // -----------------------------------------------------------------------------------------
        // полнейшее нарушение икапсуляции
        // но пока, это попытка оптимизировать работу с IOController через указатель.
        // Т.е. работая с датчиками через итераторы..
        inline IOStateList::iterator ioBegin()
        {
            return ioList.begin();
        }
        inline IOStateList::iterator ioEnd()
        {
            return ioList.end();
        }
        inline IOStateList::iterator find( uniset::ObjectId k )
        {
            return ioList.find(k);
        }
        inline int ioCount() const
        {
            return ioList.size();
        }

    protected:

        // доступ к элементам через итератор
        // return итоговое значение
        virtual long localSetValueIt( IOStateList::iterator& it, const uniset::ObjectId sid,
                                      CORBA::Long value, uniset::ObjectId sup_id );

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

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

        // -- работа через указатель ---
        virtual long localSetValue( std::shared_ptr<USensorInfo>& usi, CORBA::Long value, uniset::ObjectId sup_id );
        long localGetValue( std::shared_ptr<USensorInfo>& usi) ;

#ifndef DISABLE_REST_API
        // http API
        virtual Poco::JSON::Object::Ptr request_get( const std::string& req, const Poco::URI::QueryParameters& p );
        virtual Poco::JSON::Object::Ptr request_sensors( const std::string& req, const Poco::URI::QueryParameters& p );
        void getSensorInfo( Poco::JSON::Array::Ptr& jdata, std::shared_ptr<USensorInfo>& s , bool shortInfo = false );
#endif

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

        virtual void activateInit();

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

        typedef sigc::signal<void, std::shared_ptr<USensorInfo>&, IOController*> InitSignal;

        // signal по изменению определённого датчика
        InitSignal signal_init();

        void ioRegistration(std::shared_ptr<USensorInfo>& usi, bool force = false );

        void ioUnRegistration( const uniset::ObjectId sid );

        // ------------------------------
        inline IOController_i::SensorIOInfo
        SensorIOInfo(long v, UniversalIO::IOType t, const IOController_i::SensorInfo& si,
                     uniset::Message::Priority p = uniset::Message::Medium,
                     long defval = 0, IOController_i::CalibrateInfo* ci = 0,
                     uniset::ObjectId sup_id = uniset::DefaultObjectId )
        {
            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;
            ai.supplier = sup_id;

            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 std::move(ai);
        };

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

        virtual void dumpToDB();

        IOController();

        // доступ к списку c изменением только для своих
        IOStateList::iterator myioBegin();
        IOStateList::iterator myioEnd();
        IOStateList::iterator myiofind( uniset::ObjectId id );
        size_t ioCount();
        // --------------------------

    private:
        friend class NCRestorer;
        friend class SMInterface;

        std::mutex siganyMutex;
        ChangeSignal sigAnyChange;

        std::mutex siganyundefMutex;
        ChangeSignal sigAnyUndefChange;
        InitSignal sigInit;

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

        std::mutex loggingMutex; 
    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(): d_value(1), d_off_value(0)
            {
                d_si.id = uniset::DefaultObjectId;
                d_si.node = uniset::DefaultObjectId;
                default_val = 0;
                value = default_val;
                real_value = default_val;
                dbignore = false;
                undefined = false;
                blocked = false;
                supplier = uniset::DefaultObjectId;
            }

            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);

            // Дополнительные (вспомогательные поля)
            uniset::uniset_rwmutex val_lock; 
            static const size_t MaxUserData = 4;
            void* userdata[MaxUserData] = { nullptr, nullptr, nullptr, nullptr }; 
            // сигнал для реализации механизма зависимостией..
            // (все зависимые датчики подключаются к нему (см. NCRestorer::init_depends_signals)
            uniset::uniset_rwmutex changeMutex;
            ChangeSignal sigChange;

            uniset::uniset_rwmutex undefMutex;
            ChangeUndefinedStateSignal sigUndefChange;

            IOController_i::SensorInfo d_si = { uniset::DefaultObjectId, uniset::DefaultObjectId };  
            long d_value = { 1 }; 
            long d_off_value = { 0 }; 
            std::shared_ptr<USensorInfo> d_usi; // shared_ptr на датчик от которого зависит этот.

            size_t nchanges = { 0 }; // количество изменений датчика

            // функция обработки информации об изменении состояния датчика, от которого зависит данный
            void checkDepend( std::shared_ptr<USensorInfo>& d_usi, IOController* );

            void init( const IOController_i::SensorIOInfo& s );

            inline IOController_i::SensorIOInfo makeSensorIOInfo()
            {
                uniset::uniset_rwmutex_rlock lock(val_lock);
                IOController_i::SensorIOInfo s(*this);
                return std::move(s);
            }

            inline uniset::SensorMessage makeSensorMessage()
            {
                uniset::SensorMessage sm;
                sm.id           = si.id;
                sm.node         = si.node; // uniset_conf()->getLocalNode()?
                sm.sensor_type  = type;
                sm.priority     = (uniset::Message::Priority)priority;

                // лочим только изменяемые поля
                {
                    uniset::uniset_rwmutex_rlock lock(val_lock);
                    sm.value        = value;
                    sm.sm_tv.tv_sec    = tv_sec;
                    sm.sm_tv.tv_nsec   = tv_nsec;
                    sm.ci           = ci;
                    sm.supplier     = supplier;
                    sm.undefined    = undefined;
                }

                return std::move(sm);
            }
        };
};
// -------------------------------------------------------------------------
} // end of uniset namespace
// --------------------------------------------------------------------------
#endif
// --------------------------------------------------------------------------