cadstar_parts_lib_model.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2023 Roberto Fernandez Bautista <[email protected]>
 * Copyright (C) 2023 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 3 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, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef CADSTAR_PARTS_LIB_MODEL_H
#define CADSTAR_PARTS_LIB_MODEL_H
 
#include <map>
#include <optional>
#include <string>
#include <vector>
#include <io/cadstar/cadstar_archive_objects.h>
 
struct CADSTAR_PART_ENTRY;
struct CADSTAR_SWAP_GROUP;
struct CADSTAR_ATTRIBUTE_VALUE;
struct CADSTAR_PART_SYMBOL_ENTRY;
struct CADSTAR_PART_PIN;
struct CADSTAR_PART_NODE;
 
struct CADSTAR_PARTS_LIB_MODEL
{
    std::optional<long>               m_FormatNumber;
    std::map<long, CADSTAR_PART_NODE> m_HierarchyNodes;
    std::vector<CADSTAR_PART_ENTRY>   m_PartEntries;
};
 
 
struct CADSTAR_PART_ENTRY
{
    std::string                m_Name;
    std::optional<std::string> m_Number;
    std::optional<std::string> m_Version;
    std::optional<std::string> m_Description;
    std::string                m_Pcb_component;
    std::optional<std::string> m_Pcb_alternate;
    std::optional<std::string> m_Value; // *VALUE Note: ? character = the start of a new line
    std::optional<std::string> m_PartDefinitionName; // *DFN
    std::string                m_ComponentStem = "";
    std::optional<long>        m_MaxPinCount;
 
    std::optional<std::string> m_SpicePartName;
    std::optional<std::string> m_SpiceModel;
 
    std::optional<std::string> m_AcceptancePartName; // The part the acceptance text refers to
    std::optional<std::string> m_AcceptanceText; // "Part Acceptance" has canonical meaning
 
    bool m_GateSwappingAllowed = true;
    bool m_PinsVisible = true;
 
    std::map<long, std::string> m_PinNamesMap;
 
    std::map<long, std::string> m_PinLabelsMap;
 
    std::vector<std::vector<long>> m_PinEquivalences;
 
    std::vector<CADSTAR_SWAP_GROUP> m_InternalSwapGroup;
 
    std::vector<CADSTAR_SWAP_GROUP> m_ExternalSwapGroup;
 
    std::map<std::string, std::string> m_UserAttributes;
 
    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE> m_SchAttributes;
 
    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE> m_PcbAttributes;
 
    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE> m_SchAndPcbAttributes;
 
    std::map<std::string, CADSTAR_ATTRIBUTE_VALUE> m_PartAttributes;
 
    std::vector<CADSTAR_PART_SYMBOL_ENTRY> m_Symbols;
 
    std::map<std::string, std::vector<CADSTAR_PART_PIN>> m_HiddenPins;
};
 
 
struct CADSTAR_PART_PIN
{
    CADSTAR_PART_PIN() :
            m_Identifier( 0 ),
            m_Position( CADSTAR_PIN_POSITION::TOP_RIGHT ),
            m_Type( CADSTAR_PIN_TYPE::UNCOMMITTED ),
            m_Loading()
    {};
 
    CADSTAR_PART_PIN( long aId, CADSTAR_PIN_POSITION aPos, CADSTAR_PIN_TYPE aType,
                      std::optional<long> aLoading ) :
            m_Identifier( aId ),
            m_Position( aPos ),
            m_Type( aType ),
            m_Loading( aLoading )
    {};
 
    long                       m_Identifier;
    CADSTAR_PIN_POSITION       m_Position;
    CADSTAR_PIN_TYPE           m_Type;
    std::optional<long>        m_Loading;
};
 
 
struct CADSTAR_PART_SYMBOL_ENTRY
{
    CADSTAR_PART_SYMBOL_ENTRY() {};
 
    CADSTAR_PART_SYMBOL_ENTRY( std::string aName, std::optional<std::string> aAlternate,
                               std::vector<CADSTAR_PART_PIN> aPins ) :
            m_SymbolName( aName ),
            m_SymbolAlternateName( aAlternate ),
            m_Pins( aPins )
    {};
 
    std::string                   m_SymbolName;
    std::optional<std::string>    m_SymbolAlternateName;
    std::vector<CADSTAR_PART_PIN> m_Pins;
};
 
 
struct CADSTAR_ATTRIBUTE_VALUE
{
    bool        m_ReadOnly = false;
    std::string m_Value;
};
 
 
struct CADSTAR_SWAP_GROUP
{
    std::optional<std::string> m_Name;
 
    std::vector<std::vector<long>> m_Gates;
};
 
 
struct CADSTAR_PART_NODE
{
    std::optional<long>      m_ParentNodeIdx;
    std::string              m_Name;
    std::vector<std::string> m_PartNames; 
};
 
#endif //CADSTAR_PARTS_LIB_MODEL_H