initial commit for github

2019-12-12 14:41:47 +01:00 · 2019-12-12 14:41:47 +01:00 · 60968612de
commit 60968612de
370 changed files with 68427 additions and 0 deletions
--- a/ddlrepresentation/ddlresolver.cpp
+++ b/ddlrepresentation/ddlresolver.cpp
@ -0,0 +1,571 @@
+/**
+ * @file
+ *
+ * @copyright
+ * @verbatim
+   Copyright @ 2017 Audi Electronics Venture GmbH. All rights reserved.
+
+       This Source Code Form is subject to the terms of the Mozilla
+       Public License, v. 2.0. If a copy of the MPL was not distributed
+       with this file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+   If it is not possible or desirable to put the notice in a particular file, then
+   You may include the notice in a location (such as a LICENSE file in a
+   relevant directory) where a recipient would be likely to look for such a notice.
+
+   You may add additional accurate notices of copyright ownership.
+   @endverbatim
+*/
+
+#include "ddlresolver.h"
+
+#include "a_util/result/error_def.h"
+#include "legacy_error_macros.h"
+
+#include "ddldescription.h"
+#include "ddlunit.h"
+#include "ddlbaseunit.h"
+#include "ddlprefix.h"
+#include "ddldatatype.h"
+#include "ddlenum.h"
+#include "ddlcomplex.h"
+#include "ddlstream.h"
+#include "ddlstreammetatype.h"
+#include "ddlheader.h"
+#include "ddlextdeclaration.h"
+#include "ddlrefunit.h"
+#include "ddlelement.h"
+#include "ddlstreamstruct.h"
+
+
+namespace ddl
+{
+    //define all needed error types and values locally
+    _MAKE_RESULT(-4, ERR_POINTER)
+    _MAKE_RESULT(-5, ERR_INVALID_ARG)
+    _MAKE_RESULT(-16, ERR_NOT_IMPL)
+    _MAKE_RESULT(-20, ERR_NOT_FOUND)
+    _MAKE_RESULT(-37, ERR_NOT_INITIALIZED)
+
+    DDLResolver::DDLResolver() :
+        _dom{},
+        _target{},
+        _version(DDLVersion::ddl_version_invalid),
+        _stack_parents{},
+        _resolved_types{},
+        _units{},
+        _data_types{},
+        _enums{},
+        _structs{},
+        _streams{}
+    {
+#if defined(WIN32) && _MSC_VER < 1900
+        _set_output_format(_TWO_DIGIT_EXPONENT);
+#endif // WIN32
+    }
+
+    DDLResolver::DDLResolver(const std::string& strTarget) :
+        DDLResolver()
+    {
+        _target = strTarget;
+    }
+
+    a_util::result::Result DDLResolver::createBase(const DDLDescription* poDescription)
+    {
+        _resolved_types.clear();
+        _dom.fromString("<?xml version=\"1.0\" encoding=\"iso-8859-1\" standalone=\"no\"?>\n \
+                          <adtf:ddl xmlns:adtf=\"adtf\"> \n \
+                          </adtf:ddl>");
+        RETURN_IF_FAILED(poDescription->getHeader()->accept(this));
+
+        _units = _dom.getRoot().createChild("units");
+        _data_types = _dom.getRoot().createChild("datatypes");
+        if (_version >= DDLVersion::ddl_version_20)
+        {
+            _enums = _dom.getRoot().createChild("enums");
+        }
+        _structs = _dom.getRoot().createChild("structs");
+        _streams = _dom.getRoot().createChild("streams");
+
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visitDDL(const DDLDescription* poDescription)
+    {
+        if (!poDescription) { return ERR_POINTER; }
+        if (_target.empty())
+        {
+            // no target specified
+            return ERR_NOT_INITIALIZED;
+        }
+
+        RETURN_IF_FAILED(createBase(poDescription));
+
+        a_util::result::Result nResult = ERR_NOT_FOUND;
+
+        DDLUnitVec vecDDLUnits = poDescription->getUnits();
+        DDLUnitIt itUnitFound = std::find_if(vecDDLUnits.begin(), vecDDLUnits.end(),
+                                              DDLCompareFunctor<>(_target));
+
+        if (vecDDLUnits.end() != itUnitFound)
+        {
+            nResult = (*itUnitFound)->accept(this);
+            return nResult;
+        }
+
+        DDLDTVec vecDTs = poDescription->getDatatypes();
+        DDLDTIt itDTFound = std::find_if(vecDTs.begin(), vecDTs.end(), DDLCompareFunctor<>(_target));
+
+        if (itDTFound != vecDTs.end())
+        {
+            // primitive data type
+            nResult = (*itDTFound)->accept(this);
+            return nResult;
+        }
+
+        DDLComplexVec vecStructs = poDescription->getStructs();
+        DDLComplexIt itStructFound = std::find_if(vecStructs.begin(),
+                                                   vecStructs.end(), DDLCompareFunctor<>(_target));
+
+        if (itStructFound != vecStructs.end())
+        {
+            // complex data type
+            nResult = (*itStructFound)->accept(this);
+            return nResult;
+        }
+
+        DDLStreamVec vecStreams = poDescription->getStreams();
+        DDLStreamIt itStreamFound = std::find_if(vecStreams.begin(),
+                                                  vecStreams.end(), DDLCompareFunctor<>(_target));
+
+        if (itStreamFound != vecStreams.end())
+        {
+            // stream
+            nResult = (*itStreamFound)->accept(this);
+            return nResult;
+        }
+        return nResult;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLHeader* poHeader)
+    {
+        if (!poHeader) { return ERR_POINTER; }
+        a_util::xml::DOMElement oHeaderElement = _dom.getRoot().createChild("header");
+        a_util::xml::DOMElement oTmpElement;
+        oTmpElement = oHeaderElement.createChild("language_version");
+        _version = poHeader->getLanguageVersion();
+        oTmpElement.setData(_version.toString());
+        oTmpElement = oHeaderElement.createChild("author");
+        oTmpElement.setData(poHeader->getAuthor());
+        // Use current date for creation and change date
+        oTmpElement = oHeaderElement.createChild("date_creation");
+        oTmpElement.setData(poHeader->getDateCreation().format("%d.%m.%Y"));
+        oTmpElement = oHeaderElement.createChild("date_change");
+        oTmpElement.setData(poHeader->getDateChange().format("%d.%m.%Y"));
+        oTmpElement = oHeaderElement.createChild("description");
+        oTmpElement.setData(poHeader->getDescription());
+        DDLExtDeclarationVec vecExtDecls = poHeader->getExtDeclarations();
+        for (DDLExtDeclarationIt itED = vecExtDecls.begin();
+            vecExtDecls.end() != itED; ++itED)
+        {
+            RETURN_IF_FAILED((*itED)->accept(this));
+        }
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLExtDeclaration* poExtDeclaration)
+    {
+        if (!poExtDeclaration) { return ERR_POINTER; }
+        a_util::xml::DOMElement oHeader;
+        if (!_dom.getRoot().findNode("header", oHeader))
+        {
+            return ERR_NOT_FOUND;
+        }
+        a_util::xml::DOMElement oEDElement = oHeader.createChild("ext_declaration");
+        oEDElement.setAttribute("key", poExtDeclaration->getKey());
+        oEDElement.setAttribute("value", poExtDeclaration->getValue());
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLBaseunit* poBaseunit)
+    {
+        if (!poBaseunit) { return ERR_POINTER; }
+        a_util::xml::DOMElement oBUElement;
+        if (_units.findNode(a_util::strings::format("baseunit[@name='%s']",
+            poBaseunit->getName().c_str()), oBUElement))
+        {
+            // this element was already visited
+            return a_util::result::SUCCESS;
+        }
+        oBUElement = _units.createChild("baseunit");
+        oBUElement.setAttribute("name", poBaseunit->getName());
+        oBUElement.setAttribute("symbol", poBaseunit->getSymbol());
+        oBUElement.setAttribute("description", poBaseunit->getDescription());
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLPrefix* poPrefix)
+    {
+        if (!poPrefix) { return ERR_POINTER; }
+        a_util::xml::DOMElement oUnits;
+        a_util::xml::DOMElement oPrefixElement;
+        if (!_dom.getRoot().findNode("units", oUnits))
+        {
+            return ERR_NOT_FOUND;
+        }
+        if (oUnits.findNode(a_util::strings::format("prefixes[@name='%s']",
+            poPrefix->getName().c_str()), oPrefixElement))
+        {
+            // this element was already visited
+            return a_util::result::SUCCESS;
+        }
+        oPrefixElement = oUnits.createChild("prefixes");
+        oPrefixElement.setAttribute("name", poPrefix->getName());
+        oPrefixElement.setAttribute("symbol", poPrefix->getSymbol());
+        oPrefixElement.setAttribute("power",
+            a_util::strings::toString((int32_t)poPrefix->getPower()));
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLUnit* poUnit)
+    {
+        if (!poUnit) { return ERR_POINTER; }
+        a_util::xml::DOMElement oUnitElement;
+        a_util::xml::DOMElement oTmpElement;
+        if (_units.findNode(a_util::strings::format("unit[@name='%s']",
+            poUnit->getName().c_str()), oUnitElement))
+        {
+            // this element was already visited
+            return a_util::result::SUCCESS;
+        }
+        oUnitElement = _units.createChild("unit");
+        oUnitElement.setAttribute("name", poUnit->getName());
+        oTmpElement = oUnitElement.createChild("numerator");
+        oTmpElement.setData(poUnit->getNumerator());
+        oTmpElement = oUnitElement.createChild("denominator");
+        oTmpElement.setData(poUnit->getDenominator());
+        oTmpElement = oUnitElement.createChild("offset");
+        oTmpElement.setData(a_util::strings::toString(static_cast<double>
+            (poUnit->getOffset())));
+        std::vector<DDLRefUnit*> vecDDLRefUnits = poUnit->getRefUnits();
+        _stack_parents.push(oUnitElement);
+        for (size_t i = 0; i < vecDDLRefUnits.size(); i++)
+        {
+            RETURN_IF_FAILED(vecDDLRefUnits[i]->accept(this));
+        }
+        _stack_parents.pop();
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLRefUnit* poRefUnit)
+    {
+        if (!poRefUnit) { return ERR_POINTER; }
+        a_util::xml::DOMElement oRUElement;
+        oRUElement = _stack_parents.top().createChild("refUnit");
+        oRUElement.setAttribute("name", poRefUnit->getName());
+        RETURN_IF_FAILED(poRefUnit->getUnitObject()->accept(this));
+        oRUElement.setAttribute("power",
+            a_util::strings::toString((int32_t)poRefUnit->getPower()));
+        oRUElement.setAttribute("prefix", poRefUnit->getPrefix());
+        return poRefUnit->getPrefixObject()->accept(this);
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLDataType* poDataType)
+    {
+        if (!poDataType) { return ERR_POINTER; }
+        a_util::xml::DOMElement oDTElement;
+        if (_resolved_types.find(poDataType->getName()) != _resolved_types.end())
+        {
+            return a_util::result::SUCCESS;
+        }
+        _resolved_types.insert(poDataType->getName());
+
+        oDTElement = _data_types.createChild("datatype");
+        if (_version <  DDLVersion::ddl_version_11)
+        {
+            oDTElement.setAttribute("type", poDataType->getName());
+        }
+        else
+        {
+            oDTElement.setAttribute("name", poDataType->getName());
+        }
+        oDTElement.setAttribute("size",
+            a_util::strings::toString(static_cast<uint32_t>(poDataType->getNumBits())));
+        if (!poDataType->getDescription().empty())
+        {
+            oDTElement.setAttribute("description",
+                poDataType->getDescription());
+        }
+        if (poDataType->getArraysize() > 1)
+        {
+            oDTElement.setAttribute("arraysize",
+                a_util::strings::toString(static_cast<uint32_t>
+                (poDataType->getArraysize())));
+        }
+        if (!poDataType->getUnit().empty())
+        {
+            oDTElement.setAttribute("unit", poDataType->getUnit());
+            RETURN_IF_FAILED(poDataType->getUnitObject()->accept(this));
+        }
+        if (_version >= DDLVersion::ddl_version_30)
+        {
+            // min and max values are supported since DDL 3.0
+            if (poDataType->isMinValid())
+            {
+                oDTElement.setAttribute("min", poDataType->getMinValue());
+            }
+            if (poDataType->isMaxValid())
+            {
+                oDTElement.setAttribute("max", poDataType->getMaxValue());
+            }
+        }
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLComplex* poStruct)
+    {
+        if (!poStruct) { return ERR_POINTER; }
+        a_util::xml::DOMElement oStructElement;
+        if (_resolved_types.find(poStruct->getName()) != _resolved_types.end())
+        {
+            return a_util::result::SUCCESS;
+        }
+        _resolved_types.insert(poStruct->getName());
+
+        oStructElement = _structs.createChild("struct");
+        oStructElement.setAttribute("name", poStruct->getName());
+        oStructElement.setAttribute("version",
+            a_util::strings::toString(static_cast<uint32_t>(poStruct->getVersion())));
+        if (!poStruct->getComment().empty())
+        {
+            oStructElement.setAttribute("comment", poStruct->getComment());
+        }
+        if (_version >= DDLVersion::ddl_version_11)
+        {
+            oStructElement.setAttribute("alignment",
+                DDLAlignment::toString(poStruct->getAlignment()));
+        }
+        _stack_parents.push(oStructElement);
+        std::vector<DDLElement*> vecDDLElements = poStruct->getElements();
+        for (size_t i = 0; i < vecDDLElements.size(); i++)
+        {
+            RETURN_IF_FAILED(vecDDLElements[i]->accept(this));
+        }
+        _stack_parents.pop();
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLElement* poElement)
+    {
+        if (!poElement) { return ERR_POINTER; }
+        a_util::xml::DOMElement oElem;
+        oElem = _stack_parents.top().createChild("element");
+        oElem.setAttribute("type", poElement->getType());
+        IDDLDataType* pTypeObject = poElement->getTypeObject();
+        if (!pTypeObject)
+        {
+            return ERR_NOT_FOUND;
+        }
+        RETURN_IF_FAILED(pTypeObject->accept(this));
+        oElem.setAttribute("name", poElement->getName());
+        oElem.setAttribute("bytepos",
+            a_util::strings::toString(static_cast<uint32_t>
+            (poElement->getBytepos())));
+        if ((_version <  DDLVersion::ddl_version_11 && poElement->getBitpos() != 1) ||
+            (_version >= DDLVersion::ddl_version_11 && poElement->getBitpos() > 0))
+        {
+            oElem.setAttribute("bitpos",
+                a_util::strings::toString(static_cast<uint32_t>
+                (poElement->getBitpos())));
+        }
+        if (poElement->getNumBits() > 0)
+        {
+            if (1 == poElement->getArraysize())
+            {
+                // only check the "numbits"-attribute for data-types (DDLDataType), because
+                // "numbits"-attribute for complex-types (DDLComplex) may tempt to configuration errors
+                DDLDataType *poDT = dynamic_cast<DDLDataType*>(pTypeObject);
+                if (NULL != poDT)
+                {
+                    if (poElement->getNumBits() == poDT->getNumBits())
+                    {
+                        oElem.setAttribute("numbits", a_util::strings::toString(static_cast<uint32_t>
+                            (poElement->getNumBits())));
+                    }
+                    else
+                    {
+                        return ERR_INVALID_ARG;
+                    }
+                }
+            }
+            else
+            {
+                return ERR_INVALID_ARG;
+            }
+        }
+        if (!poElement->getDescription().empty())
+        {
+            oElem.setAttribute("description", poElement->getDescription());
+        }
+        if(poElement->getArraysize() == 0 || !poElement->getArraySizeSource().empty())
+        {
+            oElem.setAttribute("arraysize",poElement->getArraySizeSource());
+        }
+        else
+        {
+            oElem.setAttribute("arraysize",
+                a_util::strings::toString(static_cast<uint32_t>
+                (poElement->getArraysize())));
+        }
+        if (!poElement->getUnit().empty())
+        {
+            oElem.setAttribute("unit", poElement->getUnit());
+            RETURN_IF_FAILED(poElement->getUnitObject()->accept(this));
+        }
+        oElem.setAttribute("byteorder",
+            DDLByteorder::toString(poElement->getByteorder()));
+        oElem.setAttribute("alignment",
+            DDLAlignment::toString(poElement->getAlignment()));
+        if (!poElement->getComment().empty())
+        {
+            oElem.setAttribute("comment", poElement->getComment());
+        }
+
+        std::string strConstValue = poElement->getConstantValue();
+        if (!strConstValue.empty())
+        {
+            oElem.setAttribute("value", strConstValue);
+        }
+
+        if (_version >= DDLVersion::ddl_version_30)
+        {
+            // min, max, default, scale, and offset values are supported since DDL 3.0
+            if (poElement->isMinValid())
+            {
+                oElem.setAttribute("min", poElement->getMinValue());
+            }
+
+            if (poElement->isMaxValid())
+            {
+                oElem.setAttribute("max", poElement->getMaxValue());
+            }
+
+            if (poElement->isDefaultValid())
+            {
+                oElem.setAttribute("default", poElement->getDefaultValue());
+            }
+
+            if (poElement->isScaleValid())
+            {
+                oElem.setAttribute("scale", poElement->getScaleValue());
+            }
+
+            if (poElement->isOffsetValid())
+            {
+                oElem.setAttribute("offset", poElement->getOffsetValue());
+            }
+        }
+
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLStream* poStream)
+    {
+        if (!poStream) { return ERR_POINTER; }
+        a_util::xml::DOMElement oStreamElement;
+        oStreamElement = _streams.createChild("stream");
+        if (!poStream->getName().empty())
+        {
+            oStreamElement.setAttribute("name", poStream->getName());
+        }
+        oStreamElement.setAttribute("type", poStream->getType());
+        RETURN_IF_FAILED(poStream->getTypeObject()->accept(this));
+        if (!poStream->getDescription().empty())
+        {
+            oStreamElement.setAttribute("description",
+                poStream->getDescription());
+        }
+        std::vector<DDLStreamStruct*> vecStructs = poStream->getStructs();
+        _stack_parents.push(oStreamElement);
+        for (size_t i = 0; i < vecStructs.size(); i++)
+        {
+            RETURN_IF_FAILED(vecStructs[i]->accept(this));
+        }
+        _stack_parents.pop();
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLStreamStruct* poStreamStruct)
+    {
+        if (!poStreamStruct) { return ERR_POINTER; }
+        a_util::xml::DOMElement oStruct;
+        oStruct = _stack_parents.top().createChild("struct");
+        oStruct.setAttribute("type", poStreamStruct->getType());
+        RETURN_IF_FAILED(poStreamStruct->getTypeObject()->accept(this));
+        if (!poStreamStruct->getName().empty())
+        {
+            oStruct.setAttribute("name", poStreamStruct->getName());
+        }
+        oStruct.setAttribute("bytepos",
+            a_util::strings::toString(static_cast<uint32_t>
+            (poStreamStruct->getBytepos())));
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLEnum* poEnum)
+    {
+        if (!poEnum) { return ERR_POINTER; }
+        a_util::xml::DOMElement oDTElement;
+        if (_enums.findNode(a_util::strings::format("enum[@name='%s']",
+            poEnum->getName().c_str()), oDTElement))
+        {
+            // this element was already visited
+            return a_util::result::SUCCESS;
+        }
+        oDTElement = _enums.createChild("enum");
+
+        oDTElement.setAttribute("name", poEnum->getName());
+       // oDTElement->setAttribute("value", poEnum->getValue());
+        oDTElement.setAttribute("type", poEnum->getType());
+
+         EnumNameValueVec vecNameValues = poEnum->getValues();
+         a_util::xml::DOMElement oEnumElement;
+         for (EnumNameValueVec::iterator itElem = vecNameValues.begin(); itElem != vecNameValues.end(); ++itElem)
+         {
+             oEnumElement = oDTElement.createChild("element");
+
+             oEnumElement.setAttribute("name", itElem->first);
+             oEnumElement.setAttribute("value", itElem->second);
+         }
+
+
+        return a_util::result::SUCCESS;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLStreamMetaType* poStreamMetaType)
+    {
+        return ERR_NOT_IMPL;
+    }
+
+    a_util::result::Result DDLResolver::visit(const DDLProperty* poProperty)
+    {
+        return ERR_NOT_IMPL;
+    }
+
+    std::string DDLResolver::getResolvedXML() const
+    {
+        std::string strResult = _dom.toString().c_str();
+        if (strResult == "<xml />")
+        {
+            // DOM is empty
+            return a_util::strings::empty_string;
+        }
+        return strResult;
+    }
+
+    void DDLResolver::setTargetName(const std::string& name)
+    {
+        _target = name;
+    }
+
+}   // namespace ddl