allegro_db_utils.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
 * or you may search the http://www.gnu.org website for the version 2 license,
 * or you may write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA
 */
 
#pragma once

 
#include <concepts>
#include <cstdint>
#include <functional>
#include <optional>
#include <type_traits>
#include <unordered_set>
#include <variant>
 
#include <ki_exception.h>
 
#include <convert/allegro_pcb_structs.h>
#include <convert/allegro_db.h>
 
#include <wx/log.h>
#include <wx/string.h>
 
 
namespace ALLEGRO
{
 
inline const wxChar* const traceAllegroUtils = wxT( "KICAD_ALLEGRO_BUILDER" );
 

template <ALLEGRO_BLOCK_DATA BLK_T>
constexpr bool BlockTypeMatches( uint8_t aType )
{
    // Segments can be any of three code (H/oblique/V)
    if constexpr( std::is_same_v<BLK_T, BLK_0x15_16_17_SEGMENT> )
        return aType == 0x15 || aType == 0x16 || aType == 0x17;
    else
        return aType == BLK_T::BLOCK_TYPE_CODE;
}

template <ALLEGRO_BLOCK_DATA BLK_T>
const BLK_T& BlockDataAs( const BLOCK_BASE& aBlock )
{
    wxASSERT( BlockTypeMatches<BLK_T>( aBlock.GetBlockType() ) );
    return static_cast<const BLOCK<BLK_T>&>( aBlock ).GetData();
}
 

template <ALLEGRO_BLOCK_DATA BLK_T>
class BLOCK_REF
{
public:
    BLOCK_REF() :
            m_block( nullptr )
    {
    }
 
    explicit BLOCK_REF( const BLOCK_BASE* aBlock ) :
            m_block( aBlock )
    {
    }

    explicit operator bool() const { return m_block != nullptr; }
 
    const BLK_T& operator*() const
    {
        wxASSERT( m_block != nullptr );
        return BlockDataAs<BLK_T>( *m_block );
    }
 
    const BLK_T* operator->() const
    {
        wxASSERT( m_block != nullptr );
        return &BlockDataAs<BLK_T>( *m_block );
    }
 
    const BLOCK_BASE* Block() const { return m_block; }
 
private:
    const BLOCK_BASE* m_block;
};
 

uint32_t GetPrimaryNext( const BLOCK_BASE& aBlock );
 

class LL_WALKER
{
public:
    using NEXT_FUNC_T = std::function<uint32_t( const BLOCK_BASE& )>;
 
    class ITERATOR
    {
    public:
        ITERATOR() :
                m_current( 0 ),
                m_currBlock( nullptr ),
                m_tail( 0 ),
                m_board( nullptr ),
                m_nextFunc( nullptr )
        {
        }

        ITERATOR( uint32_t aCurrent, uint32_t aTail, const BRD_DB& aBoard,
                  const NEXT_FUNC_T& aNextFunc ) :
                m_current( aCurrent ),
                m_tail( aTail ),
                m_board( &aBoard ),
                m_nextFunc( &aNextFunc )
        {
            m_currBlock = m_board->GetObjectByKey( m_current );
 
            if( !m_currBlock )
                m_current = 0;
            else
                m_visited.insert( m_current );
        }
 
        const BLOCK_BASE* operator*() const
        {
            return m_currBlock;
        }
 
        ITERATOR& operator++()
        {
            if( m_current == m_tail || !m_currBlock )
            {
                m_current = 0;
            }
            else
            {
                m_current = ( *m_nextFunc )( *m_currBlock );
 
                if( m_current == m_tail || m_board->IsSentinel( m_current ) )
                {
                    m_current = 0;
                }
                else if( !m_visited.insert( m_current ).second )
                {
                    THROW_IO_ERROR( wxString::Format( "Cycle detected in linked list at key %#010x", m_current ) );
                }
                else
                {
                    m_currBlock = m_board->GetObjectByKey( m_current );
 
                    if( m_currBlock == nullptr )
                        m_current = 0;
                }
            }
 
            return *this;
        }
 
        friend bool operator==( const ITERATOR& aLhs, const ITERATOR& aRhs )
        {
            return aLhs.m_current == aRhs.m_current;
        }
 
    private:
        uint32_t                     m_current;
        const BLOCK_BASE*            m_currBlock;
        uint32_t                     m_tail;
        const BRD_DB*                m_board;
        const NEXT_FUNC_T*           m_nextFunc;
        std::unordered_set<uint32_t> m_visited;
    };

    LL_WALKER( uint32_t aHead, uint32_t aTail, const BRD_DB& aBoard,
               NEXT_FUNC_T aNextFunc = GetPrimaryNext ) :
            m_head( aHead ),
            m_tail( aTail ),
            m_board( aBoard ),
            m_nextFunction( std::move( aNextFunc ) )
    {
    }

    LL_WALKER( const FILE_HEADER::LINKED_LIST& aList, const BRD_DB& aBoard,
               NEXT_FUNC_T aNextFunc = GetPrimaryNext ) :
            LL_WALKER( aList.m_Head, aList.m_Tail, aBoard, std::move( aNextFunc ) )
    {
    }
 
    ITERATOR begin() const
    {
        return ITERATOR( m_head, m_tail, m_board, m_nextFunction );
    }
 
    ITERATOR end() const
    {
        return ITERATOR{};
    }
 
private:
    uint32_t      m_head;
    uint32_t      m_tail;
    const BRD_DB& m_board;
    NEXT_FUNC_T   m_nextFunction;
};
 

enum class MISMATCH_POLICY
{
    SKIP,      
    LOG_TRACE, 
    THROW,     
    REPORT     
};
 

using MISMATCH_REPORTER = std::function<void( uint8_t aGotType, const BLOCK_BASE& aBlock )>;

template <ALLEGRO_BLOCK_DATA T>
class TYPED_LL_WALKER
{
public:
    class ITERATOR
    {
    public:
        ITERATOR() = default;
 
        ITERATOR( LL_WALKER::ITERATOR aCurrent, MISMATCH_POLICY aPolicy, const MISMATCH_REPORTER* aReporter ) :
                m_baseIter( aCurrent ),
                m_policy( aPolicy ),
                m_reporter( aReporter )
        {
            skipMismatches();
        }
 
        const T& operator*() const { return BlockDataAs<T>( **m_baseIter ); }
        const T* operator->() const { return &BlockDataAs<T>( **m_baseIter ); }

        size_t GetBlockOffset() const { return ( *m_baseIter )->GetOffset(); }
 
        ITERATOR& operator++()
        {
            ++m_baseIter;
            skipMismatches();
            return *this;
        }
 
        friend bool operator==( const ITERATOR& aLhs, const ITERATOR& aRhs )
        {
            return aLhs.m_baseIter == aRhs.m_baseIter;
        }
 
    private:
        void skipMismatches()
        {
            while( m_baseIter != LL_WALKER::ITERATOR{} )
            {
                const BLOCK_BASE* block = *m_baseIter;
                const uint8_t     blockType = block->GetBlockType();
 
                if( BlockTypeMatches<T>( blockType ) )
                    break;
 
                const auto blockTypeDesc = []() -> wxString
                {
                    if constexpr( std::is_same_v<T, BLK_0x15_16_17_SEGMENT> )
                        return wxS( "0x15/0x16/0x17 (segment)" );
                    else
                        return wxString::Format( wxS( "%#04x" ), T::BLOCK_TYPE_CODE );
                };
 
                switch( m_policy )
                {
                case MISMATCH_POLICY::THROW:
                    THROW_IO_ERROR(
                            wxString::Format( "Expected block type %s, got %#04x", blockTypeDesc(), blockType ) );
                case MISMATCH_POLICY::LOG_TRACE:
                    wxLogTrace( traceAllegroUtils, "Expected block type %s, got %#04x, skipping", blockTypeDesc(),
                                blockType );
                    break;
                case MISMATCH_POLICY::REPORT:
                    if( m_reporter )
                        ( *m_reporter )( blockType, *block );
                    break;
                case MISMATCH_POLICY::SKIP: break;
                }
 
                ++m_baseIter;
            }
        }
 
        LL_WALKER::ITERATOR      m_baseIter;
        MISMATCH_POLICY          m_policy = MISMATCH_POLICY::SKIP;
        const MISMATCH_REPORTER* m_reporter = nullptr;
    };
 
    TYPED_LL_WALKER( uint32_t aHead, uint32_t aTail, const BRD_DB& aBoard,
                     MISMATCH_POLICY        aPolicy = MISMATCH_POLICY::SKIP,
                     LL_WALKER::NEXT_FUNC_T aNextFunc = GetPrimaryNext ) :
            m_walker( aHead, aTail, aBoard, std::move( aNextFunc ) ),
            m_policy( aPolicy )
    {
    }
 
    TYPED_LL_WALKER( const FILE_HEADER::LINKED_LIST& aList, const BRD_DB& aBoard,
                     MISMATCH_POLICY        aPolicy = MISMATCH_POLICY::SKIP,
                     LL_WALKER::NEXT_FUNC_T aNextFunc = GetPrimaryNext ) :
            TYPED_LL_WALKER( aList.m_Head, aList.m_Tail, aBoard, aPolicy, std::move( aNextFunc ) )
    {
    }
 
    void SetMismatchReporter( MISMATCH_REPORTER aReporter )
    {
        m_mismatchReporter = std::move( aReporter );
    }
 
    ITERATOR begin() const
    {
        return ITERATOR( m_walker.begin(), m_policy, &m_mismatchReporter );
    }
 
    ITERATOR end() const
    {
        return {};
    }
 
private:
    LL_WALKER         m_walker;
    MISMATCH_POLICY   m_policy;
    MISMATCH_REPORTER m_mismatchReporter;
};
 

using FIELD_VALUE = std::variant<wxString, uint32_t>;

std::optional<FIELD_VALUE> GetFirstFieldOfType( const BRD_DB& aDb, uint32_t aFieldsPtr, uint32_t aEndKey,
                                                uint16_t aFieldCode );

std::optional<int> GetFirstFieldOfTypeInt( const BRD_DB& aDb, uint32_t aFieldsPtr, uint32_t aEndKey,
                                           uint16_t aFieldCode );
 
} // namespace ALLEGRO