#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 250 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 1441 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;
}