PropertyInfo.h

Go to the documentation of this file.

/****
 * ConfigDB/PropertyInfo.h
 *
 * Copyright 2024 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the ConfigDB Library
 *
 * This library 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, version 3 or later.
 *
 * This library 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 library.
 * If not, see <https://www.gnu.org/licenses/>.
 *
 ****/
 
#pragma once
 
#include <WString.h>
#include <Data/Range.h>
#include "Number.h"
#include <FlashString/Array.hpp>
#include <FlashString/Vector.hpp>
 
#define CONFIGDB_PROPERTY_TYPE_MAP(XX)                                                                                 \
    XX(Boolean, 1)                                                                                                     \
    XX(Int8, 1)                                                                                                        \
    XX(Int16, 2)                                                                                                       \
    XX(Int32, 4)                                                                                                       \
    XX(Int64, 8)                                                                                                       \
    XX(Enum, 1)                                                                                                        \
    XX(UInt8, 1)                                                                                                       \
    XX(UInt16, 2)                                                                                                      \
    XX(UInt32, 4)                                                                                                      \
    XX(Number, 4)                                                                                                      \
    XX(String, sizeof(StringId))                                                                                       \
    XX(Object, sizeof(ObjectInfo*))                                                                                    \
    XX(Alias, 0)
 
namespace ConfigDB
{
DEFINE_FSTR_LOCAL(fstr_empty, "")
 
enum class PropertyType : uint32_t {
#define XX(name, ...) name,
    CONFIGDB_PROPERTY_TYPE_MAP(XX)
#undef XX
};
 
using StringId = uint16_t;
 
struct ObjectInfo;
 
inline uint8_t getPropertySize(PropertyType type)
{
    switch(type) {
#define XX(tag, size)                                                                                                  \
    case PropertyType::tag:                                                                                            \
        return size;
        CONFIGDB_PROPERTY_TYPE_MAP(XX)
#undef XX
    }
    return 0;
}
 
struct EnumInfo {
    PropertyType type;       
    FSTR::ObjectBase values; //< Possible values
 
    uint8_t getItemSize() const
    {
        return (type == PropertyType::String) ? sizeof(FSTR::String*) : getPropertySize(type);
    }
 
    unsigned length() const
    {
        return values.length() / getItemSize();
    }
 
    String getString(uint8_t index) const;
    int find(const char* value, unsigned length) const;
 
    template <typename T> const FSTR::Array<T>& getArray() const
    {
        return values.as<FSTR::Array<T>>();
    }
 
    const FSTR::Vector<FSTR::String>& getStrings() const
    {
        return values.as<FSTR::Vector<FSTR::String>>();
    }
 
    template <typename T> T getValue(uint8_t index) const
    {
        return getArray<T>()[index];
    }
};
 
template <typename T> class EnumRange : public TRange<T>
{
public:
    using TRange<T>::TRange;
 
    T random() const
    {
        TRange<uint8_t> range{uint8_t(this->min), uint8_t(this->max)};
        return T(range.random());
    }
};
 
struct PropertyInfo {
    using RangeNumber = TRange<const_number_t>;
    using RangeInt8 = TRange<int32_t>;
    using RangeInt16 = TRange<int32_t>;
    using RangeInt32 = TRange<int32_t>;
    using RangeInt64 = TRange<int64_t>;
    using RangeUInt8 = TRange<uint32_t>;
    using RangeUInt16 = TRange<uint32_t>;
    using RangeUInt32 = TRange<uint32_t>;
 
    // Variant property information depends on type
    union Variant {
        const FlashString* defaultString;
        const ObjectInfo* object;
        const EnumInfo* enuminfo;
        const RangeNumber* number;
        const RangeInt8* int8;
        const RangeInt16* int16;
        const RangeInt32* int32;
        const RangeInt64* int64;
        const RangeUInt8* uint8;
        const RangeUInt16* uint16;
        const RangeUInt32* uint32;
    };
 
    PropertyType type;
    const FlashString& name;
    uint32_t offset; 
    Variant variant;
 
    static const PropertyInfo empty;
 
    explicit operator bool() const
    {
        return this != &empty;
    }
 
    bool isStringType() const
    {
        if(type == PropertyType::String) {
            return true;
        }
        if(type == PropertyType::Enum && variant.enuminfo->type == PropertyType::String) {
            return true;
        }
        return false;
    }
 
    uint8_t getSize() const
    {
        return getPropertySize(type);
    }
 
    int findObject(const char* name, unsigned length) const;
 
    int findProperty(const char* name, unsigned length) const;
 
    const PropertyInfo& getObject(unsigned index) const;
};
 
} // namespace ConfigDB
 
String toString(ConfigDB::PropertyType type);