refdes_tracker.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.
 *
 * KiCad 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 3 of the License, or
 * (at your option) any later version.
 *
 * KiCad 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 KiCad.  If not, see <https://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <mutex>
#include <set>
#include <sstream>
#include <map>
#include <vector>
#include <functional>
#include <algorithm>
 
// Forward declaration
class SCH_REFERENCE;
 
template<typename T>
using UNITS_CHECKER_FUNC = std::function<bool(const T& aTestRef,
                                              const std::vector<T>& aExistingRefs,
                                              const std::vector<int>& aRequiredUnits)>;
 
class REFDES_TRACKER
{
public:
    explicit REFDES_TRACKER( bool aThreadSafe = false );
 
    bool Insert( const std::string& aRefDes );
 
    bool Contains( const std::string& aRefDes ) const;
 
    int GetNextRefDes( const std::string& aPrefix, int aMinValue = 1 );
 
    int GetNextRefDesForUnits( const SCH_REFERENCE& aRef,
                               const std::map<int, std::vector<SCH_REFERENCE>>& aRefNumberMap,
                               const std::vector<int>& aRequiredUnits,
                               int aMinValue );
 
    void SetUnitsChecker( const UNITS_CHECKER_FUNC<SCH_REFERENCE>& aChecker );
 
    void ClearUnitsChecker();
 
    std::string Serialize() const;
 
    bool Deserialize( const std::string& aData );
 
    void Clear();
 
    size_t Size() const;
 
    bool GetReuseRefDes() const { return m_reuseRefDes; }
    void SetReuseRefDes( bool aReuse ) { m_reuseRefDes = aReuse; }
 
private:
    struct PREFIX_DATA
    {
        std::set<int>              m_usedNumbers; 
        mutable std::map<int, int> m_nextCache;   
        mutable int                m_baseNext;    
        mutable bool               m_cacheValid;  
 
        PREFIX_DATA() : m_baseNext( 1 ), m_cacheValid( false ) {}
    };
 
    mutable std::mutex      m_mutex;            
    bool                    m_threadSafe;       
 
    std::unordered_map<std::string, PREFIX_DATA> m_prefixData;
    std::unordered_set<std::string>              m_allRefDes;
 
    bool m_reuseRefDes; 
 
    UNITS_CHECKER_FUNC<SCH_REFERENCE> m_externalUnitsChecker;
 
    bool insertImpl( const std::string& aRefDes );
 
    void clearImpl();
 
    bool containsImpl( const std::string& aRefDes ) const;
 
    std::pair<std::string, int> parseRefDes( const std::string& aRefDes ) const;
 
    void updateCacheOnInsert( PREFIX_DATA& aData, int aInsertedNumber ) const;
 
    int findNextAvailable( const PREFIX_DATA& aData, int aMinValue ) const;
 
    bool areUnitsAvailable( const SCH_REFERENCE& aRef,
                            const std::vector<SCH_REFERENCE>& aRefVector,
                            const std::vector<int>& aRequiredUnits ) const;
 
    bool insertNumber( const std::string& aPrefix, int aNumber );
 
    std::string escapeForSerialization( const std::string& aStr ) const;
 
    std::string unescapeFromSerialization( const std::string& aStr ) const;
 
    std::vector<std::string> splitString( const std::string& aStr, char aDelimiter ) const;
 
    void updateBaseNext( PREFIX_DATA& aData ) const;
};