Initial comment updates

Quotient/events/roommessageevent.h

@@ -156,7 +156,7 @@ class QUOTIENT_API RoomMessageEvent : public RoomEvent {
     //! \note This will return the ID of the event if it is the thread root.
     //!
     //! \note If the event is the thread root event and has not been updated with the server-side
-    //!       the function will return and empty string as we can tell if the message
+    //!       the function will return an empty string as we can't tell if the message
     //!       is threaded.
     //!
     //! \return The event ID of the thread root if threaded, an empty string otherwise.

Quotient/room.cpp

@@ -1776,7 +1776,7 @@ void Room::Private::updateThread(const RoomEvent* event)
         return;
     }
 
-    if (threads.exisits(rme->threadRootEventId())) {
+    if (threads.exists(rme->threadRootEventId())) {
         auto thread = threads.getThread(rme->threadRootEventId());
         const auto threadLatestIndex = eventsIndex.constFind(thread->latestEventId());
         if (threadLatestIndex == eventsIndex.cend()) {
@@ -1796,7 +1796,9 @@ void Room::Private::updateThread(const RoomEvent* event)
             threads.add(std::make_unique<Thread>(rme->threadRootEventId(),
                         // For pending events we can get the full correct details when the remote echo comes in.
                         rme->id().isEmpty() ? rme->threadRootEventId() : rme->id(),
-                        rme->id().isEmpty() ? 1 : 2,
+                        // When we can't find the root we assume its a historical event that will load later if
+                        // we can find it we assume a new thread was just created.
+                        rme->id().isEmpty() || q->findInTimeline(rme->threadRootEventId()) == historyEdge() ? 1 : 2,
                         rme->senderId() == connection->userId()));
         }
     }

Quotient/threadview.cpp

@@ -7,37 +7,38 @@
 
 using namespace Quotient;
 
+namespace {
+inline auto checkThreadRoot(const QString& threadRootId) {
+    return [threadRootId](const std::unique_ptr<Thread>& thread) { return threadRootId == thread->threadRootId(); };
+}
+}
+
 void ThreadView::add(std::unique_ptr<Thread> thread)
 {
     _threads.push_back(std::move(thread));
 }
 
 bool ThreadView::erase(const QString& threadRootId)
 {
-    auto threadIt = std::find_if(_threads.begin(), _threads.end(), [threadRootId](const auto& thread) { return thread->threadRootId() == threadRootId; });
-    if (threadIt == _threads.end()) {
-        return false;
-    }
-     _threads.erase(threadIt);
-    return true;
+    return std::erase_if(_threads, checkThreadRoot(threadRootId)) > 0;
 }
 
-bool ThreadView::exisits(const QString& threadRootId) const
+bool ThreadView::exists(const QString& threadRootId) const
 {
-    return std::find_if(_threads.begin(), _threads.end(), [threadRootId](const auto& thread) { return thread->threadRootId() == threadRootId; }) != _threads.end();
+    return std::ranges::any_of(_threads, checkThreadRoot(threadRootId));
 }
 
 Thread* ThreadView::getThread(const QString& threadRootId) const
 {
-    auto threadIt = std::find_if(_threads.begin(), _threads.end(), [threadRootId](const auto& thread) { return thread->threadRootId() == threadRootId; });
+    auto threadIt = std::ranges::find_if(_threads, checkThreadRoot(threadRootId));
     if (threadIt == _threads.end()) {
         return nullptr;
     }
     return threadIt->get();
 }
 
 Thread::Thread(QString threadRootId, QString latestEventId, int size, bool localUserParticipated)
-    : _threadRootId(threadRootId), _latestEventId(threadRootId), _size(size), _localUserParticipated(localUserParticipated)
+    : _threadRootId(threadRootId), _latestEventId(latestEventId), _size(size), _localUserParticipated(localUserParticipated)
 {}
 
 QString Thread::threadRootId() const
@@ -68,7 +69,7 @@ bool Thread::addEvent(const RoomMessageEvent* event, bool isLatest, bool isLocal
     if (isLatest) {
         _latestEventId = event->id();
     }
-    _size++;
+    ++_size;
     if (!_localUserParticipated) {
         _localUserParticipated = isLocalUser;
     }

Quotient/threadview.h

@@ -38,7 +38,7 @@ class QUOTIENT_API ThreadView {
 
     bool erase(const QString& threadRootId);
 
-    bool exisits(const QString& threadRootId) const;
+    bool exists(const QString& threadRootId) const;
 
     Thread* getThread(const QString& threadRootId) const;