PerScreenStates.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 fuddlesworth
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#pragma once
 
#include <PhosphorEngine/EngineTypes.h>
#include <PhosphorEngine/IPlacementState.h>
 
#include <functional>
#include <optional>
#include <type_traits>
 
#include <QHash>
#include <QString>
#include <QtGlobal>
 
namespace PhosphorEngine {
 
template<typename StateT>
class PerScreenStates
{
    static_assert(std::is_base_of_v<IPlacementState, StateT>,
                  "PerScreenStates<StateT>: StateT must implement PhosphorEngine::IPlacementState");
 
public:
    StateT* forKey(const PlacementStateKey& key, const std::function<StateT*()>& factory)
    {
        auto it = m_states.find(key);
        if (it != m_states.end()) {
            return it.value();
        }
        StateT* created = factory ? factory() : nullptr;
        if (created) {
            m_states.insert(key, created);
        }
        return created;
    }
 
    StateT* stateForKey(const PlacementStateKey& key) const
    {
        return m_states.value(key);
    }
 
    bool containsKey(const PlacementStateKey& key) const
    {
        return m_states.contains(key);
    }
 
    void insertState(const PlacementStateKey& key, StateT* state)
    {
        m_states.insert(key, state);
    }
 
    StateT* takeState(const PlacementStateKey& key)
    {
        return m_states.take(key);
    }
 
    int stateCount() const
    {
        return m_states.size();
    }
 
    const QHash<PlacementStateKey, StateT*>& states() const
    {
        return m_states;
    }
 
    // ── Reverse (window -> key) map ──────────────────────────────────────────
    bool hasWindow(const QString& windowId) const
    {
        return m_windowToKey.contains(windowId);
    }
 
    PlacementStateKey keyForWindow(const QString& windowId) const
    {
        return m_windowToKey.value(windowId);
    }
 
    std::optional<PlacementStateKey> windowKey(const QString& windowId) const
    {
        auto it = m_windowToKey.constFind(windowId);
        if (it == m_windowToKey.constEnd()) {
            return std::nullopt;
        }
        return it.value();
    }
 
    void setKeyForWindow(const QString& windowId, const PlacementStateKey& key)
    {
        m_windowToKey.insert(windowId, key);
    }
 
    void removeWindow(const QString& windowId)
    {
        m_windowToKey.remove(windowId);
    }
 
    PlacementStateKey takeWindow(const QString& windowId)
    {
        return m_windowToKey.take(windowId);
    }
 
    const QHash<QString, PlacementStateKey>& windowKeys() const
    {
        return m_windowToKey;
    }
 
    StateT* forWindow(const QString& windowId, PlacementStateKey* outKey = nullptr) const
    {
        auto it = m_windowToKey.constFind(windowId);
        if (it == m_windowToKey.constEnd()) {
            return nullptr;
        }
        if (outKey) {
            *outKey = it.value();
        }
        return m_states.value(it.value());
    }
 
    void migrate(const QString& windowId, const PlacementStateKey& oldKey, const PlacementStateKey& newKey)
    {
        Q_ASSERT(!m_windowToKey.contains(windowId) || m_windowToKey.value(windowId) == oldKey);
        Q_UNUSED(oldKey)
        m_windowToKey.insert(windowId, newKey);
    }
 
    void rekeyWindows(const PlacementStateKey& oldKey, const PlacementStateKey& newKey)
    {
        for (auto it = m_windowToKey.begin(); it != m_windowToKey.end(); ++it) {
            if (it.value() == oldKey) {
                it.value() = newKey;
            }
        }
    }
 
    void removeStatesIf(const std::function<bool(const PlacementStateKey&, StateT*)>& pred,
                        const std::function<void(const PlacementStateKey&, StateT*)>& onRemove)
    {
        for (auto it = m_states.begin(); it != m_states.end();) {
            if (pred(it.key(), it.value())) {
                if (onRemove) {
                    onRemove(it.key(), it.value());
                }
                it = m_states.erase(it);
            } else {
                ++it;
            }
        }
    }
 
    void removeWindowsIf(const std::function<bool(const QString&, const PlacementStateKey&)>& pred)
    {
        for (auto it = m_windowToKey.begin(); it != m_windowToKey.end();) {
            if (pred(it.key(), it.value())) {
                it = m_windowToKey.erase(it);
            } else {
                ++it;
            }
        }
    }
 
private:
    QHash<PlacementStateKey, StateT*> m_states; 
    QHash<QString, PlacementStateKey> m_windowToKey; 
};
 
} // namespace PhosphorEngine