Object.hpp

Go to the documentation of this file.

/****
 * Object.hpp - Definitions and macros common to all object types
 *
 * Copyright 2019 mikee47 <mike@sillyhouse.net>
 *
 * This file is part of the FlashString 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/>.
 *
 * @author: 2018 - Mikee47 <mike@sillyhouse.net>
 *
 ****/
 
#pragma once
 
#include "Utility.hpp"
#include "ObjectBase.hpp"
#include "ObjectIterator.hpp"
 
#define DECLARE_FSTR_OBJECT(name, ObjectType) extern const ObjectType& name;
 
#define DEFINE_FSTR_REF(name, ObjectType, object) const ObjectType& name PROGMEM = object.template as<ObjectType>();
 
#define DEFINE_FSTR_REF_NAMED(name, ObjectType) DEFINE_FSTR_REF(name, ObjectType, FSTR_DATA_NAME(name).object);
 
#define FSTR_DATA_NAME(name) __fstr__##name
 
#define FSTR_PTR(objref) static_cast<std::remove_reference<decltype(objref)>::type*>(&FSTR_DATA_NAME(objref).object)
 
#define FSTR_CHECK_STRUCT(name)                                                                                        \
    static_assert(std::is_pod<decltype(name)>::value, "FSTR structure not POD");                                       \
    static_assert(offsetof(decltype(name), data) == sizeof(uint32_t), "FSTR structure alignment error");
 
#define IMPORT_FSTR_OBJECT(name, ObjectType, file)                                                                     \
    IMPORT_FSTR_DATA(FSTR_DATA_NAME(name), file)                                                                       \
    extern "C" __attribute__((visibility("hidden"))) const FSTR::ObjectBase FSTR_DATA_NAME(name);                      \
    DEFINE_FSTR_REF(name, ObjectType, FSTR_DATA_NAME(name));
 
#define IMPORT_FSTR_OBJECT_LOCAL(name, ObjectType, file)                                                               \
    IMPORT_FSTR_DATA(FSTR_DATA_NAME(name), file)                                                                       \
    extern "C" __attribute__((visibility("hidden"))) const FSTR::ObjectBase FSTR_DATA_NAME(name);                      \
    static constexpr DEFINE_FSTR_REF(name, ObjectType, FSTR_DATA_NAME(name));
 
namespace FSTR
{
template <class ObjectType, typename ElementType> class Object : public ObjectBase
{
public:
    using DataPtrType = const ElementType*;
    using Iterator = ObjectIterator<ObjectType, ElementType>;
 
    Object() : ObjectBase{lengthInvalid}
    {
#ifndef ARCH_HOST
        // Illegal on real flash object
        assert(!isFlashPtr(this));
#endif
    }
 
    Object(const Object& obj) : ObjectBase{obj.isCopy() ? obj.flashLength_ : uint32_t(&obj) | copyBit}
    {
    }
 
    Iterator begin() const
    {
        return Iterator(as<ObjectType>(), 0);
    }
 
    Iterator end() const
    {
        return Iterator(as<ObjectType>(), length());
    }
 
    static constexpr const ObjectType& empty()
    {
        return empty_.as<const ObjectType>();
    }
 
    FSTR_INLINE constexpr const size_t length() const
    {
        return ObjectBase::length() / sizeof(ElementType);
    }
 
    template <typename ValueType> int indexOf(const ValueType& value) const
    {
        auto& self = as<ObjectType>();
        auto dataptr = self.data();
        auto len = self.length();
        for(unsigned i = 0; i < len; ++i) {
            if(self.unsafeValueAt(dataptr, i) == value) {
                return i;
            }
        }
 
        return -1;
    }
 
    FSTR_INLINE ElementType valueAt(unsigned index) const
    {
        return (index < length()) ? unsafeValueAt(data(), index) : ElementType{};
    }
 
    FSTR_INLINE ElementType operator[](unsigned index) const
    {
        return valueAt(index);
    }
 
    FSTR_INLINE size_t elementSize() const
    {
        return sizeof(ElementType);
    }
 
    FSTR_INLINE DataPtrType data() const
    {
        return reinterpret_cast<DataPtrType>(ObjectBase::data());
    }
 
    size_t read(size_t index, ElementType* buffer, size_t count) const
    {
        auto offset = index * sizeof(ElementType);
        count *= sizeof(ElementType);
        return ObjectBase::read(offset, buffer, count) / sizeof(ElementType);
    }
 
    size_t readFlash(size_t index, ElementType* buffer, size_t count) const
    {
        auto offset = index * sizeof(ElementType);
        count *= sizeof(ElementType);
        return ObjectBase::readFlash(offset, buffer, count) / sizeof(ElementType);
    }
 
    FSTR_INLINE ElementType unsafeValueAt(const DataPtrType dataptr, unsigned index) const
    {
        return readValue(dataptr + index);
    }
};
 
} // namespace FSTR