XmlHelper.h

Go to the documentation of this file.

 
#ifndef PANDORA_XML_HELPER_H
#define PANDORA_XML_HELPER_H 1
 
#include "Objects/CartesianVector.h"
#include "Objects/TrackState.h"
 
#include "Pandora/PandoraInternal.h"
#include "Pandora/StatusCodes.h"
 
#include "Xml/tinyxml.h"
 
namespace pandora
{
 
class XmlHelper
{
public:
    template <typename T>
    static StatusCode ReadValue(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, T &t);
 
    template <typename T>
    static StatusCode ReadVectorOfValues(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, std::vector<T> &vector);
 
    template <typename T>
    static StatusCode Read2DVectorOfValues(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, const std::string &rowName,
        std::vector< std::vector<T> > &vector);
 
    static StatusCode ProcessAlgorithm(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, const std::string &description,
        std::string &algorithmName);
 
    static StatusCode ProcessFirstAlgorithm(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, std::string &algorithmName);
 
    static StatusCode ProcessAlgorithmList(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, const std::string &listName,
        StringVector &algorithmNames);
 
    static StatusCode ProcessAlgorithmTool(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, const std::string &description,
        AlgorithmTool *&pAlgorithmTool);
 
    static StatusCode ProcessFirstAlgorithmTool(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, AlgorithmTool *&pAlgorithmTool);
 
    static StatusCode ProcessAlgorithmToolList(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, const std::string &listName,
        AlgorithmToolVector &algorithmToolVector);
 
    static void TokenizeString(const std::string &inputString, StringVector &tokens, const std::string &delimiter = " ");
};
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline StatusCode XmlHelper::ReadValue(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, T &t)
{
    const TiXmlElement *const pXmlElement = xmlHandle.FirstChild(xmlElementName).Element();
 
    if (!pXmlElement)
        return STATUS_CODE_NOT_FOUND;
 
    if (!StringToType(pXmlElement->GetText(), t))
        return STATUS_CODE_FAILURE;
 
    return STATUS_CODE_SUCCESS;
}
 
template <>
inline StatusCode XmlHelper::ReadValue<CartesianVector>(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, CartesianVector &t)
{
    const TiXmlElement *const pXmlElement = xmlHandle.FirstChild(xmlElementName).Element();
 
    if (!pXmlElement)
        return STATUS_CODE_NOT_FOUND;
 
    StringVector tokens;
    TokenizeString(pXmlElement->GetText(), tokens);
 
    if (tokens.size() != 3)
        return STATUS_CODE_FAILURE;
 
    float x(0.f), y(0.f), z(0.f);
 
    if (!StringToType(tokens[0], x) || !StringToType(tokens[1], y) || !StringToType(tokens[2], z))
        return STATUS_CODE_FAILURE;
 
    t = CartesianVector(x, y, z);
 
    return STATUS_CODE_SUCCESS;
}
 
template <>
inline StatusCode XmlHelper::ReadValue<TrackState>(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, TrackState &t)
{
    const TiXmlElement *const pXmlElement = xmlHandle.FirstChild(xmlElementName).Element();
 
    if (!pXmlElement)
        return STATUS_CODE_NOT_FOUND;
 
    StringVector tokens;
    TokenizeString(pXmlElement->GetText(), tokens);
 
    if (tokens.size() != 6)
        return STATUS_CODE_FAILURE;
 
    float x(0.f), y(0.f), z(0.f), px(0.f), py(0.f), pz(0.f);
 
    if (!StringToType(tokens[0], x) || !StringToType(tokens[1], y) || !StringToType(tokens[2], z) ||
        !StringToType(tokens[3], px) || !StringToType(tokens[4], py) || !StringToType(tokens[5], pz))
    {
        return STATUS_CODE_FAILURE;
    }
 
    t = TrackState(x, y, z, px, py, pz);
 
    return STATUS_CODE_SUCCESS;
}
 
template <>
inline StatusCode XmlHelper::ReadValue<bool>(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, bool &t)
{
    const TiXmlElement *const pXmlElement = xmlHandle.FirstChild(xmlElementName).Element();
 
    if (!pXmlElement)
        return STATUS_CODE_NOT_FOUND;
 
    const std::string xmlElementString = pXmlElement->GetText();
 
    if ((xmlElementString == "1") || (xmlElementString == "true"))
    {
        t = true;
    }
    else if ((xmlElementString == "0") || (xmlElementString == "false"))
    {
        t = false;
    }
    else
    {
        return STATUS_CODE_FAILURE;
    }
 
    return STATUS_CODE_SUCCESS;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline StatusCode XmlHelper::ReadVectorOfValues(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, std::vector<T> &vector)
{
    const TiXmlElement *const pXmlElement = xmlHandle.FirstChild(xmlElementName).Element();
 
    if (!pXmlElement)
        return STATUS_CODE_NOT_FOUND;
 
    StringVector tokens;
    TokenizeString(pXmlElement->GetText(), tokens);
 
    for (const std::string &token : tokens)
    {
        T t;
 
        if (!StringToType(token, t))
            return STATUS_CODE_FAILURE;
 
        vector.push_back(t);
    }
 
    return STATUS_CODE_SUCCESS;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
template <typename T>
inline StatusCode XmlHelper::Read2DVectorOfValues(const TiXmlHandle &xmlHandle, const std::string &xmlElementName, const std::string &rowName,
    std::vector< std::vector<T> > &vector)
{
    TiXmlElement *const pXmlElement = xmlHandle.FirstChild(xmlElementName).Element();
 
    if (!pXmlElement)
        return STATUS_CODE_NOT_FOUND;
 
    TiXmlElement *pXmlRowElement = TiXmlHandle(pXmlElement).FirstChild(rowName).Element();
 
    if (!pXmlRowElement)
        return STATUS_CODE_NOT_FOUND;
 
    for ( ; nullptr != pXmlRowElement; pXmlRowElement = pXmlRowElement->NextSiblingElement(rowName))
    {
        std::vector<T> rowVector;
 
        StringVector tokens;
        TokenizeString(pXmlRowElement->GetText(), tokens);
 
        for (const std::string &token : tokens)
        {
            T t;
 
            if (!StringToType(token, t))
                return STATUS_CODE_FAILURE;
 
            rowVector.push_back(t);
        }
 
        vector.push_back(rowVector);
    }
 
    return STATUS_CODE_SUCCESS;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline StatusCode XmlHelper::ProcessFirstAlgorithm(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, std::string &algorithmName)
{
    const std::string emptyDescription;
    return XmlHelper::ProcessAlgorithm(algorithm, xmlHandle, emptyDescription, algorithmName);
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
inline StatusCode XmlHelper::ProcessFirstAlgorithmTool(const Algorithm &algorithm, const TiXmlHandle &xmlHandle, AlgorithmTool *&pAlgorithmTool)
{
    const std::string emptyDescription;
    return XmlHelper::ProcessAlgorithmTool(algorithm, xmlHandle, emptyDescription, pAlgorithmTool);
}
 
} // namespace pandora
 
#endif // #ifndef PANDORA_XML_HELPER_H