RegisterPropertiesFactory.cpp

Go to the documentation of this file.

#include "robot_instance/RegisterPropertiesFactory.h"

using namespace std;
using namespace log4cpp;

RegisterPropertiesFactory::RegisterPropertiesFactory()
{
}

RegisterPropertiesFactory::~RegisterPropertiesFactory()
{
}

RegisterPropertiesPtr RegisterPropertiesFactory::fromXml(const std::string& xml)
{
    TiXmlDocument file;
    file.Parse(xml.c_str());
    TiXmlHandle doc(&file);
    TiXmlHandle registerHandle(doc.FirstChild("Register"));

    RegisterPropertiesPtr registerProperties = boost::make_shared<RegisterProperties>();

    if (registerHandle.ToElement())
    {
        if (registerHandle.ToElement()->Attribute("type"))
        {
            if (string(registerHandle.ToElement()->Attribute("type")) == string("Control"))
            {
                registerProperties->isWritable = true;
            }
        }

        // Check for Certificate
        TiXmlHandle certificateElement(registerHandle.FirstChildElement("Certificate"));

        if (certificateElement.ToElement())
        {
            if (certificateElement.ToElement()->Attribute("value"))
            {
                uint16_t value;
                stringstream ss;
                ss << std::hex << certificateElement.ToElement()->Attribute("value");
                ss >> value;
                registerProperties->REGISTER_CERTIFICATE_VALUE = value;
            }
            else
            {
                registerProperties->REGISTER_CERTIFICATE_VALUE = 0;
                NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::WARN, "No certificate value found, using default of [0x0000].");
            }

            if (certificateElement.ToElement()->Attribute("mask"))
            {
                uint16_t mask;
                stringstream ss;
                ss << std::hex << certificateElement.ToElement()->Attribute("mask");
                ss >> mask;
                registerProperties->REGISTER_CERTIFICATE_MASK = mask;
            }
            else
            {
                registerProperties->REGISTER_CERTIFICATE_MASK = 0;
                NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::WARN, "No certificate mask found, using default of [0x0000].");
            }
        }
        else
        {
            registerProperties->REGISTER_CERTIFICATE_VALUE = 0;
            registerProperties->REGISTER_CERTIFICATE_MASK = 0;
            NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::WARN, "The element [Certificate] was not found, using defaults for value and mask [0x0000].");
        }

        NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.RegisterPropertiesFactory") << Priority::INFO << "Register property [REGISTER_CERTIFICATE_VALUE]: 0x" << std::hex << registerProperties->REGISTER_CERTIFICATE_VALUE;
        NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.RegisterPropertiesFactory") << Priority::INFO << "Register property [REGISTER_CERTIFICATE_MASK]: 0x" << std::hex << registerProperties->REGISTER_CERTIFICATE_MASK;

        // Check for Entries
        TiXmlHandle entriesElement(registerHandle.FirstChildElement("Entries"));

        if (certificateElement.ToElement())
        {
            TiXmlHandle currentEntryElement = 0;

            currentEntryElement = entriesElement.FirstChild("Entry");

            while (currentEntryElement.ToElement())
            {
                string id("");
                string description("");
                BitMinion::BitIndexEnumType index = BitMinion::BIT_ZERO_INDEX;
                BitMinion::BitCountMaskEnumType size = BitMinion::ONE_BIT_MASK;

                if (currentEntryElement.ToElement()->Attribute("id"))
                {
                    id = currentEntryElement.ToElement()->Attribute("id");

                    if (id.length() == 0)
                    {
                        NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::ERROR, "The attribute [id] is malformed.");
                        MissingXMLElementException missingXMLElementException;
                        throw missingXMLElementException;
                    }
                }
                else
                {
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::ERROR, "The attribute [id] was not found for element [Entry].");
                    MissingXMLElementException missingXMLElementException;
                    throw missingXMLElementException;
                }

                NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::DEBUG, "Attribute [id] parsed.");

                if (currentEntryElement.ToElement()->Attribute("index"))
                {
                    try
                    {
                        index = (BitMinion::BitIndexEnumType)boost::lexical_cast<unsigned int>(currentEntryElement.ToElement()->Attribute("index"));
                    }
                    catch (boost::bad_lexical_cast)
                    {
                        NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::ERROR, "The attribute [index] is malformed.");
                        MissingXMLElementException missingXMLElementException;
                        throw missingXMLElementException;
                    }
                }
                else
                {
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::ERROR, "The attribute [index] was not found for element [Entry].");
                    MissingXMLElementException missingXMLElementException;
                    throw missingXMLElementException;
                }

                NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::DEBUG, "Attribute [index] parsed.");

                if (currentEntryElement.ToElement()->Attribute("size"))
                {
                    try
                    {
                        size = (BitMinion::BitCountMaskEnumType)((1 << boost::lexical_cast<unsigned int>(currentEntryElement.ToElement()->Attribute("size"))) - 1);
                    }
                    catch (boost::bad_lexical_cast)
                    {
                        NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::ERROR, "The attribute [size] is malformed.");
                        MissingXMLElementException missingXMLElementException;
                        throw missingXMLElementException;
                    }
                }
                else
                {
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::ERROR, "The attribute [size] was not found for element [Entry].");
                    MissingXMLElementException missingXMLElementException;
                    throw missingXMLElementException;
                }

                NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::DEBUG, "Attribute [size] parsed.");

                TiXmlHandle descriptionElement(currentEntryElement.FirstChildElement("Description"));

                if (descriptionElement.ToElement())
                {
                    if (descriptionElement.ToElement()->GetText())
                    {
                        description = descriptionElement.ToElement()->GetText();
                    }
                }
                else
                {
                    NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::WARN, "The element [Description] was not found, using default of [\"\"].");
                }

                NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::DEBUG, "Attribute [description] parsed.");

                registerProperties->registerProperty[id] = PropertyDef(id, description, index, size);

                NasaCommonLogging::Logger::getCategory("gov.nasa.robonet.RegisterPropertiesFactory") << Priority::INFO << "Register property [" << id << "]: index=" << index << " size=" << size << " desc=\"" << description << "\"";

                currentEntryElement = currentEntryElement.ToElement()->NextSiblingElement("Entry");
            }

            NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::INFO, "Property map is populated.");

            for (PropertyDefMap::iterator it = registerProperties->registerProperty.begin(); it != registerProperties->registerProperty.end(); it++)
            {
                registerProperties->registerPropertyVector.push_back(&(it->second));
            }

            sort(registerProperties->registerPropertyVector.begin(), registerProperties->registerPropertyVector.end(), RegisterProperties::comparePropertyDefPointers());

            NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::INFO, "Property map vector is populated and sorted.");
        }

        return registerProperties;
    }
    else
    {
        NasaCommonLogging::Logger::log("gov.nasa.robonet.RegisterPropertiesFactory", Priority::ERROR, "The element [Register] was not found.");
        MissingXMLElementException missingXMLElementException;
        throw missingXMLElementException;
    }
}