Refactor shared X-Plane model parser in common header only functions

ref T290

src/blackmisc/simulation/xplane/qtfreeutils.h

@@ -0,0 +1,182 @@
+/* Copyright (C) 2018
+ * swift Project Community / Contributors
+ *
+ * This file is part of swift project. It is subject to the license terms in the LICENSE file found in the top-level
+ * directory of this distribution and at http://www.swift-project.org/license.html. No part of swift project,
+ * including this file, may be copied, modified, propagated, or distributed except according to the terms
+ * contained in the LICENSE file.
+ */
+
+//! \file
+
+#ifndef BLACKMISC_SIMULATION_XPLANE_XPLANQTFREEUTILS_H
+#define BLACKMISC_SIMULATION_XPLANE_XPLANQTFREEUTILS_H
+
+#include <string>
+#include <fstream>
+#include <vector>
+
+// Strict header only X-Plane model parser utils shared between BlackMisc and XSwiftBus.
+// Header only is necessary to no require XSwiftBus to link against BlackMisc.
+
+namespace BlackMisc
+{
+    namespace Simulation
+    {
+        namespace XPlane
+        {
+            namespace QtFreeUtils
+            {
+                //! Get filename (including all extensions) from a filePath
+                std::string getFileName(const std::string &filePath)
+                {
+                    const std::string seperator = "/\\";
+                    const std::size_t sepPos = filePath.find_last_of(seperator);
+                    if (sepPos != std::string::npos)
+                    {
+                        return filePath.substr(sepPos + 1, filePath.size() - 1);
+                    }
+                    else
+                    {
+                        return filePath;
+                    }
+                }
+
+                //! Get the name of the parent directory
+                std::string getDirName(const std::string &filePath)
+                {
+                    const std::string seperator = "/\\";
+                    const std::size_t sepPos = filePath.find_last_of(seperator);
+                    if (sepPos != std::string::npos)
+                    {
+                        std::string dirPath = filePath.substr(0, sepPos);
+                        return getFileName(dirPath);
+                    }
+                    else
+                    {
+                        return {};
+                    }
+                }
+
+                //! Get the base name of the file
+                std::string getBaseName(const std::string &filePath)
+                {
+                    const std::string seperator = ".";
+                    const std::string fileName = getFileName(filePath);
+                    std::size_t sepPos = fileName.find(seperator);
+                    if (sepPos != std::string::npos)
+                    {
+                        return fileName.substr(0, sepPos);
+                    }
+                    else
+                    {
+                        return fileName;
+                    }
+                }
+
+                //! Split string by delimiter and maxSplitCount times
+                std::vector<std::string> split(const std::string &str, size_t maxSplitCount = 0, const std::string &delimiter = " ")
+                {
+                    std::string s(str);
+                    size_t pos = 0;
+                    std::vector<std::string> tokens;
+                    while ((pos = s.find(delimiter)) != std::string::npos)
+                    {
+                        tokens.push_back(s.substr(0, pos));
+                        s.erase(0, pos + delimiter.length());
+                        if (maxSplitCount > 0 && tokens.size() == maxSplitCount) { break; }
+                    }
+                    tokens.push_back(s);
+                    return tokens;
+                }
+
+                //! ACF properties
+                struct AcfProperties
+                {
+                    std::string aircraftIcaoCode;   //!< Aircraft ICAO code
+                    std::string modelDescription;   //!< Model description
+                    std::string modelName;          //!< Model name
+                    std::string author;             //!< Model author
+                    std::string modelString;        //!< Generated model string
+                };
+
+                //! Get the model string for a flyable aircraft
+                std::string stringForFlyableModel(const AcfProperties &acfProperties, const std::string &acfFile)
+                {
+                    if (! acfProperties.author.empty())
+                    {
+                        if (! acfProperties.modelName.empty())
+                        {
+                            if (acfProperties.modelName.find(acfProperties.author) != std::string::npos) { return acfProperties.modelName; }
+                            else { return acfProperties.author + ' ' + acfProperties.modelName; }
+                        }
+                        else if (! acfProperties.aircraftIcaoCode.empty())
+                        {
+                            return acfProperties.author + ' ' + acfProperties.aircraftIcaoCode;
+                        }
+                    }
+                    return getDirName(acfFile) + ' ' + getBaseName(acfFile);
+                }
+
+                //! Extract ACF properties from an aircraft file
+                AcfProperties extractAcfProperties(const std::string &filePath)
+                {
+                    std::ifstream fs(filePath, std::ios::in);
+                    if (!fs.is_open()) { return {}; }
+
+                    std::string i;
+                    std::string version;
+                    std::string acf;
+                    std::getline(fs, i);
+                    std::getline(fs, version);
+                    std::getline(fs, acf);
+
+                    AcfProperties acfProperties;
+
+                    if (i == "I" && version.find("version") != std::string::npos && acf == "ACF")
+                    {
+                        std::string line;
+                        while (std::getline(fs, line))
+                        {
+                            auto tokens = split(line, 2);
+                            if (tokens.size() < 3 || tokens.at(0) != "P") { continue; }
+
+                            if (tokens.at(1) == "acf/_ICAO")
+                            {
+                                acfProperties.aircraftIcaoCode = tokens.at(2);
+                            }
+                            else if (tokens.at(1) == "acf/_descrip")
+                            {
+                                acfProperties.modelDescription = "[ACF] " + tokens.at(2);
+                            }
+                            else if (tokens.at(1) == "acf/_name")
+                            {
+                                acfProperties.modelName = tokens.at(2);
+                            }
+                            else if (tokens.at(1) == "acf/_studio")
+                            {
+                                acfProperties.author = tokens.at(2);
+                            }
+                            else if (tokens.at(1) == "acf/_author")
+                            {
+                                if (!acfProperties.author.empty()) { continue; }
+                                std::string author = tokens.at(2);
+                                size_t pos = author.find_first_not_of("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_");
+                                author = author.substr(0, pos);
+                                if (author.empty()) { continue; }
+                                acfProperties.author = author;
+                            }
+                        }
+                    }
+
+                    fs.close();
+                    acfProperties.modelString = stringForFlyableModel(acfProperties, filePath);
+                    return acfProperties;
+                }
+            }
+        } // namespace
+    } // namespace
+} // namespace
+
+#endif // guard
+