#include <cadstar_pcb_archive_parser.h>

Inheritance diagram for CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB:

Public Member Functions
void	Parse (XNODE aNode, PARSER_CONTEXT aContext) override

bool	ParseSubNode (XNODE aChildNode, PARSER_CONTEXT aContext)

Public Attributes
std::map< COPPERCODE_ID, COPPERCODE >	CopperCodes

std::map< SPACINGCODE_ID, SPACINGCODE >	SpacingCodes
	Spacing Design Rules. More...

std::map< RULESET_ID, RULESET >	Rulesets
	Used for area design rules. More...

std::map< PADCODE_ID, PADCODE >	PadCodes

std::map< VIACODE_ID, VIACODE >	ViaCodes

std::map< LAYERPAIR_ID, LAYERPAIR >	LayerPairs
	Default vias to use between pairs of layers. More...

std::vector< SPCCLASSSPACE >	SpacingClasses

std::map< LINECODE_ID, LINECODE >	LineCodes

std::map< HATCHCODE_ID, HATCHCODE >	HatchCodes

std::map< TEXTCODE_ID, TEXTCODE >	TextCodes

std::map< ROUTECODE_ID, ROUTECODE >	RouteCodes

std::map< ATTRIBUTE_ID, ATTRNAME >	AttributeNames

std::map< NETCLASS_ID, CADSTAR_NETCLASS >	NetClasses

std::map< SPACING_CLASS_ID, SPCCLASSNAME >	SpacingClassNames

Detailed Description

Definition at line 384 of file cadstar_pcb_archive_parser.h.

Member Function Documentation

◆ Parse()

void CADSTAR_PCB_ARCHIVE_PARSER::CODEDEFS_PCB::Parse	(	XNODE *	aNode,
		PARSER_CONTEXT *	aContext
	)

overridevirtual

Implements CADSTAR_ARCHIVE_PARSER::PARSER.

Definition at line 232 of file cadstar_pcb_archive_parser.cpp.

 {
     wxASSERT( aNode->GetName() == wxT( "CODEDEFS" ) );
 
     XNODE* cNode = aNode->GetChildren();
 
     for( ; cNode; cNode = cNode->GetNext() )
     {
         wxString nodeName = cNode->GetName();
 
         if( ParseSubNode( cNode, aContext ) ) // in CADSTAR_ARCHIVE_PARSER::CODEDEFS
         {
         }
         else if( nodeName == wxT( "COPPERCODE" ) )
         {
             COPPERCODE coppercode;
             coppercode.Parse( cNode, aContext );
             CopperCodes.insert( std::make_pair( coppercode.ID, coppercode ) );
         }
         else if( nodeName == wxT( "SPACINGCODE" ) )
         {
             SPACINGCODE spacingcode;
             spacingcode.Parse( cNode, aContext );
             SpacingCodes.insert( std::make_pair( spacingcode.ID, spacingcode ) );
         }
         else if( nodeName == wxT( "RULESET" ) )
         {
             RULESET ruleset;
             ruleset.Parse( cNode, aContext );
             Rulesets.insert( std::make_pair( ruleset.ID, ruleset ) );
         }
         else if( nodeName == wxT( "PADCODE" ) )
         {
             PADCODE padcode;
             padcode.Parse( cNode, aContext );
             PadCodes.insert( std::make_pair( padcode.ID, padcode ) );
         }
         else if( nodeName == wxT( "VIACODE" ) )
         {
             VIACODE viacode;
             viacode.Parse( cNode, aContext );
             ViaCodes.insert( std::make_pair( viacode.ID, viacode ) );
         }
         else if( nodeName == wxT( "LAYERPAIR" ) )
         {
             LAYERPAIR layerpair;
             layerpair.Parse( cNode, aContext );
             LayerPairs.insert( std::make_pair( layerpair.ID, layerpair ) );
         }
         else if( nodeName == wxT( "SPCCLASSSPACE" ) )
         {
             SPCCLASSSPACE spcclassspace;
             spcclassspace.Parse( cNode, aContext );
             SpacingClasses.push_back( spcclassspace );
         }
         else
         {
             THROW_UNKNOWN_NODE_IO_ERROR( nodeName, aNode->GetName() );
         }
     }
 }

Referenced by CADSTAR_PCB_ARCHIVE_PARSER::ASSIGNMENTS::Parse().

◆ ParseSubNode()

bool CADSTAR_ARCHIVE_PARSER::CODEDEFS::ParseSubNode	(	XNODE *	aChildNode,
		PARSER_CONTEXT *	aContext
	)

inherited

Definition at line 1341 of file cadstar_archive_parser.cpp.

 {
     wxString nodeName = aChildNode->GetName();
 
     if( nodeName == wxT( "LINECODE" ) )
     {
         LINECODE linecode;
         linecode.Parse( aChildNode, aContext );
         LineCodes.insert( std::make_pair( linecode.ID, linecode ) );
     }
     else if( nodeName == wxT( "HATCHCODE" ) )
     {
         HATCHCODE hatchcode;
         hatchcode.Parse( aChildNode, aContext );
         HatchCodes.insert( std::make_pair( hatchcode.ID, hatchcode ) );
     }
     else if( nodeName == wxT( "TEXTCODE" ) )
     {
         TEXTCODE textcode;
         textcode.Parse( aChildNode, aContext );
         TextCodes.insert( std::make_pair( textcode.ID, textcode ) );
     }
     else if( nodeName == wxT( "ROUTECODE" ) )
     {
         ROUTECODE routecode;
         routecode.Parse( aChildNode, aContext );
         RouteCodes.insert( std::make_pair( routecode.ID, routecode ) );
     }
     else if( nodeName == wxT( "ATTRNAME" ) )
     {
         ATTRNAME attrname;
         attrname.Parse( aChildNode, aContext );
         AttributeNames.insert( std::make_pair( attrname.ID, attrname ) );
     }
     else if( nodeName == wxT( "NETCLASS" ) )
     {
         CADSTAR_NETCLASS netclass;
         netclass.Parse( aChildNode, aContext );
         NetClasses.insert( std::make_pair( netclass.ID, netclass ) );
     }
     else if( nodeName == wxT( "SPCCLASSNAME" ) )
     {
         SPCCLASSNAME spcclassname;
         spcclassname.Parse( aChildNode, aContext );
         SpacingClassNames.insert( std::make_pair( spcclassname.ID, spcclassname ) );
     }
     else
     {
         return false;
     }
 
     return true;
 }