Revise Partition in-memory storage mechanism (#2564)

This PR makes some changes to the way partition tables are constructed internally.
The changes are intended to make the system more intuitive, flexible, and to pave the way for external disk (SD card) storage interfaces.

**Use linked list to store partition tables**

Currently the partition table is allocated using a fixed array of `Partition::Info` structures.
This means any additional information would cause all partition entries to increase in size.

This has been changed to a linked list so that future extensions can be accommodated.
It also avoids having a fixed limit on the partition table size.

**Replace `CustomDevice::createPartition` methods with `partitions().add()`**

'create' was a poor naming choice as it doesn't write anything to storage, just updates the partition table.
These methods have been removed in favour of operating on the `partitions()` property directly.
The default `Device::partitions()` is read-only (const) but it is overridden in custom devices to support writes, etc.

**Add `Partition::FullType` for better type/subtype handling**

Partition types consist of a `type` and `subtype` component, however standard subtypes can be referred to using just the subtype as these are defined using strong enums from which the type can be inferred.

When explicitly providing both a type and subtype, this must now be provided as a `FullType` structure,
e.g. `{`Storage::Partition::Type::Data`, 100}`. This simplifies the API and removes any ambiguity between overloaded method parameters.

Author: mikee47

Sming/Components/IFS

@@ -18,39 +18,23 @@ Iterator::Iterator(Partition::Type type, uint8_t subtype) : mSearch{nullptr, typ
 	next();
 }
 
-bool Iterator::next()
+void Iterator::next()
 {
 	while(mDevice != nullptr) {
-		while(uint8_t(++mPos) < mDevice->partitions().count()) {
-			auto entry = mDevice->partitions()[mPos];
-
-			if(mSearch.type != Partition::Type::any && mSearch.type != entry.type()) {
-				continue;
-			}
-
-			if(mSearch.subType != Partition::SubType::any && mSearch.subType != entry.subType()) {
-				continue;
+		mInfo = mInfo ? mInfo->getNext() : mDevice->partitions().mEntries.head();
+		if(mInfo == nullptr) {
+			if(mSearch.device != nullptr) {
+				break;
 			}
-
-			return true;
+			mDevice = mDevice->getNext();
+			mInfo = nullptr;
+			continue;
 		}
 
-		if(mSearch.device != nullptr) {
+		if(mInfo->match(mSearch.type, mSearch.subType)) {
 			break;
 		}
-
-		mDevice = mDevice->getNext();
-		mPos = beforeStart;
 	}
-
-	mDevice = nullptr;
-	mPos = afterEnd;
-	return false;
-}
-
-Partition Iterator::operator*() const
-{
-	return mDevice ? mDevice->partitions()[mPos] : Partition{};
 }
 
 } // namespace Storage

Sming/Components/Storage/src/CustomDevice.cpp

@@ -123,6 +123,11 @@ String toLongString(Partition::Type type, uint8_t subType)
 
 namespace Storage
 {
+Partition::FullType::operator String() const
+{
+	return toString(type, subtype);
+}
+
 String Partition::typeString() const
 {
 	return toString(type(), subType());

Sming/Components/Storage/src/Iterator.cpp

@@ -16,21 +16,14 @@ namespace Storage
 {
 void PartitionTable::load(const esp_partition_info_t* entry, unsigned count)
 {
-	if(count == 0) {
-		mEntries.reset();
-		mCount = count;
-		return;
-	}
-
-	mCount = count;
-	mEntries.reset(new Partition::Info[count]);
+	mEntries.clear();
 	for(unsigned i = 0; i < count; ++i) {
 		auto& e = entry[i];
 		// name may not be zero-terminated
 		char name[Partition::nameSize + 1];
 		memcpy(name, e.name, Partition::nameSize);
 		name[Partition::nameSize] = '\0';
-		mEntries.get()[i] = Partition::Info{name, e.type, e.subtype, e.offset, e.size, e.flags};
+		add(name, {e.type, e.subtype}, e.offset, e.size, e.flags);
 	}
 }
 

Sming/Components/Storage/src/Partition.cpp

@@ -21,15 +21,15 @@ bool ProgMem::read(uint32_t address, void* dst, size_t size)
 	return readCount == size;
 }
 
-Partition ProgMem::createPartition(const String& name, const void* flashPtr, size_t size, Partition::Type type,
-								   uint8_t subtype)
+Partition ProgMem::ProgMemPartitionTable::add(const String& name, const void* flashPtr, size_t size,
+											  Partition::FullType type)
 {
 	auto addr = flashmem_get_address(flashPtr);
 	if(addr == 0) {
 		return Partition{};
 	}
 
-	return createPartition(name, type, subtype, addr, size, Partition::Flag::readOnly);
+	return CustomPartitionTable::add(name, type, addr, size, Partition::Flag::readOnly);
 }
 
 } // namespace Storage

Sming/Components/Storage/src/PartitionTable.cpp

@@ -9,17 +9,8 @@
  ****/
 
 #include "include/Storage/SysMem.h"
-#include <esp_spi_flash.h>
 
 namespace Storage
 {
 SysMem sysMem;
-
-Partition SysMem::createPartition(const String& name, const FSTR::ObjectBase& fstr, Partition::Type type,
-								  uint8_t subtype)
-{
-	return createPartition(name, type, subtype, reinterpret_cast<uint32_t>(fstr.data()), fstr.size(),
-						   Partition::Flag::readOnly);
-}
-
 } // namespace Storage

Sming/Components/Storage/src/ProgMem.cpp

@@ -10,25 +10,23 @@ namespace Storage
 {
 /**
  * @brief Class to support dynamic partitions
- *
- * Call `createPartition` to add partitions up to a maximum of 16 entries.
  */
 class CustomDevice : public Device
 {
 public:
-	Partition createPartition(const Partition::Info& info);
-
-	Partition createPartition(const String& name, Partition::Type type, uint8_t subtype, uint32_t offset, size_t size,
-							  Partition::Flags flags = 0)
+	class CustomPartitionTable : public PartitionTable
 	{
-		return createPartition(Partition::Info{name, type, subtype, offset, size, flags});
-	}
+	public:
+		using PartitionTable::add;
+		using PartitionTable::clear;
+	};
 
-	template <typename SubType>
-	Partition createPartition(const String& name, SubType subtype, uint32_t offset, size_t size,
-							  Partition::Flags flags = 0)
+	/**
+	 * @brief Provide read/write access to in-memory partition table
+	 */
+	CustomPartitionTable& partitions()
 	{
-		return createPartition(name, Partition::Type(SubType::partitionType), uint8_t(subtype), offset, size, flags);
+		return static_cast<CustomPartitionTable&>(mPartitions);
 	}
 };
 

Sming/Components/Storage/src/SysMem.cpp

@@ -56,6 +56,9 @@ class Device : public LinkedObjectTemplate<Device>
 		return getName() == name;
 	}
 
+	/**
+	 * @brief Provide read-only access to partition table
+	 */
 	const PartitionTable& partitions() const
 	{
 		return mPartitions;

Sming/Components/Storage/src/include/Storage/CustomDevice.h

@@ -32,7 +32,7 @@ class Iterator : public std::iterator<std::forward_iterator_tag, Partition>
 
 	explicit operator bool() const
 	{
-		return (mDevice != nullptr) && (mPos > beforeStart) && (mPos < afterEnd);
+		return mDevice && mInfo;
 	}
 
 	Iterator operator++(int)
@@ -50,15 +50,18 @@ class Iterator : public std::iterator<std::forward_iterator_tag, Partition>
 
 	bool operator==(const Iterator& other) const
 	{
-		return (mDevice == other.mDevice) && (mPos == other.mPos);
+		return mInfo == other.mInfo;
 	}
 
 	bool operator!=(const Iterator& other) const
 	{
 		return !operator==(other);
 	}
 
-	Partition operator*() const;
+	Partition operator*() const
+	{
+		return mDevice && mInfo ? Partition(*mDevice, *mInfo) : Partition{};
+	}
 
 	Iterator begin()
 	{
@@ -71,15 +74,11 @@ class Iterator : public std::iterator<std::forward_iterator_tag, Partition>
 	}
 
 private:
-	static constexpr int8_t beforeStart{-1};
-	static constexpr int8_t afterEnd{0x7f};
-
-	Iterator() : mPos(afterEnd)
+	Iterator()
 	{
 	}
 
-	bool seek(uint8_t pos);
-	bool next();
+	void next();
 
 	struct Search {
 		Device* device;
@@ -88,7 +87,7 @@ class Iterator : public std::iterator<std::forward_iterator_tag, Partition>
 	};
 	Search mSearch{};
 	Device* mDevice{nullptr};
-	int8_t mPos{beforeStart};
+	const Partition::Info* mInfo{nullptr};
 };
 
 } // namespace Storage