ModuleType.h

#pragma once

#include <set>

#include "model/CustomTypeID.h"
#include "util/Enum.h"

namespace BeeeOn {

class ModuleType {
public:
        struct AttributeEnum {
                enum Raw {
                        ATTR_INNER = 1,
                        ATTR_MANUAL_ONLY = 2,
                        ATTR_OUTER = 3,
                        ATTR_CONTROLLABLE = 4,
                };

                static EnumHelper<Raw>::ValueMap &valueMap();
        };

        struct TypeEnum {
                enum Raw {
                        TYPE_UNKNOWN = 0,
                        TYPE_AVAILABILITY = 1,
                        TYPE_BATTERY = 2,
                        TYPE_BITMAP = 3,
                        TYPE_BRIGHTNESS = 4,
                        TYPE_CO2 = 5,
                        TYPE_ENUM = 6,
                        TYPE_FIRE = 7,
                        TYPE_HUMIDITY = 8,
                        TYPE_LUMINANCE = 9,
                        TYPE_MOTION = 10,
                        TYPE_NOISE = 11,
                        TYPE_OPEN_CLOSE = 12,
                        TYPE_ON_OFF = 13,
                        TYPE_PERFORMANCE = 14,
                        TYPE_PRESSURE = 15,
                        TYPE_RSSI = 16,
                        TYPE_SECURITY_ALERT = 17,
                        TYPE_SHAKE = 18,
                        TYPE_TEMPERATURE = 19,
                        TYPE_ULTRAVIOLET = 20,
                        TYPE_POWER = 21,
                        TYPE_VOLTAGE = 22,
                        TYPE_CURRENT = 23,
                        TYPE_FREQUENCY = 24,
                        TYPE_COLOR_TEMPERATURE = 25,
                        TYPE_COLOR = 26,
                        TYPE_SMOKE = 27,
                        TYPE_HEAT = 28,
                        TYPE_PM25 = 29,
                        TYPE_OPEN_RATIO = 30,
                };

                static EnumHelper<Raw>::ValueMap &valueMap();
        };

        struct UnitEnum {
                enum Raw {
                        NONE,
                        BINARY,
                        PERCENT,
                        PPM,
                        LUX,
                        DECIBEL,
                        HECTOPASCAL,
                        CELSIUS,
                        UVINDEX,
                        WATT,
                        VOLT,
                        AMPERE,
                        HERTZ,
                        KELVIN,
                        UG_M3,
                };

                static EnumHelper<Raw>::ValueMap &valueMap();
        };

        typedef Enum<TypeEnum> Type;
        typedef Enum<AttributeEnum> Attribute;

        class Unit : public Enum<UnitEnum> {
        public:
                Unit(const UnitEnum::Raw &raw);

                bool isValid(double value) const;

                std::string symbol(bool plain = false) const;

                std::string format(double value, bool plain = false) const;
        };

        ModuleType();
        ModuleType(const Type &type);
        ModuleType(const Type &type, const std::set<Attribute> &attributes);
        ModuleType(const Type &type, const CustomTypeID &customID);
        ModuleType(const Type &type, const CustomTypeID &customID, const std::set<Attribute> &attributes);

        Unit baseUnit() const;

        void setType(const Type &type);
        Type type() const;

        void setAttributes(const std::set<Attribute> &attributes);
        std::set<Attribute> attributes() const;

        bool isControllable() const;

        void setCustomTypeID(CustomTypeID id);
        CustomTypeID customTypeID() const;

        static ModuleType parse(std::string input);

protected:
        static bool hasCombination(
                const std::set<Attribute> &attributes,
                const std::set<Attribute> &check);
        static void assureValidAttributes(
                const std::set<Attribute> &attributes);

private:
        Type m_type;
        std::set<Attribute> m_attributes;
        CustomTypeID m_customID;
};

}