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 (C) 2020-2022 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_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 ) :
 Filename( aFilename ), Header(), Assignments(),
 m_rootNode( nullptr ), CADSTAR_ARCHIVE_PARSER()
 {
 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;
 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;
 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;
 
 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;
 
 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; 
 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;
 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; 
 
 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;
 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_