text_var_dependency.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright The KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program 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; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 program; if not, you may find one here:
 * http://www.gnu.org/licenses/old-licenses/gpl-2.0.html
 */
 
#ifndef TEXT_VAR_DEPENDENCY_H_
#define TEXT_VAR_DEPENDENCY_H_
 
#include <kicommon.h>
#include <cstdint>
#include <functional>
#include <initializer_list>
#include <shared_mutex>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <wx/string.h>
 
 
class EDA_ITEM;
class EDA_TEXT;
 

struct KICOMMON_API TEXT_VAR_REF_KEY
{
    enum class KIND : std::uint8_t
    {
        LOCAL,
        CROSS_REF,
        PROJECT_VAR,
        ENV_VAR,
        TITLE_BLOCK,
        SPECIAL,
        OP
    };
 
    KIND     kind = KIND::LOCAL;
    wxString primary;
    wxString secondary;
 
    bool operator==( const TEXT_VAR_REF_KEY& ) const = default;

    static TEXT_VAR_REF_KEY FromToken( const wxString& aToken );
 
    bool IsTrackable() const { return kind != KIND::OP; }
};
 

KICOMMON_API std::vector<TEXT_VAR_REF_KEY> FilterTrackable(
        const std::vector<TEXT_VAR_REF_KEY>& aRefs );
 
 
struct KICOMMON_API TEXT_VAR_REF_KEY_HASH
{
    std::size_t operator()( const TEXT_VAR_REF_KEY& aKey ) const;
};
 

class KICOMMON_API TEXT_VAR_DEPENDENCY_INDEX
{
public:
    TEXT_VAR_DEPENDENCY_INDEX() = default;

    void Register( EDA_ITEM* aItem, const std::vector<TEXT_VAR_REF_KEY>& aKeys );

    void Unregister( EDA_ITEM* aItem );

    void ForEachDependent( const TEXT_VAR_REF_KEY& aKey,
                           const std::function<void( EDA_ITEM* )>& aFn ) const;

    void Clear();
 
    std::size_t DependentCount( const TEXT_VAR_REF_KEY& aKey ) const;
    std::size_t ItemCount() const;

    std::vector<TEXT_VAR_REF_KEY> GetRegisteredKeys() const;
 
private:
    mutable std::shared_mutex m_mutex;
 
    std::unordered_map<TEXT_VAR_REF_KEY,
                       std::unordered_set<EDA_ITEM*>,
                       TEXT_VAR_REF_KEY_HASH> m_dependents;
 
    std::unordered_map<EDA_ITEM*, std::vector<TEXT_VAR_REF_KEY>> m_itemKeys;
};
 

class KICOMMON_API TEXT_VAR_TRACKER
{
public:
    using SourceKeyExtractor = std::function<std::vector<TEXT_VAR_REF_KEY>( EDA_ITEM* )>;

    using InvalidateCallback = std::function<void( EDA_ITEM* aDependent,
                                                   const TEXT_VAR_REF_KEY& aKey )>;

    using ListenerHandle = std::size_t;
    static constexpr ListenerHandle INVALID_LISTENER = 0;
 
    explicit TEXT_VAR_TRACKER( SourceKeyExtractor aSourceKeyExtractor = {} );
 
    TEXT_VAR_DEPENDENCY_INDEX&       Index()       { return m_index; }
    const TEXT_VAR_DEPENDENCY_INDEX& Index() const { return m_index; }
 
    void SetSourceKeyExtractor( SourceKeyExtractor aExtractor );

    [[nodiscard]] ListenerHandle AddInvalidateListener( InvalidateCallback aCallback );

    void RemoveInvalidateListener( ListenerHandle aHandle );

    void RegisterItem( EDA_ITEM* aItem, const std::vector<TEXT_VAR_REF_KEY>& aKeys );

    void UnregisterItem( EDA_ITEM* aItem );

    void HandleItemChanged( EDA_ITEM* aItem, const std::vector<TEXT_VAR_REF_KEY>& aUpdatedKeys );

    void InvalidateKey( const TEXT_VAR_REF_KEY& aKey );

    void InvalidateByKind( std::initializer_list<TEXT_VAR_REF_KEY::KIND> aKinds );

    void InvalidateProjectScoped();

    void InvalidateVariantScoped();
 
    void Clear() { m_index.Clear(); }
 
private:
    void fanOutSourceKeys( EDA_ITEM* aItem );
 
    TEXT_VAR_DEPENDENCY_INDEX                              m_index;
    SourceKeyExtractor                                     m_extractSourceKeys;
 
    // m_invalidateListeners is read from InvalidateKey (possibly re-entrantly
    // via a callback that triggers another invalidation) and mutated by
    // Add/RemoveInvalidateListener. A shared_mutex protects both paths and
    // is held only long enough to snapshot the callbacks before invoking
    // them unlocked.
    mutable std::shared_mutex                              m_listenersMutex;
    std::unordered_map<ListenerHandle, InvalidateCallback> m_invalidateListeners;
    ListenerHandle                                         m_nextListenerHandle = 1;
};
 
 
#endif // TEXT_VAR_DEPENDENCY_H_