DDXMLElement.cc

Go to the documentation of this file.

#include "DetectorDescription/Parser/src/DDXMLElement.h"

#include <iostream>
#include <memory>
#include <utility>
#include <string>

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"

class DDCompactView;
class DDLElementRegistry;

DDXMLElement::DDXMLElement(DDLElementRegistry* myreg) : myRegistry_(myreg), attributes_(), text_(), autoClear_(false) {}

DDXMLElement::DDXMLElement(DDLElementRegistry* myreg, const bool& clearme)
    : myRegistry_(myreg), attributes_(), text_(), autoClear_(clearme) {}

// For pre-processing, after attributes are loaded.  Default, do nothing!
void DDXMLElement::preProcessElement(const std::string& name, const std::string& nmspace, DDCompactView& cpv) {}

// This loads the attributes into the attributes_ std::vector.
void DDXMLElement::loadAttributes(const std::string& elemName,
                                  const std::vector<std::string>& names,
                                  const std::vector<std::string>& values,
                                  const std::string& nmspace,
                                  DDCompactView& cpv) {
  attributes_.resize(attributes_.size() + 1);
  DDXMLAttribute& tAttributes = attributes_.back();

  // adds attributes
  for (size_t i = 0; i < names.size(); ++i) {
    tAttributes.insert(std::make_pair(names[i], values[i]));
  }

  preProcessElement(elemName, nmspace, cpv);
}

// clear data.
void DDXMLElement::clear(void) {
  text_.clear();
  attributes_.clear();
  attributeAccumulator_.clear();
}

// Access to current attributes by name.
const std::string& DDXMLElement::getAttribute(const std::string& name) const {
  static const std::string ldef;
  if (!attributes_.empty())
    return get(name, attributes_.size() - 1);
  return ldef;
}

const DDXMLAttribute& DDXMLElement::getAttributeSet(size_t aIndex) const { return attributes_[aIndex]; }

const DDName DDXMLElement::getDDName(const std::string& defaultNS, const std::string& attname, size_t aIndex) {
  if (aIndex < attributes_.size() && attributes_[aIndex].find(attname) != attributes_[aIndex].end()) {
    std::string ns = defaultNS;
    // For the user to fully control namespaces they must provide for
    // all name attributes something of the form, for example:
    //        <Solid name="ns:name" ...
    // If defaultNS is "!" (magic I don't like) then find and set
    // the namespace properly.
    if (defaultNS == "!") {
      ns = "";
    }
    const std::string& name = attributes_[aIndex].find(attname)->second;
    std::string rn = name;
    size_t foundColon = name.find(':');
    if (foundColon != std::string::npos) {
      ns = name.substr(0, foundColon);
      rn = name.substr(foundColon + 1);
    }
    return DDName(rn, ns);
  }
  std::string msg = "DDXMLElement:getDDName failed.  It was asked to make ";
  msg += "a DDName using attribute: " + attname;
  msg += " in position: " + std::to_string(aIndex) + ".  There are ";
  msg += std::to_string(attributes_.size()) + " entries in the element.";
  throwError(msg);
  return DDName("justToCompile", "justToCompile");  // used to make sure it compiles
}

// Returns a specific value from the aIndex set of attributes.
const std::string& DDXMLElement::get(const std::string& name, const size_t aIndex) const {
  static const std::string sts;
  if (aIndex < attributes_.size()) {
    DDXMLAttribute::const_iterator it = attributes_[aIndex].find(name);
    if (attributes_[aIndex].end() == it) {
      return sts;
    } else
      return (it->second);
  }
  std::string msg = "DDXMLElement:get failed.  It was asked for attribute " + name;
  msg += " in position " + std::to_string(aIndex) + " when there are only ";
  msg += std::to_string(attributes_.size()) + " in the element storage.\n";
  throwError(msg);
  // meaningless...
  return sts;
}

// Returns a specific set of values as a std::vector of std::strings,
// given the attribute name.
std::vector<std::string> DDXMLElement::getVectorAttribute(const std::string& name) {
  //  The idea here is that the attributeAccumulator_ is a cache of
  //  on-the-fly generation from the std::vector<DDXMLAttribute> and the
  //  reason is simply to speed things up if it is requested more than once.
  std::vector<std::string> tv;
  AttrAccumType::const_iterator ita = attributeAccumulator_.find(name);
  if (ita != attributeAccumulator_.end()) {
    tv = attributeAccumulator_[name];
    if (tv.size() < attributes_.size()) {
      appendAttributes(tv, name);
    }
  } else {
    if (!attributes_.empty()) {
      appendAttributes(tv, name);
    } else {
      //      throw cms::Exception("DDException") << msg;
    }
  }
  return tv;
}

// Default do-nothing processElementBases.
void DDXMLElement::processElement(const std::string& name, const std::string& nmspace, DDCompactView& cpv) {
  loadText(std::string());
  if (autoClear_)
    clear();
}

void DDXMLElement::loadText(const std::string& inText) { text_.emplace_back(inText); }

void DDXMLElement::appendText(const std::string& inText) {
  static const std::string cr("\n");
  if (!text_.empty()) {
    text_[text_.size() - 1] += cr;
    text_[text_.size() - 1] += inText;
  } else {
    std::string msg = "DDXMLElement::appendText could not append to non-existent text.";
    throwError(msg);
  }
}

const std::string DDXMLElement::getText(size_t tindex) const {
  if (tindex > text_.size()) {
    std::string msg = "DDXMLElement::getText tindex is greater than text_.size()).";
    throwError(msg);
  }
  return text_[tindex];
}

bool DDXMLElement::gotText(void) const {
  if (!text_.empty())
    return true;
  return false;
}

std::ostream& operator<<(std::ostream& os, const DDXMLElement& element) {
  element.stream(os);
  return os;
}

void DDXMLElement::stream(std::ostream& os) const {
  os << "Output of current element attributes:" << std::endl;
  for (const auto& attribute : attributes_) {
    for (DDXMLAttribute::const_iterator it = attribute.begin(); it != attribute.end(); ++it)
      os << it->first << " = " << it->second << "\t";
    os << std::endl;
  }
}

void DDXMLElement::appendAttributes(std::vector<std::string>& tv, const std::string& name) {
  for (size_t i = tv.size(); i < attributes_.size(); ++i) {
    DDXMLAttribute::const_iterator itnv = attributes_[i].find(name);
    if (itnv != attributes_[i].end())
      tv.emplace_back(itnv->second);
    else
      tv.emplace_back("");
  }
}

// Number of elements accumulated.
size_t DDXMLElement::size(void) const { return attributes_.size(); }

std::vector<DDXMLAttribute>::const_iterator DDXMLElement::begin(void) {
  myIter_ = attributes_.begin();
  return attributes_.begin();
}

std::vector<DDXMLAttribute>::const_iterator DDXMLElement::end(void) {
  myIter_ = attributes_.end();
  return attributes_.end();
}

std::vector<DDXMLAttribute>::const_iterator& DDXMLElement::operator++(int inc) {
  myIter_ = myIter_ + inc;
  return myIter_;
}

const std::string& DDXMLElement::parent(void) const { return parentElement_; }

void DDXMLElement::setParent(const std::string& pename) { parentElement_ = pename; }

void DDXMLElement::setSelf(const std::string& sename) { myElement_ = sename; }

bool DDXMLElement::isEmpty(void) const { return (attributes_.empty() ? true : false); }

void DDXMLElement::throwError(const std::string& keyMessage) const {
  std::string msg = keyMessage + "\n";
  msg += " Element " + myElement_ + "\n";

  throw cms::Exception("DDException") << msg;
}