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
ClhepEvaluator	evaluator_
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 23 of file DDLElementRegistry.h.

Member Typedef Documentation

RegistryMap

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

Definition at line 25 of file DDLElementRegistry.h.

Constructor & Destructor Documentation

DDLElementRegistry()

DDLElementRegistry::DDLElementRegistry

(

void

)

Definition at line 39 of file DDLElementRegistry.cc.

{}

~DDLElementRegistry()

DDLElementRegistry::~DDLElementRegistry

(

void

)

Definition at line 41 of file DDLElementRegistry.cc.

References registry_.

{ registry_.clear(); }

Member Function Documentation

evaluator()

ClhepEvaluator& DDLElementRegistry::evaluator ( )

inline

Definition at line 42 of file DDLElementRegistry.h.

References evaluator_.

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

{ return evaluator_; }

getElement()

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 43 of file DDLElementRegistry.cc.

References Skims_PA_cff::name, and registry_.

Referenced by DDLSAX2FileHandler::characters(), DDLBooleanSolid::dumpBooleanSolid(), DDLSAX2FileHandler::endElement(), DDLPgonGenerator::preProcessElement(), DDLAssembly::preProcessElement(), DDLRotationSequence::preProcessElement(), DDLShapelessSolid::preProcessElement(), DDLAlgorithm::preProcessElement(), DDLBooleanSolid::preProcessElement(), DDLPosPart::preProcessElement(), DDLPolyGenerator::preProcessElement(), DDLCompositeMaterial::preProcessElement(), DDLLogicalPart::preProcessElement(), DDLPgonGenerator::processElement(), DDLRotationSequence::processElement(), DDLAlgorithm::processElement(), DDLRotationByAxis::processElement(), DDLSpecPar::processElement(), DDLPosPart::processElement(), DDLBooleanSolid::processElement(), DDLPolyGenerator::processElement(), DDLCompositeMaterial::processElement(), DDLLogicalPart::processElement(), DDLMaterial::setReference(), DDLSolid::setReference(), and DDLSAX2FileHandler::startElement().

                                                                                {
  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 == "UnionSolid" || name == "SubtractionSolid" || name == "IntersectionSolid") {
      myret = std::make_shared<DDLBooleanSolid>(this);
    } else if (name == "ShapelessSolid") {
      myret = std::make_shared<DDLShapelessSolid>(this);
    } else if (name == "Sphere") {
      myret = std::make_shared<DDLSphere>(this);
    } else if (name == "EllipticalTube") {
      myret = std::make_shared<DDLEllipticalTube>(this);
    } else if (name == "ExtrudedPolygon") {
      myret = std::make_shared<DDLPgonGenerator>(this);
    } else if (name == "Assembly")
      myret = std::make_shared<DDLAssembly>(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;
}

registerElement()

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

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

Member Data Documentation

evaluator_

ClhepEvaluator DDLElementRegistry::evaluator_

private

Definition at line 46 of file DDLElementRegistry.h.

Referenced by evaluator().

registry_

RegistryMap DDLElementRegistry::registry_

private

Definition at line 45 of file DDLElementRegistry.h.

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