DataElementFactory.h

Go to the documentation of this file.

#ifndef DATAELEMENTFACTORY_H_
#define DATAELEMENTFACTORY_H_

#include "robot_instance/RobonetDataElement.h"
#include "robot_instance/StringUtilities.h"
#include "robot_instance/XmlParserExceptions.h"
#include "nasa_common_logging/Logger.h"
#include "tinyxml.h"
#include <string>
#include <sstream>
#include <utility>
#include <vector>
#include <stdexcept>
#include "shared_memory_transport/smtclient.hpp"

// Exceptions ----------------------------------------------------------

class InvalidDataElementTypeException: public std::exception
{
    virtual const char* what() const throw()
    {
        return "Cannot call DataElementFactory methods for DataElement type T when T does not equal RobonetDataElement.  A specialization of this method needs to be added to DataElementFactory.cpp to support your DataElement type.";
    }
};

template <typename T>
class DataElementFactory
{
    std::shared_ptr<SMT::SMTClient> smtclient;
public:
    DataElementFactory(std::shared_ptr<SMT::SMTClient> client = nullptr):
        smtclient(client) {};
    virtual ~DataElementFactory() {};

    std::pair< std::string, boost::shared_ptr<T> > fromXml(const std::string& elementName, const std::string& robonetNode, const std::string& xml)
    {
        InvalidDataElementTypeException invalidDataElementTypeException;
        throw invalidDataElementTypeException;
    }

    std::pair< std::string, boost::shared_ptr<T> > stringsToDataElement(const std::string& name, const std::string& type, const std::string& direction, const std::string& channel, const std::string& node, const std::string& offset1, const std::string& offset2, const std::string& group, const std::string& style)
    {
        InvalidDataElementTypeException invalidDataElementTypeException;
        throw invalidDataElementTypeException;
    }
};

template <>
class DataElementFactory<RobonetDataElement>
{
    std::shared_ptr<SMT::SMTClient> smtclient;
public:
    DataElementFactory(std::shared_ptr<SMT::SMTClient> client = nullptr):
        smtclient(client) {};
    virtual ~DataElementFactory() {};

    std::pair< std::string, RobonetDataElementPtr > fromXml(const std::string& elementName, const std::string& robonetNode, const std::string& xml)
    {
        TiXmlDocument file;
        file.Parse(xml.c_str());

        TiXmlHandle doc(&file);

        RobonetDataElementPtr dataElement;
        std::string str;
        std::string name;
        std::string type;
        std::string channel;
        std::string node;
        std::string offset1;
        std::string offset2;
        DataElement::ReadWrite direction = DataElement::Read;
        std::string group;
        RobonetDataElement::ElementStyle style = RobonetDataElement::Normal;
        // For SMT stuff later
        std::stringstream err;
        std::string smttype;

        TiXmlHandle elementHandle(doc.FirstChild("Element"));

        if (elementHandle.ToElement())
        {
            if (elementHandle.ToElement()->Attribute("id"))
            {
                if (robonetNode.size() <= 0)
                {
                    std::stringstream err;
                    err << "The robonetNode parameter is required.";
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                    throw std::runtime_error(err.str());
                }

                if (elementName.size() > 0)
                {
                    name = StringUtilities::makeFullyQualifiedRoboDynElement(elementName, elementHandle.ToElement()->Attribute("id"));
                }
                else
                {
                    std::stringstream err;
                    err << "The elementName parameter is required.";
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                    throw std::runtime_error(err.str());
                }
            }
            else
            {
                std::stringstream err;
                err << "The attribute [id] was not found for element [" << elementHandle.ToElement()->ValueStr() << "]";
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                //throw runtime_error(err.str());
                MissingXMLElementException missingXMLElementException;
                throw missingXMLElementException;
            }

            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "Element name: " << name;

            if (elementHandle.ToElement()->Attribute("type"))
            {
                type = elementHandle.ToElement()->Attribute("type");
            }
            else
            {
                std::stringstream err;
                err << "The attribute [type] was not found for element [" << elementHandle.ToElement()->ValueStr() << "]";
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                //throw runtime_error(err.str());
                MissingXMLElementException missingXMLElementException;
                throw missingXMLElementException;
            }

            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        type: " << type;

            if (elementHandle.ToElement()->Attribute("direction"))
            {
                str = elementHandle.ToElement()->Attribute("direction");

                if ( str.compare("Read") == 0 )
                {
                    direction = DataElement::Read;
                }
                else if ( str.compare("Write") == 0 )
                {
                    direction = DataElement::Write;
                }
                else
                {
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, "DataElementFactory::xmlToDataElement() - Direction must be either Read or Write, not '" + str + "'");
                    MissingXMLElementException missingXMLElementException;
                    throw missingXMLElementException;
                }
            }
            else
            {
                std::stringstream err;
                err << "The attribute [direction] was not found for element [" << elementHandle.ToElement()->ValueStr() << "]";
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                //throw runtime_error(err.str());
                MissingXMLElementException missingXMLElementException;
                throw missingXMLElementException;
            }

            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        direction: " << str;

            channel = StringUtilities::getRobonetChannel(robonetNode);
            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        channel: " << channel;

            node = StringUtilities::getRobonetNode(robonetNode);
            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        node: " << node;

            if (elementHandle.ToElement()->Attribute("offset1"))
            {
                offset1 = elementHandle.ToElement()->Attribute("offset1");
            }
            else
            {
                std::stringstream err;
                err << "The attribute [offset1] was not found for element [" << elementHandle.ToElement()->ValueStr() << "]";
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                //throw runtime_error(err.str());
                MissingXMLElementException missingXMLElementException;
                throw missingXMLElementException;
            }

            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        offset1: " << offset1;

            if (elementHandle.ToElement()->Attribute("offset2"))
            {
                offset2 = elementHandle.ToElement()->Attribute("offset2");
            }

            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        offset2: " << offset2;

            if (elementHandle.ToElement()->Attribute("group"))
            {
                group = elementHandle.ToElement()->Attribute("group");
            }
            else
            {
                std::stringstream err;
                err << "The attribute [group] was not found for element [" << elementHandle.ToElement()->ValueStr() << "]";
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                //throw runtime_error(err.str());
                MissingXMLElementException missingXMLElementException;
                throw missingXMLElementException;
            }

            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        group: " << group;

            if (elementHandle.ToElement()->Attribute("style"))
            {
                str = elementHandle.ToElement()->Attribute("style");

                if ( str.compare("Normal") == 0 )
                {
                    style = RobonetDataElement::Normal;
                }
                else if ( str.compare("MotCom") == 0 )
                {
                    style = RobonetDataElement::MotCom;
                }
                else if ( str.compare("Temperature") == 0 )
                {
                    style = RobonetDataElement::Temperature;
                }
                else if ( str.compare("BrakePwm") == 0 )
                {
                    style = RobonetDataElement::BrakePwm;
                }
                else if ( str.compare("FixedPointMilli") == 0 )
                {
                    style = RobonetDataElement::FixedPointMilli;
                }
                else if ( str.compare("UnsignedFixedPointMilli") == 0 )
                {
                    style = RobonetDataElement::UnsignedFixedPointMilli;
                }
                else if ( str.compare("FixedPointCenti") == 0 )
                {
                    style = RobonetDataElement::FixedPointCenti;
                }
                else if ( str.compare("UnsignedFixedPointCenti") == 0 )
                {
                    style = RobonetDataElement::UnsignedFixedPointCenti;
                }
                else if ( str.compare("PowConTemperature") == 0 )
                {
                    style = RobonetDataElement::PowConTemperature;
                }
                else if ( str.compare("PowConCurrentMany") == 0 )
                {
                    style = RobonetDataElement::PowConCurrentMany;
                }
                else if ( str.compare("PowConVoltageMany") == 0 )
                {
                    style = RobonetDataElement::PowConVoltageMany;
                }
                else
                {
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, "DataElementFactory::xmlToDataElement() - Style must be either Normal, MotCom, Temperature or BrakePwm, not '" + str + "'");
                    MissingXMLElementException missingXMLElementException;
                    throw missingXMLElementException;
                }
            }
            else
            {
                std::stringstream err;
                err << "The attribute [style] was not found for element [" << elementHandle.ToElement()->ValueStr() << "]";
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
                //throw runtime_error(err.str());
                MissingXMLElementException missingXMLElementException;
                throw missingXMLElementException;
            }

            NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.DataElementFactory") << log4cpp::Priority::INFO << "        style: " << str;
        }
        else
        {
            std::stringstream err;
            err << "The element [Element] was not found.";
            NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::ERROR, err.str());
            //throw runtime_error(err.str());
            MissingXMLElementException missingXMLElementException;
            throw missingXMLElementException;
        }

        // Only attempt to add to SMT if the client exists
        if ( smtclient ) {
            try {
                // Suffix _t not used in SMT, eliminate it if it exists:
                smttype = type.substr(0, type.rfind("_t"));
                // SMT has different float types as well...
                if ( !smttype.compare("float") ){
                    smttype = "float32";
                }
                if ( !smttype.compare("double") ){
                    smttype = "float64";
                }
                // Use uint8 for booleans, since that should be used under the hood.
                if ( !smttype.compare("bool") ){
                    smttype = "uint8";
                }
                // Attempt to create an SMT ressource. Linux = big-endian.
                auto resource = std::make_shared<SMT::Resource>( smtclient->createResource(name, smttype, 0, 0, "big", "") );
                // Use the resource in creating the RDE:
                dataElement.reset(new RobonetDataElement(type, direction, channel, node, RobonetDataElement::OffsetPair(offset1, offset2), group, style, resource));
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::DEBUG, "Added RDE `" + name + "` with SMT::Resource");
            }
            catch (const SMT::SMTException e) {
                // Either the resource couldn't be created, or it already existed?
                // So says the Python API at least...
                // This isn't a failure... yet, so just log:
                err << "DataElementFactory::xmlToDataElement() - Problem creating SMT Resource `" << name << "`: ";
                err << e.what();
                NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::DEBUG, err.str());
                // Create RDE as normal without the SMT Resource (for now)
                dataElement.reset(new RobonetDataElement(type, direction, channel, node, RobonetDataElement::OffsetPair(offset1, offset2), group, style));
            }
        } else {
            // Since we're deprecating non SMT stuff, we'll log a warning.
            NasaCommonLogging::Logger::log("gov.nasa.robonet.DataElementFactory", log4cpp::Priority::WARN, "DataElementFactory::xmlToDataElement() - SMTClient not specified. Not using SMT for now. This will be DEPRECATED soon.");
            // Create RDE as normal without the SMT Resource (for now)
            dataElement.reset(new RobonetDataElement(type, direction, channel, node, RobonetDataElement::OffsetPair(offset1, offset2), group, style));
        }

        return std::make_pair(name, dataElement);
    }

};

#endif /* DATAELEMENTFACTORY_H_ */