CDIUtils.hxx

Go to the documentation of this file.

 
#ifndef _OPENLCB_CDIUTILS_HXX_
#define _OPENLCB_CDIUTILS_HXX_
 
#include "sxmlc.h"
 
namespace openlcb
{
 
class CDIUtils
{
public:
    struct XMLDocDeleter
    {
        void operator()(XMLDoc *doc)
        {
            if (!doc)
                return;
            cleanup_doc(doc);
            XMLDoc_free(doc);
            delete doc;
        }
    };
 
    typedef std::unique_ptr<XMLDoc, XMLDocDeleter> xmldoc_ptr_t;
 
    struct SXmlStringDeleter
    {
        void operator()(const SXML_CHAR *data)
        {
            free(const_cast<SXML_CHAR *>(data));
        }
    };
    typedef std::unique_ptr<const SXML_CHAR, SXmlStringDeleter> xmlstring_t;
 
    static XMLNode *find_child_or_null(const XMLNode *parent, const char *tag)
    {
        auto count = XMLNode_get_children_count(parent);
        for (int i = 0; i < count; ++i)
        {
            auto *c = XMLNode_get_child(parent, i);
            if (strcmp(tag, c->tag) == 0)
                return c;
        }
        return nullptr;
    }
 
    static string find_node_name(const XMLNode *node, const char *def)
    {
        auto *n = find_child_or_null(node, "name");
        if (n == nullptr || n->text == nullptr)
            return def;
        return n->text;
    }
 
    static string find_node_description(const XMLNode *node)
    {
        auto *n = find_child_or_null(node, "description");
        if (n == nullptr || n->text == nullptr)
            return "";
        return n->text;
    }
 
    // this is a helper function that checks to see if the passed node has an 
    // element named by *tag in it. Sets the bool found to true or false
    // accordingly and also returns a nullptr (if element is undefined)
    // otherwise it will return the value of the element
    static int find_numeric_element(
        const XMLNode *parent, const char *tag, bool *found)
    {
        auto *n = find_child_or_null(parent, tag);
        // if there is no element defined set bool to false, return any value
        if (n == nullptr || n->text == nullptr){
            *found = false;
            return 0;// there is no defined element
        }
        // if the numeric element was found set the bool to true and return it
        *found = true;
        return atoi(n->text); // convert to int and return element value
    }
 
    static int find_node_min(const XMLNode *node, bool *found)
    {
        return find_numeric_element(node, "min", found);
    }
 
    static int find_node_max(const XMLNode *node, bool *found)
    {
        return find_numeric_element(node, "max", found);
    }
 
    static int find_node_default(const XMLNode *node, bool *found)
    {
        return find_numeric_element(node, "default", found);
    }
    
    static void prepare_doc(XMLDoc *doc)
    {
        auto *node = XMLDoc_root(doc);
        while (node)
        {
            node->user = nullptr;
            node = XMLNode_next(node);
        }
    }
 
    static void cleanup_doc(XMLDoc *doc)
    {
        auto *node = XMLDoc_root(doc);
        while (node)
        {
            free(node->user);
            node->user = nullptr;
            node = XMLNode_next(node);
        }
    }
 
    template <class T, typename... Args>
    static void new_userinfo(T **info, XMLNode *node, Args &&... args)
    {
        HASSERT(node->user == nullptr);
        static_assert(std::is_trivially_destructible<T>::value == true,
            "Userdata attached to nodes must be trivially destructible");
        *info = static_cast<T *>(malloc(sizeof(T)));
        new (*info) T(std::forward<Args>(args)...);
        node->user = *info;
    }
 
    template <class T> static void get_userinfo(T **info, const XMLNode *node)
    {
        HASSERT(node);
        *info = static_cast<T *>(node->user);
    }
 
    struct NodeInfo
    {
        int offset_from_parent = 0;
        int size = 0;
    };
 
    static int get_numeric_attribute(
        const XMLNode *node, const char *attr_name, int def = 0)
    {
        const SXML_CHAR *attr_value;
        XMLNode_get_attribute_with_default(
            const_cast<XMLNode *>(node), attr_name, &attr_value, nullptr);
        xmlstring_t d(attr_value);
        if ((!attr_value) || (attr_value[0] == 0))
        {
            return def;
        }
        return atoi(attr_value);
    }
 
    enum class DataType {
        UNKNOWN = 0,
        GROUP,
        INT,
        FLOAT,
        STRING,
        EVENTID
    };
 
    static DataType get_type_from_node(XMLNode *child)
    {
        if (strcmp(child->tag, "group") == 0)
        {
            return DataType::GROUP;
        }
        if (strcmp(child->tag, "int") == 0)
        {
            return DataType::INT;
        }
        if (strcmp(child->tag, "eventid") == 0)
        {
            return DataType::EVENTID;
        }
        if (strcmp(child->tag, "string") == 0)
        {
            return DataType::STRING;
        }
        if (strcmp(child->tag, "float") == 0)
        {
            return DataType::FLOAT;
        }
        return DataType::UNKNOWN;
    };
 
    static void layout_segment(XMLNode *segment)
    {
        HASSERT(strcmp(segment->tag, "segment") == 0);
        unsigned current_offset = get_numeric_attribute(segment, "origin");
        NodeInfo *info;
        new_userinfo(&info, segment);
        info->offset_from_parent = current_offset;
        if (XMLNode_get_children_count(segment) == 0)
            return;
        XMLNode *current_parent = segment;
        XMLNode *current_child = XMLNode_get_child(segment, 0);
        NodeInfo *parent_info = info;
        while (true)
        {
            if (strcmp(current_child->tag, "name") == 0 ||
                strcmp(current_child->tag, "description") == 0 ||
                strcmp(current_child->tag, "repname") == 0)
            {
                // Do nothing, not a data element
            }
            else
            {
                new_userinfo(&info, current_child);
                parent_info->size +=
                    get_numeric_attribute(current_child, "offset", 0);
                info->offset_from_parent = parent_info->size;
                auto type = get_type_from_node(current_child);
                switch (type)
                {
                    case DataType::UNKNOWN:
                        // Probably should not get here.
                        break;
                    case DataType::EVENTID:
                        info->size = 8;
                        break;
                    case DataType::STRING:
                    case DataType::INT:
                    case DataType::FLOAT:
                        info->size =
                            get_numeric_attribute(current_child, "size", 1);
                        break;
                    case DataType::GROUP:
                        if (XMLNode_get_children_count(current_child) > 0)
                        {
                            current_parent = current_child;
                            current_child =
                                XMLNode_get_child(current_parent, 0);
                            get_userinfo(&parent_info, current_parent);
                            continue;
                        }
                        // an empty group has size == 0 and we don't need to do
                        // anything here.
                        break;
                }
                parent_info->size += info->size;
            }
 
            // Move to next child.
            while ((current_child = XMLNode_next_sibling(current_child)) ==
                nullptr)
            {
                // End of children; must go up.
                if (current_parent == segment)
                {
                    // nowhere to go up
                    break;
                }
                current_child = current_parent;
                current_parent = current_child->father;
                // handle groups with repetitions
                get_userinfo(&info, current_child);
                get_userinfo(&parent_info, current_parent);
                int repcount = get_replication(current_child);
                info->size *= repcount;
                parent_info->size += info->size;
            }
            if (current_parent == segment && current_child == nullptr)
            {
                // end of iteration
                break;
            }
        }
    }
 
    static int get_replication(const XMLNode *group)
    {
        HASSERT(strcmp(group->tag, "group") == 0);
        return get_numeric_attribute(group, "replication", 1);
    }
 
    struct CDINodeRep
    {
        const XMLNode *node_;
        unsigned address_;
 
        CDINodeRep()
            : node_(nullptr)
            , address_(0)
        {
        }
 
        CDINodeRep(const XMLNode *node, std::nullptr_t)
            : node_(node)
            , address_(0)
        {
        }
 
        CDINodeRep(const XMLNode *segment)
        {
            NodeInfo *info;
            get_userinfo(&info, segment);
            HASSERT(info);
            node_ = segment;
            address_ = info->offset_from_parent;
        }
 
        CDINodeRep(const CDINodeRep *parent, const XMLNode *child)
        {
            HASSERT(child->father == parent->node_);
            node_ = child;
            if (strcmp(child->tag, "group") == 0)
            {
                HASSERT(get_replication(child) == 1);
            }
            address_ = parent->get_child_address(child);
        }
 
        CDINodeRep(const CDINodeRep *parent, const XMLNode *group, unsigned replica)
        {
            HASSERT(group->father == parent->node_);
            node_ = group;
            int replication = get_replication(group);
            HASSERT(replication > 1);
            NodeInfo *info;
            get_userinfo(&info, group);
            HASSERT(info);
            unsigned base_address = parent->get_child_address(group);
            unsigned stride = info->size / replication;
            address_ = base_address + stride * replica;
        }
 
        template <typename... Args> void reset(Args &&... args)
        {
            new (this) CDINodeRep(std::forward<Args>(args)...);
        }
 
        unsigned get_child_address(const XMLNode *child) const
        {
            HASSERT(child->father == node_);
            NodeInfo *info;
            get_userinfo(&info, child);
            HASSERT(info);
            return address_ + info->offset_from_parent;
        }
 
        unsigned get_child_size(const XMLNode *child) const
        {
            HASSERT(child->father == node_);
            NodeInfo *info;
            get_userinfo(&info, child);
            HASSERT(info);
            return info->size;
        }
    };
 
private:
    CDIUtils();
};
 
} // namespace openlcb
 
#endif // _OPENLCB_CDIUTILS_HXX_