initial commit for github

mapping/ddl_helper.cpp

@@ -0,0 +1,135 @@
+/**
+ * @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 "ddl_helper.h"
+
+#include <utility>
+#include <vector>
+
+#include "a_util/strings.h"
+
+using namespace mapping;
+
+//define all needed error types and values locally
+_MAKE_RESULT(-5, ERR_INVALID_ARG)
+
+namespace mapping
+{
+    _MAKE_RESULT(-20, ERR_NOT_FOUND)
+}
+
+static a_util::result::Result ParseElementPath(const std::string& strPath,
+    std::vector<std::pair<std::string, int> >& vecPath)
+{
+    vecPath.clear();
+
+    std::vector<std::string> lstPath = a_util::strings::split(strPath, ".");
+
+    for (std::vector<std::string>::const_iterator it = lstPath.begin(); it != lstPath.end(); ++it)
+    {
+        const std::string& strPathElem = *it;
+
+        std::pair<std::string, int> oPair;
+        size_t idxBegin = strPathElem.find('[');
+        if (idxBegin != std::string::npos)
+        {
+            size_t idxEnd = strPathElem.find(']', idxBegin);
+            if (idxEnd == std::string::npos || idxEnd != strPathElem.size() - 1)
+            {
+                return ERR_INVALID_ARG;
+            }
+            oPair.first = strPathElem.substr(0, idxBegin);
+            std::string strSubscript = strPathElem.substr(idxBegin + 1);
+            strSubscript.erase(strSubscript.size() - 1);
+            int nSubscript = a_util::strings::toInt32(strSubscript);
+            if (!a_util::strings::isInt64(strSubscript) || nSubscript < 0)
+            {
+                return ERR_INVALID_ARG;
+            }
+            oPair.second = nSubscript;
+        }
+        else
+        {
+            oPair.first = strPathElem;
+            oPair.second = -1;
+        }
+
+        vecPath.push_back(oPair);
+    }
+
+    return a_util::result::SUCCESS;
+}
+
+static const ddl::DDLElement* GetNestedElement(const ddl::DDLElementVec& vecElements,
+    std::vector<std::pair<std::string, int> > vecPath)
+{
+    std::pair<std::string, int> oPair = vecPath.front();
+    vecPath.erase(vecPath.begin());
+
+    for (ddl::DDLElementItConst it = vecElements.begin(); it != vecElements.end(); ++it)
+    {
+        if ((*it)->getName() == oPair.first)
+        {
+            // check array size
+            if (oPair.second > -1)
+            {
+                if ((*it)->getArraysize() <= (unsigned int)oPair.second)
+                {
+                    return NULL;
+                }
+            }
+
+            if (vecPath.empty())
+            {
+                return *it;
+            }
+            else
+            {
+                const ddl::DDLComplex* pCmplx =
+                    dynamic_cast<const ddl::DDLComplex*>((*it)->getTypeObject());
+                if (pCmplx)
+                {
+                    return GetNestedElement(pCmplx->getElements(), vecPath);
+                }
+            }
+            break;
+        }
+    }
+
+    return NULL;
+}
+
+a_util::result::Result DDLHelper::LookupElement(const ddl::DDLComplex& oStruct,
+    const std::string& strPath, const ddl::DDLElement*& pElement, bool& bIsArrayElement)
+{
+    std::vector<std::pair<std::string, int> > vecPath;
+    if (isFailed(ParseElementPath(strPath, vecPath)))
+    {
+        return ERR_NOT_FOUND;
+    }
+
+    const ddl::DDLElement* pElem = GetNestedElement(oStruct.getElements(), vecPath);
+    if (pElem)
+    {
+        pElement = pElem;
+        bIsArrayElement = vecPath.back().second > -1;
+        return a_util::result::SUCCESS;
+    }
+
+    return ERR_NOT_FOUND;
+}