NCRestorer.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 NCRestorer_H_
#define NCRestorer_H_
// ------------------------------------------------------------------------------------------
#include <memory>
#include <sigc++/sigc++.h>
#include <string>
#include "UniXML.h"
#include "Restorer.h"
#include "IOController.h"
#include "IONotifyController.h"
// ------------------------------------------------------------------------------------------
namespace uniset
{
class NCRestorer
{
    public:

        NCRestorer();
        virtual ~NCRestorer();

        struct SInfo:
            public IOController::USensorInfo
        {
            SInfo( const SInfo& ) = delete;
            const SInfo& operator=(const SInfo& ) = delete;
            SInfo( SInfo&& ) = default;
            SInfo& operator=(SInfo&& ) = default;

            SInfo( IOController_i::SensorInfo& si, UniversalIO::IOType& t,
                   uniset::Message::Message::Priority& p, long& def ) noexcept
            {
                this->si = si;
                this->type = t;
                this->priority = p;
                this->default_val = def;
            }

            SInfo() noexcept
            {
                this->type = UniversalIO::DI;
                this->priority = uniset::Message::Medium;
                this->default_val = 0;
            }

            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, 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, std::shared_ptr<IOController::USensorInfo>& inf, IONotifyController::ConsumerListInfo&& 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, std::shared_ptr<IOController::USensorInfo>& inf, bool force = false )
        {
            ic->ioRegistration(inf, force);
        }

        static inline IOController::IOStateList::iterator ioFind( IONotifyController* ic, uniset::ObjectId k ) noexcept
        {
            return ic->myiofind(k);
        }

        static inline IOController::IOStateList::iterator ioEnd( IONotifyController* ic ) noexcept
        {
            return ic->myioEnd();
        }
        static inline IOController::IOStateList::iterator ioBegin( IONotifyController* ic ) noexcept
        {
            return ic->myioBegin();
        }

        static void init_depends_signals( IONotifyController* ic );
};
// ------------------------------------------------------------------------------------------
class NCRestorer_XML:
    public Restorer_XML,
    public NCRestorer
{
    public:

        NCRestorer_XML( const std::string& fname );

        NCRestorer_XML( const std::string& fname, const std::string& sensor_filterField, const std::string& sensor_filterValue = "" );

        virtual ~NCRestorer_XML();
        NCRestorer_XML();

        void setThresholdsFilter( const std::string& filterField, const std::string& filterValue = "" );

        bool setFileName( const std::string& file, bool create );
        inline std::string getFileName() const noexcept
        {
            return fname;
        }

        void setReadThresholdItem( ReaderSlot sl );

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

        static void set_dumptime( const std::shared_ptr<UniXML>& xml, xmlNode* node );
        static xmlNode* bind_node( const std::shared_ptr<UniXML>& xml, xmlNode* root, const std::string& nodename, const std::string& nm = "");
        static xmlNode* rebind_node( const std::shared_ptr<UniXML>& xml, xmlNode* root, const std::string& nodename, const std::string& nm = "");

        std::string s_filterField = { "" };
        std::string s_filterValue = { "" };
        std::string t_filterField = { "" };
        std::string t_filterValue = { "" };

        std::string fname = { "" };
        std::shared_ptr<UniXML> uxml;
        ReaderSlot rtslot;
        NCReaderSlot ncrslot;

    private:
};
// -------------------------------------------------------------------------
} // end of uniset namespace
// ------------------------------------------------------------------------------------------
#endif