#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 1345 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;
 }