GenericZWaveMapperRegistry.h

#pragma once

#include <iosfwd>
#include <map>

#include "model/ModuleID.h"
#include "model/ModuleType.h"
#include "util/Loggable.h"
#include "zwave/ZWaveMapperRegistry.h"

namespace BeeeOn {

class GenericZWaveMapperRegistry :
        public ZWaveMapperRegistry,
        Loggable {
public:
        class GenericMapper : public ZWaveMapperRegistry::Mapper {
        public:
                typedef Poco::SharedPtr<GenericMapper> Ptr;

                static uint8_t ID_MANGLE_BITS;

                GenericMapper(const ZWaveNode::Identity &id, const std::string &product);

                DeviceID buildID() const override;

                std::string product() const override;

                std::list<ModuleType> types() const override;
                SensorValue convert(const ZWaveNode::Value &value) const override;
                ZWaveNode::Value convert(const ModuleID &id, double value) const override;

                void mapType(
                        const ZWaveNode::CommandClass &cc,
                        const ModuleType &type);

        protected:
                void cannotConvert(const ZWaveNode::Value &value) const;

        private:
                std::map<ZWaveNode::CommandClass, ModuleID> m_mapping;
                std::map<ModuleID, ModuleType> m_modules;
        };

        GenericZWaveMapperRegistry();

        void loadTypesMapping(const std::string &file);
        void loadTypesMapping(std::istream &in);

        Mapper::Ptr resolve(const ZWaveNode &node) override;

private:
        std::map<std::pair<uint8_t, uint8_t>, ModuleType> m_typesMapping;

        std::map<std::pair<uint8_t, uint8_t>, unsigned int> m_typesOrder;
};

}