DDLElementRegistry Class Reference

The main class for processing parsed elements. More...

#include <DDLElementRegistry.h>

Public Types
typedef std::map< std::string, std::shared_ptr< DDXMLElement > >	RegistryMap

Public Member Functions
	DDLElementRegistry ()
ClhepEvaluator &	evaluator ()
std::shared_ptr< DDXMLElement >	getElement (const std::string &name)
	THE most important part. Getting the pointer to a given element type. More...
void	registerElement (const std::string &name, DDXMLElement *)
	This allows other Elements to register themselves with the static registry. More...
	~DDLElementRegistry ()

Private Attributes
RegistryMap	registry_

Detailed Description

The main class for processing parsed elements.

This class is designed to serve as a registry of all DDL XML elements.

This class is responsible for constructing and destructing any necessary DDL element.

Definition at line 25 of file DDLElementRegistry.h.

Member Typedef Documentation

typedef std::map<std::string, std::shared_ptr<DDXMLElement> > DDLElementRegistry::RegistryMap

Definition at line 29 of file DDLElementRegistry.h.

Constructor & Destructor Documentation

DDLElementRegistry::DDLElementRegistry

(

void

)

Definition at line 44 of file DDLElementRegistry.cc.

{}

DDLElementRegistry::~DDLElementRegistry

(

void

)

Definition at line 47 of file DDLElementRegistry.cc.

References registry_.

{
  registry_.clear();
}

Member Function Documentation

ClhepEvaluator& DDLElementRegistry::evaluator ( )

inline

Definition at line 46 of file DDLElementRegistry.h.

References DDI::Singleton< I >::instance().

Referenced by DDLVector::do_makeDouble(), DDLMap::do_makeDouble(), DDLRotationAndReflection::isLeftHanded(), DDLRotationAndReflection::makeX(), DDLRotationAndReflection::makeY(), DDLRotationAndReflection::makeZ(), DDLPgonGenerator::processElement(), DDLMultiUnionSolid::processElement(), DDLTubs::processElement(), DDLPseudoTrap::processElement(), DDLTrapezoid::processElement(), DDLParallelepiped::processElement(), DDLTorus::processElement(), DDLOrb::processElement(), DDLEllipsoid::processElement(), DDLEllipticalTube::processElement(), DDLSphere::processElement(), DDLAlgorithm::processElement(), DDLSpecPar::processElement(), DDLCone::processElement(), DDLBox::processElement(), DDLBooleanSolid::processElement(), DDLDivision::processElement(), DDLRotationAndReflection::processElement(), DDLPosPart::processElement(), DDLElementaryMaterial::processElement(), DDLPolyGenerator::processElement(), DDLNumeric::processElement(), DDLCompositeMaterial::processElement(), DDLVector::processElement(), DDLMap::processElement(), and DDLRotationByAxis::processOne().

{ return DDI::Singleton<ClhepEvaluator>::instance(); }

std::shared_ptr< DDXMLElement > DDLElementRegistry::getElement

(

const std::string &

name

)

THE most important part. Getting the pointer to a given element type.

If this is called with a DDXMLElementRegistry pointer, it will simply return a pointer if already registered or NULL, no instantiating.

Definition at line 53 of file DDLElementRegistry.cc.

References dataset::name, and registry_.

Referenced by DDLBooleanSolid::dumpBooleanSolid(), DDLMultiUnionSolid::dumpMultiUnionSolid(), DDLMultiUnionSolid::preProcessElement(), DDLPgonGenerator::preProcessElement(), DDLReflectionSolid::preProcessElement(), DDLRotationSequence::preProcessElement(), DDLAlgorithm::preProcessElement(), DDLShapelessSolid::preProcessElement(), DDLPosPart::preProcessElement(), DDLBooleanSolid::preProcessElement(), DDLPolyGenerator::preProcessElement(), DDLCompositeMaterial::preProcessElement(), DDLLogicalPart::preProcessElement(), DDLMultiUnionSolid::processElement(), DDLPgonGenerator::processElement(), DDLReflectionSolid::processElement(), DDLRotationSequence::processElement(), DDLRotationByAxis::processElement(), DDLAlgorithm::processElement(), DDLSpecPar::processElement(), DDLBooleanSolid::processElement(), DDLPolyGenerator::processElement(), DDLPosPart::processElement(), DDLCompositeMaterial::processElement(), DDLLogicalPart::processElement(), DDLMaterial::setReference(), and DDLSolid::setReference().

{
  RegistryMap::iterator it = registry_.find( name );
  std::shared_ptr<DDXMLElement> myret( nullptr );
  if( it != registry_.end())
  {
    return it->second;
  } else {
    // Make the Solid handlers and register them.
    if (name == "Box")
    {
      myret = std::make_shared<DDLBox>(this);
    }
    else if (name == "Cone")
    {
      myret = std::make_shared<DDLCone>(this);
    }
    else if (name == "Polyhedra" || name == "Polycone")
    {
      myret = std::make_shared<DDLPolyGenerator>(this);
    }
    else if (name == "Trapezoid" || name == "Trd1")
    {
      myret = std::make_shared<DDLTrapezoid>(this);
    }
    else if (name == "PseudoTrap")
    {
      myret = std::make_shared<DDLPseudoTrap>(this);
    }
    else if (name == "Tubs" || name == "CutTubs" || name == "Tube" || name == "TruncTubs")
    {
      myret = std::make_shared<DDLTubs>(this);
    }
    else if (name == "Torus")
    {
      myret = std::make_shared<DDLTorus>(this);
    }
    else if (name == "ReflectionSolid")
    {
      myret = std::make_shared<DDLReflectionSolid>(this);
    }
    else if (name == "UnionSolid" || name == "SubtractionSolid"
         || name == "IntersectionSolid")
    {
      myret = std::make_shared<DDLBooleanSolid>(this);
    }
    else if (name == "MultiUnionSolid" )
    {
      myret = std::make_shared<DDLMultiUnionSolid>(this);
    }
    else if (name == "ShapelessSolid")
    {
      myret = std::make_shared<DDLShapelessSolid>(this);
    }
    else if (name == "Sphere")
    {
      myret = std::make_shared<DDLSphere>(this);
    }
    else if (name == "Orb")
    {
      myret = std::make_shared<DDLOrb>(this);
    }
    else if (name == "EllipticalTube")
    {
      myret = std::make_shared<DDLEllipticalTube>(this);
    }
    else if (name == "Ellipsoid")
    {
      myret = std::make_shared<DDLEllipsoid>(this);
    }
    else if (name == "Parallelepiped")
    {
      myret = std::make_shared<DDLParallelepiped>(this);
    }
    else if (name == "ExtrudedPolygon")
      myret = std::make_shared<DDLPgonGenerator>(this);

    //  LogicalParts, Positioners, Materials, Rotations, Reflections
    //  and Specific (Specified?) Parameters
    else if (name == "PosPart")
    {
      myret = std::make_shared<DDLPosPart>(this);
    }
    else if (name == "CompositeMaterial")
    {
      myret = std::make_shared<DDLCompositeMaterial>(this);
    }
    else if (name == "ElementaryMaterial")
    {
      myret = std::make_shared<DDLElementaryMaterial>(this);
    }
    else if (name == "LogicalPart")
    {
      myret = std::make_shared<DDLLogicalPart>(this);
    }
    else if (name == "ReflectionRotation" || name == "Rotation" )
    {
      myret = std::make_shared<DDLRotationAndReflection>(this);
    }
    else if (name == "SpecPar")
    {
      myret = std::make_shared<DDLSpecPar>(this);
    }
    else if (name == "RotationSequence")
    {
      myret = std::make_shared<DDLRotationSequence>(this);
    }
    else if (name == "RotationByAxis")
    {
      myret = std::make_shared<DDLRotationByAxis>(this);
    }
    // Special, need them around.
    else if (name == "SpecParSection") {
      myret = std::make_shared<DDXMLElement>(this, true);
    }
    else if (name == "Vector") {
      myret = std::make_shared<DDLVector>(this);
    }
    else if (name == "Map") {
      myret = std::make_shared<DDLMap>(this);
    }
    else if (name == "String") {
      myret = std::make_shared<DDLString>(this);
    }
    else if (name == "Numeric") {
      myret = std::make_shared<DDLNumeric>(this);
    }
    else if (name == "Algorithm") {
      myret = std::make_shared<DDLAlgorithm>(this);
    }
    else if (name == "Division") {
      myret = std::make_shared<DDLDivision>(this);
    }

    // Supporting Cast of elements.
    //  All elements which simply accumulate attributes which are then used
    //  by one of the above elements.
    else if (name == "MaterialFraction"
         || name == "RZPoint" || name == "XYPoint" || name == "PartSelector"
         || name == "Parameter" || name == "ZSection" || name == "ZXYSection"
         || name == "Translation" 
         || name == "rSolid" || name == "rMaterial" 
         || name == "rParent" || name == "rChild"
         || name == "rRotation" || name == "rReflectionRotation"
         || name == "DDDefinition" )
    {
      myret = std::make_shared<DDXMLElement>(this);
    }

    //  IF it is a new element return a default XMLElement which processes nothing.
    //  Since there are elements in the XML which require no processing, they
    //  can all use the same DDXMLElement which defaults to anything.  A validated
    //  XML document (i.e. validated with XML Schema) will work properly.
    //  As of 8/16/2002:  Elements like LogicalPartSection and any other *Section
    //  XML elements of the DDLSchema are taken care of by this.
    else
    {
      myret = std::make_shared<DDXMLElement>(this);
    }
    
    // Actually register the thing
    registry_[name] = myret;
  }
  return myret;
}

void DDLElementRegistry::registerElement	(	const std::string &	name,
		DDXMLElement *
	)

This allows other Elements to register themselves with the static registry.

Member Data Documentation

RegistryMap DDLElementRegistry::registry_

private

Definition at line 49 of file DDLElementRegistry.h.

Referenced by getElement(), and ~DDLElementRegistry().