Branch.cc

Go to the documentation of this file.

#include <utl/Reader.h>
#include <utl/Branch.h>
#include <utl/XercesUtil.h>

#include <utl/ErrorLogger.h>
#include <utl/UnitGrammar.h>
#include <utl/ExpressionParser.h>
#include <utl/AugerException.h>
#include <utl/UTCDateTime.h>
#include <utl/StringCompare.h>

#include <utl/Function.h>

#include <xercesc/util/XercesVersion.hpp>
#if _XERCES_VERSION >= 30000
#  define HAVE_XERCES3
#  include <xercesc/dom/DOMLSSerializer.hpp>
#else
#  include <xercesc/framework/MemBufFormatTarget.hpp>
#endif
#include <xercesc/dom/DOMImplementation.hpp>
#include <xercesc/dom/DOMImplementationLS.hpp>

// this is here only for the AsString function, which should be in a utils section
#include <utl/ReaderErrorReporter.h>

#include <boost/tokenizer.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/lambda/lambda.hpp>

using namespace utl;
using namespace xercesc;
using namespace std;


inline
void
Branch::ZeroBranchCheck()
  const
{
  if (*this)
    return;

  WARNING(fWarning);
  const string err = "Operating on null-Branch. " + fWarning;
  ERROR(err);
  throw XMLParseException(err);
}


Branch
Branch::GetTopBranch()
  const
{
  ZeroBranchCheck();
  const auto ownerDoc = GetDOMNode()->getOwnerDocument();
  if (ownerDoc)
    return Branch(fOwner, ownerDoc->getDocumentElement());
  else {
    Branch b(fOwner, nullptr);
    b.SetWarning("Owner document (top branch) not found.");
    return b;
  }
}


Branch
Branch::GetParent()
  const
{
  ZeroBranchCheck();

  if (fDOMNode->getNodeType() != DOMNode::ELEMENT_NODE)
    return Branch();
  DOMNode* const parentNode = fDOMNode->getParentNode();
  if (!parentNode || parentNode->getNodeType() != DOMNode::ELEMENT_NODE)
    return Branch();
  return Branch(fOwner, parentNode);
}



Branch
Branch::GetFirstChild()
  const
{
  ZeroBranchCheck();

  DOMNode* childNode = fDOMNode->getFirstChild();
  while (childNode && childNode->getNodeType() != DOMNode::ELEMENT_NODE)
    childNode = childNode->getNextSibling();

  Branch b(fOwner, childNode);
  if (!childNode) {
    ostringstream warn;
    warn << "First child in branch '" << GetName() << "' not found.";
    b.SetWarning(warn.str());
  }
  return b;
}



Branch
Branch::GetChild(const string& requestedName,
                 AttributeMap requestedAttributeMap)
  const
{
  ZeroBranchCheck();

  requestedAttributeMap.erase("unit");
  requestedAttributeMap.erase("UNIT");
  requestedAttributeMap.erase("Unit");
  requestedAttributeMap.erase("variables");
  requestedAttributeMap.erase("VARIABLES");
  requestedAttributeMap.erase("Variables");

  for (DOMNode* childNode = fDOMNode->getFirstChild();
       childNode; childNode = childNode->getNextSibling())

    if (childNode->getNodeType() == DOMNode::ELEMENT_NODE) {

      const string foundName = AsString(childNode->getNodeName());

      if (foundName == requestedName) {

        // Get all the attributes into a map.
        AttributeMap foundAttributeMap;
        const DOMNamedNodeMap* const attributes = childNode->getAttributes();

        for (unsigned int i = 0; i < attributes->getLength(); ++i) {

          const DOMNode* const attr = attributes->item(i);

          foundAttributeMap.insert(make_pair(AsString(attr->getNodeName()),
                                             AsString(attr->getNodeValue())));

        } // filled up foundAttributeMap

        // First, discard any unit attributes in either the found or requested maps.
        // Units are treated as a special case.
        foundAttributeMap.erase("unit");
        foundAttributeMap.erase("UNIT");
        foundAttributeMap.erase("Unit");
        foundAttributeMap.erase("variables");
        foundAttributeMap.erase("VARIABLES");
        foundAttributeMap.erase("Variables");

        // Check for exact match between remaining attributes and attribute
        // values in the requested and found maps
        if (foundAttributeMap.size() == requestedAttributeMap.size()) {

          bool foundIt = true;

          // try to disqualify equality
          for (auto foundIter = foundAttributeMap.begin();
               foundIter != foundAttributeMap.end(); ++foundIter) {

            const auto requestedIter = requestedAttributeMap.find(foundIter->first);
            if (requestedIter == requestedAttributeMap.end() ||
                foundIter->second != requestedIter->second) {
              foundIt = false;
              break;
            }

          }

          if (foundIt)
            return Branch(fOwner, childNode);

        }

      } // same name

    } // condition ELEMENT_NODE

  Branch b;
  ostringstream warn;
  warn << "Child <" << requestedName << "> in branch <"
       << GetName() << "> not found";
  b.SetWarning(warn.str());
  return b; // null-branch
}



Branch
Branch::GetChild(const string& requestedName)
  const
{
  // don't ZeroBranchCheck() here
  AttributeMap dummy;
  return GetChild(requestedName, dummy);
}


Branch
Branch::GetChild(const string& requestedName, const string& att)
  const
{
  // don't ZeroBranchCheck() here

  using namespace boost;

  if (att.empty())
    return GetChild(requestedName);

  char_separator<char> aSep(" ");
  char_separator<char> kvSep("=");
  typedef tokenizer<char_separator<char> > Tokenizer;
  Tokenizer aTok(att, aSep);
  AttributeMap attMap;
  for (Tokenizer::const_iterator aIt = aTok.begin(); aIt != aTok.end(); ++aIt) {
    string key;
    string value;
    Tokenizer kvTok(*aIt, kvSep);
    Tokenizer::const_iterator kvIt = kvTok.begin();
    if (kvIt != kvTok.end()) {
      key = *kvIt;
      ++kvIt;
      if (kvIt != kvTok.end())
        value = *kvIt;
    }
    attMap[key] = value;
  }

  return GetChild(requestedName, attMap);
}


unsigned int
Branch::GetNChildren()
  const
{
  unsigned int i = 0;
  for (Branch b = GetFirstChild(); b; ++b)
    ++i;
  return i;
}


AttributeMap
Branch::GetAttributes()
  const
{
  ZeroBranchCheck();

  AttributeMap attrMap;

  const DOMNamedNodeMap* const attributes = fDOMNode->getAttributes();
  for (unsigned int i = 0; i < attributes->getLength(); ++i) {
    const DOMNode* const attr = attributes->item(i);
    attrMap[AsString(attr->getNodeName())] = AsString(attr->getNodeValue());
  }
  return attrMap;
}


Branch
Branch::GetNextSibling()
  const
{
  ZeroBranchCheck();

  DOMNode* siblingNode = fDOMNode->getNextSibling();

  while (siblingNode && siblingNode->getNodeType() != DOMNode::ELEMENT_NODE)
    siblingNode = siblingNode->getNextSibling();

  Branch b(fOwner, siblingNode);
  if (!siblingNode) {
    ostringstream warn;
    warn << "Next sibling of branch <" << GetName() << "> not found";
    b.SetWarning(warn.str());
  }
  return b;
}


Branch
Branch::GetPreviousSibling()
  const
{
  ZeroBranchCheck();

  DOMNode* siblingNode = fDOMNode->getPreviousSibling();

  while (siblingNode && siblingNode->getNodeType() != DOMNode::ELEMENT_NODE)
    siblingNode = siblingNode->getPreviousSibling();

  Branch b(fOwner, siblingNode);
  if (!siblingNode) {
    ostringstream warn;
    warn << "Next sibling of branch <" << GetName() << "> not found";
    b.SetWarning(warn.str());
  }
  return b;
}


Branch
Branch::GetSibling(const string& requestedName, AttributeMap& attributeMap)
  const
{
  ZeroBranchCheck();

  // back up to the parent.
  DOMNode* const parentNode = fDOMNode->getParentNode();

  Branch parentBranch(fOwner, parentNode);

  if (!parentNode) {
    ostringstream warn;
    warn << "Parent of branch <" << GetName() << "> not found";
    parentBranch.SetWarning(warn.str());
  }

  return parentBranch.GetChild(requestedName, attributeMap);
}


Branch
Branch::GetSibling(const string& requestedName)
  const
{
  // don't ZeroBranchCheck() here
  AttributeMap dummy;
  return GetSibling(requestedName, dummy);
}



Branch
Branch::GetSibling(const string& requestedName, const string& id)
  const
{
  // don't ZeroBranchCheck() here
  AttributeMap idMap;
  idMap["id"] = id;
  return GetSibling(requestedName, idMap);
}


string
Branch::GetName()
  const
{
  ZeroBranchCheck();

  return AsString(fDOMNode->getNodeName());
}


// -------------------- GetData methods ------------------------------


string
Branch::GetDataString()
  const
{
  ZeroBranchCheck();

  // Find the data residing beneath this tag
  const DOMNodeList* const dataNodes = fDOMNode->getChildNodes();

  if (!dataNodes)
    return string();

  string dataString;

  for (unsigned int k = 0; k < dataNodes->getLength(); ++k) {

    const DOMNode* const currentNode = dataNodes->item(k);

    // For TEXT nodes, postpend the node onto the dataString. NB if
    // there are multiple TEXT nodes beneath this element, and they
    // are, for example, separated by one or more sub- elements,
    // these text nodes will be concatenated into a single data
    // string.
    if (currentNode->getNodeType() == DOMNode::TEXT_NODE)
      dataString += AsString(currentNode->getNodeValue());

  }

  boost::trim(dataString);
  return dataString;
}



double
Branch::GetUnit()
  const
{
  ZeroBranchCheck();

  double unit = 1;

  // Check for a unit attribute
  const DOMNamedNodeMap* const attributes = fDOMNode->getAttributes();

  if (attributes) {

    string unitString;
    for (unsigned int j = 0; j < attributes->getLength(); ++j) {
      const DOMNode* const attribute = attributes->item(j);
      const string name = AsString(attribute->getNodeName());
      if (StringEquivalent(name, "unit")) {
        unitString = AsString(attribute->getNodeValue());
        break;
      }
    }

    // If found, convert the unit to the appropriate scale factor,
    // otherwise set scale factor to 1.
    if (!unitString.empty()) {
      AugerUnitParser up;
      unit = up.Evaluate(unitString);
    }
  }

  return unit;
}


vector<string>
Branch::GetListOfVariables()  // for functions from XML attributes
  const
{
  ZeroBranchCheck();

  // Check for a unit attribute
  const DOMNamedNodeMap* const attributes = fDOMNode->getAttributes();

  vector<string> variables;

  if (attributes) {
    istringstream iss;
    string word;
    for (unsigned int i = 0; i < attributes->getLength(); ++i) {
      const DOMNode* const attr = attributes->item(i);
      const string nodeName = AsString(attr->getNodeName());
      if (StringEquivalent(nodeName, "variables")) {
        const string s = AsString(attr->getNodeValue());
        iss.clear();
        iss.str(s);
        while (iss >> word)
          variables.push_back(word);
      }
    }
  }

  return variables;
}


utl::Branch&
Branch::operator=(const Branch& b)
{
  /* Protect against self-assignment */
  if (*this != b) {
    // no need for ZeroBranchCheck(); zero-Branch is copyable
    fDOMNode = b.fDOMNode;
    fOwner = b.fOwner;
    fWarning = b.fWarning;
  }
  return *this;
}


void
Branch::GetData(string& s)
  const
{
  // don't ZeroBranchCheck() here

  // do not use castData, as in this case
  // we want to return the ENTIRE string, including
  // possible white space.
  s = GetDataString();
}


// DV considered dangerous since user has to call free()
void
Branch::GetData(char*& /*c*/)
  const
{
  // do not use castData, as in this case
  // we want to return the ENTIRE string, including
  // possible white space. Do not forget to call free.

  /*const string s = GetDataString();
  c = strdup(s.c_str());*/
  ERROR("This method requires user to call free() after "
        "done with the char*! Disabled for the moment.");
  exit(1);
}


void
Branch::GetData(TimeStamp& time)
  const
{
  // don't ZeroBranchCheck() here
  time = boost::lexical_cast<UTCDateTime>(GetDataString()).GetTimeStamp();
}


void
Branch::GetData(Function& func)
  const
{
  // don't ZeroBranchCheck() here
  // DV why is vars not used anywhere?
  /*utl::SymbolTable vars;
  for (const auto &v : GetListOfVariables())
    vars[v] = 0;*/
  func = Function(GetDataString(), GetListOfVariables());
}


void
Branch::GetData(vector<TimeStamp>& vt)
  const
{
  // don't ZeroBranchCheck() here

  const string dataString = GetDataString();
  istringstream iss(dataString);
  string word;
  while (iss >> word)
    vt.push_back(boost::lexical_cast<UTCDateTime>(word).GetTimeStamp());
}


Branch
Branch::Clone()
  const
{
  // no need for ZeroBranchCheck()

  if (fDOMNode) {
    const ReaderStringInput readerInput(String());
    const Reader r(readerInput);
    return r.GetTopBranch();
  }
  return Branch();
}


string
Branch::String()
  const
{
  // this method does the same thing as GetDataString() but in a different way
  // we should consider removing duplicate functionalities.

  ZeroBranchCheck();

  DOMImplementationLS* const impl =
    DOMImplementationRegistry::getDOMImplementation(
      XercesPtrX(XMLString::transcode("LS")).Get()
    );
#ifdef HAVE_XERCES3
  XercesPtr<DOMLSSerializer> serializer(impl->createLSSerializer());
  XercesPtrC dom(XMLString::transcode(serializer->writeToString(fDOMNode)));
  const string res(dom.Get());
  return res;
#else
  XercesPtr<DOMWriter> writer(impl->createDOMWriter());
  MemBufFormatTarget memForm;
  writer->writeNode(&memForm, *fDOMNode);
  return string((const char*)memForm.getRawBuffer());
#endif
}


void
Branch::GetData(utl::TabulatedFunction& tf)
  const
{
  const vector<double> x = GetChild("x").Get<vector<double>>();
  vector<double> y = GetChild("y").Get<vector<double>>();
  Branch scaleYB = GetChild("scaleY");
  if (scaleYB) {
    const double s = scaleYB.Get<double>();
    transform(y.begin(), y.end(), y.begin(), [&s](const auto& elem) { return elem * s; });
  }
  tf.Clear();
  for (unsigned int i = 0, n = x.size(); i < n; ++i)
    tf.PushBack(x[i], y[i]);
}


#define UTL_BRANCH_GETDATA_WITH_CAST_ONLY(_Type_...) \
void                                                 \
Branch::GetData(_Type_& t)                           \
  const                                              \
{                                                    \
  CastData(t);                                       \
}

UTL_BRANCH_GETDATA_WITH_CAST_ONLY(bool)
UTL_BRANCH_GETDATA_WITH_CAST_ONLY(vector<bool>)
UTL_BRANCH_GETDATA_WITH_CAST_ONLY(list<bool>)
UTL_BRANCH_GETDATA_WITH_CAST_ONLY(vector<string>)
UTL_BRANCH_GETDATA_WITH_CAST_ONLY(list<string>)

#undef UTL_BRANCH_GETDATA_WITH_CAST_ONLY