mirror of
https://github.com/eclipse-openvehicle-api/openvehicle-api.git
synced 2026-02-05 15:18:45 +00:00
489 lines
21 KiB
C++
489 lines
21 KiB
C++
#ifndef VSS_HELPER_H
|
|
#define VSS_HELPER_H
|
|
|
|
#include <iostream>
|
|
#include <vector>
|
|
#include <unordered_set>
|
|
#include <algorithm>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <fstream>
|
|
#include <thread>
|
|
#include <chrono>
|
|
//#include <algorithm>
|
|
#include <interfaces/dispatch.h>
|
|
|
|
namespace sdv
|
|
{
|
|
/**
|
|
* @brief vss namespace
|
|
*/
|
|
namespace vss
|
|
{
|
|
/**
|
|
* @brief The entity declaration type.
|
|
*/
|
|
enum class EDeclType : uint32_t
|
|
{
|
|
/// Unknown type
|
|
decltype_unknown,
|
|
/// Integer type (int16_t)
|
|
decltype_short,
|
|
/// Integer type (int32_t)
|
|
decltype_long,
|
|
/// Integer type (int64_t)
|
|
decltype_long_long,
|
|
/// Octet type (uint8_t)
|
|
decltype_octet,
|
|
/// Integer type (uint16_t)
|
|
decltype_unsigned_short,
|
|
/// Integer type (uint32)
|
|
decltype_unsigned_long,
|
|
/// Integer type (uint64_t)
|
|
decltype_unsigned_long_long,
|
|
/// Floating point type
|
|
decltype_float,
|
|
/// Floating point type
|
|
decltype_double,
|
|
/// Floating point type
|
|
decltype_long_double,
|
|
/// Fixed point templated type
|
|
decltype_fixed,
|
|
/// Character type (int8_t)
|
|
decltype_char,
|
|
/// UTF-16 character
|
|
decltype_char16,
|
|
/// UTF-32 character
|
|
decltype_char32,
|
|
/// Character type
|
|
decltype_wchar,
|
|
/// Boolean type
|
|
decltype_boolean,
|
|
/// Native type
|
|
decltype_native,
|
|
/// ASCII templated string type
|
|
decltype_string,
|
|
/// UTF-8 templated string type
|
|
decltype_u8string,
|
|
/// UTF-16 templated string type
|
|
decltype_u16string,
|
|
/// UTF-32 templated string type
|
|
decltype_u32string,
|
|
/// Wide templated string type
|
|
decltype_wstring,
|
|
/// Enum type
|
|
decltype_enum,
|
|
/// Struct type
|
|
decltype_struct,
|
|
/// Union type
|
|
decltype_union,
|
|
/// Module type
|
|
decltype_module,
|
|
/// Interface type (not used in declarations)
|
|
decltype_interface,
|
|
/// Interface type (not used in declarations)
|
|
decltype_exception,
|
|
/// Attribute type (not used in declarations)
|
|
decltype_attribute,
|
|
/// Operation type (not used in declarations)
|
|
decltype_operation,
|
|
/// Parameter type (only for operations)
|
|
decltype_parameter,
|
|
/// Enum entry type (only for enums)
|
|
decltype_enum_entry,
|
|
/// Case entry type (only for unions)
|
|
decltype_case_entry,
|
|
/// Typedef type
|
|
decltype_typedef,
|
|
/// Void type (only for operations)
|
|
decltype_void,
|
|
/// Meta data type
|
|
decltype_meta,
|
|
/// Pointer templated data type
|
|
decltype_pointer,
|
|
/// Sequence templated data type
|
|
decltype_sequence,
|
|
/// Map templated data type
|
|
decltype_map,
|
|
/// Bitset data type
|
|
decltype_bitset,
|
|
/// Bitfield templated data type
|
|
decltype_bitfield,
|
|
/// Bitmask data type
|
|
decltype_bitmask,
|
|
/// Any composite data type
|
|
decltype_any,
|
|
/// Interface ID data type
|
|
decltype_interface_id,
|
|
/// Interface data type
|
|
decltype_interface_type,
|
|
/// Exception ID data type
|
|
decltype_exception_id,
|
|
};
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief VSS code generator helper class.
|
|
*/
|
|
class CVSSHelper
|
|
{
|
|
|
|
public:
|
|
|
|
/**
|
|
* @brief Signal definition structure (vehicle device) with a single function/value combination
|
|
*/
|
|
struct SFunctionVDDefinition
|
|
{
|
|
std::string idlType; ///< signal value type (IDL: boolean, float, uint8, ...)
|
|
std::string functionName; ///< signal value set function name
|
|
std::string signalName; ///< signal name
|
|
std::string canSignalName; ///< can signal name (combination of signak messages and signal name)
|
|
std::string formula; ///< c++ code if the value has to be converted
|
|
};
|
|
|
|
/**
|
|
* @brief Signal definition structure (basic service) with a single function/value combination
|
|
*/
|
|
struct SFunctionBSDefinition
|
|
{
|
|
std::string idlType; ///< signal value type (IDL: boolean, float, uint8, ...)
|
|
std::string functionName; ///< signal value set function name
|
|
std::string signalName; ///< signal name
|
|
};
|
|
|
|
/**
|
|
* @brief Signal definition structure (vehicle device) with a single function/value combination
|
|
*/
|
|
struct SSignalVDDefinition
|
|
{
|
|
std::string vssDefinition; ///< vss interface string
|
|
std::string className; ///< class name
|
|
sdv::core::ESignalDirection signalDirection = sdv::core::ESignalDirection::sigdir_rx; ///< signal direction, either rx or tx
|
|
std::vector<SFunctionVDDefinition> vecFunctions; ///< list of functions of the vss interface
|
|
};
|
|
|
|
/**
|
|
* @brief Signal definition structure (basic service) with a single function/value combination
|
|
*/
|
|
struct SSignalBSDefinition
|
|
{
|
|
std::string vssDefinition; ///< vss interface string
|
|
std::string vssVDDefinition; ///< vss interface string
|
|
std::string className; ///< class name
|
|
sdv::core::ESignalDirection signalDirection = sdv::core::ESignalDirection::sigdir_rx; ///< signal direction, either rx or tx
|
|
std::vector<SFunctionBSDefinition> vecFunctions; ///< list of functions of the vss interface
|
|
};
|
|
|
|
/**
|
|
* @brief Check if all required VD definitions are found required by the BS signals
|
|
* @param[in] bSilent if true do not print error to console.
|
|
* @param[in] vdSignals containing all signals definitions of the vehicle devices.
|
|
* @param[in] bsSignals containing all signals definitions of the basic services.
|
|
* @return Returns true on success when all definitions are found, otherwise false.
|
|
*/
|
|
static bool VehicleDeviceVSSDefinitionExists(bool bSilent, const std::vector<SSignalVDDefinition>& vdSignals,
|
|
const std::vector<SSignalBSDefinition>& bsSignals);
|
|
|
|
protected:
|
|
|
|
/**
|
|
* @brief Create the cmake if not exists and if content has changed
|
|
* @param[in] filePath full path to the file
|
|
* @param[in] cmakeContent content of the cmake file
|
|
*/
|
|
void CreateCMakeFile(const std::filesystem::path& filePath, const std::string& cmakeContent) const;
|
|
|
|
/**
|
|
* @brief Converts the filename of a full path to lowercase
|
|
* @param[in] fullPath full path
|
|
* @return Returns full path but the filename is lowercase
|
|
*/
|
|
std::filesystem::path MakeLowercaseFilename(std::filesystem::path& fullPath) const;
|
|
|
|
/**
|
|
* @brief Add multiple space characters to increase the input string to a certain size.
|
|
* @param[in] ssInput Reference to the input string.
|
|
* @param[in] size of the final string.
|
|
* @return Returns the string increased by space characters.
|
|
*/
|
|
std::string Align(const std::string& ssInput, size_t size) const;
|
|
|
|
/**
|
|
* @brief trim spaces from begin of the string and end of the string
|
|
* @param[in] ssInput Reference to the input string to be checked.
|
|
* @return Returns string without the spaces at front and at the end
|
|
*/
|
|
std::string Trim(const std::string& ssInput) const;
|
|
|
|
/**
|
|
* @brief check for space characters in the string.
|
|
* @param[in] ssInput Reference to the input string to be checked.
|
|
* @return Returns true if string contains no space character, otherwise false.
|
|
*/
|
|
bool MustNotContainSpaces(const std::string& ssInput) const;
|
|
|
|
/**
|
|
* @brief Get the maximal string size of all class names in the vector container.
|
|
* @param[in] signals containing all signals definitions which have to be checked.
|
|
* @param[in] ssTitle Reference to the title string. Is minimum of the return value.
|
|
* @return Returns the string size of the largest class name string.
|
|
*/
|
|
size_t GetMaxClassName(const std::vector<SSignalVDDefinition>& signals, const std::string& ssTitle) const;
|
|
|
|
/**
|
|
* @brief Get the maximal string size of all IDL type strings in the vector container.
|
|
* @param[in] signals containing all signals definitions which have to be checked.
|
|
* @param[in] ssTitle Reference to the title string. Is minimum of the return value.
|
|
* @return Returns the string size of the largest IDL type string.
|
|
*/
|
|
size_t GetMaxIDLType(const std::vector<SSignalVDDefinition>& signals, const std::string& ssTitle) const;
|
|
|
|
/**
|
|
* @brief Get the maximal string size of all ctype strings in the vector container.
|
|
* @param[in] signals containing all signals definitions which have to be checked.
|
|
* @param[in] ssTitle Reference to the title string. Is minimum of the return value.
|
|
* @return Returns the string size of the largest ctype string.
|
|
*/
|
|
size_t GetMaxCTypeFromIDLType(const std::vector<SSignalVDDefinition>& signals, const std::string& ssTitle) const;
|
|
|
|
/**
|
|
* @brief Get the maximal string size of all signal name strings in the vector container.
|
|
* @param[in] signals containing all signals definitions which have to be checked.
|
|
* @param[in] ssTitle Reference to the title string. Is minimum of the return value.
|
|
* @return Returns the string size of the largest signal names string.
|
|
*/
|
|
size_t GetMaxSignalName(const std::vector<SSignalVDDefinition>& signals, const std::string& ssTitle) const;
|
|
|
|
/**
|
|
* @brief Get the maximal string size of all CAN signal name strings in the vector container.
|
|
* @param[in] signals containing all signals definitions which have to be checked.
|
|
* @param[in] ssTitle Reference to the title string. Is minimum of the return value.
|
|
* @return Returns the string size of the largest signal names string.
|
|
*/
|
|
size_t GetMaxCANSignalName(const std::vector<SSignalVDDefinition>& signals, const std::string& ssTitle) const;
|
|
|
|
/**
|
|
* @brief Get the maximal string size of all function name strings in the vector container.
|
|
* @param[in] signals containing all signals definitions which have to be checked.
|
|
* @param[in] ssTitle Reference to the title string. Is minimum of the return value.
|
|
* @return Returns the string size of the largest function names string.
|
|
*/
|
|
size_t GetMaxFunctionName(const std::vector<SSignalVDDefinition>& signals, const std::string& ssTitle) const;
|
|
|
|
/**
|
|
* @brief Get the maximal string size of all vss strings in the vector container.
|
|
* @param[in] signals containing all signals definitions which have to be checked.
|
|
* @param[in] ssTitle Reference to the title string. Is minimum of the return value.
|
|
* @return Returns the string size of the largest vss string.
|
|
*/
|
|
size_t GetMaxVSSDefinition(const std::vector<SSignalVDDefinition>& signals, const std::string& ssTitle) const;
|
|
|
|
/**
|
|
* @brief check for '.' characters in the string.
|
|
* @param[in] ssInput Reference to the input string to be checked.
|
|
* @param[in] mustBeEmpty If true input string must not be empty
|
|
* @return Returns true if string contains '.' or is empty depending on mustBeEmpty, otherwise false.
|
|
*/
|
|
bool MustContainDotOrIsEmpty(const std::string& ssInput, bool mustBeEmpty) const;
|
|
|
|
/**
|
|
* @brief check if vss parts are string and no number. If number add '_'
|
|
* for vehicle.chassis.axel.01.left return vehicle.chassis.axel._01.left
|
|
* @param[in] ssInput Reference to the input string to be checked.
|
|
* @return Returns valid vss string.
|
|
*/
|
|
std::string ValidateVSSFormatNumbers(const std::string& ssInput) const;
|
|
|
|
/**
|
|
* @brief check if string is a number
|
|
* @param[in] ssInput Reference to the input string to be checked.
|
|
* @return Returns false if it is a number, otherwise true.
|
|
*/
|
|
bool IsNumber(const std::string& ssInput) const;
|
|
|
|
/**
|
|
* @brief Returns input string or if empty, returns default string.
|
|
* @param[in] ssInput string
|
|
* @param[in] ssDefaultString string used as default if input string is empty
|
|
* @param[in] index number will be added to the default string.
|
|
* @return Returns input string or if empty returns default string added by the number.
|
|
*/
|
|
std::string GenerateDefaultIfEmpty(const std::string& ssInput, std::string ssDefaultString, const uint32_t& index) const;
|
|
|
|
/**
|
|
* @brief Returns input string but starts and ends with "'".
|
|
* @param[in] ssInput string
|
|
* @return Returns the input string with "'" added at the frond and the end.
|
|
*/
|
|
std::string AddQuotationMarks(const std::string& ssInput) const;
|
|
|
|
/**
|
|
* @brief Replaces some characters of the input string.
|
|
* @param[in] ssInput string.
|
|
* @param[in] from character to be replaced
|
|
* @param[in] to replacement character.
|
|
* @return Returns the string with replacements.
|
|
*/
|
|
std::string ReplaceCharacters(const std::string& ssInput, const std::string& from, const std::string& to) const;
|
|
|
|
/**
|
|
* @brief turn the input string to upper case
|
|
* @param[in] ssInput string.
|
|
* @return Returns the input string but all characters are upper case
|
|
*/
|
|
std::string ToUpper(const std::string& ssInput) const;
|
|
|
|
/**
|
|
* @brief remove the last part of the vss string
|
|
* @param[in] ssInput vss string
|
|
* @return Returns the string but removed the last part after charatcer '.'.
|
|
*/
|
|
std::string ShortenVSSString(const std::string& ssInput) const;
|
|
|
|
/**
|
|
* @brief add to the type a cast, for example for 'std::string' it adds "const std::string&'
|
|
* @param[in] ssSignalType the string representing the type
|
|
* @return Returns either original string or 'const' and '&' added.
|
|
*/
|
|
std::string CastValueType(const std::string& ssSignalType) const;
|
|
|
|
/**
|
|
* @brief find IDL type and return CType
|
|
* @param[in] ssIDLType string representing IDL type
|
|
* @return CType string if IDL type found, otherwise empty string
|
|
*/
|
|
std::string GetCTypeFromIDLType(const std::string& ssIDLType) const;
|
|
|
|
/**
|
|
* @brief validate if all IDL type are valid
|
|
* @param[in] vecTypes container of the IDL types
|
|
* @param[in] silent information to console if not silent
|
|
* @return True if IDL types are valid, otherwise false
|
|
*/
|
|
bool ValidateIDLTypes(const std::vector<std::string>& vecTypes, const bool silent) const;
|
|
|
|
/**
|
|
* @brief Create folder or sub folder
|
|
* @param[in] rootPath complete root path
|
|
* @param[in] subfolder in case this parameter is empty only root path is created otherwise rootPath + subfolder
|
|
* @return true if directory exists or is created successfully, otherwise false
|
|
*/
|
|
bool CreateFolder(const std::filesystem::path& rootPath, const std::string& subfolder) const;
|
|
|
|
/**
|
|
* @brief deletes a header file
|
|
* @param[in] path full path to a folder
|
|
* @param[in] fileNameNoExtension a file name without the extension
|
|
*/
|
|
void DeleteHeaderFile(const std::filesystem::path& path, const std::string& fileNameNoExtension) const;
|
|
|
|
/**
|
|
* @brief Validates the code style (signal name starts with lower case, function name upper case ...
|
|
* @param[in] function function definition structure
|
|
* @param[in] verbose print information to console only if true
|
|
*/
|
|
void ValidateVDCodeStyle(const SFunctionVDDefinition& function, const bool verbose) const;
|
|
|
|
/**
|
|
* @brief Validates the code style (signal name starts with lower case, function name upper case ...
|
|
* @param[in] function function definition structure
|
|
* @param[in] verbose print information to console only if true
|
|
*/
|
|
void ValidateBSCodeStyle(const SFunctionBSDefinition& function, const bool verbose) const;
|
|
|
|
/**
|
|
* @brief Validates the code style (signal name starts with lower case, function name upper case ...
|
|
* @param[in] signal signal definition structure
|
|
* @param[in] verbose print information to console only if true
|
|
*/
|
|
void ValidateVDCodeStyle(const SSignalVDDefinition& signal, const bool verbose) const;
|
|
|
|
/**
|
|
* @brief Validates the code style (signal name starts with lower case, function name upper case ...
|
|
* @param[in] signal signal definition structure
|
|
* @param[in] verbose print information to console only if true
|
|
*/
|
|
void ValidateBSCodeStyle(const SSignalBSDefinition& signal, const bool verbose) const;
|
|
|
|
private:
|
|
|
|
/**
|
|
* @brief Declaration type name association.
|
|
*/
|
|
using TDeclTypeAssoc = std::pair<std::string, sdv::vss::EDeclType>;
|
|
|
|
/**
|
|
* @brief change EDeclType to cType string
|
|
* @param[in] eDeclType EDeclTyp type
|
|
* @return Returns cType stringif available, otherwise empty string
|
|
*/
|
|
std::string MapDeclType2CType(const sdv::vss::EDeclType eDeclType) const;
|
|
|
|
/**
|
|
* @brief Mapping between declaration type and string name.
|
|
* @attention Some types have multiple string representatives (e.g. sdv::vss::EDeclType::decltype_short vs. 'short' and
|
|
* 'int16').
|
|
* @attention Based on the provided extensions on the command line, the types might be extended by: char16, char32, u8string,
|
|
* u16string, u32string, pointer, interface_id, interface_t and exception_id
|
|
*/
|
|
const std::vector<TDeclTypeAssoc> m_vecDeclTypes = {
|
|
{"short", sdv::vss::EDeclType::decltype_short},
|
|
{"unsigned short", sdv::vss::EDeclType::decltype_unsigned_short},
|
|
{"long", sdv::vss::EDeclType::decltype_long},
|
|
{"unsigned long", sdv::vss::EDeclType::decltype_unsigned_long},
|
|
{"long long", sdv::vss::EDeclType::decltype_long_long},
|
|
{"unsigned long long", sdv::vss::EDeclType::decltype_unsigned_long_long},
|
|
{"fixed", sdv::vss::EDeclType::decltype_fixed},
|
|
{"float", sdv::vss::EDeclType::decltype_float},
|
|
{"double", sdv::vss::EDeclType::decltype_double},
|
|
{"long double", sdv::vss::EDeclType::decltype_long_double},
|
|
{"char", sdv::vss::EDeclType::decltype_char},
|
|
{"wchar", sdv::vss::EDeclType::decltype_wchar},
|
|
{"int8", sdv::vss::EDeclType::decltype_char},
|
|
{"int16", sdv::vss::EDeclType::decltype_short},
|
|
{"int32", sdv::vss::EDeclType::decltype_long},
|
|
{"int64", sdv::vss::EDeclType::decltype_long_long},
|
|
{"int", sdv::vss::EDeclType::decltype_long},
|
|
{"uint8", sdv::vss::EDeclType::decltype_octet},
|
|
{"uint16", sdv::vss::EDeclType::decltype_unsigned_short},
|
|
{"uint32", sdv::vss::EDeclType::decltype_unsigned_long},
|
|
{"uint64", sdv::vss::EDeclType::decltype_unsigned_long_long},
|
|
{"uint", sdv::vss::EDeclType::decltype_unsigned_long},
|
|
{"boolean", sdv::vss::EDeclType::decltype_boolean},
|
|
{"native", sdv::vss::EDeclType::decltype_native},
|
|
{"octet", sdv::vss::EDeclType::decltype_octet},
|
|
{"byte", sdv::vss::EDeclType::decltype_octet},
|
|
{"string", sdv::vss::EDeclType::decltype_string},
|
|
{"wstring", sdv::vss::EDeclType::decltype_wstring},
|
|
{"enum", sdv::vss::EDeclType::decltype_enum},
|
|
{"struct", sdv::vss::EDeclType::decltype_struct},
|
|
{"union", sdv::vss::EDeclType::decltype_union},
|
|
{"operation", sdv::vss::EDeclType::decltype_operation},
|
|
{"attribute", sdv::vss::EDeclType::decltype_parameter},
|
|
{"enum_entry", sdv::vss::EDeclType::decltype_enum_entry},
|
|
{"case_entry", sdv::vss::EDeclType::decltype_case_entry},
|
|
{"typedef", sdv::vss::EDeclType::decltype_typedef},
|
|
{"sequence", sdv::vss::EDeclType::decltype_sequence},
|
|
{"map", sdv::vss::EDeclType::decltype_map},
|
|
{"bitset", sdv::vss::EDeclType::decltype_bitset},
|
|
{"bitfield", sdv::vss::EDeclType::decltype_bitfield},
|
|
{"bitmask", sdv::vss::EDeclType::decltype_bitmask},
|
|
{"any", sdv::vss::EDeclType::decltype_any},
|
|
{"void", sdv::vss::EDeclType::decltype_void},
|
|
// Add additional types based on enabled extensions
|
|
{"interface_id", sdv::vss::EDeclType::decltype_interface_id},
|
|
{"interface_t", sdv::vss::EDeclType::decltype_interface_type},
|
|
{"exception_id", sdv::vss::EDeclType::decltype_exception_id},
|
|
{"pointer", sdv::vss::EDeclType::decltype_pointer},
|
|
{"char16", sdv::vss::EDeclType::decltype_char16},
|
|
{"char32", sdv::vss::EDeclType::decltype_char32},
|
|
{"u8string", sdv::vss::EDeclType::decltype_u8string},
|
|
{"u16string", sdv::vss::EDeclType::decltype_u16string},
|
|
{"u32string", sdv::vss::EDeclType::decltype_u32string}
|
|
};
|
|
};
|
|
|
|
#endif // !defined VSS_HELPER_H
|