cadstar_pcb_archive_parser.h

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2020 Roberto Fernandez Bautista <[email protected]>
 * 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 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 <https://www.gnu.org/licenses/>.
 */

 
#ifndef CADSTAR_PCB_ARCHIVE_PARSER_H_
#define CADSTAR_PCB_ARCHIVE_PARSER_H_
 
#include <map>
#include <io/cadstar/cadstar_archive_parser.h>
#include <vector>
 
//=================================
// MACRO DEFINITIONS
//=================================
#define UNDEFINED_MATERIAL_ID ( MATERIAL_ID ) wxEmptyString
#define UNDEFINED_PHYSICAL_LAYER ( PHYSICAL_LAYER_ID ) - 1

class CADSTAR_PCB_ARCHIVE_PARSER : public CADSTAR_ARCHIVE_PARSER
{
public:
    explicit CADSTAR_PCB_ARCHIVE_PARSER( const wxString& aFilename ) :
            CADSTAR_ARCHIVE_PARSER(),
            Filename( aFilename ), Header(), Assignments(),
            m_rootNode( nullptr )
    {
        KiCadUnitMultiplier = 10; // assume hundredth micron
    }
 
 
    virtual ~CADSTAR_PCB_ARCHIVE_PARSER()
    {
        if( m_rootNode )
            delete m_rootNode;
    }

    void Parse( bool aLibrary = false );
 
    typedef wxString MATERIAL_ID;
    typedef long     PHYSICAL_LAYER_ID;
    typedef wxString COPPERCODE_ID;
    typedef wxString PADCODE_ID;
    typedef wxString VIACODE_ID;
    typedef wxString SPACINGCODE_ID;
    typedef wxString LAYERPAIR_ID;
    typedef wxString RULESET_ID;
    typedef wxString COMP_AREA_ID;
    typedef long     PAD_ID; 
    typedef wxString DIMENSION_ID;
    typedef wxString BOARD_ID;
    typedef wxString AREA_ID;
    typedef wxString COMPONENT_ID;
    typedef wxString TEMPLATE_ID;
    typedef long     COPPER_TERM_ID;
    typedef wxString COPPER_ID;
    typedef wxString DRILL_TABLE_ID;
    typedef wxString TRUNK_ID;

    enum class MATERIAL_LAYER_TYPE
    {
        CONSTRUCTION,
        ELECTRICAL, 
        NON_ELECTRICAL
    };
 
 
    struct MATERIAL : PARSER
    {
        MATERIAL_ID         ID;
        wxString            Name;
        MATERIAL_LAYER_TYPE Type = MATERIAL_LAYER_TYPE::NON_ELECTRICAL;
        EVALUE              Permittivity;
        EVALUE              LossTangent;
        EVALUE              Resistivity; 
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    enum class LAYER_TYPE
    {
        UNDEFINED,   
        ALLLAYER,    
        ALLELEC,     
        ALLDOC,      
        NOLAYER,     
        ASSCOMPCOPP, 
        JUMPERLAYER, 
        ELEC,
        POWER,
        NONELEC, 
        CONSTRUCTION,
        DOC
    };
 
 
    enum class LAYER_SUBTYPE
    {
        LAYERSUBTYPE_NONE,
        LAYERSUBTYPE_SILKSCREEN,
        LAYERSUBTYPE_PLACEMENT,
        LAYERSUBTYPE_ASSEMBLY,
        LAYERSUBTYPE_SOLDERRESIST,
        LAYERSUBTYPE_PASTE,
        LAYERSUBTYPE_CLEARANCE,
        LAYERSUBTYPE_ROUT,
    };
 
 
    enum class ROUTING_BIAS
    {
        UNBIASED,   
        X,          
        Y,          
        ANTI_ROUTE, 
        OBSTACLE    
    };
 
 
    enum class EMBEDDING
    {
        NONE,
        ABOVE,
        BELOW
    };
 
 
    struct LAYER : PARSER
    {
        LAYER_ID          ID;
        wxString          Name;
        wxString          Description = wxEmptyString;
        LAYER_TYPE        Type        = LAYER_TYPE::UNDEFINED;
        LAYER_SUBTYPE     SubType     = LAYER_SUBTYPE::LAYERSUBTYPE_NONE;
        PHYSICAL_LAYER_ID PhysicalLayer =
                UNDEFINED_PHYSICAL_LAYER;                 
        LAYER_ID     SwapLayerID    = UNDEFINED_LAYER_ID; 
        ROUTING_BIAS RoutingBias    = ROUTING_BIAS::UNBIASED;
        long         Thickness      = 0; 
        MATERIAL_ID  MaterialId     = UNDEFINED_MATERIAL_ID;
        EMBEDDING    Embedding      = EMBEDDING::NONE;
        bool         ReferencePlane = false;
        bool         VariantLayer   = false;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct LAYERDEFS : PARSER
    {
        std::map<MATERIAL_ID, MATERIAL> Materials;
        std::map<LAYER_ID, LAYER>       Layers;
        std::vector<LAYER_ID>           LayerStack;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct COPREASSIGN : PARSER
    {
        LAYER_ID LayerID;
        long     CopperWidth;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct COPPERCODE : PARSER
    {
        COPPERCODE_ID            ID;
        wxString                 Name;
        long                     CopperWidth;
        std::vector<COPREASSIGN> Reassigns;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct SPACINGCODE : PARSER
    {
        struct REASSIGN : PARSER
        {
            LAYER_ID LayerID;
            long     Spacing;
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };

        SPACINGCODE_ID        ID;
        long                  Spacing;
        std::vector<REASSIGN> Reassigns; 
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    enum class PAD_SHAPE_TYPE
    {
        ANNULUS,
        BULLET,
        CIRCLE, 
        DIAMOND,
        FINGER,
        OCTAGON,
        RECTANGLE,
        ROUNDED_RECT, 
        SQUARE
    };
 
 
    struct CADSTAR_PAD_SHAPE : PARSER
    {
        PAD_SHAPE_TYPE ShapeType       = PAD_SHAPE_TYPE::CIRCLE;
        long           Size            = UNDEFINED_VALUE;
        long           LeftLength      = UNDEFINED_VALUE;
        long           RightLength     = UNDEFINED_VALUE;
        long           InternalFeature = UNDEFINED_VALUE;
        long           OrientAngle     = 0; 
 
        static bool IsPadShape( XNODE* aNode );
        void        Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct PADREASSIGN : PARSER
    {
        LAYER_ID  LayerID;
        CADSTAR_PAD_SHAPE Shape;
        bool      HasShape = false; 
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct PADCODE : PARSER
    {
        PADCODE_ID ID;
        wxString   Name;
        CADSTAR_PAD_SHAPE Shape;
        long       ReliefClearance = UNDEFINED_VALUE; 
        long       ReliefWidth     = UNDEFINED_VALUE; 
        bool       Plated          = true;
        long       DrillDiameter   = UNDEFINED_VALUE;
        long       DrillOversize   = UNDEFINED_VALUE;
        long       SlotLength      = UNDEFINED_VALUE;
        long       SlotOrientation = 0;
        long       DrillXoffset    = 0;
        long       DrillYoffset    = 0;
 
        std::map<LAYER_ID, CADSTAR_PAD_SHAPE> Reassigns;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct VIAREASSIGN : PARSER
    {
        LAYER_ID  LayerID;
        CADSTAR_PAD_SHAPE Shape;
        bool      HasShape = false; 
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct VIACODE : PARSER
    {
        VIACODE_ID ID;
        wxString   Name;
        CADSTAR_PAD_SHAPE Shape;
        long       ReliefClearance = UNDEFINED_VALUE; 
        long       ReliefWidth     = UNDEFINED_VALUE; 
        long       DrillDiameter   = UNDEFINED_VALUE;
        long       DrillOversize   = UNDEFINED_VALUE;
 
        std::map<LAYER_ID, CADSTAR_PAD_SHAPE> Reassigns;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct LAYERPAIR : PARSER
    {
        LAYERPAIR_ID      ID;
        wxString          Name;
        PHYSICAL_LAYER_ID PhysicalLayerStart;
        PHYSICAL_LAYER_ID PhysicalLayerEnd;
        VIACODE_ID        ViacodeID;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct SPCCLASSSPACE : PARSER
    {
        SPACING_CLASS_ID SpacingClassID1;
        SPACING_CLASS_ID SpacingClassID2;
        LAYER_ID         LayerID; 
        long             Spacing;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct RULESET : PARSER
    {
        RULESET_ID   ID;
        wxString     Name;
        ROUTECODE_ID AreaRouteCodeID; 
        VIACODE_ID AreaViaCodeID;     
 
        std::map<SPACINGCODE_ID, SPACINGCODE>
                SpacingCodes; 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct CODEDEFS_PCB : CADSTAR_ARCHIVE_PARSER::CODEDEFS
    {
        std::map<COPPERCODE_ID, COPPERCODE>   CopperCodes;
        std::map<SPACINGCODE_ID, SPACINGCODE> SpacingCodes; 
        std::map<RULESET_ID, RULESET>         Rulesets;     
        std::map<PADCODE_ID, PADCODE>         PadCodes;
        std::map<VIACODE_ID, VIACODE>         ViaCodes;
        std::map<LAYERPAIR_ID, LAYERPAIR>
                                   LayerPairs; 
        std::vector<SPCCLASSSPACE> SpacingClasses;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct TECHNOLOGY_SECTION : CADSTAR_ARCHIVE_PARSER::SETTINGS
    {
        long MinRouteWidth;     
        long MinNeckedLength;   
        long MinUnneckedLength; 
        long MinMitre;          
        long MaxMitre;          
        long MaxPhysicalLayer;  
        long TrackGrid;         
        long ViaGrid;           
 
        bool BackOffJunctions   = false;
        bool BackOffWidthChange = false;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct ASSIGNMENTS : PARSER
    {
        LAYERDEFS          Layerdefs;
        CODEDEFS_PCB       Codedefs;
        TECHNOLOGY_SECTION Technology;
        GRIDS              Grids;
        bool               NetclassEditAttributeSettings     = false; //< Unclear what this does
        bool               SpacingclassEditAttributeSettings = false; //< Unclear what this does
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };

    struct COMPONENT_COPPER : PARSER
    {
        COPPERCODE_ID       CopperCodeID;
        LAYER_ID            LayerID;
        SHAPE               Shape; //< Uses the component's coordinate frame.
        SWAP_RULE           SwapRule = SWAP_RULE::BOTH;
        std::vector<PAD_ID> AssociatedPadIDs;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };

    struct COMPONENT_AREA : PARSER
    {
        COMP_AREA_ID ID;
        LINECODE_ID  LineCodeID;
        LAYER_ID     LayerID;
        SHAPE        Shape; //< Uses the component's coordinate frame.
        SWAP_RULE    SwapRule = SWAP_RULE::BOTH;
 
        bool NoTracks = false; 
        bool NoVias = false;   
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };

    enum class PAD_SIDE
    {
        MINIMUM,     
        MAXIMUM,     
        THROUGH_HOLE 
    };
 
 
    static PAD_SIDE GetPadSide( const wxString& aPadSideString );

    struct PAD_EXITS : PARSER
    {
        bool FreeAngle = false;
        bool North     = false;
        bool NorthEast = false;
        bool East      = false;
        bool SouthEast = false;
        bool South     = false;
        bool SouthWest = false;
        bool West      = false;
        bool NorthWest = false;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct COMPONENT_PAD : PARSER
    {
        PAD_ID     ID;
        POINT      Position; 
        PADCODE_ID PadCodeID;
        PAD_SIDE   Side; 
        long       OrientAngle = 0;
        PAD_EXITS  Exits; 
 
        wxString Identifier; 
 
        bool FirstPad = false; 
        bool PCBonlyPad = false; 
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };

    struct DIMENSION : PARSER
    {
        enum class TYPE
        {
            LINEARDIM, 
            LEADERDIM, 
            ANGLEDIM   
        };
 
 
        enum class SUBTYPE
        {
            ORTHOGONAL, 
            DIRECT,     
            ANGLED,     
            DIAMETER,   
            RADIUS,     
            ANGULAR     
        };
 
 
        struct ARROW : PARSER //"DIMARROW"
        {
            enum class STYLE
            {
                OPEN,         
                CLOSED,       
                CLEAR,        
                CLOSED_FILLED 
            };
 
            STYLE ArrowStyle = STYLE::OPEN;  
            long  UpperAngle = 0;  
            long  LowerAngle = 0;  
            long  ArrowLength = 0; 
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };

        struct TEXTFORMAT : PARSER
        {
            enum class STYLE 
            {
                INSIDE, 
                OUTSIDE 
            };
 
            STYLE Style = STYLE::INSIDE;
            long  TextGap;    
            long  TextOffset; 
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
 
        struct EXTENSION_LINE : PARSER 
        {
            LINECODE_ID LineCodeID;
 
            POINT Start;
            POINT End;
            long  Overshoot;             
            long  Offset;                
            bool  SuppressFirst = false; 
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
 
        struct LINE : PARSER 
        {
            enum class TYPE
            {
                LINEARLINE, 
                LEADERLINE, 
                ANGULARLINE 
            };
 
            enum class STYLE //DIMLINETYPE
            {
                INTERNAL, 
                EXTERNAL  
            };
 
            TYPE        Type;
            LINECODE_ID LineCodeID;            
            STYLE       Style = STYLE::INTERNAL; 
 
            POINT Start;  
            POINT End;    
            POINT Centre; 
 
            long LeaderAngle = UNDEFINED_VALUE; 
            long LeaderLineLength = UNDEFINED_VALUE; 
            long LeaderLineExtensionLength = UNDEFINED_VALUE; 
 
            static bool IsLine( XNODE* aNode );
            void        Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        TYPE         Type;
        DIMENSION_ID ID;             
        LAYER_ID     LayerID;        
        SUBTYPE      Subtype;        
        long         Precision;      
        UNITS          LinearUnits;  
        ANGUNITS       AngularUnits; 
        ARROW          Arrow;
        TEXTFORMAT     TextParams;
        EXTENSION_LINE ExtensionLineParams; 
        LINE           Line;
        TEXT           Text;
        bool           Fixed   = false;
        GROUP_ID       GroupID = wxEmptyString; 
        REUSEBLOCKREF ReuseBlockRef;
 
        static bool IsDimension( XNODE* aNode );
        void        Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };

    enum class SYMDEF_TYPE
    {
        COMPONENT, 
        JUMPER,    
        STARPOINT, 
        TESTPOINT  
    };
 
 
    struct SYMDEF_PCB : CADSTAR_ARCHIVE_PARSER::SYMDEF
    {
        SYMDEF_TYPE Type      = SYMDEF_TYPE::COMPONENT;
        long        SymHeight = 0; 
 
        std::vector<COMPONENT_COPPER>          ComponentCoppers;
        std::map<COMP_AREA_ID, COMPONENT_AREA> ComponentAreas;
        std::map<PAD_ID, COMPONENT_PAD>        ComponentPads;
        std::map<DIMENSION_ID, DIMENSION>      Dimensions; 
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct LIBRARY : PARSER
    {
        std::map<SYMDEF_ID, SYMDEF_PCB> ComponentDefinitions;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct CADSTAR_BOARD : PARSER
    {
        BOARD_ID                                ID;
        LINECODE_ID                             LineCodeID;
        SHAPE                                   Shape;
        std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE> AttributeValues;
        bool                                    Fixed = false;

        GROUP_ID      GroupID = wxEmptyString;

        REUSEBLOCKREF ReuseBlockRef;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };

    struct AREA : PARSER
    {
        AREA_ID     ID;
        LINECODE_ID LineCodeID;
        wxString    Name;
        LAYER_ID    LayerID;
        SHAPE       Shape;
 
        //TODO find out what token is used for specifying "Rule Set"
        RULESET_ID RuleSetID = wxEmptyString;
 
        bool Fixed = false;
 
        bool Placement = false; 
        bool Routing = false;   
        bool Keepout = false;   
        bool NoTracks = false;  
        bool NoVias = false;    
 
        long AreaHeight = UNDEFINED_VALUE; 
 
        GROUP_ID      GroupID = wxEmptyString; 
        REUSEBLOCKREF ReuseBlockRef;
        std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE> AttributeValues;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    enum class TESTLAND_SIDE
    {
        NONE,
        MAX, 
        MIN, 
        BOTH
    };
 
 
    static TESTLAND_SIDE ParseTestlandSide( XNODE* aNode );
 
 
    struct PIN_ATTRIBUTE : PARSER
    {
        PART_DEFINITION_PIN_ID                  Pin;
        std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE> AttributeValues;
        TESTLAND_SIDE                           TestlandSide = TESTLAND_SIDE::NONE;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct PADEXCEPTION : PARSER
    {
        PAD_ID     ID;
        PADCODE_ID PadCode      = wxEmptyString; 
        bool       OverrideExits = false;
        PAD_EXITS  Exits;
        bool       OverrideSide = false;
        PAD_SIDE   Side;
        bool       OverrideOrientation = false;
        long       OrientAngle         = 0;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct COMPONENT : PARSER
    {
        COMPONENT_ID ID;
        wxString     Name; 
        PART_ID      PartID;
        SYMDEF_ID    SymdefID;
        POINT        Origin; 
 
        GROUP_ID      GroupID = wxEmptyString; 
        REUSEBLOCKREF ReuseBlockRef;
        COMPONENT_ID  VariantParentComponentID = wxEmptyString;
        VARIANT_ID    VariantID                = wxEmptyString;
        long          OrientAngle              = 0;
        bool          TestPoint = false; 
        bool        Mirror      = false;
        bool        Fixed       = false;
        READABILITY Readability = READABILITY::BOTTOM_TO_TOP;
 
        std::map<ATTRIBUTE_ID, TEXT_LOCATION> TextLocations; 
        std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE>    AttributeValues;
        std::map<PART_DEFINITION_PIN_ID, wxString> PinLabels; 
        std::map<PART_DEFINITION_PIN_ID, PIN_ATTRIBUTE> PinAttributes;
        std::map<PAD_ID, PADEXCEPTION>                  PadExceptions; 
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct TRUNK : PARSER
    {
        TRUNK_ID ID;
        wxString Definition; // TODO: more work required to fully parse the TRUNK structure
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct NET_PCB : CADSTAR_ARCHIVE_PARSER::NET
    {
        struct PIN : PARSER 
        {
            NETELEMENT_ID ID; 
            COMPONENT_ID  ComponentID;
            PAD_ID        PadID;
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        struct JUNCTION_PCB : CADSTAR_ARCHIVE_PARSER::NET::JUNCTION 
        {
            TRUNK_ID TrunkID; 
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        struct VIA : PARSER 
        {
            NETELEMENT_ID ID; 
            VIACODE_ID    ViaCodeID;
            LAYERPAIR_ID  LayerPairID;
            POINT         Location;
            TRUNK_ID      TrunkID;                 
            GROUP_ID      GroupID = wxEmptyString; 
            REUSEBLOCKREF ReuseBlockRef;
            TESTLAND_SIDE TestlandSide = TESTLAND_SIDE::NONE;
            bool          Fixed        = false;
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        struct COPPER_TERMINAL : PARSER 
        {
            NETELEMENT_ID  ID; 
            COPPER_ID      CopperID;
            COPPER_TERM_ID CopperTermNum;
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        struct ROUTE_VERTEX 
        {
            long   RouteWidth = 0;
            bool   RouteWidthIsExplicit = true; 
            bool   TeardropAtStart = false;
            bool   TeardropAtEnd = false;
            long   TeardropAtStartAngle = 0;
            long   TeardropAtEndAngle = 0;
            bool   Fixed = false;
            VERTEX Vertex;

            XNODE* Parse( XNODE* aNode, PARSER_CONTEXT* aContext );
        };
 
        struct ROUTE : PARSER 
        {
            LAYER_ID                  LayerID = wxEmptyString;
            POINT                     StartPoint;
            std::vector<ROUTE_VERTEX> RouteVertices;
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        struct CONNECTION_PCB : CADSTAR_ARCHIVE_PARSER::NET::CONNECTION 
        {
            ROUTE Route;
            bool  Unrouted = false; 
 
            LAYER_ID UnrouteLayerID = wxEmptyString; 
            TRUNK_ID TrunkID;                        
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        std::map<NETELEMENT_ID, PIN>             Pins;
        std::map<NETELEMENT_ID, JUNCTION_PCB>    Junctions;
        std::map<NETELEMENT_ID, VIA>             Vias;
        std::map<NETELEMENT_ID, COPPER_TERMINAL> CopperTerminals;
        std::vector<CONNECTION_PCB>              Connections;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };

    struct TEMPLATE : PARSER
    {
        struct POURING : PARSER
        {
            enum class COPPER_FILL_TYPE
            {
                FILLED,
                HATCHED 
            };

            enum class RELIEF_TYPE
            {
                CROSS,  
                CUTOUTS 
            };
 
 
            COPPERCODE_ID CopperCodeID;       
            COPPERCODE_ID ReliefCopperCodeID; 
 
            long ClearanceWidth;      
            long SliverWidth;         
            long AdditionalIsolation; 
            long ThermalReliefPadsAngle; 
            long ThermalReliefViasAngle; 
            long MinIsolatedCopper = UNDEFINED_VALUE; 
            long MinDisjointCopper = UNDEFINED_VALUE; 
 
            bool ThermalReliefOnPads  = true;  
            bool ThermalReliefOnVias  = true;  
            bool AllowInNoRouting     = false; 
            bool BoxIsolatedPins      = false; 
            bool AutomaticRepour      = false; 
            bool TargetForAutorouting = false; 
 
            RELIEF_TYPE      ReliefType  = RELIEF_TYPE::CROSS;       
            COPPER_FILL_TYPE FillType    = COPPER_FILL_TYPE::FILLED; 
            HATCHCODE_ID     HatchCodeID = wxEmptyString; 
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        TEMPLATE_ID   ID;
        LINECODE_ID   LineCodeID;
        wxString      Name;
        NET_ID        NetID;
        LAYER_ID      LayerID;
        POURING       Pouring; 
        SHAPE         Shape;
        bool          Fixed   = false;
        GROUP_ID      GroupID = wxEmptyString; 
        REUSEBLOCKREF ReuseBlockRef;
 
        std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE> AttributeValues;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct COPPER : PARSER
    {
        struct NETREF : PARSER
        {
            struct COPPER_TERM : PARSER
            {
                COPPER_TERM_ID ID;
                POINT          Location;
                bool           Fixed = false;
 
                void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
            };
 
            NET_ID                                NetID = wxEmptyString;
            std::map<COPPER_TERM_ID, COPPER_TERM> CopperTerminals;
            bool                                  Fixed = false;
 
            void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
        };
 
        COPPER_ID     ID;
        COPPERCODE_ID CopperCodeID;
        LAYER_ID      LayerID;
        NETREF        NetRef;
        SHAPE         Shape;
        TEMPLATE_ID   PouredTemplateID = wxEmptyString; 
        bool          Fixed   = false;
        GROUP_ID      GroupID = wxEmptyString; 
        REUSEBLOCKREF ReuseBlockRef;
 
        std::map<ATTRIBUTE_ID, ATTRIBUTE_VALUE> AttributeValues;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    enum class NETSYNCH
    {
        UNDEFINED,
        WARNING,
        FULL
    };
 
 
    struct DRILL_TABLE : PARSER
    {
        DRILL_TABLE_ID ID;
        LAYER_ID       LayerID;
        POINT          Position;
        long           OrientAngle = 0;
        bool           Mirror      = false;
        bool           Fixed       = false;
        READABILITY    Readability = READABILITY::BOTTOM_TO_TOP;
        GROUP_ID       GroupID     = wxEmptyString; 
        REUSEBLOCKREF ReuseBlockRef;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    struct LAYOUT : PARSER
    {
        NETSYNCH NetSynch = NETSYNCH::UNDEFINED;
 
        std::map<GROUP_ID, GROUP>           Groups;
        std::map<REUSEBLOCK_ID, REUSEBLOCK> ReuseBlocks;
 
        std::map<BOARD_ID, CADSTAR_BOARD> Boards; 
        std::map<FIGURE_ID, FIGURE>                             Figures;
        std::map<AREA_ID, AREA>                                 Areas;
        std::map<COMPONENT_ID, COMPONENT>                       Components;
        std::map<DOCUMENTATION_SYMBOL_ID, DOCUMENTATION_SYMBOL> DocumentationSymbols;
        std::map<TRUNK_ID, TRUNK>                               Trunks;
        std::map<NET_ID, NET_PCB>                               Nets; 
        std::map<TEMPLATE_ID, TEMPLATE>                         Templates;
        std::map<COPPER_ID, COPPER>                             Coppers;
        std::map<TEXT_ID, TEXT>                                 Texts;
        std::map<DIMENSION_ID, DIMENSION>                       Dimensions;
        std::map<DRILL_TABLE_ID, DRILL_TABLE>                   DrillTables;
        VARIANT_HIERARCHY                                       VariantHierarchy;
 
        void Parse( XNODE* aNode, PARSER_CONTEXT* aContext ) override;
    };
 
 
    wxString Filename;
 
    HEADER      Header;
    ASSIGNMENTS Assignments;
    LIBRARY     Library;
    PARTS       Parts;
    LAYOUT      Layout;
 
    int KiCadUnitMultiplier; 
 
private:
    XNODE* m_rootNode; // Currently parsed root node
 
}; //CADSTAR_PCB_ARCHIVE_PARSER
 
#endif // CADSTAR_PCB_ARCHIVE_PARSER_H_