lauchmelder/ddl
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

initial commit for github

Browse source
This commit is contained in:
Pierre 2019-12-12 14:41:47 +01:00
commit 60968612de
370 changed files with 68427 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

65
.clang-tidy Normal file
View file

@ -0,0 +1,65 @@
Checks: '-*,readability-identifier-naming,readability-braces-around-statements'
WarningsAsErrors: 'readability-identifier-naming*,readability-braces-around-statements*'
HeaderFilterRegex: '.*'
CheckOptions:
- { key: readability-identifier-naming.NamespaceCase, value: lower_case }
- { key: readability-identifier-naming.InlineNamespaceCase, value: lower_case }
- { key: readability-identifier-naming.EnumConstantCase, value: lower_case }
- { key: readability-identifier-naming.ConstexprVariableCase, value: lower_case }
- { key: readability-identifier-naming.ConstantMemberCase, value: lower_case }
- { key: readability-identifier-naming.PrivateMemberCase, value: lower_case }
- { key: readability-identifier-naming.PrivateMemberPrefix, value: '_'}
- { key: readability-identifier-naming.ProtectedMemberCase, value: lower_case }
- { key: readability-identifier-naming.ProtectedMemberPrefix, value: '_'}
- { key: readability-identifier-naming.PublicMemberCase, value: lower_case }
- { key: readability-identifier-naming.PublicMemberPrefix, value: ''}
- { key: readability-identifier-naming.MemberCase, value: lower_case }
- { key: readability-identifier-naming.ClassConstantCase, value: lower_case }
- { key: readability-identifier-naming.ClassMemberCase, value: lower_case }
- { key: readability-identifier-naming.GlobalConstantCase, value: lower_case }
- { key: readability-identifier-naming.GlobalVariableCase, value: lower_case }
- { key: readability-identifier-naming.LocalConstantCase, value: lower_case }
- { key: readability-identifier-naming.LocalVariableCase, value: lower_case }
- { key: readability-identifier-naming.StaticConstantCase, value: lower_case }
- { key: readability-identifier-naming.StaticVariableCase, value: lower_case }
- { key: readability-identifier-naming.ConstantCase, value: lower_case }
- { key: readability-identifier-naming.VariableCase, value: lower_case }
- { key: readability-identifier-naming.ConstantParameterCase, value: lower_case }
- { key: readability-identifier-naming.ParameterPackCase, value: lower_case }
- { key: readability-identifier-naming.ParameterCase, value: lower_case }
- { key: readability-identifier-naming.AbstractClassCase, value: lower_case }
- { key: readability-identifier-naming.StructCase, value: CamelCase }
- { key: readability-identifier-naming.ClassCase, value: CamelCase }
- { key: readability-identifier-naming.AbstractClassCase, value: CamelCase }
- { key: readability-identifier-naming.UnionCase, value: CamelCase } # not specified
- { key: readability-identifier-naming.EnumCase, value: CamelCase }
- { key: readability-identifier-naming.GlobalFunctionCase, value: camelCase }
- { key: readability-identifier-naming.ConstexprFunctionCase, value: camelCase }
- { key: readability-identifier-naming.FunctionCase, value: camelCase }
- { key: readability-identifier-naming.ConstexprMethodCase, value: camelCase }
- { key: readability-identifier-naming.VirtualMethodCase, value: camelCase }
- { key: readability-identifier-naming.ClassMethodCase, value: camelCase }
- { key: readability-identifier-naming.PrivateMethodCase, value: camelCase }
- { key: readability-identifier-naming.ProtectedMethodCase, value: camelCase }
- { key: readability-identifier-naming.PublicMethodCase, value: camelCase }
- { key: readability-identifier-naming.MethodCase, value: camelCase }
- { key: readability-identifier-naming.TypedefCase, value: CamelCase }
- { key: readability-identifier-naming.UsingCase, value: CamelCase } # not specified
- { key: readability-identifier-naming.TypeAliasCase, value: CamelCase } # overrides using case
- { key: readability-identifier-naming.TypeTemplateParameterCase, value: UPPER_CASE }
- { key: readability-identifier-naming.ValueTemplateParameterCase, value: lower_case }
- { key: readability-identifier-naming.TemplateTemplateParameterCase, value: UPPER_CASE }
- { key: readability-identifier-naming.TemplateParameterCase, value: UPPER_CASE }
- { key: readability-identifier-naming.TypeAliasCase, value: CamelCase } # overrides using case
- { key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE }

144
CMakeLists.txt Normal file
View file

@ -0,0 +1,144 @@
cmake_minimum_required(VERSION 3.8.2) # cxx_std_11
project(ddl_library VERSION 4.4.0)
# Disable extensions here and require the chosen CMAKE_CXX_STANDARD
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_STANDARD 11)
# if Conan is used, we have to include the generated file and doing some basic setup
if(CONAN_COMPILER)
if ( EXISTS ${CMAKE_CURRENT_BINARY_DIR}/conanbuildinfo.cmake)
include(${CMAKE_CURRENT_BINARY_DIR}/conanbuildinfo.cmake)
elseif ( EXISTS ${CMAKE_CURRENT_BINARY_DIR}/../conanbuildinfo.cmake)
include(${CMAKE_CURRENT_BINARY_DIR}/../conanbuildinfo.cmake)
elseif ( EXISTS ${CMAKE_CURRENT_BINARY_DIR}/conanbuildinfo_multi.cmake)
include(${CMAKE_CURRENT_BINARY_DIR}/conanbuildinfo_multi.cmake)
elseif ( EXISTS ${CMAKE_CURRENT_BINARY_DIR}/../conanbuildinfo_multi.cmake)
include(${CMAKE_CURRENT_BINARY_DIR}/../conanbuildinfo_multi.cmake)
else()
message(FATAL_ERROR "Conan build info can't be found.")
endif()
if(CORTEX_WORKSPACE)
conan_basic_setup(TARGETS)
else()
conan_basic_setup(TARGETS NO_OUTPUT_DIRS)
endif()
endif()
# Options #################################################
option(ddl_cmake_enable_tests
"Enable tests - requires googletest (default: OFF)"
OFF)
option(ddl_cmake_enable_installation
"Enable installation of the ddl library to CMAKE_INSTALL_PREFIX (default: OFF)"
OFF)
option(ddl_cmake_enable_ddl_generator_tools
"Enable building of the two tools ddl2header and header2ddl (default: OFF)"
OFF)
# End Options #############################################
# Disable extensions here and require the chosen CMAKE_CXX_STANDARD (coming from e.g. Conan)
set(CMAKE_CXX_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
# Check for default install prefix and cmake build type (UNIX)
include(./cmake/check_cmake_install_prefix.cmake)
include(./cmake/check_cmake_build_type.cmake)
# Enable multicore compilation on Windows
include(./cmake/enable_multicore_compilation.cmake)
# Use integrated debug symbols on Windows (avoiding PDBs)
include(./cmake/use_integrated_debug_symbols.cmake)
# Set library name conventions
include(./cmake/set_library_naming_conventions.cmake)
# Enable folders
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
# Add a_util dependency
find_package(a_util 5.4 REQUIRED)
# Include sources
include(./ddlrepresentation/pkg_ddlrepresentation.sources)
include(./codec/codec.sources)
include(./serialization/serialization.sources)
include(./mapping/mapping.sources)
add_library(ddl STATIC
${DDLREPRESENTATION_CPP}
${CODEC_CPP}
${SERIALIZATION_CPP}
${MAPPING_CPP}
${DDLREPRESENTATION_H}
${CODEC_H}
${SERIALIZATION_H}
${MAPPING_CONFIGURATION_H}
${MAPPING_ENGINE_H}
${MAPPING_H}
ddl.h
legacy_error_macros.h
)
set_target_properties(ddl PROPERTIES FOLDER ddl)
target_include_directories(ddl PUBLIC
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
$<INSTALL_INTERFACE:include>
)
# a_util is public since its part of the ddl api
target_link_libraries(ddl PUBLIC a_util)
target_compile_features(ddl INTERFACE cxx_std_11) # C++11 for self and dependants
target_compile_options(ddl PRIVATE $<$<CXX_COMPILER_ID:GNU>:-fPIC>)
# Create version config
include(CMakePackageConfigHelpers)
write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/cmake/ddl-config-version.cmake
COMPATIBILITY AnyNewerVersion)
configure_file(cmake/ddl-config.cmake.in
"${CMAKE_CURRENT_BINARY_DIR}/ddl/ddlConfig.cmake"
)
if(ddl_cmake_enable_tests)
set(ddl_cmake_integrated_tests ON)
enable_testing()
add_subdirectory(test)
endif()
add_subdirectory(ddlgenerators)
if(ddl_cmake_enable_installation)
install(TARGETS ddl ARCHIVE DESTINATION lib)
install(FILES ${DDLREPRESENTATION_INSTALL} DESTINATION include/${DDLREPRESENTATION_DIR})
install(FILES ${CODEC_INSTALL} DESTINATION include/${CODEC_DIR})
install(FILES ${SERIALIZATION_INSTALL} DESTINATION include/${SERIALIZATION_DIR})
install(FILES ${MAPPING_CONFIGURATION_INSTALL} DESTINATION include/${MAPPING_DIR}/configuration)
install(FILES ${MAPPING_ENGINE_INSTALL} DESTINATION include/${MAPPING_DIR}/engine)
install(FILES ${MAPPING_INSTALL} DESTINATION include/${MAPPING_DIR})
install(FILES ddl.h legacy_error_macros.h DESTINATION include)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/ddl-config-version.cmake DESTINATION cmake)
configure_file(cmake/ddl-config.cmake.in ${CMAKE_INSTALL_PREFIX}/cmake/ddl-config.cmake @ONLY)
install(FILES cmake/migrate_to_ddl_4_1.cmake cmake/ddl4.1_replacements.txt cmake/migrate_to_ddl_4_1.sh.in DESTINATION cmake)
install(FILES README.md DESTINATION .)
else()
# This allows a host product to use find_package from within the build-tree
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/cmake/ddl-config.cmake "")
endif()
##this enables a post-install command, so this must be "Last Dir Standing"!!!
add_subdirectory(doc)
# License Information must be delivered anyway!
install(FILES doc/license/MPL2.0.txt DESTINATION ./)
install(FILES doc/license/MPL2.0.txt DESTINATION doc/license)
install(FILES doc/input/used_licenses.md DESTINATION doc/license)
install(FILES doc/input/mpl.md DESTINATION doc/license)

376
LICENSE Normal file
View file

@ -0,0 +1,376 @@
Mozilla Public License Version 2.0
==================================
1. Definitions
--------------
1.1. "Contributor"
means each individual or legal entity that creates, contributes to
the creation of, or owns Covered Software.
1.2. "Contributor Version"
means the combination of the Contributions of others (if any) used
by a Contributor and that particular Contributor's Contribution.
1.3. "Contribution"
means Covered Software of a particular Contributor.
1.4. "Covered Software"
means Source Code Form to which the initial Contributor has attached
the notice in Exhibit A, the Executable Form of such Source Code
Form, and Modifications of such Source Code Form, in each case
including portions thereof.
1.5. "Incompatible With Secondary Licenses"
means
a. that the initial Contributor has attached the notice described
in Exhibit B to the Covered Software; or
b. that the Covered Software was made available under the terms of
version 1.1 or earlier of the License, but not also under the
terms of a Secondary License.
1.6. "Executable Form"
means any form of the work other than Source Code Form.
1.7. "Larger Work"
means a work that combines Covered Software with other material, in
a separate file or files, that is not Covered Software.
1.8. "License"
means this document.
1.9. "Licensable"
means having the right to grant, to the maximum extent possible,
whether at the time of the initial grant or subsequently, any and
all of the rights conveyed by this License.
1.10. "Modifications"
means any of the following:
a. any file in Source Code Form that results from an addition to,
deletion from, or modification of the contents of Covered
Software; or
b. any new file in Source Code Form that contains any Covered
Software.
1.11. "Patent Claims" of a Contributor
means any patent claim(s), including without limitation, method,
process, and apparatus claims, in any patent Licensable by such
Contributor that would be infringed, but for the grant of the
License, by the making, using, selling, offering for sale, having
made, import, or transfer of either its Contributions or its
Contributor Version.
1.12. "Secondary License"
means either the GNU General Public License, Version 2.0, the GNU
Lesser General Public License, Version 2.1, the GNU Affero General
Public License, Version 3.0, or any later versions of those
licenses.
1.13. "Source Code Form"
means the form of the work preferred for making modifications.
1.14. "You" (or "Your")
means an individual or a legal entity exercising rights under this
License. For legal entities, "You" includes any entity that
controls, is controlled by, or is under common control with You. For
purposes of this definition, "control" means (a) the power, direct
or indirect, to cause the direction or management of such entity,
whether by contract or otherwise, or (b) ownership of more than
fifty percent (50%) of the outstanding shares or beneficial
ownership of such entity.
2. License Grants and Conditions
--------------------------------
### 2.1. Grants
Each Contributor hereby grants You a world-wide, royalty-free,
non-exclusive license:
a. under intellectual property rights (other than patent or trademark)
Licensable by such Contributor to use, reproduce, make available,
modify, display, perform, distribute, and otherwise exploit its
Contributions, either on an unmodified basis, with Modifications, or
as part of a Larger Work; and
b. under Patent Claims of such Contributor to make, use, sell, offer
for sale, have made, import, and otherwise transfer either its
Contributions or its Contributor Version.
### 2.2. Effective Date
The licenses granted in Section 2.1 with respect to any Contribution
become effective for each Contribution on the date the Contributor first
distributes such Contribution.
### 2.3. Limitations on Grant Scope
The licenses granted in this Section 2 are the only rights granted under
this License. No additional rights or licenses will be implied from the
distribution or licensing of Covered Software under this License.
Notwithstanding Section 2.1(b) above, no patent license is granted by a
Contributor:
a. for any code that a Contributor has removed from Covered Software;
or
b. for infringements caused by: (i) Your and any other third party's
modifications of Covered Software, or (ii) the combination of its
Contributions with other software (except as part of its Contributor
Version); or
c. under Patent Claims infringed by Covered Software in the absence of
its Contributions.
This License does not grant any rights in the trademarks, service marks,
or logos of any Contributor (except as may be necessary to comply with
the notice requirements in Section 3.4).
### 2.4. Subsequent Licenses
No Contributor makes additional grants as a result of Your choice to
distribute the Covered Software under a subsequent version of this
License (see Section 10.2) or under the terms of a Secondary License (if
permitted under the terms of Section 3.3).
### 2.5. Representation
Each Contributor represents that the Contributor believes its
Contributions are its original creation(s) or it has sufficient rights
to grant the rights to its Contributions conveyed by this License.
### 2.6. Fair Use
This License is not intended to limit any rights You have under
applicable copyright doctrines of fair use, fair dealing, or other
equivalents.
### 2.7. Conditions
Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
in Section 2.1.
3. Responsibilities
-------------------
### 3.1. Distribution of Source Form
All distribution of Covered Software in Source Code Form, including any
Modifications that You create or to which You contribute, must be under
the terms of this License. You must inform recipients that the Source
Code Form of the Covered Software is governed by the terms of this
License, and how they can obtain a copy of this License. You may not
attempt to alter or restrict the recipients' rights in the Source Code
Form.
### 3.2. Distribution of Executable Form
If You distribute Covered Software in Executable Form then:
a. such Covered Software must also be made available in Source Code
Form, as described in Section 3.1, and You must inform recipients of
the Executable Form how they can obtain a copy of such Source Code
Form by reasonable means in a timely manner, at a charge no more
than the cost of distribution to the recipient; and
b. You may distribute such Executable Form under the terms of this
License, or sublicense it under different terms, provided that the
license for the Executable Form does not attempt to limit or alter
the recipients' rights in the Source Code Form under this License.
### 3.3. Distribution of a Larger Work
You may create and distribute a Larger Work under terms of Your choice,
provided that You also comply with the requirements of this License for
the Covered Software. If the Larger Work is a combination of Covered
Software with a work governed by one or more Secondary Licenses, and the
Covered Software is not Incompatible With Secondary Licenses, this
License permits You to additionally distribute such Covered Software
under the terms of such Secondary License(s), so that the recipient of
the Larger Work may, at their option, further distribute the Covered
Software under the terms of either this License or such Secondary
License(s).
### 3.4. Notices
You may not remove or alter the substance of any license notices
(including copyright notices, patent notices, disclaimers of warranty,
or limitations of liability) contained within the Source Code Form of
the Covered Software, except that You may alter any license notices to
the extent required to remedy known factual inaccuracies.
### 3.5. Application of Additional Terms
You may choose to offer, and to charge a fee for, warranty, support,
indemnity or liability obligations to one or more recipients of Covered
Software. However, You may do so only on Your own behalf, and not on
behalf of any Contributor. You must make it absolutely clear that any
such warranty, support, indemnity, or liability obligation is offered by
You alone, and You hereby agree to indemnify every Contributor for any
liability incurred by such Contributor as a result of warranty, support,
indemnity or liability terms You offer. You may include additional
disclaimers of warranty and limitations of liability specific to any
jurisdiction.
4. Inability to Comply Due to Statute or Regulation
---------------------------------------------------
If it is impossible for You to comply with any of the terms of this
License with respect to some or all of the Covered Software due to
statute, judicial order, or regulation then You must: (a) comply with
the terms of this License to the maximum extent possible; and (b)
describe the limitations and the code they affect. Such description must
be placed in a text file included with all distributions of the Covered
Software under this License. Except to the extent prohibited by statute
or regulation, such description must be sufficiently detailed for a
recipient of ordinary skill to be able to understand it.
5. Termination
--------------
5.1. The rights granted under this License will terminate automatically
if You fail to comply with any of its terms. However, if You become
compliant, then the rights granted under this License from a particular
Contributor are reinstated (a) provisionally, unless and until such
Contributor explicitly and finally terminates Your grants, and (b) on an
ongoing basis, if such Contributor fails to notify You of the
non-compliance by some reasonable means prior to 60 days after You have
come back into compliance. Moreover, Your grants from a particular
Contributor are reinstated on an ongoing basis if such Contributor
notifies You of the non-compliance by some reasonable means, this is the
first time You have received notice of non-compliance with this License
from such Contributor, and You become compliant prior to 30 days after
Your receipt of the notice.
5.2. If You initiate litigation against any entity by asserting a patent
infringement claim (excluding declaratory judgment actions,
counter-claims, and cross-claims) alleging that a Contributor Version
directly or indirectly infringes any patent, then the rights granted to
You by any and all Contributors for the Covered Software under
Section 2.1 of this License shall terminate.
5.3. In the event of termination under Sections 5.1 or 5.2 above, all
end user license agreements (excluding distributors and resellers) which
have been validly granted by You or Your distributors under this License
prior to termination shall survive termination.
6. Disclaimer of Warranty
-------------------------
*Covered Software is provided under this License on an "as is" basis,
without warranty of any kind, either expressed, implied, or statutory,
including, without limitation, warranties that the Covered Software is
free of defects, merchantable, fit for a particular purpose or
non-infringing. The entire risk as to the quality and performance of the
Covered Software is with You. Should any Covered Software prove
defective in any respect, You (not any Contributor) assume the cost of
any necessary servicing, repair, or correction. This disclaimer of
warranty constitutes an essential part of this License. No use of any
Covered Software is authorized under this License except under this
disclaimer.*
7. Limitation of Liability
--------------------------
*Under no circumstances and under no legal theory, whether tort
(including negligence), contract, or otherwise, shall any Contributor,
or anyone who distributes Covered Software as permitted above, be liable
to You for any direct, indirect, special, incidental, or consequential
damages of any character including, without limitation, damages for lost
profits, loss of goodwill, work stoppage, computer failure or
malfunction, or any and all other commercial damages or losses, even if
such party shall have been informed of the possibility of such damages.
This limitation of liability shall not apply to liability for death or
personal injury resulting from such party's negligence to the extent
applicable law prohibits such limitation. Some jurisdictions do not
allow the exclusion or limitation of incidental or consequential
damages, so this exclusion and limitation may not apply to You.*
8. Litigation
-------------
Any litigation relating to this License may be brought only in the
courts of a jurisdiction where the defendant maintains its principal
place of business and such litigation shall be governed by laws of that
jurisdiction, without reference to its conflict-of-law provisions.
Nothing in this Section shall prevent a party's ability to bring
cross-claims or counter-claims.
9. Miscellaneous
----------------
This License represents the complete agreement concerning the subject
matter hereof. If any provision of this License is held to be
unenforceable, such provision shall be reformed only to the extent
necessary to make it enforceable. Any law or regulation which provides
that the language of a contract shall be construed against the drafter
shall not be used to construe this License against a Contributor.
10. Versions of the License
---------------------------
### 10.1. New Versions
Mozilla Foundation is the license steward. Except as provided in
Section 10.3, no one other than the license steward has the right to
modify or publish new versions of this License. Each version will be
given a distinguishing version number.
### 10.2. Effect of New Versions
You may distribute the Covered Software under the terms of the version
of the License under which You originally received the Covered Software,
or under the terms of any subsequent version published by the license
steward.
### 10.3. Modified Versions
If you create software not governed by this License, and you want to
create a new license for such software, you may create and use a
modified version of this License if you rename the license and remove
any references to the name of the license steward (except to note that
such modified license differs from this License).
### 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
If You choose to distribute Source Code Form that is Incompatible With
Secondary Licenses under the terms of this version of the License, the
notice described in Exhibit B of this License must be attached.
Exhibit A - Source Code Form License Notice
-------------------------------------------
> 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.
Exhibit B - "Incompatible With Secondary Licenses" Notice
---------------------------------------------------------
> This Source Code Form is "Incompatible With Secondary Licenses", as
> defined by the Mozilla Public License, v. 2.0.

198
README.md Normal file
View file

@ -0,0 +1,198 @@
# DDL Library {#mainpage}
# Description
The Data Defintion Language (DDL) Package provides utilities to handle data descriptions and data defined by these descriptions.
#include <ddl.h>
* [DDL specification](doc/input/ddl_specification.md) ([link](@ref page_ddl_specification))
_____________________
# DDL Library Parts
This library contains following internal parts:
## OO DDL
A Memory Model for the DDL Language.
* See [OO DDL Documentation](doc/input/oo-ddl.md) ([link](@ref page_oo_ddl))
ddlrepresentation/pkg_ddlrepresentation.h
## Codec API
Access, decode and encode ddl described memory data.
* See [Codec Documentation](doc/input/codec.md) ([link](@ref page_codec))
codec/pkg_codec.h
## DDL-2-header and header-2-DDL generation
Generating a c-header file from DDL and vice versa.
* See [DDL Generators](doc/input/ddl_generators.md)([link](@ref page_ddl_generators))
ddlgenerators/generatorlibrary
ddlgenerators/ddl2header
ddlgenerators/header2ddl
## Mapping Functionality
Map data from one DDL structure to another
* See [Mapping specification](doc/input/mapping_specification.md)([link](@ref page_signal_mapping_spec))
mapping/pkg_mapping.h
## DDL 4.1 migration process
DDL version 4.1.0 introduced an updated coding style which led to changes in all APIs.
* A migration guide is available at [Migration to 4.1](doc/input/migration_4_1.md) ([link](@ref page_migration_4_1))
________________________
# License Information
This library is provided under [MPL 2.0](doc/input/mpl.md)([link](@ref page_mpl)).
Have also a look at doc/licence for all license information.
See also [used licenses](doc/input/used_licenses.md)([link](@ref page_used_licenses)) for licenses of integrated libraries.
________________________
# Change Log
For change history have a look at [Change Log](doc/changelog.md)([link](@ref page_changelog))
________________________
# Dependencies
## a_util library
The libraries above depend on the *a_util library*
See a_util repository at https://github.com/AEV
## How to build
### Build Environment
The libraries are build and tested only under following compilers and operating systems:
#### Windows 7 64 Bit
* Visual Studio C++ 2015 Update 3.1 (Update 3 and KB3165756)
#### Linux Ubuntu 16.04 LTS
* On other distributions make at least sure that libc has version >= 2.23 and libstdc++ >= 6.0.21.
* gcc 5.4
### How to build
If you can not reach the above online repositories the bundle of it is delivered within a separate download area or installation.
See [Delivered repository versions](@ref page_delivered_versions).
#### Build a_util first
The ADTF File Library will only build if a installation of a_utils library is provided.
Following libraries of the a_utils are necessary:
* a_util_concurrency
* a_util_memory
* a_util_regex
* a_util_strings
* a_util_datetime
* a_util_filesystem
* a_util_xml
- Use CMAKE at least in version 3.5.1.
- Use the Release Branch \p "Release/a_util-version-branch" see [Delivered repository versions](@ref page_delivered_versions)
- Use CMakeLists.txt within the main directory as Source Directory
- Do not forget to set a CMAKE_INSTALL_PREFIX
- Build and install for Debug and Release
#### Build ddl library
- Use CMAKE at least in version 3.5.1.
- Use the Release Branch \p "Release/ddl-version-branch". see [Delivered repository versions](@ref page_delivered_versions)
- Use CMakeLists.txt within the main directory as Source Directory
- Do not forget to set a CMAKE_INSTALL_PREFIX
- Build and install for Debug and Release
##### Cmake options and dependencies
<table>
<tr>
<td>
a_util_DIR
</td>
<td>
must be set to *a_util_install*/lib/cmake/a_util
</td>
<td>
See a_util repository at https://github.com/AEV
</td>
</tr>
<tr>
<td>
ddl_cmake_enable_documentation ON/OFF
</td>
<td>
choose wether a documentation is created or not
</td>
<td>
dependency to a valid doxygen executable needed (see http://www.doxygen.nl/)
</td>
</tr>
<tr>
<td>
ddl_cmake_enable_tests ON/OFF
</td>
<td>
choose wether the tests where build while building the libraries or not
</td>
<td>
dependency to a valid gtest package needed (see https://github.com/google/googletest)
</td>
</tr>
<tr>
<td>
ddl_cmake_enable_generator_tools ON/OFF
</td>
<td>
choose wether the tools must be build too
</td>
<td>
</td>
</tr>
<tr>
<td>
ddl_cmake_enable_installation ON/OFF
</td>
<td>
choose wether the tools must be build too
</td>
<td>
</td>
</tr>
</table>

12
cmake/check_cmake_build_type.cmake Normal file
View file

@ -0,0 +1,12 @@
## Check build type and terminate cmake if none is given
if(UNIX)
if(NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";Debug;" AND
NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";Release;" AND
NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";RelWithDebInfo;" AND
NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";MinSizeRel;")
message(FATAL_ERROR "'CMAKE_BUILD_TYPE' is either empty or set to an unknown build type")
endif(NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";Debug;" AND
NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";Release;" AND
NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";RelWithDebInfo;" AND
NOT ";${CMAKE_BUILD_TYPE};" STREQUAL ";MinSizeRel;")
endif(UNIX)

20
cmake/check_cmake_install_prefix.cmake Normal file
View file

@ -0,0 +1,20 @@
## This must always be the first check when running cmake
set(CURRENT_OPTION "ddl_cmake_enable_warn_on_default_cmake_install_prefix")
option(${CURRENT_OPTION} "Warn if 'CMAKE_INSTALL_PREFIX is set to default (default: ON)" ON)
if(${CURRENT_OPTION})
if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT OR
";${util_cmake_CMAKE_DEFAULT_INSTALL_PREFIX};" STREQUAL ";${CMAKE_INSTALL_PREFIX};")
message(WARNING "'CMAKE_INSTALL_PREFIX' is currently set to the default value. Suppress \
this check by disabling '${CURRENT_OPTION}'")
## Enable warning for more than just the first run of cmake
set(util_cmake_CMAKE_DEFAULT_INSTALL_PREFIX ${CMAKE_INSTALL_PREFIX} CACHE INTERNAL "")
else()
unset(util_cmake_CMAKE_DEFAULT_INSTALL_PREFIX)
endif(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT OR
";${util_cmake_CMAKE_DEFAULT_INSTALL_PREFIX};" STREQUAL ";${CMAKE_INSTALL_PREFIX};")
endif(${CURRENT_OPTION})
unset(CURRENT_OPTION)

45
cmake/ddl-config.cmake.in Normal file
View file

@ -0,0 +1,45 @@
if(ddl_FOUND)
return()
endif()
# Compute the installation prefix relative to this file.
get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH)
get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH)
if(_IMPORT_PREFIX STREQUAL "/")
set(_IMPORT_PREFIX "")
endif()
# Add imported library target
add_library(ddl STATIC IMPORTED)
if (WIN32)
set(_LIB_PREFIX "")
set(_LIB_ENDING "lib")
else()
set(_LIB_PREFIX "lib")
set(_LIB_ENDING "a")
endif()
set_target_properties(ddl PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include"
INTERFACE_LINK_LIBRARIES "a_util"
INTERFACE_COMPILE_FEATURES "cxx_std_11"
IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${_LIB_PREFIX}ddl@CMAKE_DEBUG_POSTFIX@.${_LIB_ENDING}"
IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${_LIB_PREFIX}ddl@CMAKE_RELEASE_POSTFIX@.${_LIB_ENDING}"
IMPORTED_LOCATION_RELWITHDEBINFO "${_IMPORT_PREFIX}/lib/${_LIB_PREFIX}ddl@CMAKE_RELWITHDEBINFO_POSTFIX@.${_LIB_ENDING}"
IMPORTED_LOCATION_MINSIZEREL "${_IMPORT_PREFIX}/lib/${_LIB_PREFIX}ddl@CMAKE_MINSIZEREL_POSTFIX@.${_LIB_ENDING}"
)
set(ddl_INCLUDE_DIRS ${_IMPORT_PREFIX}/include)
set(ddl_LIBRARY_DIRS ${_IMPORT_PREFIX}/lib)
set(ddl_BINARY_DIRS ${_IMPORT_PREFIX}/bin)
# Cleanup temporary variables.
unset(_LIB_ENDING)
unset(_IMPORT_PREFIX)
include("${CMAKE_CURRENT_LIST_DIR}/migrate_to_ddl_4_1.cmake")
set(ddl_FOUND true)

132
cmake/ddl4.1_replacements.txt Normal file
View file

@ -0,0 +1,132 @@
cBitSerializer;BitSerializer
cCodec;Codec
cCodecFactory;CodecFactory
cDDL;DDL
cDDLAlignment;DDLAlignment
cDDLAutoVec;DDLAutoVec
cDDLBaseunit;DDLBaseunit
cDDLByteorder;DDLByteorder
cDDLCloner;DDLCloner
cDDLComplex;DDLComplex
cDDLContainer;DDLContainer
cDDLContainerNoClone;DDLContainerNoClone
cDDLDataType;DDLDataType
cDDLDescription;DDLDescription
cDDLElement;DDLElement
cDDLEnum;DDLEnum
cDDLError;DDLError
cDDLExtDeclaration;DDLExtDeclaration
cDDLHeader;DDLHeader
cDDLHelper;DDLHelper
cDDLImporter;DDLImporter
cDDLInspector;DDLInspector
cDDLPrefix;DDLPrefix
cDDLPrinter;DDLPrinter
cDDLProperty;DDLProperty
cDDLRefUnit;DDLRefUnit
cDDLRepair;DDLRepair
cDDLResolver;DDLResolver
cDDLStream;DDLStream
cDDLStreamMetaType;DDLStreamMetaType
cDDLStreamStruct;DDLStreamStruct
cDDLUnit;DDLUnit
cDDLVersionHelper;DDLVersionHelper
cDataTrigger;DataTrigger
cDecoder;Decoder
cElementAccessor;ElementAccessor
cMapAssignment;MapAssignment
cMapConfiguration;MapConfiguration
cMapDataTrigger;MapDataTrigger
cMapEnumTableTransformation;MapEnumTableTransformation
cMapHeader;MapHeader
cMapPeriodicTrigger;MapPeriodicTrigger
cMapPolynomTransformation;MapPolynomTransformation
cMapSignalTrigger;MapSignalTrigger
cMapSource;MapSource
cMapTarget;MapTarget
cMapTransformationBase;MapTransformationBase
cMapTriggerBase;MapTriggerBase
cMappingEngine;MappingEngine
cPeriodicTrigger;PeriodicTrigger
cSignalTrigger;SignalTrigger
cSource;Source
cStaticCodec;StaticCodec
cStaticDecoder;StaticDecoder
cStructLayout;StructLayout
cTarget;Target
cTargetElement;TargetElement
cTriggerBase;TriggerBase
eByteorder;Byteorder
eDDLAlignment;DDLAlignment
eImporterMsgSeverity;ImporterMsgSeverity
sImporterMsg;ImporterMsg
tAssignments;Assignments
tConstants;Constants
tDDLBaseunitIt;DDLBaseunitIt
tDDLBaseunitVec;DDLBaseunitVec
tDDLComplexIt;DDLComplexIt
tDDLComplexVec;DDLComplexVec
tDDLDTIt;DDLDTIt
tDDLDTVec;DDLDTVec
tDDLElementIt;DDLElementIt
tDDLElementItConst;DDLElementItConst
tDDLElementVec;DDLElementVec
tDDLEnumIt;DDLEnumIt
tDDLEnumVec;DDLEnumVec
tDDLExtDeclarationIt;DDLExtDeclarationIt
tDDLExtDeclarationVec;DDLExtDeclarationVec
tDDLPrefixIt;DDLPrefixIt
tDDLPrefixVec;DDLPrefixVec
tDDLPropertyVec;DDLPropertyVec
tDDLRefUnitIt;DDLRefUnitIt
tDDLRefUnitVec;DDLRefUnitVec
tDDLStreamIt;DDLStreamIt
tDDLStreamMap;DDLStreamMap
tDDLStreamMapIt;DDLStreamMapIt
tDDLStreamMetaTypeVec;DDLStreamMetaTypeVec
tDDLStreamStructIt;DDLStreamStructIt
tDDLStreamStructVec;DDLStreamStructVec
tDDLStreamVec;DDLStreamVec
tDDLUnitIt;DDLUnitIt
tDDLUnitVec;DDLUnitVec
tDDLVec;DDLVec
tDataRepresentation;DataRepresentation
tDescriptionCheckFlags;DescriptionCheckFlags
tDynamicStructLayoutElement;DynamicStructLayoutElement
tEnumNameValueVec;EnumNameValueVec
tImporterMsgList;ImporterMsgList
tItemCheckFlags;ItemCheckFlags
tMapAssignmentList;MapAssignmentList
tMapConfigFlags;MapConfigFlags
tMapErrorList;MapErrorList
tMapSourceList;MapSourceList
tMapSourceNameList;MapSourceNameList
tMapStrConversionList;MapStrConversionList
tMapTargetList;MapTargetList
tMapTransformationList;MapTransformationList
tMapTriggerList;MapTriggerList
tMemoryBuffer;MemoryBuffer
tMemoryBuffer;MemoryBuffer
tSourceMap;SourceMap
tTargetElementList;TargetElementList
tTargetMap;TargetMap
tTargetRefList;TargetRefList
tTargetSet;TargetSet
tTriggerCounters;TriggerCounters
tTriggerMap;TriggerMap
tTriggers;Triggers
tTypeMap;TypeMap
DestroyDDL;destroyDDL
PLATFORM_NOT_SUPPORTED;platform_not_supported
PLATFORM_LITTLE_ENDIAN_8;plattform_little_endian_8
PLATFORM_BIG_ENDIAN_8;platform_big_endian_8
eNOE;e_noe
eLE;e_le
eBE;e_be
eSeverity;severity
strDesc;desc
eImporterInfo;importer_info
eImporterWarning;importer_warning
eImporterError;importer_error
MC_LOAD_MAPPING;mc_load_mapping
MC_MERGE_MAPPING;mc_merge_mapping

5
cmake/enable_multicore_compilation.cmake Normal file
View file

@ -0,0 +1,5 @@
if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
# enable multicore compilation
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /MP")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
endif()

50
cmake/migrate_to_ddl_4_1.cmake Normal file
View file

@ -0,0 +1,50 @@
function(ddl_migrate_4_1)
set(options "")
set(oneValueArgs TARGET)
set(multiValueArgs "")
cmake_parse_arguments(CLANG_TIDY "${options}" "${oneValueArgs}"
"${multiValueArgs}" ${ARGN} )
get_target_property(inc_dirs ${CLANG_TIDY_TARGET} INCLUDE_DIRECTORIES)
get_target_property(target_sources ${CLANG_TIDY_TARGET} SOURCES)
get_target_property(target_folder ${CLANG_TIDY_TARGET} FOLDER)
get_target_property(link_libs ${CLANG_TIDY_TARGET} LINK_LIBRARIES)
foreach(lib ${link_libs})
get_target_property(lib_inc_dirs ${lib} INTERFACE_INCLUDE_DIRECTORIES)
if(lib_inc_dirs)
list(APPEND inc_dirs ${lib_inc_dirs})
endif()
endforeach(lib)
foreach(inc ${inc_dirs})
list(APPEND inc_list -isystem${inc})
endforeach(inc)
# filter headers that are included in sources
list(FILTER target_sources INCLUDE REGEX ".*\.cpp$")
set(TIDY_SCRIPT ${CMAKE_CURRENT_BINARY_DIR}/run-clang-tidy-fix-${CLANG_TIDY_TARGET}.sh)
string (REPLACE ";" " " target_sources_spaces "${target_sources}")
string (REPLACE ";" " " inc_list_spaces "${inc_list}")
string (CONCAT TIDY_STRING
"${CONAN_BIN_DIRS_CLANG}/clang-tidy "
" ${target_sources_spaces} "
" -header-filter=.* "
" -fix "
" -fix-errors "
" -- "
" ${inc_list_spaces} "
" -std=c++14 "
" ${CMAKE_CXX_FLAGS} ")
file(GENERATE OUTPUT ${TIDY_SCRIPT} CONTENT "${TIDY_STRING}")
set(REPLACEMENT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
set(REPLACEMENTS_FILE ${ddl_INCLUDE_DIRS}/../cmake/ddl4.1_replacements.txt)
configure_file(${ddl_INCLUDE_DIRS}/../cmake/migrate_to_ddl_4_1.sh.in ${CMAKE_CURRENT_BINARY_DIR}/${CLANG_TIDY_TARGET}_migrate_to_ddl_4_1.sh @ONLY)
endfunction(ddl_migrate_4_1)

19
cmake/migrate_to_ddl_4_1.sh.in Normal file
View file

@ -0,0 +1,19 @@
#!/bin/bash
while IFS=';' read -ra line || [[ -n "$line" ]]; do
find @REPLACEMENT_DIR@ -type f -readable -writable -exec sed -i "s/\b${line[0]}\b/${line[1]}/g" {} \;
done < @REPLACEMENTS_FILE@
i="0"
CWD="$(pwd)"
cd "@CMAKE_CURRENT_SOURCE_DIR@"
chmod +x @TIDY_SCRIPT@
while [ $i -lt 50 ]; do
@TIDY_SCRIPT@ 2>&1 | grep 'clang-tidy applied .* suggested fixes'
if [ $? != 0 ]; then
break
fi
i=$[$i+1]
done
@TIDY_SCRIPT@
cd "$CWD"

2
cmake/set_library_naming_conventions.cmake Normal file
View file

@ -0,0 +1,2 @@
##differentiate between debug and release
set(CMAKE_DEBUG_POSTFIX "d${CMAKE_RELEASE_POSTFIX}")

12
cmake/use_integrated_debug_symbols.cmake Normal file
View file

@ -0,0 +1,12 @@
if(CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
# compile with /Z7 to avoid pdb generation and integrate debug symbols
string(REGEX REPLACE "/Z[iI7]" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /Z7")
string(REGEX REPLACE "/Z[iI7]" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /Z7")
string(REGEX REPLACE "/Z[iI7]" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} /Z7")
string(REGEX REPLACE "/Z[iI7]" "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
set(CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO} /Z7")
endif()

573
codec/access_element.h Normal file
View file

@ -0,0 +1,573 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef DDL_STRUCT_ELEMENT_ACCESS_CLASS_HEADER
#define DDL_STRUCT_ELEMENT_ACCESS_CLASS_HEADER
#include <a_util/result.h>
#include "struct_element.h"
#include "codec_factory.h"
namespace ddl
{
namespace access_element
{
//define all needed error types and values locally
_MAKE_RESULT(-3, ERR_UNEXPECTED)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
namespace detail
{
/// For internal use only. @internal
template <typename T>
static inline size_t getElementCount(const T& type)
{
return type.getElementCount();
}
/// For internal use only. @internal
template <typename T>
static inline a_util::result::Result getElement(const T& type, size_t element_index, const StructElement*& element)
{
return type.getElement(element_index, element);
}
/// For internal use only. @internal
template <>
inline size_t getElementCount(const CodecFactory& type)
{
return type.getStaticElementCount();
}
/// For internal use only. @internal
template <>
inline a_util::result::Result getElement(const CodecFactory& type, size_t element_index, const StructElement*& element)
{
return type.getStaticElement(element_index, element);
}
/// For internal use only. @internal
template <typename T>
a_util::result::Result find_complex_index(const T& decoder, const std::string& struct_name,
size_t& index, const char* post_fix)
{
if (struct_name.empty())
{
index = 0;
return a_util::result::SUCCESS;
}
size_t element_count = getElementCount(decoder);
std::string prefix = struct_name + post_fix;
for (size_t element_index = 0; element_index < element_count; ++element_index)
{
const StructElement* element;
if (isOk(getElement(decoder, element_index, element)))
{
if (a_util::strings::compare(element->name.c_str(), prefix.c_str(), 0, prefix.size()) == 0)
{
index = element_index;
return a_util::result::SUCCESS;
}
}
}
return ERR_NOT_FOUND;
}
}
/**
* find the index of an element by name.
* @param[in] decoder The decoder or factory.
* @param[in] element_name The name of the element.
* @param[out] index The index of the found element.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result find_index(const T& decoder, const std::string& element_name, size_t& index)
{
size_t element_count = detail::getElementCount(decoder);
for (size_t element_index = 0; element_index < element_count; ++element_index)
{
const StructElement* element;
if (isOk(detail::getElement(decoder, element_index, element)))
{
if (element->name == element_name)
{
index = element_index;
return a_util::result::SUCCESS;
}
}
}
return ERR_NOT_FOUND;
}
/**
* find the index of the first element of a sub-structure by name.
* @param[in] decoder The decoder or factory.
* @param[in] struct_name The name of the sub-structure.
* @param[out] index The index of the found element.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result find_struct_index(const T& decoder, const std::string& struct_name, size_t& index)
{
return detail::find_complex_index<T>(decoder, struct_name, index, ".");
}
/**
* find the index of the first element of an array by name.
* @param[in] decoder The decoder or factory.
* @param[in] array_name The name of the array.
* @param[out] index The index of the found element.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result find_array_index(const T& decoder, const std::string& array_name, size_t& index)
{
return detail::find_complex_index<T>(decoder, array_name, index, "[");
}
/**
* find the index of the first element after an array by name.
* @param[in] decoder The decoder or factory.
* @param[in] array_name The name of the array.
* @param[out] index The index of the found element.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result find_array_end_index(const T& decoder, const std::string& array_name, size_t& index)
{
size_t element_count = detail::getElementCount(decoder);
std::string prefix = array_name + "[";
for (index += 1; index < element_count; ++index)
{
const StructElement* element;
if (isFailed(detail::getElement(decoder, index, element)))
{
return a_util::result::SUCCESS;
}
if (a_util::strings::compare(element->name.c_str(), prefix.c_str(), 0, prefix.size()) != 0)
{
return a_util::result::SUCCESS;
}
}
return a_util::result::SUCCESS;
}
/**
* Get the value of an element by name.
* @param[in] decoder The decoder.
* @param[in] element_name The name of the element.
* @param[out] value The location where the value should be copied to.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result get_value(const T& decoder, const std::string& element_name, void* value)
{
size_t element_index;
a_util::result::Result res = find_index(decoder, element_name, element_index);
if (a_util::result::isFailed(res)) return res;
return decoder.getElementValue(element_index, value);
}
/**
* Set the value of an element by name.
* @param[in] codec The codec.
* @param[in] element_name The name of the element.
* @param[in] value The location where the value should be copied from.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result set_value(T& codec, const std::string& element_name, const void* value)
{
size_t element_index;
a_util::result::Result res = find_index(codec, element_name, element_index);
if (a_util::result::isFailed(res)) return res;
return codec.setElementValue(element_index, value);
}
/**
* Get the value of an element by name.
* @param[in] decoder The decoder.
* @param[in] element_name The name of the element.
* @retval The value of the element.
*/
template <typename T>
a_util::variant::Variant get_value(const T& decoder, const std::string& element_name)
{
a_util::variant::Variant result;
size_t element_index;
if (isOk(find_index(decoder, element_name, element_index)))
{
decoder.getElementValue(element_index, result);
}
return result;
}
/**
* Set the value of an element by name.
* @param[in] codec The codec.
* @param[in] element_name The name of the element.
* @param[in] value The new value.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result set_value(T& codec, const std::string& element_name, const a_util::variant::Variant& value)
{
size_t element_index;
a_util::result::Result res = find_index(codec, element_name, element_index);
if (a_util::result::isFailed(res)) return res;
return codec.setElementValue(element_index, value);
}
/**
* Get the value of an element by index.
* @param[in] decoder The decoder.
* @param[in] element_index The index of the element.
* @retval The value of the element.
*/
template <typename T>
a_util::variant::Variant get_value(const T& decoder, size_t element_index)
{
a_util::variant::Variant result;
if (isOk(decoder.getElementValue(element_index, result)))
{
return result;
}
return a_util::variant::Variant(static_cast<int32_t>(0));
}
/**
* Get a pointer to an element by name.
* @param[in] decoder The decoder.
* @param[in] element_name The name of the element.
* @return Address of the element.
*/
template <typename T>
const void* get_value_address(const T& decoder, const std::string& element_name)
{
size_t element_index;
if (isOk(find_index(decoder, element_name, element_index)))
{
return decoder.getElementAddress(element_index);
}
return NULL;
}
/**
* Get a pointer to an element by name.
* @param[in] codec The codec.
* @param[in] element_name The name of the element.
* @return Address of the element.
*/
template <typename T>
void* get_value_address(T& codec, const std::string& element_name)
{
size_t element_index;
if (isOk(find_index(codec, element_name, element_index)))
{
return codec.getElementAddress(element_index);
}
return NULL;
}
/**
* Get a pointer to a sub-structure by name.
* @param[in] decoder The codec.
* @param[in] struct_name The name of the structure.
* @return Address of the sub-structure.
*/
template <typename STRUCT, typename T>
const STRUCT* get_struct_address(const T& decoder, const std::string& struct_name)
{
size_t element_index;
if (isOk(find_struct_index(decoder, struct_name, element_index)))
{
return reinterpret_cast<const STRUCT*>(decoder.getElementAddress(element_index));
}
return NULL;
}
/**
* Get a pointer to a sub-structure by name.
* @param[in] codec The codec.
* @param[in] struct_name The name of the structure.
* @return Address of the sub-structure.
*/
template <typename STRUCT, typename T>
STRUCT* get_struct_address(T& codec, const std::string& struct_name)
{
size_t element_index;
if (isOk(find_struct_index(codec, struct_name, element_index)))
{
return reinterpret_cast<STRUCT*>(codec.getElementAddress(element_index));
}
return NULL;
}
/**
* Copy a sub-structure out of the structure.
* @param[in] decoder The decoder.
* @param[in] struct_name The name of the structure.
* @param[out] struct_value The location the sub-structure will be copied to.
* @retval ERR_NOT_FOUND No structure with the requested name was found.
*/
template <typename T, typename CODEC>
a_util::result::Result get_struct_value(const CODEC& decoder, const std::string& struct_name, T* struct_value)
{
const T* address = get_struct_address<T>(decoder, struct_name);
if (!address)
{
return ERR_NOT_FOUND;
}
a_util::memory::copy(struct_value, sizeof(T), address, sizeof(T));
return a_util::result::SUCCESS;
}
/**
* Copy a sub-structure into the structure.
* @param[in] codec The codec.
* @param[in] struct_name The name of the structure.
* @param[in] struct_value The location the sub-structure will be copied from.
* @retval ERR_NOT_FOUND No structure with the requested name was found.
*/
template <typename T, typename CODEC>
a_util::result::Result set_struct_value(CODEC& codec, const std::string& struct_name, const T* struct_value)
{
T* address = get_struct_address<T>(codec, struct_name);
if (!address)
{
return ERR_NOT_FOUND;
}
a_util::memory::copy(address, sizeof(T), struct_value, sizeof(T));
return a_util::result::SUCCESS;
}
/**
* Get a pointer to an array by name.
* @param[in] decoder The decoder.
* @param[in] array_name The name of the array.
* @return Address of the array.
*/
template <typename ARRAY_TYPE, typename T>
const ARRAY_TYPE* get_array_address(const T& decoder, const std::string& array_name)
{
size_t element_index;
if (isOk(find_array_index(decoder, array_name, element_index)))
{
return reinterpret_cast<const ARRAY_TYPE*>(decoder.getElementAddress(element_index));
}
return NULL;
}
/**
* Get a pointer to an array by name.
* @param[in] codec The codec.
* @param[in] array_name The name of the array.
* @return Address of the array.
*/
template <typename ARRAY_TYPE, typename T>
ARRAY_TYPE* get_array_address(T& codec, const std::string& array_name)
{
size_t element_index;
if (isOk(find_array_index(codec, array_name, element_index)))
{
return reinterpret_cast<ARRAY_TYPE*>(codec.getElementAddress(element_index));
}
return NULL;
}
/**
* Get information about an array.
* @param[in] decoder The decoder.
* @param[in] array_name The name of the array.
* @param[out] start_address The address of the first element of the array.
* @param[out] size The amount of elements of the array.
* @retval ERR_NOT_FOUND No array with the requested name was found.
*/
template <typename CODEC>
a_util::result::Result get_array(const CODEC& decoder, const std::string& array_name,
const void*& start_address, size_t& size)
{
size_t start_index = 0;
a_util::result::Result res = find_array_index(decoder, array_name, start_index);
if (a_util::result::isFailed(res)) return res;
size_t end_index = start_index;
res = find_array_end_index(decoder, array_name, end_index);
if (a_util::result::isFailed(res)) return res;
start_address = decoder.getElementAddress(start_index);
if (!start_address)
{
return ERR_UNEXPECTED;
}
const void* end_adress = decoder.getElementAddress(end_index);
if (end_adress)
{
size = static_cast<const uint8_t*>(end_adress) -
static_cast<const uint8_t*>(start_address);
}
else
{
// it reaches til the end
size_t start_offset = static_cast<const uint8_t*>(start_address) -
static_cast<const uint8_t*>(decoder.getElementAddress(0));
size = decoder.getBufferSize(decoder.getRepresentation()) - start_offset;
}
return a_util::result::SUCCESS;
}
/**
* Copy an array out of the structure.
* @param[in] decoder The decoder.
* @param[in] array_name The name of the array.
* @param[out] array_value The location the array will be copied to.
* @retval ERR_NOT_FOUND No array with the requested name was found.
*/
template <typename T, typename CODEC>
a_util::result::Result get_array_value(const CODEC& decoder, const std::string& array_name, T* array_value)
{
const void* start_address;
size_t size;
a_util::result::Result res = get_array(decoder, array_name, start_address, size);
if (a_util::result::isFailed(res)) return res;
a_util::memory::copy(array_value, size, start_address, size);
return a_util::result::SUCCESS;
}
/**
* Set the value of the requested element to zero.
* @param[in] codec The codec.
* @param[in] element_name The name of the element.
* @retval ERR_NOT_FOUND No element with the requested name was found.
*/
template <typename T>
a_util::result::Result reset(T& codec, const std::string& element_name)
{
size_t element_index;
a_util::result::Result res = find_index(codec, element_name, element_index);
if (a_util::result::isFailed(res)) return res;
uint64_t zero = 0;
return codec.setElementValue(element_index, &zero);
}
///For internal use only. @internal
#define GET_ENUM_CASE(__variant_type, __data_type) \
case a_util::variant::VT_##__variant_type:\
{\
__data_type xValue = value.get##__variant_type();\
for (EnumType::const_iterator it = element->p_enum->begin(); it != element->p_enum->end(); ++it)\
{\
if (xValue == it->second.as##__variant_type())\
{\
return it->first;\
}\
}\
break;\
}
/**
* Get the value of an element as a string, using enum value names if available.
* @param[in] decoder The decoder.
* @param[in] element The index of the element.
* @return A string representation of the value.
*/
template <typename T>
std::string get_value_as_string(const T& decoder, size_t element_index)
{
a_util::variant::Variant value;
const StructElement* element;
if (isOk(decoder.getElement(element_index, element)))
{
if (isOk(decoder.getElementValue(element_index, value)))
{
if (element->p_enum)
{
switch (value.getType())
{
GET_ENUM_CASE(Bool, bool)
GET_ENUM_CASE(Int8, int8_t)
GET_ENUM_CASE(UInt8, uint8_t)
GET_ENUM_CASE(Int16, int16_t)
GET_ENUM_CASE(UInt16, uint16_t)
GET_ENUM_CASE(Int32, int32_t)
GET_ENUM_CASE(UInt32, uint32_t)
GET_ENUM_CASE(Int64, int64_t)
GET_ENUM_CASE(UInt64, uint64_t)
GET_ENUM_CASE(Float, float)
GET_ENUM_CASE(Double, double)
default: break;
}
}
}
}
return value.asString();
}
/**
* Get the value of an element as a string, using enum value names if available.
* @param[in] decoder The decoder.
* @param[in] element_name The name of the element.
* @return A string representation of the value.
*/
template <typename T>
std::string get_value_as_string(const T& decoder, const std::string& element_name)
{
size_t element_index;
if (isOk(find_index(decoder, element_name, element_index)))
{
return get_value_as_string(decoder, element_index);
}
return "";
}
}
}
#endif

97
codec/bitserializer.cpp Normal file
View file

@ -0,0 +1,97 @@
/**
* @file
* Raw memory related functionality
*
* @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 "a_util/memory.h"
#include "bitserializer.h"
using namespace a_util;
using namespace a_util::memory;
a_util::memory::Endianess a_util::memory::get_platform_endianess()
{
uint32_t value = 0x01020304;
if (((unsigned char*)&value)[0] == 0x04 &&
((unsigned char*)&value)[2] == 0x02)
{
return bit_little_endian;
}
else if (((unsigned char*)&value)[0] == 0x01 &&
((unsigned char*)&value)[2] == 0x03)
{
return bit_big_endian;
}
else
{
throw std::runtime_error("unsupported endianess");
}
}
std::string a_util::memory::detail::formatBits(uint64_t value)
{
std::string bit_string;
for (int i = 0; i < (int)sizeof(uint64_t) * 8; i++)
{
if (i % 8 == 0)
{
bit_string += " | ";
}
bit_string += a_util::strings::toString((value >> (63 - i)) & 1);
}
return bit_string;
}
a_util::result::Result a_util::memory::detail::convertSignalEndianess(uint64_t *signal, Endianess endianess, size_t bit_length)
{
if (bit_length > 8) // Signal is bigger than one byte
{
if (endianess != get_platform_endianess()) // Byteorder was different on writing platform
{
if (bit_length > (4 * 8)) // 64 Bit
{
// If the BE signal is shorter than 8 byte, make sure the value is aligned
// at the LSB end, seen from a BE viewpoint.
if (endianess == bit_big_endian)
{
*signal <<= (((8 * 8) - (bit_length)) / 8) * 8;
}
*reinterpret_cast<uint64_t*>(signal) = a_util::memory::swapEndianess(*reinterpret_cast<uint64_t*>(signal));
}
else if (bit_length > (2 * 8)) // 32 Bit
{
// If the BE signal is shorter than 4 byte, make sure the value is aligned
// at the LSB end, seen from a BE viewpoint.
if (endianess == bit_big_endian)
{
*signal <<= (((4 * 8) - (bit_length)) / 8) * 8;
}
*reinterpret_cast<uint32_t*>(signal) = a_util::memory::swapEndianess(*reinterpret_cast<uint32_t*>(signal));
}
else // 16 Bit
{
*reinterpret_cast<uint16_t*>(signal) = a_util::memory::swapEndianess(*reinterpret_cast<uint16_t*>(signal));
}
}
}
return a_util::result::SUCCESS;
}

750
codec/bitserializer.h Normal file
View file

@ -0,0 +1,750 @@
/**
* @file
* Raw memory related functionality
*
* @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
*/
#ifndef A_UTILS_UTIL_MEMORY_BITSERIALIZER_INCLUDED
#define A_UTILS_UTIL_MEMORY_BITSERIALIZER_INCLUDED
#include <algorithm>
#include "a_util/memory.h"
#include "a_util/result.h"
namespace a_util
{
namespace memory
{
//define all needed error types and values locally
_MAKE_RESULT(-4, ERR_POINTER);
_MAKE_RESULT(-5, ERR_INVALID_ARG);
/// Enum describing the endianess
typedef enum
{
bit_little_endian = 1,
bit_big_endian = 2,
} Endianess;
/**
* Returns the endianess of the platform
* @return See \ref Endianess
*/
Endianess get_platform_endianess();
namespace detail
{
/**
* Format the bit pattern of a uint64_t value to a string
* Used for debug purposes.
*
* @param [in] value The value to print.
* @retval The bitstring
*/
std::string formatBits(uint64_t value);
/**
* Convert the endianess of a signal by correctly swapping the byte order if required.
* The variable signal is a uint64_t, but the value that needs conversion might be smaller.
* The parameter bit_length determines if a 16, 32 or 64 value should be swapped.
* For a LE system, reading BE signals of 3, 5, 6 or 7 bytes length the value will be aligned
* within a 4 or 8 byte value before swapping bytes.
*
* @param [in,out] signal Pointer to the variable to store the read value in.
* @param [in] endianess Parameter describing the endianess of the bitfield to convert.
* @param [in] bit_length Number of bits to read.
*
* @return Returns a standard result code.
*/
a_util::result::Result convertSignalEndianess(uint64_t *signal, Endianess endianess, size_t bit_length);
/**
* Converter Base
* Contains the base methods used by all inheriting Converter classes.
*/
template<typename T>
class ConverterBase {
protected:
/**
* Read value from bitfield.
* Operating on a uint64_t copy to allow bit shifting and masking operations.
*
* @param [in] buffer Pointer to the memory buffer to read from.
* @param [in] start_bit Bit position to start reading from. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to read.
* @param [out] value Pointer to the variable to store the read value in.
* @param [in] endianess Parameter describing the endianess of the bitfield to read from.
*
* @return Returns a standard result code.
*/
static a_util::result::Result readSignal(uint8_t *buffer, size_t start_bit, size_t bit_length, T* value,
Endianess endianess = get_platform_endianess())
{
/*
* offset_end offset_start
* _ ____
* | | | |
* ....|...abcde|fghijklm|no......|.... Buffer (index 0 on the right end side)
* |_______________|
* bit_length ^
* |
* start_bit
*/
// 1) COPY relevant bytes of Buffer content to result variable.
uint64_t result = 0; // Result value
uint64_t ninth_byte = 0; // variable to eventually store a ninth byte from buffer
size_t bytes_to_read = 0;
copyBytesFromBuffer(buffer, &result, start_bit, bit_length, &ninth_byte, &bytes_to_read);
// 2) TRIM unrelevant bits and SHIFT to align value.
// Number of bits the start position is offset from 0 (0 for aligned signal)
size_t offset_start = start_bit % 8;
// Number of bits the end position is offset from the end of the last byte (0 for complete bytes)
size_t offset_end = (8 - ((start_bit + bit_length) % 8)) % 8;
/**********************************************************************************************
* Distinguish between LE and BE operating systems to get the shift operations right *
**********************************************************************************************/
// On LE System
if (get_platform_endianess() == bit_little_endian)
{
/* Use bit mask to remove bits on the higher end, which do not belong to the value to read.
*
* ...|...abcde|fghijklm|no......| => 000|000abcde|fghijklm|no......|
*
*/
cutLeadingBits(&result, bit_length + offset_start);
/* Shift right to align start at position 0 (also trims the right end).
*
* 000|000abcde|fghijklm|no......| => 000|00000000|0abcdefg|hijklmno|
*
*/
result >>= offset_start;
// Eventually get bits from the copied 9th byte.
if (ninth_byte > 0) // nothing to take care of if nothing was copied or all copied bits are 0.
{
// deleteAll unwanted bits from ninth byte.
cutLeadingBits(&ninth_byte, (8 - offset_end));
size_t bit_size = sizeof(result) * 8;
// Shift requested bits from the 9th byte into the right position to be combined with result.
ninth_byte <<= (bit_size - offset_start);
// merge value together from all nine bytes.
result = result | ninth_byte;
}
// BE Signal needs byte order swapping.
if (endianess == bit_big_endian)
{
// Only for reading partial bytes. Filling the missing bits differs from LE Signal.
if (bit_length % 8 != 0)
{
/* Shift left to align end position.
*
* 000|0abcdefg|hijklmno| => 000|abcdefgh|ijklmno0|
*
*/
result <<= (offset_end + offset_start) % 8;
/* Shift bits within MSByte, filling the gap with 0s.
*
* 000|abcdefgh|ijklmno0| => 000|abcdefgh|0ijklmno|
* ^ ^
* MSByte MSByte
*/
uint8_t *ms_byte = (uint8_t*)&result;
ms_byte[0] >>= (offset_end + offset_start) % 8;
}
/* swap bytes to LE.
*
* 000|abcdefgh|0ijklmno| => 000|0ijklmno|abcdefgh|
*
*/
detail::convertSignalEndianess(&result, endianess, bit_length);
}
}
// On BE System
else
{
/* swap bytes to simulate LE shifting operations.
*
* |...abcde|fghijklm|no......|... => ...|no......|fghijklm|...abcde|
*
*/
detail::convertSignalEndianess(&result, bit_little_endian, sizeof(result) * 8);
// LE Signal
if (endianess == bit_little_endian)
{
/* Use bit mask to remove bits on the higher end, which do not belong to the value to read.
*
* ...|no......|fghijklm|...abcde| => ...|no......|fghijklm|000abcde|
*
*/
cutLeadingBits(&result, (sizeof(result) * 8) - offset_end); // Cut away only offset_end bits.
/* Shift right to align bits within LSByte (BE Shifting!).
*
* ...|no......|fghijklm|000abcde| => ...|hijklmno|0abcdefg|00000000|
*
*/
result >>= offset_start;
/* Shift right to align LSByte on the left side (BE Shifting!).
*
* ...|hijklmno|0abcdefg|00000000| => |hijklmno|0abcdefg|000
*
* Shift over all
* empty bytes = (all bits - occupied bits (bit_length) - already shifted bits) / number of bytes
*/
result >>= (((sizeof(result) * 8) - bit_length - offset_start) / sizeof(result)) * 8;
// No further byte swap, because there has been one swap before the shift operations already.
}
// BE Signal
else
{
/* Shift left to align bits within LSByte (now rightmost byte because of byte swap).
* Also deletes bits from end offset.
*
* ...|no......|fghijklm|...abcde| => ...|........|ijklmno.|abcdefgh|
*
*/
result <<= offset_end;
// Only for reading partial bytes. Filling the missing bits differs from LE Signal.
if (bit_length % 8 != 0)
{
/* Shift bits within MSByte to move 0s to the highest bits (also deleting all unwanted bits from start offset).
*
* ...|........|ijklmno.|abcdefgh| => ...|........|0ijklmno|abcdefgh|
*
*/
uint8_t *ms_byte = (uint8_t*)&result + (bit_length / 8); // position of the value's MSByte
ms_byte[0] >>= (offset_end + offset_start) % 8; // amount of unused bits within MSByte
}
/* swap bytes back to BE
*
* ...|........|0ijklmno|abcdefgh| => |abcdefgh|0ijklmno|...
*
*/
detail::convertSignalEndianess(&result, bit_little_endian, sizeof(result) * 8); // Change the simulated LE value back
/* Use bit mask to remove bits on the higher end, which do not belong to the value to read.
*
* |abcdefgh|0ijklmno|... => |abcdefgh|0ijklmno|000
*
* Remove everything behind the value length plus the gap within MSByte.
*/
cutLeadingBits(&result, bit_length + (offset_end + offset_start) % 8);
}
}
// Copy the resulting value to the target variable. No Casting! Data might be lost otherwise.
size_t sz = std::min(sizeof(*value), sizeof(result));
a_util::memory::copy(value, sz, &result, sz);
return a_util::result::SUCCESS;
}
/**
* Write value to bitfield.
* Operating on a uint64_t copy to allow bit shifting and masking operations.
*
* @param [in] buffer Pointer to the memory buffer to write to.
* @param [in] start_bit Bit position to start writing to. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to write.
* @param [out] value Value to write to the bitfield.
* @param [in] endianess Parameter describing the endianess of the bitfield to write to.
*
* @return Returns a standard result code.
*/
static a_util::result::Result writeSignal(uint8_t *buffer, size_t start_bit, size_t bit_length, T value,
Endianess endianess = get_platform_endianess())
{
// 1) Copy relevant bytes of Buffer content to be overwritten.
uint64_t buffer_copy = 0;
uint64_t ninth_byte = 0; // storage variable for the ninth bit from buffer
size_t bytes_to_read = 0;
copyBytesFromBuffer(buffer, &buffer_copy, start_bit, bit_length, &ninth_byte, &bytes_to_read);
// 2) Erase Bits from Buffer copy that will be overwritten TODO: BE LE system difference important here?
// Number of bits the start position is offset from 0
size_t offset_start = start_bit % 8;
// Number of bits the end position is offset from the end of the last byte
size_t offset_end = (8 - ((start_bit + bit_length) % 8)) % 8;
uint64_t mask_left = ~0ULL;
if ((bit_length + offset_start) >= (sizeof(mask_left) * 8))
{
mask_left = 0;
}
else
{
mask_left = ~0ULL;
mask_left <<= (bit_length + offset_start);
}
uint64_t mask = ~0ULL;
mask <<= offset_start;
mask = ~mask;
mask |= mask_left;
buffer_copy &= mask;
// 3) Copy value to UInt64 variable to work with.
uint64_t signal;
a_util::memory::copy(&signal, sizeof(signal), &value, sizeof(signal));
// 4) Keep only nLength bits: Remove bits that should not be written to the Buffer.
cutLeadingBits(&signal, bit_length);
// 5) Shift to align at start bit position.
int shift_amount = (int)offset_start; // Initialized to fit LE Signal shift
// BE Signal
if (endianess == bit_big_endian)
{
// swap bytes
detail::convertSignalEndianess(&signal, endianess, bit_length);
// Remove gap for partial bytes within MSByte
uint8_t *ms_byte = (uint8_t*)&signal;
int ms_shift = (8 - (bit_length % 8)) % 8;
ms_byte[0] <<= ms_shift;
shift_amount -= ms_shift;
}
// Copy most significant byte to ninth buffer byte before losing bits with the shift.
if ((offset_start + bit_length) > (sizeof(signal) * 8))
{
uint64_t signal_for_ninth_byte = signal;
signal_for_ninth_byte >>= (sizeof(signal) - 1) * 8;
signal_for_ninth_byte >>= (8 - offset_start); // Only LE Signal
uint64_t mask = ~0ULL;
mask <<= (8 - offset_end);
ninth_byte &= mask;
ninth_byte |= signal_for_ninth_byte;
}
if (shift_amount < 0)
{
signal >>= std::abs(shift_amount);
}
else
{
signal <<= shift_amount;
}
// 7) Write bytes with integrated signal back to the buffer.
buffer_copy |= signal;
size_t sz = std::min(bytes_to_read, sizeof(signal));
a_util::memory::copy(buffer + (start_bit / 8), sz, &buffer_copy, sz);
// Eventually copy ninth byte back to buffer
if (bytes_to_read > sizeof(signal))
{
a_util::memory::copy(buffer + (start_bit / 8) + sizeof(signal), 1, &ninth_byte, 1);
}
return a_util::result::SUCCESS;
}
/**
* Set the highest bits of a uint64_t value to zero. The number of bit_length lowest bits
* remain unchanged.
*
* @param [out] value Pointer to the variable to trim.
* @param [in] bit_length Number of trailing bits to remain unchanged.
*
* @return Returns a standard result code.
*/
static a_util::result::Result cutLeadingBits(uint64_t *value, size_t bit_length)
{
size_t bit_size = (sizeof(*value) * 8);
if (bit_length < bit_size)
{
uint64_t mask = ~0ULL;
mask >>= (bit_size - bit_length);
*value &= mask;
}
return a_util::result::SUCCESS;
}
/**
* Copy bytes_to_read number of bytes from the buffer to value and ninth_byte.
* Determines how many bytes need to be copied to receive a copy of all bits in the range described
* by start_bit and bit_length. The maximum for bit_length is 64, but for unaligned values the range
* may exceed 8 bytes. In this case, the required ninth byte will be copied to ninth_byte.
*
* @param [in] buffer Pointer to the memory buffer to copy from.
* @param [out] value Pointer to the variable to store the copied value in.
* @param [in] start_bit Bit position to start reading from. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to read.
* @param [out] ninth_byte Pointer to the variable to eventually store a copied ninth byte in.
* @param [out] bytes_to_read Number of bytes that need to be copied to attain all requested bits.
*
* @return Returns a standard result code.
*/
static a_util::result::Result copyBytesFromBuffer(uint8_t *buffer, uint64_t *value, size_t start_bit, size_t bit_length, uint64_t *ninth_byte, size_t *bytes_to_read)
{
// Byte within the buffer to start reading at
size_t start_byte = start_bit / 8;
// Number of bits to read: signal length + bits to fill in the offset on both sides for unaligned signals
size_t bits_to_read = bit_length + (start_bit % 8);
if ((bits_to_read % 8) > 0)
{
bits_to_read += (8 - (bits_to_read % 8));
}
// Number of bytes to read from the buffer
*bytes_to_read = bits_to_read / 8;
// Copy up to 8 bytes to result
if (*bytes_to_read > (size_t)sizeof(*value))
{
a_util::memory::copy(value, sizeof(*value), buffer + start_byte, sizeof(*value));
}
else
{
a_util::memory::copy(value, *bytes_to_read, buffer + start_byte, *bytes_to_read);
}
// The max signal size is 8 byte, but if the signal is not aligned, it might spread over 9 bytes.
if (*bytes_to_read > sizeof(*value))
{
// Get a copy of the most significant byte, which could not yet be saved to result
a_util::memory::copy(ninth_byte, 1, buffer + start_byte + sizeof(*value), 1);
}
return a_util::result::SUCCESS;
}
};
/// Template converter class to differentiate between float, signed and unsigned integer values.
template<typename T, int is_signed, int is_floating_point> class Converter;
/// Partially specialized class for Unsigned Integers
template<typename T>
class Converter<T, 0, 0> : public ConverterBase<T>
{
public:
/**
* Read unsigned integer from bitfield.
*
* @param [in] buffer Pointer to the memory buffer to read from.
* @param [in] start_bit Bit position to start reading from. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to read.
* @param [out] value Pointer to the variable to store the read value in.
* @param [in] endianess Parameter describing the endianess of the bitfield to read from.
*
* @return Returns a standard result code.
*/
static a_util::result::Result read(uint8_t *buffer, size_t start_bit, size_t bit_length, T* value,
Endianess endianess)
{
return ConverterBase<T>::readSignal(buffer, start_bit, bit_length, value, endianess);
}
/**
* Write unsigned integer to bitfield.
*
* @param [in] buffer Pointer to the memory buffer to write to.
* @param [in] start_bit Bit position to start writing to. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to write.
* @param [out] value Value to write to the bitfield.
* @param [in] endianess Parameter describing the endianess of the bitfield to write to.
*
* @return Returns a standard result code.
*/
static a_util::result::Result write(uint8_t *buffer, size_t start_bit, size_t bit_length, T value,
Endianess endianess)
{
return ConverterBase<T>::writeSignal(buffer, start_bit, bit_length, value, endianess);
}
};
/// Partially specialized class for Signed Integers
template<typename T>
class Converter<T, 1, 0> : public ConverterBase<T>
{
public:
/**
* Read signed integer from bitfield.
*
* @param [in] buffer Pointer to the memory buffer to read from.
* @param [in] start_bit Bit position to start reading from. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to read.
* @param [out] value Pointer to the variable to store the read value in.
* @param [in] endianess Parameter describing the endianess of the bitfield to read from.
*
* @return Returns a standard result code.
*/
static a_util::result::Result read(uint8_t *buffer, size_t start_bit, size_t bit_length, T* value,
Endianess endianess)
{
a_util::result::Result res = ConverterBase<T>::readSignal(buffer, start_bit, bit_length, value, endianess);
if (res != a_util::result::SUCCESS)
{
return res;
}
// replicate sign bit
*value <<= (sizeof(T) * 8) - bit_length;
*value >>= (sizeof(T) * 8) - bit_length;
return a_util::result::SUCCESS;
}
/**
* Write signed integer to bitfield.
*
* @param [in] buffer Pointer to the memory buffer to write to.
* @param [in] start_bit Bit position to start writing to. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to write.
* @param [out] value Value to write to the bitfield.
* @param [in] endianess Parameter describing the endianess of the bitfield to write to.
*
* @return Returns a standard result code.
*/
static a_util::result::Result write(uint8_t *buffer, size_t start_bit, size_t bit_length, T value,
Endianess endianess)
{
// Nothing special to take care of for writing signed integers, compared to writing unsigned integers.
return ConverterBase<T>::writeSignal(buffer, start_bit, bit_length, value, endianess);
}
};
/// Specialized class for Floats (Floats are always signed!)
template<typename T>
class Converter<T, 1, 1> : public ConverterBase<T>
{
public:
/**
* Read tFloat from bitfield.
*
* @param [in] buffer Pointer to the memory buffer to read from.
* @param [in] start_bit Bit position to start reading from. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to read.
* @param [out] value Pointer to the variable to store the read value in.
* @param [in] endianess Parameter describing the endianess of the bitfield to read from.
*
* @return Returns a standard result code.
*/
static a_util::result::Result read(uint8_t *buffer, size_t start_bit, size_t bit_length, T* value,
Endianess endianess)
{
// Read only values of size tFloat
if (sizeof(T) * 8 == bit_length)
{
return ConverterBase<T>::readSignal(buffer, start_bit, bit_length, value, endianess);
}
else
{
return ERR_INVALID_ARG;
}
}
/**
* Write tFloat to bitfield.
*
* @param [in] buffer Pointer to the memory buffer to write to.
* @param [in] start_bit Bit position to start writing to. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to write.
* @param [out] value Value to write to the bitfield.
* @param [in] endianess Parameter describing the endianess of the bitfield to write to.
*
* @return Returns a standard result code.
*/
static a_util::result::Result write(uint8_t *buffer, size_t start_bit, size_t bit_length, T value,
Endianess endianess)
{
// Write only values of size tFloat
if (sizeof(T) * 8 == bit_length)
{
return ConverterBase<T>::writeSignal(buffer, start_bit, bit_length, value, endianess);
}
else
{
return ERR_INVALID_ARG;
}
}
};
} // namespace detail
/// Bit Serializer Class
class BitSerializer
{
public:
/**
* Constructor
*/
BitSerializer(void* data, size_t data_size) :
_buffer(static_cast<uint8_t*>(data)), _buffer_bytes(data_size),
_buffer_bits(_buffer_bytes * 8)
{
}
/**
* Default Constructor
*/
BitSerializer() : _buffer(NULL), _buffer_bytes(0), _buffer_bits(0)
{
}
/**
* Read value from bitfield. Value can be of type tFloat or an unsigned or signed integer.
*
* ....|...*****|********|**......|.... Buffer (index 0 on the right end side)
* |_______________|
* bit_length ^
* |
* start_bit
*
* @param [in] start_bit Bit position to start reading from. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to read.
* @param [out] value Pointer to the variable to store the read value in.
* @param [in] endianess Parameter describing the endianess of the bitfield to read from.
*
* @return Returns a standard result code.
*/
template<typename T>
a_util::result::Result read(size_t start_bit, size_t bit_length, T* value,
Endianess endianess = get_platform_endianess())
{
// Check if in range
a_util::result::Result result_code = checkForInvalidArguments(start_bit, bit_length, sizeof(T));
if (result_code != a_util::result::SUCCESS)
{
return result_code;
}
// Call template function
detail::Converter<T, std::is_signed<T>::value,
std::is_floating_point<T>::value>
::read(_buffer, start_bit, bit_length, value, endianess);
return a_util::result::SUCCESS;
}
/**
* Write value to bitfield. Value can be of type tFloat or an unsigned or signed integer.
*
* ....|...*****|********|**......|.... Buffer (index 0 on the right end side)
* |_______________|
* bit_length ^
* |
* start_bit
*
* @param [in] start_bit Bit position to start writing to. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to write.
* @param [out] value Value to write to the bitfield.
* @param [in] endianess Parameter describing the endianess of the bitfield to write to.
*
* @return Returns a standard result code.
*/
template<typename T>
a_util::result::Result write(size_t start_bit, size_t bit_length, T value,
Endianess endianess = get_platform_endianess())
{
// Check if in range
a_util::result::Result result_code = checkForInvalidArguments(start_bit, bit_length, sizeof(T));
if (result_code != a_util::result::SUCCESS)
{
return result_code;
}
// Call template function
detail::Converter<T, std::is_signed<T>::value,
std::is_floating_point<T>::value>
::write(_buffer, start_bit, bit_length, value, endianess);
return a_util::result::SUCCESS;
}
private:
/// internal buffer
uint8_t *_buffer;
/// size of internal buffer in bytes
size_t _buffer_bytes;
/// size of internal buffer in bits
size_t _buffer_bits;
/**
* Check if the parameters for the reading and writing access are valid.
* The variable to read from or into might be too small and the accessed region of the memory buffer
* might be out of range.
*
* @param [in] start_bit Bit position to start reading from. The least significant bit
* has the index 0.
* @param [in] bit_length Number of bits to read.
* @param [in] size_variable Size of the variable to read into or write from.
*
* @return Returns a standard result code.
*/
a_util::result::Result checkForInvalidArguments(size_t start_bit, size_t bit_length, size_t size_variable)
{
if (!_buffer)
{
return ERR_POINTER;
}
// Check invalid starting point
if (start_bit >= _buffer_bits)
{
return ERR_INVALID_ARG;
}
// Check out of buffer bounds or length < 1
if ((bit_length < 1)
|| (_buffer_bits < start_bit + bit_length))
{
return ERR_INVALID_ARG;
}
// Check variable size
if (size_variable * 8 < bit_length)
{
return ERR_INVALID_ARG;
}
return a_util::result::SUCCESS;
}
};
} // namespace memory
} // namespace a_util
#endif // A_UTILS_UTIL_MEMORY_BITSERIALIZER_INCLUDED

323
codec/codec.cpp Normal file
View file

@ -0,0 +1,323 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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 "codec.h"
#include "a_util/result/error_def.h"
#include "a_util/logging.h"
#include "legacy_error_macros.h"
#include "struct_layout.h"
#include "static_codec.h"
#include "element_accessor.h"
#include "access_element.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-10, ERR_INVALID_INDEX)
static inline void BitToBytes(size_t& size)
{
if (size % 8)
{
size = size/ 8 + 1;
}
else
{
size /= 8;
}
}
Decoder::Decoder(const Decoder& oDecoder, const void* pData, size_t nDataSize,
DataRepresentation eRep):
StaticDecoder(oDecoder._layout, pData, nDataSize, eRep),
_dynamic_elements(oDecoder._dynamic_elements),
_buffer_sizes(oDecoder._buffer_sizes)
{
}
Decoder::Decoder(a_util::memory::shared_ptr<const StructLayout> pLayout, const void* pData, size_t nDataSize,
DataRepresentation eRep):
StaticDecoder(pLayout, pData, nDataSize, eRep),
_buffer_sizes(pLayout->getStaticBufferBitSizes())
{
if (_layout->hasDynamicElements())
{
a_util::result::Result oResult = calculateDynamicElements();
if (isFailed(oResult))
{
LOG_ERROR("Failed to calculate dynamic elements");
}
}
BitToBytes(_buffer_sizes.deserialized);
BitToBytes(_buffer_sizes.serialized);
}
a_util::result::Result Decoder::isValid() const
{
RETURN_IF_FAILED(_layout->isValid());
if (_data_size < getBufferSize(getRepresentation()))
{
return ERR_INVALID_ARG;
}
return a_util::result::SUCCESS;
}
a_util::result::Result Decoder::calculateDynamicElements()
{
_dynamic_elements.reset(new std::vector<StructLayoutElement>());
for (std::vector<DynamicStructLayoutElement>::const_iterator
itDynamicElement = _layout->getDynamicElements().begin();
itDynamicElement != _layout->getDynamicElements().end(); ++ itDynamicElement)
{
RETURN_IF_FAILED(addDynamicElements(*itDynamicElement, _buffer_sizes, ""));
}
return a_util::result::SUCCESS;
}
void Decoder::moveToAlignment(size_t& bit_offset, size_t alignment)
{
size_t nBitRest = bit_offset % 8;
if (nBitRest)
{
bit_offset += 8 - nBitRest;
}
size_t nByteOffset = bit_offset / 8;
size_t nRest = nByteOffset % alignment;
if (nRest)
{
bit_offset += (alignment - nRest) * 8;
}
}
a_util::result::Result Decoder::addDynamicElements(const DynamicStructLayoutElement& sDynamicElement,
Offsets& sOverallOffsets,
const std::string& strPrefix)
{
moveToAlignment(sOverallOffsets.deserialized, sDynamicElement.alignment);
if (sDynamicElement.isAlignmentElement())
{
return a_util::result::SUCCESS;
}
a_util::variant::Variant oArraySize((uint64_t)1);
bool bIsArray = sDynamicElement.isDynamicArray();
if (bIsArray)
{
oArraySize = access_element::get_value(*this,
strPrefix + sDynamicElement.size_element_name);
}
size_t nArraySize = static_cast<size_t>(oArraySize.asUInt64());
for (size_t nArrayIndex = 0; nArrayIndex < nArraySize; ++nArrayIndex)
{
RETURN_IF_FAILED(addDynamicElement(sDynamicElement,
bIsArray ? a_util::strings::format("[%d]", nArrayIndex) : "",
sOverallOffsets, strPrefix));
}
moveToAlignment(sOverallOffsets.deserialized, sDynamicElement.alignment);
return a_util::result::SUCCESS;
}
a_util::result::Result Decoder::addDynamicElement(const DynamicStructLayoutElement& sDynamicElement,
const std::string& strArrayIndex,
Offsets& sOverallOffsets,
const std::string& strPrefix)
{
RETURN_IF_FAILED(addStaticStructElements(sDynamicElement, strArrayIndex, sOverallOffsets, strPrefix));
RETURN_IF_FAILED(addDynamicStructElements(sDynamicElement, strArrayIndex, sOverallOffsets, strPrefix));
return a_util::result::SUCCESS;
}
a_util::result::Result Decoder::addStaticStructElements(const DynamicStructLayoutElement& sDynamicElement,
const std::string& strArrayIndex,
Offsets& nOverallBitOffset,
const std::string& strPrefix)
{
Offsets sStartOffsets = nOverallBitOffset;
for (std::vector<StructLayoutElement>::const_iterator itStaticElement = sDynamicElement.static_elements.begin();
itStaticElement != sDynamicElement.static_elements.end(); ++itStaticElement)
{
StructLayoutElement sElement = *itStaticElement;
sElement.deserialized.bit_offset += sStartOffsets.deserialized;
sElement.serialized.bit_offset += sStartOffsets.serialized;
nOverallBitOffset.deserialized = sElement.deserialized.bit_offset + sElement.deserialized.bit_size;
nOverallBitOffset.serialized = sElement.serialized.bit_offset + sElement.serialized.bit_size;
if (!sElement.name.empty())
{
sElement.name = a_util::strings::format("%s%s%s.%s", strPrefix.c_str(),
sDynamicElement.name.c_str(),
strArrayIndex.c_str(),
itStaticElement->name.c_str());
}
else
{
// not part of a struct, just a plain array element
sElement.name = a_util::strings::format("%s%s%s", strPrefix.c_str(),
sDynamicElement.name.c_str(),
strArrayIndex.c_str());
}
RETURN_IF_FAILED(addDynamicStructElement(sElement));
}
return a_util::result::SUCCESS;
}
a_util::result::Result Decoder::addDynamicStructElements(const DynamicStructLayoutElement& sDynamicElement,
const std::string& strArrayIndex,
Offsets& sOverallOffsets,
const std::string& strPrefix)
{
std::string strChildPrefix = a_util::strings::format("%s%s%s.", strPrefix.c_str(),
sDynamicElement.name.c_str(),
strArrayIndex.c_str());
for (std::vector<DynamicStructLayoutElement>::const_iterator
itDynamicChildElement = sDynamicElement.dynamic_elements.begin();
itDynamicChildElement != sDynamicElement.dynamic_elements.end();
++itDynamicChildElement)
{
RETURN_IF_FAILED(addDynamicElements(*itDynamicChildElement, sOverallOffsets, strChildPrefix));
}
return a_util::result::SUCCESS;
}
a_util::result::Result Decoder::addDynamicStructElement(const StructLayoutElement& sElement)
{
const Position& sPos = _element_accessor->getRepresentation() == deserialized ?
sElement.deserialized : sElement.serialized;
if (sPos.bit_offset + sPos.bit_size > _data_size * 8)
{
return ERR_INVALID_ARG;
}
_dynamic_elements->push_back(sElement);
return a_util::result::SUCCESS;
}
size_t Decoder::getElementCount() const
{
if (_dynamic_elements)
{
return _layout->getStaticElements().size() + _dynamic_elements->size();
}
return _layout->getStaticElements().size();
}
size_t Decoder::getBufferSize(DataRepresentation eRep) const
{
return eRep == deserialized ?
_buffer_sizes.deserialized :
_buffer_sizes.serialized;
}
Codec Decoder::makeCodecFor(void* pData, size_t nDataSize, DataRepresentation eRep) const
{
return Codec(*this, pData, nDataSize, eRep);
}
const StructLayoutElement* Decoder::getLayoutElement(size_t nIndex) const
{
const StructLayoutElement* pElement = NULL;
size_t nStaticElementCount = _layout->getStaticElements().size();
if (nIndex < nStaticElementCount)
{
pElement = &_layout->getStaticElements()[nIndex];
}
else if (_dynamic_elements &&
nIndex - nStaticElementCount < _dynamic_elements->size())
{
pElement = &(*_dynamic_elements)[nIndex - nStaticElementCount];
}
return pElement;
}
Codec::Codec(a_util::memory::shared_ptr<const StructLayout> pLayout, void* pData, size_t nDataSize,
DataRepresentation eRep):
Decoder(pLayout, pData, nDataSize, eRep)
{
}
Codec::Codec(const Decoder& oDecoder, void* pData, size_t nDataSize, DataRepresentation eRep):
Decoder(oDecoder, pData, nDataSize, eRep)
{
}
a_util::result::Result Codec::setElementValue(size_t nIndex, const void* pValue)
{
const StructLayoutElement* pElement = getLayoutElement(nIndex);
if (!pElement)
{
return ERR_INVALID_INDEX;
}
return _element_accessor->setValue(*pElement,
const_cast<void*>(_data),
_data_size,
pValue);
}
a_util::result::Result Codec::setElementValue(size_t nIndex, const a_util::variant::Variant& oValue)
{
const StructLayoutElement* pElement = getLayoutElement(nIndex);
if (!pElement)
{
return ERR_INVALID_INDEX;
}
return _element_accessor->setValue(*pElement, const_cast<void*>(_data),
_data_size, oValue);
}
void* Codec::getElementAddress(size_t nIndex)
{
return const_cast<void*>(StaticDecoder::getElementAddress(nIndex));
}
a_util::result::Result Codec::setConstants()
{
if (_layout->hasEnums())
{
size_t nElementCount = getElementCount();
for (size_t nElement = 0; nElement < nElementCount; ++nElement)
{
const StructLayoutElement* pElement = getLayoutElement(nElement);
if (pElement->constant)
{
RETURN_IF_FAILED(_element_accessor->setValue(*pElement, const_cast<void*>(_data),
_data_size, *pElement->constant));
}
}
}
return a_util::result::SUCCESS;
}
}

161
codec/codec.h Normal file
View file

@ -0,0 +1,161 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef DDL_CODEC_CLASS_HEADER
#define DDL_CODEC_CLASS_HEADER
#include "a_util/result.h"
#include "static_codec.h"
namespace ddl
{
class Codec;
/**
* Decoder for dynamic structures defined by a DDL definition.
*/
class Decoder: public StaticDecoder
{
public:
/**
* @copydoc StaticDecoder::isValid
*/
virtual a_util::result::Result isValid() const;
/**
* @copydoc StaticDecoder::getElementCount
*/
virtual size_t getElementCount() const;
/**
* @param[in] rep The data representation for which the buffer size should be returned.
* @return The size of the structure in the requested data representation.
*/
size_t getBufferSize(DataRepresentation rep = deserialized) const;
/**
* Create a new codec with the current dynamic structure layout for a new data buffer.
* @param[in] data The pointer to the new raw data.
* @param[in] data_size The size of the new raw data.
* @param[in] rep The representation that the data should be encoded in.
* @return A codec.
*/
Codec makeCodecFor(void* data, size_t data_size, DataRepresentation rep) const;
protected:
friend class CodecFactory;
/// For internal use only. @internal
Decoder(a_util::memory::shared_ptr<const StructLayout> layout, const void* data, size_t data_size,
DataRepresentation rep);
/// For internal use only. @internal
Decoder(const Decoder& decoder, const void* data, size_t data_size,
DataRepresentation rep);
/// For internal use only. @internal
virtual const StructLayoutElement* getLayoutElement(size_t index) const;
private:
/// For internal use only. @internal
a_util::result::Result calculateDynamicElements();
/// For internal use only. @internal
a_util::result::Result addDynamicElements(const DynamicStructLayoutElement& dynamic_element,
Offsets& overall_offsets,
const std::string& prefix);
/// For internal use only. @internal
a_util::result::Result addDynamicElement(const DynamicStructLayoutElement& dynamic_element,
const std::string& array_index,
Offsets& overall_offsets,
const std::string& prefix);
/// For internal use only. @internal
a_util::result::Result addStaticStructElements(const DynamicStructLayoutElement& dynamic_element,
const std::string& array_index,
Offsets& overall_offsets,
const std::string& prefix);
/// For internal use only. @internal
a_util::result::Result addDynamicStructElements(const DynamicStructLayoutElement& dynamic_element,
const std::string& array_index,
Offsets& overall_offsets,
const std::string& prefix);
/// For internal use only. @internal
a_util::result::Result addDynamicStructElement(const StructLayoutElement& element);
/// For internal use only. @internal
void moveToAlignment(size_t& bit_offset, size_t alignment);
protected:
/// For internal use only. @internal
a_util::memory::shared_ptr<std::vector<StructLayoutElement> > _dynamic_elements;
/// For internal use only. @internal
Offsets _buffer_sizes;
};
/**
* Decoder for dynamic structures defined by a DDL definition.
* Currently the amount of dynamic elements is determined during construction
* only (by the current values in the structure).
*/
class Codec: public Decoder
{
public:
/**
* Sets the current value of the given element by copying its data
* from the passed-in location.
* @param[in] index The index of the element.
* @param[in] value The location where the data should be copied from.
* @retval ERR_INVALID_INDEX Invalid element index.
*/
a_util::result::Result setElementValue(size_t index, const void* value);
/**
* Sets the current value of the given element to the given value.
* @param[in] index The index of the element.
* @param[in] value The value.
* @retval ERR_INVALID_INDEX Invalid element index.
*/
a_util::result::Result setElementValue(size_t index, const a_util::variant::Variant& value);
/**
* @param[in] index The index of the element.
* @return A pointer to the element or NULL in case of an error.
*/
void* getElementAddress(size_t index);
using StaticDecoder::getElementAddress;
/**
* Sets all elements to their constant values defined in the DDL.
* @return Standard result.
*/
a_util::result::Result setConstants();
protected:
friend class CodecFactory;
friend class Decoder;
/// For internal use only. @internal
Codec(a_util::memory::shared_ptr<const StructLayout> layout, void* data, size_t data_size,
DataRepresentation rep);
/// For internal use only. @internal
Codec(const Decoder& decoder, void* data, size_t data_size,
DataRepresentation rep);
};
}
#endif

29
codec/codec.sources Normal file
View file

@ -0,0 +1,29 @@
set(CODEC_DIR codec)
set(CODEC_H_PUBLIC
${CODEC_DIR}/pkg_codec.h
${CODEC_DIR}/struct_element.h
${CODEC_DIR}/access_element.h
${CODEC_DIR}/static_codec.h
${CODEC_DIR}/codec.h
${CODEC_DIR}/codec_factory.h
${CODEC_DIR}/bitserializer.h
)
set(CODEC_H
${CODEC_H_PUBLIC}
${CODEC_DIR}/struct_layout.h
${CODEC_DIR}/element_accessor.h
)
set(CODEC_CPP
${CODEC_DIR}/struct_layout.cpp
${CODEC_DIR}/element_accessor.cpp
${CODEC_DIR}/static_codec.cpp
${CODEC_DIR}/codec.cpp
${CODEC_DIR}/codec_factory.cpp
${CODEC_DIR}/bitserializer.cpp
)
set(CODEC_INSTALL ${CODEC_H_PUBLIC})
source_group(${CODEC_DIR} FILES ${CODEC_H} ${CODEC_CPP})

117
codec/codec_factory.cpp Normal file
View file

@ -0,0 +1,117 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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 "struct_layout.h"
#include "codec_factory.h"
#include "ddlrepresentation/ddl_error.h"
#include "ddlrepresentation/ddldescription.h"
#include "ddlrepresentation/ddlimporter.h"
#include "ddlrepresentation/ddlversion.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-10, ERR_INVALID_INDEX)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
_MAKE_RESULT(-37, ERR_NOT_INITIALIZED)
static a_util::result::Result getDDL(const char* strMediaDescription,
a_util::memory::unique_ptr<DDLDescription>& pDDL)
{
DDLVersion version_helper = DDLVersion::ddl_version_current;
ddl::DDLImporter oImporter;
a_util::memory::unique_ptr<ddl::DDLDescription> pDefaultDescription(
ddl::DDLDescription::createDefault(version_helper, 4));
RETURN_DDLERROR_IF_FAILED_DESC(oImporter.setXML(strMediaDescription), oImporter.getErrorDesc());
RETURN_DDLERROR_IF_FAILED_DESC(oImporter.createPartial(pDefaultDescription.get(),
version_helper),
oImporter.getErrorDesc());
pDDL.reset(oImporter.getDDL());
return a_util::result::SUCCESS;
}
CodecFactory::CodecFactory():
_layout(new StructLayout()),
_constructor_result(ERR_NOT_INITIALIZED)
{
}
CodecFactory::CodecFactory(const char* strStructName, const char* strMediaDescription)
{
a_util::memory::unique_ptr<DDLDescription> pDDL;
_constructor_result = getDDL(strMediaDescription, pDDL);
if(isOk(_constructor_result))
{
DDLComplex* pStruct = pDDL->getStructByName(strStructName);
if (pStruct)
{
_layout.reset(new StructLayout(pStruct));
_constructor_result = _layout->isValid();
}
else
{
_constructor_result = ERR_NOT_FOUND;
}
}
if (!_layout)
{
_layout.reset(new StructLayout());
}
}
CodecFactory::CodecFactory(const DDLComplex* pStruct):
_layout(new StructLayout(pStruct))
{
_constructor_result = _layout->isValid();
}
a_util::result::Result CodecFactory::isValid() const
{
return _constructor_result;
}
size_t CodecFactory::getStaticElementCount() const
{
return _layout->getStaticElements().size();
}
a_util::result::Result CodecFactory::getStaticElement(size_t nIndex, const StructElement*& pElement) const
{
if (nIndex >= getStaticElementCount())
{
return ERR_INVALID_INDEX;
}
pElement = &_layout->getStaticElements()[nIndex];
return a_util::result::SUCCESS;
}
size_t CodecFactory::getStaticBufferSize(DataRepresentation eRep) const
{
return _layout->getStaticBufferSize(eRep);
}
}

147
codec/codec_factory.h Normal file
View file

@ -0,0 +1,147 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef DDL_CODEC_FACTORY_CLASS_HEADER
#define DDL_CODEC_FACTORY_CLASS_HEADER
#include "codec.h"
#include "ddlrepresentation/ddlcomplex.h"
#include "struct_element.h"
#include "static_codec.h"
namespace ddl
{
/**
* Factory class for ddl codecs.
*/
class CodecFactory
{
public:
/**
* Empty constructor. This exists to enable uninitialized member variables of this type
* that are move-assigned later on.
*/
CodecFactory();
/**
* Constructor that take a DDL string for initialization.
* @param[in] struct_name The name of the struct for which codecs should be generated.
* @param[in] media_description The DDL description.
*/
CodecFactory(const char* struct_name,
const char* media_description);
/**
* Constructor that uses an OO-DDL struct for initialization.
* @param[in] ddl_struct The struct definition.
*/
CodecFactory(const DDLComplex* ddl_struct);
/**
* Check if the factory is in a valid state.
* @return Any errors during construction.
*/
a_util::result::Result isValid() const;
/**
* Creates a static decoder for the given data.
* @param[in] data The pointer to the raw data.
* @param[in] data_size The size of the raw data.
* @param[in] rep The representation that the data is encoded in.
* @return a static decoder.
*/
inline StaticDecoder makeStaticDecoderFor(const void* data, size_t data_size,
DataRepresentation rep = deserialized) const
{
return StaticDecoder(_layout, data, data_size, rep);
}
/**
* Creates a static codec for the given data.
* @param[in] data The pointer to the raw data.
* @param[in] data_size The size of the raw data.
* @param[in] rep The representation that the data is encoded in.
* @return a static codec.
*/
inline StaticCodec makeStaticCodecFor(void* data, size_t data_size,
DataRepresentation rep = deserialized) const
{
return StaticCodec(_layout, data, data_size, rep);
}
/**
* Creates a decoder for the given data.
* @param[in] data The pointer to the raw data.
* @param[in] data_size The size of the raw data.
* @param[in] rep The representation that the data is encoded in.
* @return a decoder.
*/
inline Decoder makeDecoderFor(const void* data, size_t data_size,
DataRepresentation rep = deserialized) const
{
return Decoder(_layout, data, data_size, rep);
}
/**
* Creates a codec for the given data.
* @param[in] data The pointer to the raw data.
* @param[in] data_size The size of the raw data.
* @param[in] rep The representation that the data is encoded in.
* @return a codec.
*/
inline Codec makeCodecFor(void* data, size_t data_size,
DataRepresentation rep = deserialized) const
{
return Codec(_layout, data, data_size, rep);
}
/**
* @return The amount of static elements contained in the handled structure.
*/
size_t getStaticElementCount() const;
/**
* Access information about an element.
* @param[in] index The index of the element.
* @param[out] element Pointer that will be updated to point to the element information.
* @retval ERR_INVALID_INDEX Invalid index.
*/
a_util::result::Result getStaticElement(size_t index, const StructElement*& element) const;
/**
* @param[in] rep The data representation for which the buffer size should be returned.
* @return The size of the structure in the requested data representation.
*/
size_t getStaticBufferSize(DataRepresentation rep = deserialized) const;
private:
/// For internal use only. @internal The struct layout.
a_util::memory::shared_ptr<const StructLayout> _layout;
/// For internal use only. @internal The constructor result.
a_util::result::Result _constructor_result;
};
}
#endif

228
codec/element_accessor.cpp Normal file
View file

@ -0,0 +1,228 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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 <assert.h>
#include "a_util/result/error_def.h"
#include "a_util/variant.h"
#include "a_util/memory.h"
#include "element_accessor.h"
#include "legacy_error_macros.h"
#include "bitserializer.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-19, ERR_NOT_SUPPORTED)
template <typename T>
a_util::result::Result get_typed_element_value(const StructLayoutElement& sElement, const void* pData,
size_t nDataSize, a_util::variant::Variant& oValue,
const ElementAccessor& oAccessor)
{
T xValue;
RETURN_IF_FAILED(oAccessor.getValue(sElement, pData, nDataSize, &xValue));
oValue = xValue;
return a_util::result::SUCCESS;
}
#define GET_CASE_TYPE(__variant_type, __data_type) \
case a_util::variant::__variant_type: \
{ \
return get_typed_element_value<__data_type>(sElement, pData, nDataSize, oValue, *this); \
}
template <typename T>
a_util::result::Result set_typed_element_value(const StructLayoutElement& sElement, void* pData,
size_t nDataSize, const a_util::variant::Variant& oValue,
const ElementAccessor& oAccessor)
{
T xHelper = oValue;
return oAccessor.setValue(sElement, pData, nDataSize, &xHelper);
}
#define SET_CASE_TYPE(__variant_type, __data_type) \
case a_util::variant::__variant_type: \
{ \
return set_typed_element_value<__data_type>(sElement, pData, nDataSize, oValue, *this); \
}
a_util::result::Result ElementAccessor::getValue(const StructLayoutElement& sElement, const void* pData,
size_t nDataSize, a_util::variant::Variant& oValue) const
{
switch(sElement.type)
{
GET_CASE_TYPE(VT_Bool, bool)
GET_CASE_TYPE(VT_Int8, int8_t)
GET_CASE_TYPE(VT_UInt8, uint8_t)
GET_CASE_TYPE(VT_Int16, int16_t)
GET_CASE_TYPE(VT_UInt16, uint16_t)
GET_CASE_TYPE(VT_Int32, int32_t)
GET_CASE_TYPE(VT_UInt32, uint32_t)
GET_CASE_TYPE(VT_Int64, int64_t)
GET_CASE_TYPE(VT_UInt64, uint64_t)
GET_CASE_TYPE(VT_Float32, float)
GET_CASE_TYPE(VT_Float64, double)
default: return ERR_NOT_SUPPORTED;
}
}
a_util::result::Result ElementAccessor::setValue(const StructLayoutElement& sElement, void* pData,
size_t nDataSize, const a_util::variant::Variant& oValue) const
{
switch(sElement.type)
{
SET_CASE_TYPE(VT_Bool, bool)
SET_CASE_TYPE(VT_Int8, int8_t)
SET_CASE_TYPE(VT_UInt8, uint8_t)
SET_CASE_TYPE(VT_Int16, int16_t)
SET_CASE_TYPE(VT_UInt16, uint16_t)
SET_CASE_TYPE(VT_Int32, int32_t)
SET_CASE_TYPE(VT_UInt32, uint32_t)
SET_CASE_TYPE(VT_Int64, int64_t)
SET_CASE_TYPE(VT_UInt64, uint64_t)
SET_CASE_TYPE(VT_Float32, float)
SET_CASE_TYPE(VT_Float64, double)
default: return ERR_NOT_SUPPORTED;
}
}
a_util::result::Result DeserializedAccessor::getValue(const StructLayoutElement& sElement, const void* pData,
size_t nDataSize, void* pElementValue) const
{
assert(sElement.deserialized.bit_offset % 8 == 0);
assert(sElement.deserialized.bit_size % 8 == 0);
size_t nByteOffset = sElement.deserialized.bit_offset / 8;
size_t nByteSize = sElement.deserialized.bit_size / 8;
if (nDataSize < nByteOffset + nByteSize)
{
return ERR_INVALID_ARG;
}
a_util::memory::copy(pElementValue, nByteSize,
reinterpret_cast<const void*>(static_cast<const uint8_t*>(pData) + nByteOffset),
nByteSize);
return a_util::result::SUCCESS;
}
a_util::result::Result DeserializedAccessor::setValue(const StructLayoutElement& sElement, void* pData,
size_t nDataSize, const void* pElementValue) const
{
assert(sElement.deserialized.bit_offset % 8 == 0);
assert(sElement.deserialized.bit_size % 8 == 0);
size_t nByteOffset = sElement.deserialized.bit_offset / 8;
size_t nByteSize = sElement.deserialized.bit_size / 8;
if (nDataSize < nByteOffset + nByteSize)
{
return ERR_INVALID_ARG;
}
a_util::memory::copy(static_cast<uint8_t*>(pData) + nByteOffset, nByteSize,
pElementValue,
nByteSize);
return a_util::result::SUCCESS;
}
const ElementAccessor& DeserializedAccessor::getInstance()
{
static DeserializedAccessor oInstance;
return oInstance;
}
const ElementAccessor& SerializedAccessor::getInstance()
{
static SerializedAccessor oInstance;
return oInstance;
}
template <typename T>
a_util::result::Result read_typed_bits(const StructLayoutElement& sElement, const void* pData,
size_t nDataSize, void* pElementValue)
{
a_util::memory::BitSerializer oHelper(const_cast<void*>(pData), nDataSize);
return oHelper.read<T>(sElement.serialized.bit_offset, sElement.serialized.bit_size,
reinterpret_cast<T*>(pElementValue),
(a_util::memory::Endianess)sElement.byte_order);
}
#define GET_CASE_TYPE_SER(__variant_type, __data_type) \
case a_util::variant::__variant_type: \
{ \
return read_typed_bits<__data_type>(sElement, pData, nDataSize, pElementValue); \
}
a_util::result::Result SerializedAccessor::getValue(const StructLayoutElement& sElement, const void* pData,
size_t nDataSize, void* pElementValue) const
{
switch(sElement.type)
{
GET_CASE_TYPE_SER(VT_Bool, bool)
GET_CASE_TYPE_SER(VT_Int8, int8_t)
GET_CASE_TYPE_SER(VT_UInt8, uint8_t)
GET_CASE_TYPE_SER(VT_Int16, int16_t)
GET_CASE_TYPE_SER(VT_UInt16, uint16_t)
GET_CASE_TYPE_SER(VT_Int32, int32_t)
GET_CASE_TYPE_SER(VT_UInt32, uint32_t)
GET_CASE_TYPE_SER(VT_Int64, int64_t)
GET_CASE_TYPE_SER(VT_UInt64, uint64_t)
GET_CASE_TYPE_SER(VT_Float32, float)
GET_CASE_TYPE_SER(VT_Float64, double)
default: return ERR_NOT_SUPPORTED;
}
}
template <typename T>
a_util::result::Result write_typed_bits(const StructLayoutElement& sElement, void* pData,
size_t nDataSize, const void* pElementValue)
{
a_util::memory::BitSerializer oHelper(pData, nDataSize);
return oHelper.write<T>(sElement.serialized.bit_offset, sElement.serialized.bit_size,
*reinterpret_cast<const T*>(pElementValue),
(a_util::memory::Endianess)sElement.byte_order);
}
#define SET_CASE_TYPE_SER(__variant_type, __data_type) \
case a_util::variant::__variant_type: \
{ \
return write_typed_bits<__data_type>(sElement, pData, nDataSize, pElementValue); \
}
a_util::result::Result SerializedAccessor::setValue(const StructLayoutElement& sElement, void* pData,
size_t nDataSize, const void* pElementValue) const
{
switch(sElement.type)
{
SET_CASE_TYPE_SER(VT_Bool, bool)
SET_CASE_TYPE_SER(VT_Int8, int8_t)
SET_CASE_TYPE_SER(VT_UInt8, uint8_t)
SET_CASE_TYPE_SER(VT_Int16, int16_t)
SET_CASE_TYPE_SER(VT_UInt16, uint16_t)
SET_CASE_TYPE_SER(VT_Int32, int32_t)
SET_CASE_TYPE_SER(VT_UInt32, uint32_t)
SET_CASE_TYPE_SER(VT_Int64, int64_t)
SET_CASE_TYPE_SER(VT_UInt64, uint64_t)
SET_CASE_TYPE_SER(VT_Float32, float)
SET_CASE_TYPE_SER(VT_Float64, double)
default: return ERR_NOT_SUPPORTED;
}
}
}

83
codec/element_accessor.h Normal file
View file

@ -0,0 +1,83 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef DDL_STRUCT_ELEMENT_ACCESS_PRIVATE_CLASS_HEADER
#define DDL_STRUCT_ELEMENT_ACCESS_PRIVATE_CLASS_HEADER
#include "a_util/result.h"
#include "struct_layout.h"
namespace ddl
{
class ElementAccessor
{
public:
virtual a_util::result::Result getValue(const StructLayoutElement& element, const void* data,
size_t data_size, void* element_value) const = 0;
virtual a_util::result::Result setValue(const StructLayoutElement& element, void* data,
size_t data_size, const void* element_value) const = 0;
virtual DataRepresentation getRepresentation() const = 0;
a_util::result::Result getValue(const StructLayoutElement& element, const void* data,
size_t data_size, a_util::variant::Variant& value) const;
a_util::result::Result setValue(const StructLayoutElement& element, void* data,
size_t data_size, const a_util::variant::Variant& value) const;
};
class DeserializedAccessor: public ElementAccessor
{
public:
virtual a_util::result::Result getValue(const StructLayoutElement& element, const void* data,
size_t data_size, void* element_value) const;
virtual a_util::result::Result setValue(const StructLayoutElement& element, void* data,
size_t data_size, const void* element_value) const;
virtual DataRepresentation getRepresentation() const
{
return deserialized;
}
static const ElementAccessor& getInstance();
};
class SerializedAccessor: public ElementAccessor
{
public:
virtual a_util::result::Result getValue(const StructLayoutElement& element, const void* data,
size_t data_size, void* element_value) const;
virtual a_util::result::Result setValue(const StructLayoutElement& element, void* data,
size_t data_size, const void* element_value) const;
virtual DataRepresentation getRepresentation() const
{
return serialized;
}
static const ElementAccessor& getInstance();
};
}
#endif

32
codec/pkg_codec.h Normal file
View file

@ -0,0 +1,32 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef _DDL_CODEC_PKG_HEADER_
#define _DDL_CODEC_PKG_HEADER_
#include "struct_element.h"
#include "static_codec.h"
#include "codec.h"
#include "codec_factory.h"
#include "access_element.h"
#include "bitserializer.h"
#endif

198
codec/static_codec.cpp Normal file
View file

@ -0,0 +1,198 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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 "static_codec.h"
#include "a_util/result/error_def.h"
#include "legacy_error_macros.h"
#include "element_accessor.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-10, ERR_INVALID_INDEX)
StaticDecoder::StaticDecoder(a_util::memory::shared_ptr<const StructLayout> pLayout,
const void* pData, size_t nDataSize,
DataRepresentation eRep):
_layout(pLayout),
_data(pData),
_data_size(nDataSize),
_element_accessor(eRep == deserialized ?
&DeserializedAccessor::getInstance() :
&SerializedAccessor::getInstance())
{
}
a_util::result::Result StaticDecoder::isValid() const
{
RETURN_IF_FAILED(_layout->isValid());
if (_data_size < getStaticBufferSize(getRepresentation()))
{
return ERR_INVALID_ARG;
}
return a_util::result::SUCCESS;
}
size_t StaticDecoder::getElementCount() const
{
return _layout->getStaticElements().size();
}
a_util::result::Result StaticDecoder::getElement(size_t nIndex, const StructElement*& pElement) const
{
pElement = getLayoutElement(nIndex);
if (!pElement)
{
return ERR_INVALID_INDEX;
}
return a_util::result::SUCCESS;
}
a_util::result::Result StaticDecoder::getElementValue(size_t nIndex, void* pValue) const
{
const StructLayoutElement* pElement = getLayoutElement(nIndex);
if (!pElement)
{
return ERR_INVALID_INDEX;
}
return _element_accessor->getValue(*pElement, _data, _data_size, pValue);
}
a_util::result::Result StaticDecoder::getElementValue(size_t nIndex, a_util::variant::Variant& oValue) const
{
const StructLayoutElement* pElement = getLayoutElement(nIndex);
if (!pElement)
{
return ERR_INVALID_INDEX;
}
return _element_accessor->getValue(*pElement, _data, _data_size, oValue);
}
const void* StaticDecoder::getElementAddress(size_t nIndex) const
{
const StructLayoutElement* pElement = getLayoutElement(nIndex);
if (!pElement)
{
return NULL;
}
size_t nBitPos = _element_accessor->getRepresentation() == deserialized ?
pElement->deserialized.bit_offset :
pElement->serialized.bit_offset;
if (nBitPos % 8)
{
return NULL;
}
size_t bit_size = _element_accessor->getRepresentation() == deserialized ?
pElement->deserialized.bit_size :
pElement->serialized.bit_size;
if ((nBitPos / 8) + (bit_size / 8) + (bit_size % 8 ? 1 : 0) >
_data_size)
{
return NULL;
}
return static_cast<const uint8_t*>(_data) + (nBitPos / 8);
}
const StructLayoutElement* StaticDecoder::getLayoutElement(size_t nIndex) const
{
const StructLayoutElement* pElement = NULL;
if (nIndex < _layout->getStaticElements().size())
{
pElement = &_layout->getStaticElements()[nIndex];
}
return pElement;
}
size_t StaticDecoder::getStaticBufferSize(DataRepresentation eRep) const
{
return _layout->getStaticBufferSize(eRep);
}
DataRepresentation StaticDecoder::getRepresentation() const
{
return _element_accessor->getRepresentation();
}
StaticCodec::StaticCodec(a_util::memory::shared_ptr<const StructLayout> pLayout,
void* pData, size_t nDataSize, DataRepresentation eRep):
StaticDecoder(pLayout, pData, nDataSize, eRep)
{
}
a_util::result::Result StaticCodec::setElementValue(size_t nIndex, const void* pValue)
{
const StructLayoutElement* pElement = getLayoutElement(nIndex);
if (!pElement)
{
return ERR_INVALID_INDEX;
}
return _element_accessor->setValue(*pElement,
const_cast<void*>(_data),
_data_size,
pValue);
}
a_util::result::Result StaticCodec::setElementValue(size_t nIndex, const a_util::variant::Variant& oValue)
{
const StructLayoutElement* pElement = getLayoutElement(nIndex);
if (!pElement)
{
return ERR_INVALID_INDEX;
}
return _element_accessor->setValue(*pElement, const_cast<void*>(_data),
_data_size, oValue);
}
void* StaticCodec::getElementAddress(size_t nIndex)
{
return const_cast<void*>(StaticDecoder::getElementAddress(nIndex));
}
a_util::result::Result StaticCodec::setConstants()
{
if (_layout->hasEnums())
{
size_t nElementCount = getElementCount();
for (size_t nElement = 0; nElement < nElementCount; ++nElement)
{
const StructLayoutElement* pElement = getLayoutElement(nElement);
if (pElement->constant)
{
RETURN_IF_FAILED(_element_accessor->setValue(*pElement, const_cast<void*>(_data),
_data_size, *pElement->constant));
}
}
}
return a_util::result::SUCCESS;
}
}

181
codec/static_codec.h Normal file
View file

@ -0,0 +1,181 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef DDL_STATIC_CODEC_CLASS_HEADER
#define DDL_STATIC_CODEC_CLASS_HEADER
#include "a_util/result.h"
#include "a_util/variant.h"
#include "a_util/memory.h"
#include "struct_element.h"
namespace ddl
{
class StructLayout;
class ElementAccessor;
/**
* Decoder for static structures defined by a DDL definition.
*/
class StaticDecoder
{
public:
/**
* Noncopyable
*/
StaticDecoder(const StaticDecoder&) = delete;
/**
* Noncopyable
*/
StaticDecoder& operator=(const StaticDecoder&) = delete;
/**
* Move constructor.
*/
StaticDecoder(StaticDecoder&&) = default;
/**
* Move assignment operator.
*/
StaticDecoder& operator=(StaticDecoder&&) = default;
/**
* @return Whether or not the decoder is valid.
* @retval ERR_INVALID_ARG The passed data is not large enough.
*/
virtual a_util::result::Result isValid() const;
/**
* @return The amount of elements contained in the data structure.
*/
virtual size_t getElementCount() const;
/**
* Access information about an element.
* @param[in] index The index of the element.
* @param[out] element Pointer that will be updated to point to the element information.
* @retval ERR_INVALID_INDEX Invalid element index.
*/
a_util::result::Result getElement(size_t index, const StructElement*& element) const;
/**
* Returns the current value of the given element by copying its data
* to the passed-in location.
* @param[in] index The index of the element.
* @param[out] value The location where the value should be copied to.
* @retval ERR_INVALID_INDEX Invalid element index.
*/
a_util::result::Result getElementValue(size_t index, void* value) const;
/**
* Returns the current value of the given element as a variant.
* @param[in] index The index of the element.
* @param[out] value The will be set to the current value.
* @retval ERR_INVALID_INDEX Invalid element index.
*/
a_util::result::Result getElementValue(size_t index, a_util::variant::Variant& value) const;
/**
* @param[in] index The index of the element.
* @return A pointer to the element or NULL in case of an error.
*/
const void* getElementAddress(size_t index) const;
/**
* @param[in] rep The data representation for which the buffer size should be returned.
* @return The size of the structure in the requested data representation.
*/
size_t getStaticBufferSize(DataRepresentation rep = deserialized) const;
/**
* @return The data representation which this decoder handles.
*/
DataRepresentation getRepresentation() const;
protected:
friend class CodecFactory;
/// For internal use only. @internal
StaticDecoder(a_util::memory::shared_ptr<const StructLayout> layout,
const void* data, size_t data_size,
DataRepresentation rep);
/// For internal use only. @internal
virtual const StructLayoutElement* getLayoutElement(size_t index) const;
protected:
/// For internal use only. @internal
a_util::memory::shared_ptr<const StructLayout> _layout;
/// For internal use only. @internal
const void* _data;
/// For internal use only. @internal
size_t _data_size;
/// For internal use only. @internal
const ElementAccessor* _element_accessor;
};
/**
* Codec for static structures defined by a DDL definition.
*/
class StaticCodec: public StaticDecoder
{
public:
/**
* Sets the current value of the given element by copying its data
* from the passed-in location.
* @param[in] index The index of the element.
* @param[in] value The location where the data should be copied from.
* @retval ERR_INVALID_INDEX Invalid element index.
*/
a_util::result::Result setElementValue(size_t index, const void* value);
/**
* Sets the current value of the given element to the given value.
* @param[in] index The index of the element.
* @param[in] value The value.
* @retval ERR_INVALID_INDEX Invalid element index.
*/
a_util::result::Result setElementValue(size_t index, const a_util::variant::Variant& value);
/**
* @param[in] index The index of the element.
* @return A pointer to the element or NULL in case of an error.
*/
void* getElementAddress(size_t index);
using StaticDecoder::getElementAddress;
/**
* Sets all elements to their constant values defined in the DDL.
* @return Standard result.
*/
a_util::result::Result setConstants();
private:
friend class CodecFactory;
/// For internal use only. @internal
StaticCodec(a_util::memory::shared_ptr<const StructLayout> layout, void* data, size_t data_size,
DataRepresentation rep);
};
}
#endif

115
codec/struct_element.h Normal file
View file

@ -0,0 +1,115 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef DDL_STRUCT_ELEMENT_CLASS_HEADER
#define DDL_STRUCT_ELEMENT_CLASS_HEADER
#include <map>
#include <string>
#include "a_util/variant.h"
#include "a_util/result.h"
namespace ddl
{
/**
* Enumeration for the data representation
*/
enum DataRepresentation
{
serialized, ///< serialized data, i.e network, on disks, can msgs, ...
deserialized ///< deserialized data, c-structs, arrays, ...
};
/**
* Typedef for enumerations name -> value.
*/
typedef std::map<std::string, a_util::variant::Variant> EnumType;
/**
* Information about an element accessible with a decoder or codec.
*/
struct StructElement
{
std::string name; ///< The full name of the element.
a_util::variant::VariantType type; ///< The type of the element.
const EnumType* p_enum; ///< pointer to an enum, can be NULL.
};
// The following classes are for internal use only
/**
* \cond INTERNAL
*/
struct Position
{
size_t bit_offset;
size_t bit_size;
};
struct StructLayoutElement: public StructElement
{
Position deserialized;
Position serialized;
int byte_order;
const a_util::variant::Variant* constant;
};
struct DynamicStructLayoutElement
{
std::string name;
size_t alignment;
std::string size_element_name;
std::vector<StructLayoutElement> static_elements;
std::vector<DynamicStructLayoutElement> dynamic_elements;
DynamicStructLayoutElement() = default;
DynamicStructLayoutElement(size_t alignment):
alignment(alignment)
{
}
bool isAlignmentElement() const
{
return name.empty();
}
bool isDynamicArray() const
{
return !size_element_name.empty();
}
};
struct Offsets
{
size_t deserialized;
size_t serialized;
};
/**
* \endcond INTERNAL
*/
}
#endif

345
codec/struct_layout.cpp Normal file
View file

@ -0,0 +1,345 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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 "a_util/result/error_def.h"
#include "legacy_error_macros.h"
#include "struct_layout.h"
#include <ddl.h>
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-19, ERR_NOT_SUPPORTED)
_MAKE_RESULT(-37, ERR_NOT_INITIALIZED)
StructLayout::StructLayout(const DDLComplex* pStruct)
{
_static_buffer_sizes.deserialized = 0;
_static_buffer_sizes.serialized = 0;
_calculations_result = calculate(pStruct);
}
StructLayout::StructLayout():
_calculations_result(ERR_NOT_INITIALIZED)
{
_static_buffer_sizes.deserialized = 0;
_static_buffer_sizes.serialized = 0;
}
#define IF_TYPE(__type, __vtype, __size) \
if (strType == __type) \
{ \
type = a_util::variant::__vtype;\
nTypeSize = __size; \
return a_util::result::SUCCESS; \
}
static a_util::result::Result getType(const std::string& strType, a_util::variant::VariantType& type, size_t& nTypeSize)
{
IF_TYPE("tBool", VT_Bool, 8)
else IF_TYPE("tChar", VT_Int8, 8)
else IF_TYPE("tInt8", VT_Int8, 8)
else IF_TYPE("tUInt8", VT_UInt8, 8)
else IF_TYPE("tInt16", VT_Int16, 16)
else IF_TYPE("tUInt16", VT_UInt16, 16)
else IF_TYPE("tInt32", VT_Int32, 32)
else IF_TYPE("tUInt32", VT_UInt32, 32)
else IF_TYPE("tInt64", VT_Int64, 64)
else IF_TYPE("tUInt64", VT_UInt64, 64)
else IF_TYPE("tFloat32", VT_Float32, 32)
else IF_TYPE("tFloat64", VT_Float64, 64)
return ERR_NOT_SUPPORTED;
}
class cConverter
{
public:
cConverter(std::vector<StructLayoutElement>& static_elements,
std::vector<DynamicStructLayoutElement>& dynamic_elements,
std::map<std::string, EnumType>& oEnums):
m_bDynamicSectionStarted(false),
_static_elements(static_elements),
_dynamic_elements(dynamic_elements),
_enums(oEnums)
{
m_sOffsets.deserialized = 0;
m_sOffsets.serialized = 0;
}
a_util::result::Result Convert(DDLComplex* pStruct)
{
return addStruct(pStruct, "", m_sOffsets.serialized, pStruct->getDDLVersion() >= DDLVersion::ddl_version_30);
}
Offsets getStaticBufferBitSizes()
{
return m_sOffsets;
}
private:
// we are not using a standard visitor pattern because we would have to recreate a stack
// for passing along all the additional parameters
a_util::result::Result Add(IDDLDataType* pType, const std::string& strFullName, size_t& nSerializedOffset,
int byte_order, int nNumBits, const std::string& strConstant, bool is_last_array_element)
{
DDLDataType* pPODType = dynamic_cast<DDLDataType*>(pType);
DDLEnum* p_enum = dynamic_cast<DDLEnum*>(pType);
EnumType* pCodecEnum = NULL;
if (p_enum)
{
pPODType = dynamic_cast<DDLDataType*>(p_enum->getTypeObject());
pCodecEnum = GetCodecEnum(p_enum);
}
if (pPODType)
{
return AddPODElement(pPODType, strFullName, nSerializedOffset, byte_order,
nNumBits, pCodecEnum, strConstant);
}
else
{
DDLComplex* pStruct = dynamic_cast<DDLComplex*>(pType);
if (pStruct)
{
return addStruct(pStruct, strFullName, nSerializedOffset,
// prior to DDL 3.0 the last array element is not padded to the alignment
!is_last_array_element || pStruct->getDDLVersion() >= DDLVersion::ddl_version_30);
}
return ERR_INVALID_ARG;
}
}
EnumType* GetCodecEnum(DDLEnum* p_enum)
{
std::map<std::string, EnumType>::iterator itEnum = _enums.find(p_enum->getName());
if (itEnum == _enums.end())
{
EnumType oCodecEnum;
const EnumNameValueVec& vecValues = p_enum->getValues();
for (EnumNameValueVec::const_iterator it = vecValues.begin(); it != vecValues.end(); ++it)
{
oCodecEnum.insert(std::make_pair(it->first, a_util::variant::Variant(it->second.c_str())));
}
itEnum = _enums.insert(std::make_pair(p_enum->getName(), oCodecEnum)).first;
}
return &itEnum->second;
}
a_util::result::Result AddPODElement(DDLDataType* pDataType, const std::string& strFullName,
size_t& nSerializedOffset, int byte_order, int nNumBits,
EnumType* p_enum,
const std::string& strConstant)
{
StructLayoutElement sElement;
sElement.name = strFullName;
RETURN_IF_FAILED(getType(pDataType->getName(), sElement.type, sElement.deserialized.bit_size));
sElement.deserialized.bit_offset = m_sOffsets.deserialized;
sElement.serialized.bit_offset = nSerializedOffset;
sElement.serialized.bit_size = nNumBits ? nNumBits : pDataType->getNumBits();
sElement.byte_order = byte_order;
sElement.p_enum = p_enum;
sElement.constant = FindConstant(strConstant);
_static_elements.push_back(sElement);
m_sOffsets.deserialized += sElement.deserialized.bit_size;
nSerializedOffset += sElement.serialized.bit_size;
return a_util::result::SUCCESS;
}
const a_util::variant::Variant* FindConstant(const std::string& strConstant)
{
if (!strConstant.empty())
{
for (std::map<std::string, EnumType>::const_iterator it = _enums.begin(); it != _enums.end(); ++it)
{
EnumType::const_iterator itValue = it->second.find(strConstant);
if (itValue != it->second.end())
{
return &itValue->second;
}
}
}
return NULL;
}
a_util::result::Result addStruct(DDLComplex* pStruct, const std::string& strFullName, size_t& nSerializedOffset, bool resize_to_alignment)
{
std::string strStructPrefix = (!strFullName.empty()) ? strFullName + "." : "";
bool bWasDynamicSectionStartedBefore = m_bDynamicSectionStarted;
size_t nStructBaseOffset = m_sOffsets.deserialized;
size_t nMaxSerializedOffset = nSerializedOffset;
DDLElementVec& vecElements = pStruct->getElements();
for (DDLElementVec::iterator it = vecElements.begin(); it != vecElements.end(); ++it)
{
size_t nElementOffset = nSerializedOffset;
RETURN_IF_FAILED(addElement(*it, strStructPrefix,
nElementOffset,
nStructBaseOffset));
nMaxSerializedOffset = std::max(nMaxSerializedOffset, nElementOffset);
}
nSerializedOffset = nMaxSerializedOffset;
if (resize_to_alignment)
{
MoveOffsetToAlignment(pStruct->getAlignment(), nStructBaseOffset);
}
if (m_bDynamicSectionStarted && !bWasDynamicSectionStartedBefore)
{
// add an alignment marker to ensure that the next element starts at the
// correct position
_dynamic_elements.push_back(pStruct->getAlignment());
}
return a_util::result::SUCCESS;
}
void MoveOffsetToAlignment(DDLAlignment::AlignmentType eAlignment, size_t alignment_base_offset)
{
size_t nRelativeOffset = m_sOffsets.deserialized - alignment_base_offset;
size_t nBitRest = nRelativeOffset % 8;
if (nBitRest)
{
nRelativeOffset += 8 - nBitRest;
}
size_t nByteOffset = nRelativeOffset / 8;
size_t nRest = nByteOffset % eAlignment;
if (nRest)
{
nRelativeOffset += (eAlignment - nRest) * 8;
}
m_sOffsets.deserialized = alignment_base_offset + nRelativeOffset;
}
a_util::result::Result addElement(DDLElement* pElement, const std::string& strStructPrefix, size_t& nSerializedOffset, size_t nStructBaseOffset)
{
if (!m_bDynamicSectionStarted)
{
m_bDynamicSectionStarted = pElement->getArraysize() == 0;
}
if (!m_bDynamicSectionStarted)
{
MoveOffsetToAlignment(pElement->getAlignment(), nStructBaseOffset);
nSerializedOffset += pElement->getBytepos() * 8 + pElement->getBitpos();
}
size_t nArraySize = std::max(pElement->getArraysize(), 1u);
for (size_t nArrayIndex = 0; nArrayIndex < nArraySize; ++nArrayIndex)
{
std::string strCurrentElementName = strStructPrefix + pElement->getName();
if (nArraySize > 1)
{
strCurrentElementName += a_util::strings::format("[%d]", nArrayIndex);
}
if (!m_bDynamicSectionStarted)
{
RETURN_IF_FAILED(Add(pElement->getTypeObject(), strCurrentElementName,
nSerializedOffset, pElement->getByteorder(),
pElement->getNumBits(),
pElement->getConstantValue(),
nArrayIndex == nArraySize - 1));
}
else
{
RETURN_IF_FAILED(addDynamicElement(pElement, strCurrentElementName, strStructPrefix));
}
}
return a_util::result::SUCCESS;
}
a_util::result::Result addDynamicElement(const DDLElement* pElement, const std::string& strFullName,
const std::string& strStructPrefix)
{
DynamicStructLayoutElement sDynamicElement;
cConverter oChildConverter(sDynamicElement.static_elements,
sDynamicElement.dynamic_elements,
_enums);
size_t nDummy = 0;
RETURN_IF_FAILED(oChildConverter.Add(pElement->getTypeObject(), "",
nDummy, pElement->getByteorder(),
pElement->getNumBits(),
pElement->getConstantValue(),
false));
sDynamicElement.name = strFullName;
sDynamicElement.alignment = pElement->getAlignment();
if (pElement->getArraysize() == 0)
{
if (pElement->getArraySizeSource().empty())
{
return ERR_INVALID_ARG;
}
sDynamicElement.size_element_name = strStructPrefix + pElement->getArraySizeSource();
}
_dynamic_elements.push_back(sDynamicElement);
return a_util::result::SUCCESS;
}
protected:
Offsets m_sOffsets;
bool m_bDynamicSectionStarted;
std::vector<StructLayoutElement>& _static_elements;
std::vector<DynamicStructLayoutElement>& _dynamic_elements;
std::map<std::string, EnumType>& _enums;
};
a_util::result::Result StructLayout::calculate(const DDLComplex* pStruct)
{
cConverter oConverter(_static_elements,
_dynamic_elements,
_enums);
RETURN_IF_FAILED(oConverter.Convert(const_cast<DDLComplex*>(pStruct)));
_static_buffer_sizes = oConverter.getStaticBufferBitSizes();
return a_util::result::SUCCESS;
}
size_t StructLayout::getStaticBufferSize(DataRepresentation eRep) const
{
size_t nResult = eRep == deserialized ?
_static_buffer_sizes.deserialized :
_static_buffer_sizes.serialized;
if (nResult % 8)
{
return nResult / 8 + 1;
}
return nResult / 8;
}
}

87
codec/struct_layout.h Normal file
View file

@ -0,0 +1,87 @@
/**
* @file
* Implementation of the ADTF default media description.
*
* @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
*/
#ifndef DDL_STRUCT_LAYOUT_CLASS_HEADER
#define DDL_STRUCT_LAYOUT_CLASS_HEADER
#include "struct_element.h"
namespace ddl
{
class DDLComplex;
/**
* @internal
* This class is for internal use only.
*/
class StructLayout
{
public:
StructLayout();
StructLayout(const DDLComplex* ddl_struct);
a_util::result::Result isValid() const
{
return _calculations_result;
}
const std::vector<StructLayoutElement>& getStaticElements() const
{
return _static_elements;
}
const std::vector<DynamicStructLayoutElement>& getDynamicElements() const
{
return _dynamic_elements;
}
bool hasDynamicElements() const
{
return !_dynamic_elements.empty();
}
bool hasEnums() const
{
return !_enums.empty();
}
const Offsets& getStaticBufferBitSizes() const
{
return _static_buffer_sizes;
}
size_t getStaticBufferSize(DataRepresentation rep) const;
private:
a_util::result::Result calculate(const DDLComplex* ddl_struct);
private:
std::vector<StructLayoutElement> _static_elements;
std::vector<DynamicStructLayoutElement> _dynamic_elements;
std::map<std::string, EnumType> _enums;
Offsets _static_buffer_sizes;
a_util::result::Result _calculations_result;
};
}
#endif

31
ddl.h Normal file
View file

@ -0,0 +1,31 @@
/**
* @file
* Package header for DDL
*
* @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
*/
#ifndef _PACKAGE_DDL_HEADER_
#define _PACKAGE_DDL_HEADER_
#include "ddlrepresentation/ddl_common.h"
// Include individual DDL modules
#include "ddlrepresentation/pkg_ddlrepresentation.h"
#include "codec/pkg_codec.h"
#include "serialization/pkg_serialization.h"
#include "mapping/pkg_mapping.h"
#endif // _PACKAGE_DDL_HEADER_

3
ddlgenerators/CMakeLists.txt Normal file
View file

@ -0,0 +1,3 @@
add_subdirectory(generator_library)
add_subdirectory(ddl2header)
add_subdirectory(header2ddl)

30
ddlgenerators/ddl2header/CMakeLists.txt Normal file
View file

@ -0,0 +1,30 @@
set(PROJECT_NAME ddl2header)
set(SOURCES
main.cpp
ddl2header_commandline.h
ddl2header_commandline.cpp
${DDL_GENERATOR_COMMON}
${HEADER_PRESENTATION_H}
${HEADER_PRESENTATION_CPP}
)
if (WIN32)
#list(APPEND SOURCES native_resource.rc)
endif (WIN32)
add_executable(${PROJECT_NAME} WIN32 ${SOURCES})
target_link_libraries(${PROJECT_NAME}
ddl
ddl_generator
)
if(MSVC)
set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS "/SUBSYSTEM:console")
endif(MSVC)
install(TARGETS ${PROJECT_NAME} DESTINATION ./bin/debug CONFIGURATIONS Debug)
install(TARGETS ${PROJECT_NAME} DESTINATION ./bin CONFIGURATIONS Release RelWithDebInfo)
set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER ddl/utils)

79
ddlgenerators/ddl2header/ddl2header_commandline.cpp Normal file
View file

@ -0,0 +1,79 @@
/**
* @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 <iostream>
#include "ddl2header_commandline.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
namespace ddl
{
DDL2HeaderCommandLine::DDL2HeaderCommandLine(): CommandLine()
{
_cli |= getNamespaceOpt();
_cli |= getDisplaceableStringOpt();
}
std::string DDL2HeaderCommandLine::getNamespace()
{
return _opt_namespace;
}
std::string DDL2HeaderCommandLine::getDisplaceableString()
{
return _opt_displaceable_string;
}
void DDL2HeaderCommandLine::printExamples()
{
std::cout << std::endl << "If the target header file exists already the descriptions will be merged." << std::endl;
std::cout << "This can lead to data loss in the existing header file." << std::endl << std::endl;
std::cout << "examples: " << std::endl;
std::cout << " --headerfile=c:/myHeaderFile.h " <<
"--descriptionfile=c:/myDescriptionFile.description";
std::cout << std::endl << " or" << std::endl;
std::cout << " --headerfile=c:/myHeaderFile.h " <<
"--descriptionfile=c:/myDescriptionFile.description ";
std::cout << "-struct=tMyStruct" << std::endl;
}
clara::Opt DDL2HeaderCommandLine::getNamespaceOpt()
{
return clara::Opt(_opt_namespace, "name")
["-n"]["--namespace"]
("[Optional] Place all generated elements in this namespace");
}
clara::Opt DDL2HeaderCommandLine::getDisplaceableStringOpt()
{
return clara::Opt(_opt_displaceable_string, "string")
["--displace"]
(" [Optional] Remove this string from beginning of all element names.");
}
}

47
ddlgenerators/ddl2header/ddl2header_commandline.h Normal file
View file

@ -0,0 +1,47 @@
/**
* @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
*/
#ifndef _DDL2HEADER_COMMAND_LINE_H_
#define _DDL2HEADER_COMMAND_LINE_H_
#include "commandline.h"
namespace ddl
{
class DDL2HeaderCommandLine: public ddl::CommandLine
{
public:
DDL2HeaderCommandLine();
std::string getNamespace();
std::string getDisplaceableString();
protected:
void printExamples();
clara::Opt getNamespaceOpt();
clara::Opt getDisplaceableStringOpt();
std::string _opt_namespace;
std::string _opt_displaceable_string;
};
}
#endif

66
ddlgenerators/ddl2header/main.cpp Normal file
View file

@ -0,0 +1,66 @@
/**
* @file
* Launcher.
*
* @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 <a_util/result.h>
#include <ddl_generator_core.h>
#include "ddl2header_commandline.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
int main(int argc, char* argv[])
{
ddl::DDL2HeaderCommandLine cmdLine;
if (a_util::result::isFailed(cmdLine.parseArgs(argc, argv)))
{
return ERR_INVALID_ARG.getCode();
}
if (cmdLine.isHelpRequested())
{
cmdLine.printHelp();
return ERR_NOERROR.getCode();
}
if (a_util::result::isFailed(cmdLine.checkMandatoryArguments()))
{
return ERR_INVALID_ARG.getCode();
}
DDLUtilsCore core;
a_util::result::Result res = core.generateHeaderFile(cmdLine.getDescriptionFile(),
cmdLine.getHeaderFile(), cmdLine.getStruct(), cmdLine.getNamespace(),
cmdLine.getDisplaceableString());
if (a_util::result::isFailed(res))
{
LOG_ERROR("Error: An error occured during generating the header file.");
}
return res.getErrorCode();
}

30
ddlgenerators/generator_library/CMakeLists.txt Normal file
View file

@ -0,0 +1,30 @@
##################################################################
# Common Package Integration File for the LIB - ddl generator
#
#
##################################################################
##################################################################
# Section for required other package to compile
find_package(Clara REQUIRED) #enable INTERFACE target Clara
include(ddl_generator_lib.sources)
include_directories(${DDL_GENERATOR_LIB_INCLUDE_DIR})
set(SOURCES
${DDL_GENERATOR_COMMON}
${HEADER_PRESENTATION_H}
${HEADER_PRESENTATION_CPP}
)
add_library(ddl_generator STATIC ${SOURCES})
target_include_directories(ddl_generator PUBLIC
$<BUILD_INTERFACE:${DDL_GENERATOR_LIB_INCLUDE_DIR}>
)
target_link_libraries(ddl_generator
ddl Clara)
set_target_properties(ddl_generator PROPERTIES FOLDER ddl/utils)

126
ddlgenerators/generator_library/commandline.cpp Normal file
View file

@ -0,0 +1,126 @@
/**
* @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 <iostream>
#include "commandline.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
namespace ddl
{
CommandLine::CommandLine()
{
_cli |= clara::Help(_showhelp);
_cli |= getHeaderFileOpt();
_cli |= getDescriptionFileOpt();
_cli |= getStructOpt();
}
CommandLine::~CommandLine()
{
}
a_util::result::Result CommandLine::parseArgs(int argc, char* argv[])
{
auto result = _cli.parse(clara::Args(argc, argv));
if (!result)
{
std::cerr << "Error in command line: " << result.errorMessage() << std::endl;
return ERR_INVALID_ARG;
}
return ERR_NOERROR;
}
bool CommandLine::isHelpRequested()
{
return _showhelp;
}
void CommandLine::printHelp()
{
std::cout << _cli << std::endl;
printExamples();
}
a_util::result::Result CommandLine::checkMandatoryArguments()
{
a_util::result::Result result = ERR_NOERROR;
if (_opt_header_file.empty())
{
std::cerr << "Error: No option 'headerfile' is set. " <<
"Please use option '--help' for further information." << std::endl;
result = ERR_INVALID_ARG;
}
if (_opt_description_file.empty())
{
std::cerr << "Error: No option 'descriptionfile' is set. " <<
"Please use option '--help' for further information." << std::endl;
result = ERR_INVALID_ARG;
}
return result;
}
std::string CommandLine::getHeaderFile()
{
return _opt_header_file;
}
std::string CommandLine::getDescriptionFile()
{
return _opt_description_file;
}
std::string CommandLine::getStruct()
{
return _opt_struct;
}
clara::Opt CommandLine::getHeaderFileOpt()
{
return clara::Opt(_opt_header_file, "file")
["-f"]["--headerfile"]
("[Mandatory] The path to the header file.");
}
clara::Opt CommandLine::getDescriptionFileOpt()
{
return clara::Opt(_opt_description_file, "file")
["-d"]["--descriptionfile"]
("[Mandatory] The path to the description file.");
}
clara::Opt CommandLine::getStructOpt()
{
return clara::Opt(_opt_struct, "structName")
["-s"]["--struct"]
("[Optional] Just create the description file for the given struct "
"of the header file.");
}
}

60
ddlgenerators/generator_library/commandline.h Normal file
View file

@ -0,0 +1,60 @@
/**
* @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
*/
#ifndef _DDL_COMMAND_LINE_H_
#define _DDL_COMMAND_LINE_H_
#include <a_util/result.h>
#include <clara.hpp>
namespace ddl
{
class CommandLine
{
public:
CommandLine();
virtual ~CommandLine();
a_util::result::Result parseArgs(int argc, char* argv[]);
bool isHelpRequested();
void printHelp();
virtual a_util::result::Result checkMandatoryArguments();
std::string getHeaderFile();
std::string getDescriptionFile();
std::string getStruct();
protected:
virtual void printExamples() = 0;
clara::Opt getHeaderFileOpt();
clara::Opt getDescriptionFileOpt();
clara::Opt getStructOpt();
clara::Parser _cli;
bool _showhelp = false;
std::string _opt_header_file;
std::string _opt_description_file;
std::string _opt_struct;
};
}
#endif

166
ddlgenerators/generator_library/ddl_generator_core.cpp Normal file
View file

@ -0,0 +1,166 @@
/**
* @file
* Implementation of core
*
* @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_generator_core.h"
#include <ddl.h>
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-11, ERR_INVALID_FILE)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
_MAKE_RESULT(-24, ERR_PATH_NOT_FOUND)
_MAKE_RESULT(-38, ERR_FAILED)
}
}
using namespace ddl_generator::oo;
/*Helper function*/
a_util::result::Result checkIfFileExists(const a_util::filesystem::Path& path)
{
if (!a_util::filesystem::exists(path))
{
return ERR_PATH_NOT_FOUND;
}
return ERR_NOERROR;
}
/*DDLUtilsCore*/
DDLUtilsCore::DDLUtilsCore()
{
_ddl_manager = NULL;
}
DDLUtilsCore::~DDLUtilsCore()
{
delete _ddl_manager;
_ddl_manager = NULL;
}
a_util::result::Result DDLUtilsCore::generateDescriptionFile(const a_util::filesystem::Path& header_path,
const a_util::filesystem::Path& description_path,
const ddl::DDLVersion& version /* 4.0 */, const std::string struct_name /*= ""*/)
{
// check if description file still exists and struct has to be added
if (a_util::result::isOk(checkIfFileExists(description_path)))
{
std::string error_msg;
if (a_util::result::isFailed(setDescription(description_path, error_msg)))
{
LOG_INFO(error_msg.c_str());
return (ERR_INVALID_FILE);
}
ddl::DDLVersion existing_version = _ddl_manager->getDDL()->getHeader()->getLanguageVersion();
if (existing_version > version)
{
LOG_ERROR(a_util::strings::format(
"Exising description file has a newer Version (%s) as the requested Version (%s). Version downgrade is not possible!",
existing_version.toString().c_str(), version.toString().c_str()).c_str());
return ERR_FAILED;
}
}
std::string error_msg;
if (a_util::result::isFailed(setDescriptionFromHeader(header_path, description_path,
error_msg, version, struct_name)))
{
LOG_INFO(error_msg.c_str());
return ERR_FAILED;
}
if (a_util::result::isFailed(_ddl_manager->searchForStructs()))
{
LOG_INFO("Info: No structs found in description file.");
return ERR_FAILED;
}
// create description file
if (a_util::result::isFailed(_ddl_manager->printToDDLFile(description_path, error_msg)))
{
LOG_INFO("Error: Could not create file. %s", error_msg.c_str());
return ERR_FAILED;
}
LOG_INFO("Success: Description file created.");
return ERR_NOERROR;
}
a_util::result::Result DDLUtilsCore::generateHeaderFile(const a_util::filesystem::Path& description_path,
const a_util::filesystem::Path& header_path, const std::string struct_name /*= ""*/,
const std::string name_space /*= ""*/, const std::string displace /*= ""*/)
{
// check if description file still exists and struct has to be added
if (a_util::result::isOk(checkIfFileExists(header_path)))
{
std::string error_msg;
if (a_util::result::isFailed(setDescriptionFromHeader(header_path, description_path, error_msg)))
{
LOG_INFO(error_msg.c_str());
return ERR_FAILED;
}
}
std::string error_msg;
if (a_util::result::isFailed(setDescription(description_path, error_msg, struct_name)))
{
LOG_INFO(error_msg.c_str());
return (ERR_INVALID_FILE);
}
if (a_util::result::isFailed(_ddl_manager->printToHeaderFile(header_path, error_msg, name_space, displace)))
{
LOG_INFO("Error: Could not create header file. %s", error_msg.c_str());
return (ERR_FAILED);
}
LOG_INFO("Success: Header file created.");
return ERR_NOERROR;
}
a_util::result::Result DDLUtilsCore::setDescription(const a_util::filesystem::Path& description_path,
std::string& error_msg, const std::string struct_name)
{
if (!_ddl_manager)
{
_ddl_manager = new DDLManager();
}
return _ddl_manager->mergeWithDDLFile(description_path, error_msg, struct_name);
}
a_util::result::Result DDLUtilsCore::setDescriptionFromHeader(const a_util::filesystem::Path& header_path,
const a_util::filesystem::Path& description_path, std::string& error_msg,
const ddl::DDLVersion& version /*= 4.0*/, const std::string struct_name /*= ""*/)
{
if (!_ddl_manager)
{
_ddl_manager = new DDLManager();
}
a_util::result::Result result = _ddl_manager->mergeWithHeaderFile(header_path, error_msg, version, struct_name);
if (a_util::result::isFailed(result))
{
LOG_INFO("Error: Could not read header file '%s'.", header_path.toString().c_str());
}
return result;
}

92
ddlgenerators/generator_library/ddl_generator_core.h Normal file
View file

@ -0,0 +1,92 @@
/**
* @file
* Implementation of core
*
* @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
*/
#ifndef DDL_GENERATOR_H
#define DDL_GENERATOR_H
#include <ddl.h>
#include "ddl_manager.h"
#define EXTENSION_DESCRIPTIONFILE "DESCRIPTION"
#define EXTENSION_HEADERFILE "H"
class DDLUtilsCore
{
public:
/**
* CTOR
* @param [in]
*/
DDLUtilsCore();
/**
* DTOR
*/
~DDLUtilsCore();
/**
* Create new ddl file from header file
* @param[in] header_path - path to the header file
* @param[in] description_path - path to the ddl file
* @param[in] struct_name - merge only this struct to the existing ddl
* @retval ERR_NOERROR Everything went as expected.
*/
a_util::result::Result generateDescriptionFile(const a_util::filesystem::Path& header_path,
const a_util::filesystem::Path& description_path, const ddl::DDLVersion& version = ddl::DDLVersion::ddl_version_current,
const std::string struct_name = "");
/**
* Create new header file from ddl file
* @param[in] description_path - path to the ddl file
* @param[in] header_path - path to the header file
* @param[in] struct_name - merge only this struct to the existing ddl
* @retval ERR_NOERROR Everything went as expected.
*/
a_util::result::Result generateHeaderFile(const a_util::filesystem::Path& description_path,
const a_util::filesystem::Path& header_path, const std::string struct_name = "", const std::string name_space = "", const std::string displace = "");
private:
/**
* Add existing ddl file
* @param[in] description_path - path to the ddl file
* @param[out] error_msg - error message, gives more information if it failed
* @param[in] struct_name - merge only this struct to the existing ddl
* @retval ERR_NOERROR Everything went as expected.
*/
a_util::result::Result setDescription(const a_util::filesystem::Path& description_path,
std::string& error_msg, const std::string struct_name = "");
/**
* Create new ddl file from header file
* @param[in] header_path - path to the header file
* @param[in] description_path - path to the new ddl file
* @param[in] struct_name - merge only this struct to the existing ddl
* @retval ERR_NOERROR Everything went as expected.
*/
a_util::result::Result setDescriptionFromHeader(const a_util::filesystem::Path& header_path,
const a_util::filesystem::Path& description_path, std::string& error_msg,
const ddl::DDLVersion& version = ddl::DDLVersion::ddl_version_current, const std::string struct_name = "");
private:
/// Mamanger map
DDLManager* _ddl_manager;
};
#endif //DDL_GENERATOR_H

45
ddlgenerators/generator_library/ddl_generator_lib.sources Normal file
View file

@ -0,0 +1,45 @@
set(HEADER_PRESENTATION_DIRECTORY_NAME headerrepresentation)
set(HEADER_PRESENTATION_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}/${HEADER_PRESENTATION_DIRECTORY_NAME})
set(DDL_GENERATOR_LIB_INCLUDE_DIR ${CMAKE_CURRENT_LIST_DIR})
set(HEADER_PRESENTATION_H ${HEADER_PRESENTATION_DIRECTORY}/ddl_to_header_converter.h
${HEADER_PRESENTATION_DIRECTORY}/header_basic_type.h
${HEADER_PRESENTATION_DIRECTORY}/header_constant.h
${HEADER_PRESENTATION_DIRECTORY}/header_enum.h
${HEADER_PRESENTATION_DIRECTORY}/header_header.h
${HEADER_PRESENTATION_DIRECTORY}/header_importer.h
${HEADER_PRESENTATION_DIRECTORY}/header_printer.h
${HEADER_PRESENTATION_DIRECTORY}/header_struct.h
${HEADER_PRESENTATION_DIRECTORY}/header_struct_element.h
${HEADER_PRESENTATION_DIRECTORY}/header_to_ddl_converter.h
${HEADER_PRESENTATION_DIRECTORY}/header_type.h
${HEADER_PRESENTATION_DIRECTORY}/header_typedef.h
${HEADER_PRESENTATION_DIRECTORY}/header_visitor_intf.h
${HEADER_PRESENTATION_DIRECTORY}/header_factorymethod_intf.h
${HEADER_PRESENTATION_DIRECTORY}/header_base_intf.h
${HEADER_PRESENTATION_DIRECTORY}/parserhelper.h)
set(HEADER_PRESENTATION_CPP
${HEADER_PRESENTATION_DIRECTORY}/ddl_to_header_converter.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_basic_type.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_constant.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_enum.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_header.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_importer.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_printer.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_struct.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_struct_element.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_to_ddl_converter.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_type.cpp
${HEADER_PRESENTATION_DIRECTORY}/header_typedef.cpp
${HEADER_PRESENTATION_DIRECTORY}/parserhelper.cpp)
set(DDL_GENERATOR_COMMON
${CMAKE_CURRENT_LIST_DIR}/ddl_manager.h
${CMAKE_CURRENT_LIST_DIR}/ddl_manager.cpp
${CMAKE_CURRENT_LIST_DIR}/ddl_generator_core.h
${CMAKE_CURRENT_LIST_DIR}/ddl_generator_core.cpp
${CMAKE_CURRENT_LIST_DIR}/commandline.h
${CMAKE_CURRENT_LIST_DIR}/commandline.cpp)

396
ddlgenerators/generator_library/ddl_manager.cpp Normal file
View file

@ -0,0 +1,396 @@
/**
* @file
* Implementation of FEP MDE core
*
* @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_manager.h"
#include <ddl.h>
#include "headerrepresentation/header_header.h"
#include "headerrepresentation/header_importer.h"
#include "headerrepresentation/header_to_ddl_converter.h"
#include "headerrepresentation/header_printer.h"
#include "headerrepresentation/ddl_to_header_converter.h"
#include <algorithm>
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-4, ERR_POINTER)
_MAKE_RESULT(-11, ERR_INVALID_FILE)
_MAKE_RESULT(-24, ERR_PATH_NOT_FOUND)
_MAKE_RESULT(-38, ERR_FAILED)
}
}
using namespace ddl_generator::oo;
DDLManager::DDLManager()
{
_ddl_description = NULL;
}
DDLManager::~DDLManager()
{
if (NULL != _ddl_description)
{
ddl::DDLImporter::destroyDDL(_ddl_description);
_ddl_description = NULL;
}
}
a_util::result::Result DDLManager::setDefaultDDL()
{
if (_ddl_description == NULL)
{
_ddl_description = ddl::DDLDescription::createDefault();
_ddl_description->getHeader()->setDescription("Generated with AEV Media Description Editor");
}
return ERR_NOERROR;
}
a_util::result::Result DDLManager::mergeWithDDLFile(const a_util::filesystem::Path& ddl_path, std::string& error_msg, const std::string& struct_name)
{
if (!a_util::filesystem::exists(ddl_path))
{
error_msg = a_util::strings::format("Description file '%s' not found.", ddl_path.toString().c_str());
return ERR_PATH_NOT_FOUND;
}
ddl::DDLImporter ddl_importer;
if (isFailed(ddl_importer.setFile(ddl_path)))
{
error_msg = a_util::strings::format("Error in File '%s': %s", ddl_path.getLastElement().toString().c_str(), ddl_importer.getErrorDesc().c_str());
return ERR_FAILED;
}
;
if (a_util::result::isFailed(ddl_importer.createNew()))
{
error_msg = ddl_importer.getErrorDesc();
return ERR_INVALID_FILE;
}
ddl::DDLDescription* imported_description = ddl_importer.getDDL();
a_util::result::Result res = ERR_NOERROR;
// merge if dll already exists
if (struct_name.size() == 0)
{
if (_ddl_description == NULL)
{
_ddl_description = imported_description;
}
else
{
res = _ddl_description->merge(*imported_description, 2U);
// Destroy DDL
if (NULL != imported_description)
{
ddl::DDLImporter::destroyDDL(imported_description);
imported_description = NULL;
}
}
}
else
{
// get struct from description file
res = findStructRecursively(imported_description, struct_name);
if (a_util::result::isFailed(res))
{
error_msg = a_util::strings::format("Error: Struct '%s' not found.", struct_name.c_str());
}
// Destroy DDL
if (NULL != imported_description)
{
ddl::DDLImporter::destroyDDL(imported_description);
imported_description = NULL;
}
}
if (NULL == _ddl_description)
{
res = ERR_POINTER;
}
return res;
}
a_util::result::Result DDLManager::mergeWithHeaderFile(
const a_util::filesystem::Path& header_path, std::string& error_msg,
const ddl::DDLVersion& version /*= 4.0*/, const std::string& struct_name)
{
if (!a_util::filesystem::exists(header_path))
{
error_msg = a_util::strings::format("Headerfile '%s' not found", header_path.toString().c_str());
return ERR_PATH_NOT_FOUND;
}
ddl::HeaderImporter importer;
ddl::HeaderTypesVec* default_types = ddl::HeaderImporter::getDefaultTypes();
if (isFailed((importer.setFileName(header_path))))
{
return ERR_FAILED;
}
if (isFailed((importer.setKnownTypes(default_types))))
{
return ERR_FAILED;
}
if (isFailed((importer.createNew())))
{
error_msg = importer.getLastError();
return ERR_FAILED;
}
if (importer.getLastError().length() > 0)
{
LOG_ERROR(importer.getLastError().c_str());
return ERR_INVALID_FILE;
}
ddl::Header* header = importer.getHeader();
if (NULL == header)
{
return ERR_POINTER;
}
ddl::DDLDescription* tmp_desc = NULL;
a_util::result::Result res = ERR_NOERROR;
if (struct_name.size() == 0)
{
// create DDL from header file
ddl::HeaderToDDLConverter converter;
if (isFailed((converter.visit(header))))
{
return ERR_FAILED;
}
if (isFailed((converter.createNew(version))))
{
return ERR_FAILED;
}
tmp_desc = converter.getDDL();
if (NULL == tmp_desc)
{
res = ERR_POINTER;
}
}
else
{
// get struct from header file
ddl::HeaderStructs header_structs = header->getStructs();
ddl::HeaderStruct* found_struct = NULL;
for (ddl::HeaderStructs::const_iterator it_struct = header_structs.begin();
it_struct != header_structs.end();
it_struct++)
{
if (0 == struct_name.compare((*it_struct)->getName()))
{
found_struct = *it_struct;
break;
}
}
// check if struct is available in header file
if (NULL == found_struct)
{
error_msg = a_util::strings::format("Error: Struct '%s' not found in header file.", struct_name.c_str());
res = ERR_INVALID_FILE;
}
else
{
// create DDL from struct of header file
ddl::HeaderToDDLConverter converter;
if (isFailed((converter.visit(found_struct))))
{
return ERR_FAILED;
}
if (isFailed((converter.createNew(version))))
{
return ERR_FAILED;
}
tmp_desc = converter.getDDL();
if (NULL == tmp_desc)
{
res = ERR_POINTER;
}
}
}
if (NULL != _ddl_description)
{
if (NULL != tmp_desc)
{
res = _ddl_description->merge(*tmp_desc);
}
}
else
{
_ddl_description = tmp_desc;
}
if (NULL != header)
{
importer.DestroyHeader();
header = NULL;
}
for (ddl::HeaderTypesVec::iterator it = default_types->begin(); it != default_types->end(); it++)
{
delete *it;
*it = NULL;
}
default_types->clear();
delete default_types;
default_types = NULL;
return res;
}
ddl::DDLDescription* DDLManager::getDDL()
{
return _ddl_description;
}
a_util::result::Result DDLManager::printToDDLFile(const a_util::filesystem::Path& ddl_path, std::string& error_msg)
{
ddl::DDLPrinter ddl_printer;
if (a_util::result::isFailed(ddl_printer.visitDDL(_ddl_description)))
{
return ERR_POINTER;
}
if (a_util::result::isFailed(ddl_printer.toFile(ddl_path)))
{
return (ERR_INVALID_FILE);
}
return ERR_NOERROR;
}
a_util::result::Result DDLManager::printToHeaderFile(const a_util::filesystem::Path& header_file, std::string& error_msg,
const std::string name_space /** = ""*/, const std::string displace /** = ""*/)
{
// Create header from ddl
ddl::DDLToHeaderConverter converter;
converter.setDisplaceableString(displace);
ddl::HeaderTypesVec* default_types = NULL;
default_types = ddl::HeaderImporter::getDefaultTypes();
converter.setKnownTypes(default_types);
if (a_util::result::isFailed(converter.visitDDL(_ddl_description)))
{
error_msg = converter.getError();
return ERR_FAILED;
}
if (isFailed((converter.createNew())))
{
error_msg = converter.getError();
return ERR_FAILED;
}
ddl::Header* header = converter.getHeader();
if (NULL == header)
{
return ERR_POINTER;
}
// create header file
ddl::HeaderPrinter printer;
printer.SetNamespace(name_space);
if (a_util::result::isFailed(printer.visit(header)))
{
return (ERR_INVALID_FILE);
}
if (a_util::result::isFailed(printer.writeToFile(header_file)))
{
return (ERR_FAILED);
}
return ERR_NOERROR;
}
a_util::result::Result DDLManager::searchForStructs()
{
ddl::DDLComplexVec ddl_structs = _ddl_description->getStructs();
if (0 == ddl_structs.size())
{
return (ERR_INVALID_FILE);
}
return ERR_NOERROR;
}
ddl::ImporterMsgList DDLManager::checkValidity()
{
ddl::ImporterMsgList msg_list = ddl::DDLInspector::checkValidyOfNestedStructs(_ddl_description);
if (!(msg_list.size() > 0))
{
ddl::DDLInspector ddl_inspector(false);
ddl_inspector.visitDDL(_ddl_description);
msg_list = ddl_inspector.getSuggestions();
}
return msg_list;
}
a_util::result::Result DDLManager::findStructRecursively(ddl::DDLDescription* description, const std::string &struct_name)
{
if (NULL != _ddl_description && NULL != _ddl_description->getStructByName(struct_name))
{
// struct was already added, skip
return ERR_NOERROR;
}
a_util::result::Result res = ERR_NOERROR;
ddl::DDLComplexVec ddl_structs = description->getStructs();
ddl::DDLComplex* found_struct = NULL;
for (ddl::DDLComplexVec::const_iterator it_struct = ddl_structs.begin();
it_struct != ddl_structs.end(); it_struct++)
{
if (0 == a_util::strings::compare(struct_name.c_str(), (*it_struct)->getName().c_str()))
{
found_struct = new ddl::DDLComplex(**it_struct);
break;
}
}
// check if struct is available in description file
if (NULL == found_struct)
{
return ERR_INVALID_FILE;
}
if (NULL == _ddl_description)
{
_ddl_description = ddl::DDLDescription::createDefault();
}
_ddl_description->addStruct(found_struct);
// add child-structs
for (auto it_element = found_struct->getElements().begin(); it_element != found_struct->getElements().end(); it_element++)
{
ddl::DDLElement* element = *it_element;
const std::string element_name = element->getTypeObject()->getName();
if (element->getTypeObject()->isComplex())
{
if (isFailed(findStructRecursively(description, element_name)))
{
return ERR_INVALID_FILE;
}
element->setType(_ddl_description->getStructByName(element_name));
}
}
return ERR_NOERROR;
}

93
ddlgenerators/generator_library/ddl_manager.h Normal file
View file

@ -0,0 +1,93 @@
/**
* @file
* Implementation of FEP MDE core
*
* @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.h>
#ifndef DDL_MANAGER_H
#define DDL_MANAGER_H
class DDLManager
{
public:
/**
* CTOR
* @param [in]
*/
DDLManager();
/**
* DTOR
*/
~DDLManager();
/// Set default ddl
a_util::result::Result setDefaultDDL();
/**
* Nerge with ddl file, or with default ddl if empty
* @param[in] ddl_path - path to the ddl file
* @param[out] error_msg - error message, gives more information if it failed
* @param[in] struct_name - merge only this struct to the existing ddl
* @retval ERR_NOERROR Everything went as expected.
*/
a_util::result::Result mergeWithDDLFile(const a_util::filesystem::Path& ddl_path, std::string& error_msg, const std::string& struct_name = "");
/**
* Nerge with ddl file, or with default ddl if empty
* @param[in] header_path - path to the header file
* @param[in] struct_name - merge only this struct to the existing ddl
* @retval ERR_NOERROR Everything went as expected.
*/
a_util::result::Result mergeWithHeaderFile(const a_util::filesystem::Path& header_path, std::string& error_msg,
const ddl::DDLVersion& version = ddl::DDLVersion::ddl_version_current, const std::string& struct_name = "");
/// Getter for ddl representation
ddl::DDLDescription* getDDL();
/// Print to ddl file
a_util::result::Result printToDDLFile(const a_util::filesystem::Path& ddl_path, std::string& error_msg);
/// Print to header file
a_util::result::Result printToHeaderFile(const a_util::filesystem::Path& header_file, std::string& error_msg,
const std::string name_space = "", const std::string displace = "");
/// Search if the file contains structs
a_util::result::Result searchForStructs();
/**
* Verify if the file is valid and write some errors and warnings
* @retval message list
*/
ddl::ImporterMsgList checkValidity();
private:
/** find struct struct_name in description.
* Recursively add all child-structs of struct_name as well
* @param[in] description description to search in
* @param[in] struct_name name of struct so search for
* @retval result
*/
a_util::result::Result findStructRecursively(ddl::DDLDescription* description, const std::string &struct_name);
private:
/// File name
a_util::filesystem::Path _filename;
/// ddl representation
ddl::DDLDescription* _ddl_description;
};
#endif //DDL_MANAGER_H

556
ddlgenerators/generator_library/headerrepresentation/ddl_to_header_converter.cpp Normal file
View file

@ -0,0 +1,556 @@
/**
* @file
* Description is missing.
*
* @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.h>
#include "ddl_to_header_converter.h"
#include "header_visitor_intf.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-4, ERR_POINTER)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-11, ERR_INVALID_FILE)
_MAKE_RESULT(-19, ERR_NOT_SUPPORTED)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
_MAKE_RESULT(-24, ERR_PATH_NOT_FOUND)
_MAKE_RESULT(-38, ERR_FAILED)
}
}
using namespace ddl;
namespace ddl
{
using namespace ddl_generator::oo;
DDLToHeaderConverter::DDLToHeaderConverter()
{
_header = NULL;
_known_types = NULL;
}
DDLToHeaderConverter::~DDLToHeaderConverter()
{ }
a_util::result::Result DDLToHeaderConverter::setKnownTypes(const HeaderTypesVec* types)
{
_known_types = types;
return ERR_NOERROR;
}
const std::string& DDLToHeaderConverter::getError()
{
return _error_string;
}
a_util::result::Result DDLToHeaderConverter::visitDDL(const DDLDescription *description)
{
// visit EVERYTHING and let the individual visit() method decide what to do.
DDLBaseunitVec base_units = description->getBaseunits();
for (DDLBaseunitIt iter = base_units.begin();
iter != base_units.end();
iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
DDLDTVec data_types = description->getDatatypes();
for (DDLDTIt iter = data_types.begin();
iter != data_types.end();
iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
DDLEnumVec enums = description->getEnums();
for (DDLEnumIt iter = enums.begin();
iter != enums.end();
iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
DDLPrefixVec prefixes = description->getPrefixes();
description->getHeader()->accept(this);
for (DDLPrefixIt iter = prefixes.begin();
iter != prefixes.end();
iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
DDLStreamVec streams = description->getStreams();
for (DDLStreamIt iter = streams.begin();
iter != streams.end();
iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
DDLComplexVec structs = description->getStructs();
for (DDLComplexIt iter = structs.begin();
iter != structs.end();
iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
DDLUnitVec units = description->getUnits();
for (DDLUnitIt iter = units.begin();
iter != units.end();
iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLHeader *header)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLDataType *data_type)
{
// Make sure, that the header type exists
if (findTypeByName(data_type->getName()) == NULL)
{
_error_string.append("Types that are not part of ADTF or stdint.h are not supported (");
_error_string.append(data_type->getName());
_error_string.append(").\n");
return (ERR_NOT_FOUND);
}
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLComplex *ddl_struct)
{
if (findTypeByName(ddl_struct->getName()) == NULL)
{
// Add the type, so if its referenced by one of its member, there will be no infinite loop.
HeaderStruct* header_struct = new HeaderStruct(ddl_struct->getName());
header_struct->setName(cleanUpName(ddl_struct->getName()));
header_struct->setComment(ddl_struct->getComment());
_structs.push_back(header_struct);
// parse all elements of the struct
DDLElementVec ddl_elements = ddl_struct->getElements();
for (DDLElementIt iter = ddl_elements.begin();
iter != ddl_elements.end();
iter++)
{
(*iter)->accept(this);
HeaderStructElement* header_element = new HeaderStructElement();
if ((*iter)->isDynamic())
{
// Not supported ATM
_error_string.append("Dynamic arrays are not supported.\n");
return ERR_NOT_SUPPORTED;
}
else
{
header_element->setArraySize((*iter)->getArraysize());
}
header_element->setIsConst(false);
header_element->setIsPointer(false);
header_element->setIsStatic(false);
header_element->setName(cleanUpName((*iter)->getName()));
header_element->setType(findTypeByName(cleanUpName((*iter)->getTypeObject()->getName())));
header_element->setDescription((*iter)->getDescription());
header_element->setComment((*iter)->getComment());
header_struct->addElement(header_element);
// Alignment
// Only two cases are supported at the moment:
// either the alignment of the element is the same as the default alignment of its type
// or the alignment of the element is smaller than the default alignment of its type and
// is the same as the parent structs alignment.
if (header_element->getType()->getPacking() == fromAlignment((*iter)->getAlignment()) ||
(header_element->getType()->getPacking() > fromAlignment((*iter)->getAlignment()) &&
(*iter)->getAlignment() == ddl_struct->getAlignment()))
{
// It's Okay, nothing to do here
}
else
{
_error_string.append("This alignment cannot be mapped to c-structs (");
_error_string.append(ddl_struct->getName());
_error_string.append(".");
_error_string.append((*iter)->getName());
_error_string.append(").\n");
_structs.pop_back();
delete header_struct;
return ERR_NOT_SUPPORTED;
}
}
// Setting packing after adding elements, so packing wont be recalculated inside the object
header_struct->setPacking(fromAlignment(ddl_struct->getAlignment()));
// Move this struct to the end, so that all needed types are defined front up.
_structs.erase(std::find(_structs.begin(), _structs.end(), header_struct));
_structs.push_back(header_struct);
}
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLStream *stream)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLUnit *unit)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLBaseunit *base_unit)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLExtDeclaration *ext_declaration)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLElement *element)
{
return (element->getTypeObject()->accept(this));
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLPrefix *prefix)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLRefUnit *ref_unit)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLStreamStruct *stream_struct)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLEnum *ddl_enum)
{
// Check the type
if (isFailed((ddl_enum->getTypeObject()->accept(this))))
{
return ERR_FAILED;
}
bool is_integer_enum = isEnumIntegral(ddl_enum);
if (is_integer_enum)
{
if (findTypeByName(ddl_enum->getName()) == NULL)
{
HeaderEnum* new_enum = new HeaderEnum(cleanUpName(ddl_enum->getName()));
for (auto value_iter = ddl_enum->getValues().begin(); value_iter != ddl_enum->getValues().end(); value_iter++)
{
const std::string& name = value_iter->first;
const std::string& value = value_iter->second;
new_enum->addValue(a_util::strings::toInt32(value), name);
}
_enums.push_back(new_enum);
}
return ERR_NOERROR;
}
else
{
// Non integer enums not possible in header. In that case we add the type as a typedef
// and define the values as constants of that type
// Add a typedef if not existing
if (findTypeByName(ddl_enum->getName()) == NULL)
{
_typedefs.push_back(new HeaderTypedef(cleanUpName(ddl_enum->getName()),
findTypeByName(ddl_enum->getType())));
}
const HeaderType* enum_type = findTypeByName(ddl_enum->getName());
for (auto value_iter = ddl_enum->getValues().begin(); value_iter != ddl_enum->getValues().end(); value_iter++)
{
const std::string& name = value_iter->first;
const std::string& value = value_iter->second;
HeaderConstant* constant = new HeaderConstant();
constant->setName(name);
constant->setType(enum_type);
constant->reset(value.c_str());
_constants.push_back(constant);
}
return ERR_NOERROR;
}
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLProperty* ddl_property)
{
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::visit(const DDLStreamMetaType* stream_meta_type)
{
return ERR_NOERROR;
}
Header* DDLToHeaderConverter::getHeader()
{
return _header;
}
a_util::result::Result DDLToHeaderConverter::createNew()
{
// This instance has no responsibility for the object.
_header = new Header();
_error_string = "";
BuildTypedefs();
BuildConstants();
buildStructs();
buildEnums();
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::DestroyHeader()
{
if (_header != NULL)
{
delete _header;
}
for (HeaderTypedefs::iterator iter = _typedefs.begin();
iter != _typedefs.end();
iter++)
{
delete *iter;
}
_typedefs.clear();
for (HeaderConstants::iterator iter = _constants.begin();
iter != _constants.end();
iter++)
{
delete *iter;
}
_constants.clear();
for (HeaderStructs::iterator iter = _structs.begin();
iter != _structs.end();
iter++)
{
delete *iter;
}
_structs.clear();
for (auto iter = _enums.begin();
iter != _enums.end();
iter++)
{
delete *iter;
}
_enums.clear();
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::BuildTypedefs()
{
for (HeaderTypedefs::iterator iter = _typedefs.begin();
iter != _typedefs.end();
iter++)
{
_header->addTypedef(*iter);
}
_typedefs.clear();
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::BuildConstants()
{
for (HeaderConstants::iterator iter = _constants.begin();
iter != _constants.end();
iter++)
{
_header->addConstant(*iter);
}
_constants.clear();
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::buildStructs()
{
for (HeaderStructs::iterator iter = _structs.begin();
iter != _structs.end();
iter++)
{
_header->addStruct(*iter);
}
_structs.clear();
return ERR_NOERROR;
}
a_util::result::Result DDLToHeaderConverter::buildEnums()
{
for (auto iter = _enums.begin();
iter != _enums.end();
iter++)
{
_header->addEnum(*iter);
}
_enums.clear();
return ERR_NOERROR;
}
const HeaderType* DDLToHeaderConverter::findTypeByName(const std::string &name)
{
const HeaderType* result = NULL;
if (_known_types != NULL)
{
result = findTypeByName(*_known_types, name);
}
if (result == NULL)
{
result = findTypeByName(_typedefs, name);
}
if (result == NULL)
{
result = findTypeByName(_structs, name);
}
if (result == NULL)
{
result = findTypeByName(_enums, name);
}
return result;
}
template <class C>
const HeaderType* DDLToHeaderConverter::findTypeByName(const std::vector<C> &vec,
const std::string &name)
{
const HeaderType* result = NULL;
for (typename std::vector<C>::const_iterator iter = vec.begin();
iter != vec.end();
iter++)
{
if ((*iter)->getName().compare(name) == 0)
{
result = *iter;
break;
}
}
return result;
}
size_t DDLToHeaderConverter::fromAlignment(DDLAlignment::AlignmentType alignment)
{
size_t result = 0;
switch (alignment)
{
case DDLAlignment::e_invalid:
result = 1;
break;
case DDLAlignment::e1:
result = 1;
break;
case DDLAlignment::e2:
result = 2;
break;
case DDLAlignment::e4:
result = 4;
break;
case DDLAlignment::e8:
result = 8;
break;
case DDLAlignment::e16:
result = 16;
break;
case DDLAlignment::e32:
result = 32;
break;
case DDLAlignment::e64:
result = 64;
break;
}
return result;
}
std::string DDLToHeaderConverter::cleanUpName(const std::string &name)
{
std::string result = name;
if (_displace.length() > 0)
{
if (result.find(_displace) == 0)
{
result.erase(0, _displace.length());
}
}
const std::string allowed_characters =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_1234567890";
for (size_t idx = 0; idx < result.size(); idx++)
{
if (allowed_characters.find(result.at(idx)) == std::string::npos)
{
result[idx] = '_';
}
}
return result;
}
bool DDLToHeaderConverter::isEnumIntegral(const DDLEnum *ddl_enum) const
{
for (auto iter = ddl_enum->getValues().begin(); iter != ddl_enum->getValues().end(); iter++)
{
if (!a_util::strings::isInt32(iter->second))
{
return false;
}
}
return true;
}
void DDLToHeaderConverter::setDisplaceableString(std::string displace)
{
_displace = displace;
}
}

163
ddlgenerators/generator_library/headerrepresentation/ddl_to_header_converter.h Normal file
View file

@ -0,0 +1,163 @@
/**
* @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
*/
#ifndef HEADER_DDL_TO_HEADER_CONVERTER_H_INCLUDED
#define HEADER_DDL_TO_HEADER_CONVERTER_H_INCLUDED
#include "header_type.h"
#include "header_factorymethod_intf.h"
#include "header_importer.h"
#include "header_header.h"
namespace ddl
{
typedef std::vector<const HeaderType*> HeaderConstTypes;
/**
* This class generates a header from a DDL.
* Use this class by first visiting the element(s) of the DDL you want to be part of your DDL,
* then call createNew() to create the header from the previously parsed header elements.
*/
class DDLToHeaderConverter : public IDDLVisitor, public IHeaderFactory
{
public:
/**
* CTOR
*/
DDLToHeaderConverter();
/**
* DTOR
*/
virtual ~DDLToHeaderConverter();
/**
* The method setKnownTypes adds a list of already known types.
* These types can be referenced by any member inside the new header.
* Please be aware, that neither the importer object nor the
* resulting header object will own the types. The resulting
* header object will only reference them. So the resulting header
* must be deleted before the types are deleted.
*
* @param [in] types A list of types already know to the system.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result setKnownTypes(const HeaderTypesVec* types);
/**
* The method getError returns the error messages that occurred during parsing.
*
* @returns The error messages.
*/
const std::string& getError();
void setDisplaceableString(std::string displace);
public: // implements IDDLVisitor
a_util::result::Result visitDDL(const DDLDescription *description);
a_util::result::Result visit(const DDLHeader *header);
a_util::result::Result visit(const DDLDataType *data_type);
a_util::result::Result visit(const DDLComplex *ddl_struct);
a_util::result::Result visit(const DDLStream *stream);
a_util::result::Result visit(const DDLUnit *unit);
a_util::result::Result visit(const DDLBaseunit *base_unit);
a_util::result::Result visit(const DDLExtDeclaration *ext_declaration);
a_util::result::Result visit(const DDLElement *element);
a_util::result::Result visit(const DDLPrefix *prefix);
a_util::result::Result visit(const DDLRefUnit *ref_unit);
a_util::result::Result visit(const DDLStreamStruct *stream_struct);
a_util::result::Result visit(const DDLEnum *ddl_enum);
a_util::result::Result visit(const DDLProperty* ddl_property);
a_util::result::Result visit(const DDLStreamMetaType* stream_meta_type);
public: // implements IHeaderFactory
Header* getHeader();
a_util::result::Result createNew();
a_util::result::Result DestroyHeader();
a_util::result::Result BuildTypedefs();
a_util::result::Result BuildConstants();
a_util::result::Result buildStructs();
a_util::result::Result buildEnums();
private:
/// The header to be created
Header* _header;
/// The known types
const HeaderTypesVec* _known_types;
/// The Typedefs found during parsing
HeaderTypedefs _typedefs;
/// The structs found during parsing
HeaderStructs _structs;
/// The constants found during parsing
HeaderConstants _constants;
/// The enums found during parsing
HeaderEnums _enums;
/// Collecting all error messages here.
std::string _error_string;
/// String that should be removed at the beginning of element names
std::string _displace;
/**
* The method findTypeByName searches m_vecTypes for a type by the given name.
*
* @param [in] name The name of the type to be found.
* @returns A pointer to the type if found, NULL otherwise.
*/
const HeaderType* findTypeByName(const std::string &name);
/**
* The method findTypeByName helps finding a type in a vector containin pointer to
* header types.
*
* @param [in] vec The vector to be looked through.
* @param [in] name The name of the type to be found
* @returns A pointer to the type if found, NULL otherwise.
*/
template <class C>
const HeaderType* findTypeByName(const std::vector<C> &vec, const std::string &name);
/**
* The method fromAlignment calculates the packing from an alignment value.
*
* @param [in] alignment The alignment value
* @returns The packing value, 0 if no matching packing or e0 was found.
*/
size_t fromAlignment(DDLAlignment::AlignmentType alignment);
/**
* The method cleanUpName replaces all non letter/number/underscore characters from
* the passed string with underscores and returns the result as a new string.
*
* @param [in] name The string to be cleaned up.
* @returns A string only containing letters, numbers and underscores.
*/
std::string cleanUpName(const std::string &name);
bool isEnumIntegral(const DDLEnum *ddl_enum) const;
};
}
#endif // HEADER_DDL_TO_HEADER_CONVERTER_H_INCLUDED

47
ddlgenerators/generator_library/headerrepresentation/header_base_intf.h Normal file
View file

@ -0,0 +1,47 @@
/**
* @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
*/
#ifndef HEADER_INTF_H_INCLUDED
#define HEADER_INTF_H_INCLUDED
namespace ddl
{
class IHeaderVisitor;
/**
* Basic interface class for object representation of a C header.
* E.g. it provides the accept() method for the Visitor design-pattern.
*/
class IHeaderBase
{
public:
/**
* Acceptance method for Visitor design-pattern.
* @param[in] visitor - Pointer to Visitor instance
* @retval ERR_POINTER Null-pointer committed
* @retval ERR_NOT_FOUND Required node not found.
* @retval ERR_NOT_INITIALISED The object was not or not correctly
* initialized
*/
virtual a_util::result::Result accept (IHeaderVisitor * visitor) const = 0;
};
} // namespace ddl
#endif // HEADER_INTF_H_INCLUDED

75
ddlgenerators/generator_library/headerrepresentation/header_basic_type.cpp Normal file
View file

@ -0,0 +1,75 @@
/**
* @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.h>
#include "header_basic_type.h"
#include "header_visitor_intf.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderBasicType::HeaderBasicType() : HeaderType(), _bit_size(0)
{ }
HeaderBasicType::HeaderBasicType(const std::string &name, size_t packing, size_t bit_size)
: HeaderType(name, packing), _bit_size(bit_size)
{ }
HeaderBasicType::HeaderBasicType(const HeaderBasicType& other)
: HeaderType(other), _bit_size(other._bit_size)
{ }
HeaderBasicType::~HeaderBasicType()
{ }
a_util::result::Result HeaderBasicType::accept(IHeaderVisitor *visitor) const
{
if (!visitor)
{
return ERR_INVALID_ARG;
}
return (visitor->visit(this));
}
a_util::result::Result HeaderBasicType::setBitsize_t(size_t bit_size)
{
_bit_size = bit_size;
return ERR_NOERROR;
}
size_t HeaderBasicType::getBitsize_t() const
{
return _bit_size;
}
} // namespace ddl

85
ddlgenerators/generator_library/headerrepresentation/header_basic_type.h Normal file
View file

@ -0,0 +1,85 @@
/**
* @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
*/
#ifndef HEADER_BASE_TYPE_H_INCLUDED
#define HEADER_BASE_TYPE_H_INCLUDED
#include "header_type.h"
namespace ddl
{
/**
* Representation of a basic type in a header.
*/
class HeaderBasicType : public HeaderType
{
public:
/**
* Default CTOR
*/
HeaderBasicType();
/**
* CTOR
*
* @param [in] name The name of the type.
* @param [in] packing The packing of the type
* @param [in] bit_size The size f the type in bit.
*/
HeaderBasicType(const std::string &name, size_t packing, size_t bit_size);
/**
* Copy CTOR
* @param [in] other The other type this instance will be a copy of.
*/
HeaderBasicType(const HeaderBasicType& other);
/**
* DTOR
*/
virtual ~HeaderBasicType();
/**
* The method setBitsize_t sets the size of the type in bit.
*
* @param [in] bit_size The size in bit.
* @returns Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setBitsize_t(size_t bit_size);
/**
* The method getBitsize_t returns the size of the basic type in bit.
*
* @returns The size in bit.
*/
size_t getBitsize_t() const;
public: //implements HeaderType
virtual a_util::result::Result accept(IHeaderVisitor *visitor) const;
private:
/// Stores the size of the basic type in bit
size_t _bit_size;
};
} // namespace ddl
#endif // HEADER_BASE_TYPE_H_INCLUDED

80
ddlgenerators/generator_library/headerrepresentation/header_constant.cpp Normal file
View file

@ -0,0 +1,80 @@
/**
* @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.h>
#include "header_constant.h"
#include "header_visitor_intf.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderConstant::HeaderConstant() : a_util::variant::Variant()
{ }
HeaderConstant::HeaderConstant(const HeaderConstant& other) : a_util::variant::Variant(other), _name(other._name)
{ }
HeaderConstant::~HeaderConstant()
{ }
const std::string& HeaderConstant::getName() const
{
return _name;
}
a_util::result::Result HeaderConstant::setName(const std::string& name)
{
_name = name;
return ERR_NOERROR;
}
a_util::result::Result HeaderConstant::setType(const HeaderType* type)
{
_type = type;
return ERR_NOERROR;
}
const HeaderType* HeaderConstant::getType() const
{
return _type;
}
a_util::result::Result HeaderConstant::accept(IHeaderVisitor *visitor) const
{
if (!visitor)
{
return ERR_INVALID_ARG;
}
return (visitor->visit(this));
}
} // namespace ddl

97
ddlgenerators/generator_library/headerrepresentation/header_constant.h Normal file
View file

@ -0,0 +1,97 @@
/**
* @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
*/
#ifndef HEADER_CONSTANT_H_INCLUDED
#define HEADER_CONSTANT_H_INCLUDED
#include "header_base_intf.h"
#include "header_type.h"
namespace ddl
{
/**
* Representation of a constant in a header.
* @remark
* This class is intended to represent a primitive type constant.
* Although the current architecture supports setting the type
* of the constant to a struct, it would not make much sense.
*/
class HeaderConstant : public IHeaderBase, public a_util::variant::Variant
{
public:
/**
* Default CTOR
*/
HeaderConstant();
/**
* Copy CTOR
* @param [in] other The other constant to copy from.
*/
HeaderConstant(const HeaderConstant& other);
/**
* DTOR
*/
virtual ~HeaderConstant();
/**
* This method gives access to the name of the type.
* @return The name of the element.
*/
const std::string& getName() const;
/**
* This method gives access to the name of the type.
* @param [in] name The name of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setName(const std::string& name);
/**
* The method getType gives access to the type of the constant.
*
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
const HeaderType* getType() const;
/**
* The method setType sets the type of the constant
*
* @param [in] type A pointer to the type of the constant. This class will not own the pointer.
* @returns Standard result code.
* @retval ERR_NOERROR Will always be returned.
*/
a_util::result::Result setType(const HeaderType* type);
public: // implements IHeaderBase
a_util::result::Result accept(IHeaderVisitor *visitor) const;
private:
/// The name of the constant.
std::string _name;
/// The type of the constant
const HeaderType* _type;
};
} // namespace ddl
#endif // HEADER_CONSTANT_H_INCLUDED

94
ddlgenerators/generator_library/headerrepresentation/header_enum.cpp Normal file
View file

@ -0,0 +1,94 @@
/**
* @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.h>
#include "header_enum.h"
#include "header_visitor_intf.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderEnum::HeaderEnum() : HeaderType(), _enum_values()
{ }
HeaderEnum::HeaderEnum(std::string name, size_t packing /*= 4*/)
: HeaderType(name, packing), _enum_values()
{ }
HeaderEnum::HeaderEnum(HeaderEnum& other)
: HeaderType(other), _enum_values()
{ }
HeaderEnum::~HeaderEnum()
{ }
const HeaderEnumValueMap& HeaderEnum::getValues() const
{
return _enum_values;
}
a_util::result::Result HeaderEnum::addValue(int32_t value, const std::string& name)
{
if (_enum_values.count(value) != 0)
{
// non unique key
return ERR_INVALID_ARG;
}
_enum_values[value] = name;
return ERR_NOERROR;
}
a_util::result::Result HeaderEnum::removeValue( int32_t value )
{
HeaderEnumValueMap::iterator iter = _enum_values.find(value);
if (iter == _enum_values.end())
{
return ERR_NOT_FOUND;
}
_enum_values.erase(iter);
return ERR_NOERROR;
}
a_util::result::Result HeaderEnum::accept(IHeaderVisitor *visitor) const
{
if (!visitor)
{
return ERR_INVALID_ARG;
}
return (visitor->visit(this));
}
} // namespace ddl

111
ddlgenerators/generator_library/headerrepresentation/header_enum.h Normal file
View file

@ -0,0 +1,111 @@
/**
* @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
*
* QNX support Copyright (c) 2019 by dSPACE GmbH, Paderborn, Germany. All Rights Reserved
*/
#ifndef HEADER_ENUM_H_INCLUDED
#define HEADER_ENUM_H_INCLUDED
#include "header_base_intf.h"
#include "header_type.h"
#include <map>
#include <a_util/result.h>
namespace ddl
{
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic ignored "-Wattributes" // standard type attributes are ignored when used in templates
#endif
typedef std::map<int32_t, std::string> HeaderEnumValueMap;
#if defined(__GNUC__) && (__GNUC__ == 5) && defined(__QNX__)
#pragma GCC diagnostic warning "-Wattributes" // standard type attributes are ignored when used in templates
#endif
/**
* Representation of a enum in a header.
* The class calculates its own packing from its children
* every time one or more children have been added or removed.
* To override the calculated packing, set the packing value AFTER adding
* children.
*/
class HeaderEnum : public HeaderType
{
public:
/**
* Default CTOR
*/
HeaderEnum();
/**
* CTOR
* @param [in] name The name of the struct.
* @param [in] packing The packing of the struct.
* The struct takes ownership of the passed elements.
*/
HeaderEnum(std::string name,
size_t packing = 4);
/**
* Copy CTOR
* @param [in] other The other type this instance will be a copy of.
*/
HeaderEnum(HeaderEnum& other);
/**
* DTOR
*/
virtual ~HeaderEnum();
/**
* This method gives access to the values of the enum.
* @return The enum values as a map.
*/
const HeaderEnumValueMap& getValues() const;
/**
* Add a value to this enum
* @param[in] value The enum value (must be unique for this enum)
* @param[in] name the name
*/
a_util::result::Result addValue(int32_t value, const std::string& name);
/**
* Remove a value from this enum.
* @param [in] key The key of the element to be removed.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
* @retval ERR_NOT_FOUND No element with this key was found.
*/
a_util::result::Result removeValue(int32_t value);
public: // implements cHeaderBaseType
a_util::result::Result accept(IHeaderVisitor *visitor) const;
private:
HeaderEnumValueMap _enum_values;
};
} // namespace ddl
#endif // HEADER_ENUM_H_INCLUDED

95
ddlgenerators/generator_library/headerrepresentation/header_factorymethod_intf.h Normal file
View file

@ -0,0 +1,95 @@
/**
* @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
*/
#ifndef HEADER_FACTORY_H_INCLUDED
#define HEADER_FACTORY_H_INCLUDED
namespace ddl
{
class Header;
/**
* Abstract base class/interface for Factory Method design-pattern.
*/
class IHeaderFactory
{
public:
/**
* Getter for the header object.
* @return the header object
* @attention The caller/user has the responsibility for the created
* header object! Especially take this aspect into consideration in
* matters of the deallocation of memory!
*/
virtual Header* getHeader() = 0;
/**
* Method to build up a new header hierarchy.
* This will internally create a new header. An existing old header
* will not be deleted. So make sure to have taken responsibility of all
* previously created headers by calling getHeader().
* @retval ERR_NOT_INITIALISED Not yet initialized
* @retval ERR_UNKNOWN_FORMAT Expected header hierarchy not found
* @retval ERR_FAILED Some other error occurred.
* was not found.
*/
virtual a_util::result::Result createNew() = 0;
/**
* The method DestroyHeader destroys the header object and all contained objects.
*
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
virtual a_util::result::Result DestroyHeader() = 0;
/**
* Method to build a typedef object hierarchy.
* @retval ERR_UNKNOWN_FORMAT Expected header hierarchy not found
* @retval ERR_NO_CLASS Cross reference not resolvable
*/
virtual a_util::result::Result BuildTypedefs() = 0;
/**
* Method to build a constants object hierarchy.
* @retval ERR_UNKNOWN_FORMAT Expected header hierarchy not found
* @retval ERR_NO_CLASS Cross reference not resolvable (e.g. struct)
*/
virtual a_util::result::Result BuildConstants() = 0;
/**
* Method to build a structs object hierarchy.
* @retval ERR_UNKNOWN_FORMAT Expected header hierarchy not found
* @retval ERR_NO_CLASS Cross reference not resolvable (e.g. base type)
* @retval ERR_UNKNOWN Not all firstly unknown structs have been
* resolved
*/
virtual a_util::result::Result buildStructs() = 0;
/**
* Method to build a enum object hierarchy.
* @retval ERR_UNKNOWN_FORMAT Expected header hierarchy not found
* resolved
*/
virtual a_util::result::Result buildEnums() = 0;
};
} // namespace ddl
#endif // HEADER_FACTORY_H_INCLUDED

197
ddlgenerators/generator_library/headerrepresentation/header_header.cpp Normal file
View file

@ -0,0 +1,197 @@
/**
* @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.h>
#include "header_header.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
Header::Header()
{ }
Header::Header(const Header &other)
{
_name = other._name;
for (HeaderTypedefs::const_iterator iter = other._typedefs.begin(); iter != other._typedefs.end(); iter++)
{
_typedefs.push_back(new HeaderTypedef(*(*iter)));
}
for (HeaderConstants::const_iterator iter = other._constants.begin(); iter != other._constants.end(); iter++)
{
_constants.push_back(new HeaderConstant(*(*iter)));
}
for (HeaderStructs::const_iterator iter = other._structs.begin(); iter != other._structs.end(); iter++)
{
_structs.push_back(new HeaderStruct(*(*iter)));
}
for (auto iter = other._enums.begin(); iter != other._enums.end(); iter++)
{
_enums.push_back(new HeaderEnum(*(*iter)));
}
}
Header::~Header()
{
for (HeaderTypedefs::iterator iter = _typedefs.begin(); iter != _typedefs.end(); iter++)
{
delete *iter;
}
_typedefs.clear();
for (HeaderConstants::iterator iter = _constants.begin(); iter != _constants.end(); iter++)
{
delete *iter;
}
_constants.clear();
for (HeaderStructs::iterator iter = _structs.begin(); iter != _structs.end(); iter++)
{
delete *iter;
}
_structs.clear();
for (auto iter = _enums.begin(); iter != _enums.end(); iter++)
{
delete *iter;
}
_enums.clear();
}
const std::string& Header::getName() const
{
return _name;
}
a_util::result::Result Header::setName(const std::string& name)
{
_name = name;
return ERR_NOERROR;
}
const HeaderTypedefs& Header::getTypedefs() const
{
return _typedefs;
}
a_util::result::Result Header::addTypedef(HeaderTypedef* header_typedef)
{
_typedefs.push_back(header_typedef);
return ERR_NOERROR;
}
a_util::result::Result Header::removeTypedef(const std::string &name)
{
for (HeaderTypedefs::iterator iter = _typedefs.begin(); iter != _typedefs.end(); iter++)
{
if ((*iter)->getName() == name)
{
delete *iter;
_typedefs.erase(iter);
return ERR_NOERROR;
}
}
return (ERR_NOT_FOUND);
}
const HeaderConstants& Header::getConstants() const
{
return _constants;
}
a_util::result::Result Header::addConstant(HeaderConstant* constant)
{
_constants.push_back(constant);
return ERR_NOERROR;
}
a_util::result::Result Header::removeConstant(const std::string &name)
{
for (HeaderConstants::iterator iter = _constants.begin(); iter != _constants.end(); iter++)
{
if ((*iter)->getName() == name)
{
delete *iter;
_constants.erase(iter);
return ERR_NOERROR;
}
}
return (ERR_NOT_FOUND);
}
const HeaderStructs& Header::getStructs() const
{
return _structs;
}
a_util::result::Result Header::addStruct(HeaderStruct* header_struct)
{
_structs.push_back(header_struct);
return ERR_NOERROR;
}
a_util::result::Result Header::removeStruct(const std::string &name)
{
for (HeaderStructs::iterator iter = _structs.begin(); iter != _structs.end(); iter++)
{
if ((*iter)->getName() == name)
{
delete *iter;
_structs.erase(iter);
return ERR_NOERROR;
}
}
return (ERR_NOT_FOUND);
}
const HeaderEnums& Header::getEnums() const
{
return _enums;
}
a_util::result::Result Header::addEnum(HeaderEnum* header_enum)
{
_enums.push_back(header_enum);
return ERR_NOERROR;
}
a_util::result::Result Header::accept(IHeaderVisitor * visitor) const
{
if (!visitor)
{
return ERR_INVALID_ARG;
}
return (visitor->visit(this));
}
} // namespace ddl

191
ddlgenerators/generator_library/headerrepresentation/header_header.h Normal file
View file

@ -0,0 +1,191 @@
/**
* @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
*/
#ifndef HEADER_HEADER_H_INCLUDED
#define HEADER_HEADER_H_INCLUDED
#include "header_base_intf.h"
#include "header_typedef.h"
#include "header_constant.h"
#include "header_struct.h"
#include "header_enum.h"
#include "header_visitor_intf.h"
namespace ddl
{
/**
* Container type of basic type objects
*/
typedef std::vector<HeaderTypedef*> HeaderTypedefs;
/**
* Container type of constants objects
*/
typedef std::vector<HeaderConstant*> HeaderConstants;
/**
* Container type of struct objects
*/
typedef std::vector<HeaderStruct*> HeaderStructs;
/**
* Container type of enum objects
*/
typedef std::vector<HeaderEnum*> HeaderEnums;
/**
* Main class representing a whole header file
*/
class Header : public IHeaderBase
{
public:
/**
* CTOR
*/
Header();
/**
* Copy CTOR. This will make a full copy of the other header.
* @param [in] other The other header this instance will be a copy of.
*/
Header(const Header &other);
/**
* DTOR
*/
virtual ~Header();
/**
* This method gives access to the name of the type.
* @return The name of the element.
*/
const std::string& getName() const;
/**
* This method gives access to the name of the type.
* @param [in] name The name of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setName(const std::string& name);
/**
* This method gives access to the list of typedefs from the header.
* @returns The list of typedefs
*/
const HeaderTypedefs& getTypedefs() const;
/**
* This method adds a typedef to the internal list of typedefs.
* @param [in] type_def The typedef to be added. The class takes ownership of the object.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
*/
a_util::result::Result addTypedef(HeaderTypedef* type_def);
/**
* This method removes a typedef from the internal list of typedefs.
* @param [in] name The name of the typedef to be removed.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
* @retval ERR_NOT_FOUND No typedef with this name was found.
*/
a_util::result::Result removeTypedef(const std::string &name);
/**
* This method gives access to the list of constants from the header.
* @returns The list of constants.
*/
const HeaderConstants& getConstants() const;
/**
* This method adds a constant to the internal list of constants.
* @param [in] constant The constant to be added. The class takes ownership of the object.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
*/
a_util::result::Result addConstant(HeaderConstant* constant);
/**
* This method removes a constant from the internal list of constants.
* @param [in] strName The name of the constant to be removed.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
* @retval ERR_NOT_FOUND No constant with this name was found.
*/
a_util::result::Result removeConstant(const std::string &name);
/**
* This method gives access to the list of structs from the header.
* @returns The list of structs
*/
const HeaderStructs& getStructs() const;
/**
* This method adds a struct to the internal list of structs.
* @param [in] pStruct The struct to be added. The class takes ownership of the object.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
*/
a_util::result::Result addStruct(HeaderStruct* header_struct);
/**
* This method removes a struct from the internal list of structs.
* @param [in] strName The name of the struct to be removed.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
* @retval ERR_NOT_FOUND No struct with this name was found.
*/
a_util::result::Result removeStruct(const std::string &name);
/**
* This method gives access to the list of enums from the header.
* @returns The list of enums
*/
const HeaderEnums& getEnums() const;
/**
* This method adds an enum to the internal list of enums.
* @param [in] p_enum The enum to be added. The class takes ownership of the object.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
*/
a_util::result::Result addEnum(HeaderEnum* header_enum);
public: // implementation of IHeaderBase
virtual a_util::result::Result accept(IHeaderVisitor * visitor) const;
private:
/// The name of the header (i.e. file name)
std::string _name;
/// The list of typedefs.
HeaderTypedefs _typedefs;
/// The list of constants.
HeaderConstants _constants;
/// The list of structs.
HeaderStructs _structs;
/// The list of enums
HeaderEnums _enums;
};
} // namespace ddl
#endif // HEADER_HEADER_H_INCLUDED

1324
ddlgenerators/generator_library/headerrepresentation/header_importer.cpp Normal file
View file

File diff suppressed because it is too large Load diff

222
ddlgenerators/generator_library/headerrepresentation/header_importer.h Normal file
View file

@ -0,0 +1,222 @@
/**
* @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
*/
#ifndef HEADER_IMPORTER_H_INCLUDED
#define HEADER_IMPORTER_H_INCLUDED
#include "header_factorymethod_intf.h"
#include "header_type.h"
#include "header_struct.h"
#include "header_enum.h"
#include "header_header.h"
namespace ddl
{
/**
* Container type for header types.
*/
typedef std::vector<HeaderType*> HeaderTypesVec;
/**
* The class HeaderImporter imports headers from file or string.
* The following settings can be performed regarding the import itself
* Default integer type: see setDefaultIntegerType()
*/
class HeaderImporter : IHeaderFactory
{
public:
HeaderImporter();
virtual ~HeaderImporter();
/**
* The method SetSourceString sets the text that will be parsed.
* Any filename previously set with setFileName will be ignored.
*
* @param [in] source The header string that will be parsed.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_UNKNOWN_FORMAT Could not parse the string because it is not a valid header file.
*/
a_util::result::Result setHeaderString(const std::string &source);
/**
* The method setFileName sets the path to the file that will be parsed.
* Any string previously set with setHeaderString will be ignored.
*
* @param [in] filename The path to the file.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result setFileName(const a_util::filesystem::Path &filename);
/**
* The method setKnownTypes adds a list of already known types.
* These types can be referenced by any member inside the header.
* Please be aware, that neither the importer object nor the
* resulting header object will own the types. The resulting
* header object will only reference them. So the resulting header
* must be deleted before the types are deleted.
*
* @param [in] types A list of types already know to the system.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result setKnownTypes(const HeaderTypesVec* types);
/**
* The method GetErrors gives access to the last error that occurred.
*
* @returns The last error
*/
const std::string& getLastError() const;
/**
* The method setDefaultIntegerType sets the type to be used for constants defined by
* \#define CONST_NAME 123.
* The class does not take ownership of the type.
* If no type is set, the createNew() method will try to find the type "tUInt64" within the known
* types and use this one.
*
* @remark You could pass a pointer from the known types list (setKnownTypes) for best consistency.
*
* @param [in] type The type to use for defines.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result setDefaultIntegerType(const HeaderType* type);
/**
* The method getDefaultTypes creates a list of know types. The ADTF types will be treated as
* THE basic types (so "tFloat32" is the most basic type and not "float").
* The list will contain the ADTF types and types from stdint.h.
* This list can be used with setKnownTypes()
*
* @returns A list of all known basic types. The caller will be the owner of the object.
*/
static HeaderTypesVec* getDefaultTypes();
public: // implements IHeaderFactory
virtual Header * getHeader();
virtual a_util::result::Result createNew();
virtual a_util::result::Result DestroyHeader();
virtual a_util::result::Result BuildTypedefs();
virtual a_util::result::Result BuildConstants();
virtual a_util::result::Result buildStructs();
virtual a_util::result::Result buildEnums();
private:
/**
* The method findKnownType searches all lists with known types
* (typedefs and types in _header and other types from _types)
* for a type with the passed name
*
* @param [in] name The name of the type to be found.
* @returns A pointer to the found type. If no type was found, the function returns NULL.
*/
const HeaderType* findKnownType(const std::string &name) const;
/**
* The function extractStructElements parses a block that defines a struct
* for elements.
* The function expects the passed pointer to point to the next character
* after the { character. After execution, the \a pos will point to the first
* character after the closing } character.
* The function does not keep the ownership of the elements inside the resulting vector.
* The caller is responsible to delete these elements.
* The order of the elements corresponds the order in the struct.
*
* @param [in,out] pos A pointer to the first character of the
opening "{" character of the struct block.
The pointer will point to the first character
after the closing "}" of the block.
* @returns A vector of all found struct elements.
*/
HeaderStructElementVec extractStructElements(const char* &pos);
/**
* The method addErrorDescription adds a description string to the internal error string.
* It will try to extract the line number from the position of the source string.
*
* @param [in] description The error description to be added.
* @param [in] pos A pointer to the position inside the source string where the error occurred.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result addErrorDescription(const std::string &description, const char* pos);
/**
* The method parseTypedef parses a typedef that does redefine an existing type.
*
* @param [inout] pos A pointer to the first character after the word "typedef".
After invocation of this method, this pointer will point to
the first character after the final ";" of the typedef.
If no typedef could be parsed successfully, the pos will not be altered.
* @param [out] new_type_name The name of new type
* @param [out] originalTypeName The name of the original type
* @param [out] token The token if available (like struct or enum)
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
* @retval ERR_UNKNOWN_FORMAT If a typedef could not be identified.
*/
a_util::result::Result parseTypedef(const char* &pos, std::string &token, std::string &original_type_name, std::string& new_type_name);
/**
* The function extractEnumValues parses a block that defines a enum
* for it's values.
* The function expects the passed pointer to point to the next character
* after the { character. After execution, the \a pos will point to the first
* character after the closing } character.
*
* @param [in,out] pos A pointer to the first character of the
opening "{" character of the struct block.
The pointer will point to the first character
after the closing "}" of the block.
* @returns A map of all found enum values.
*/
HeaderEnumValueMap extractEnumValues(const char* &pos);
private:
/// The internal header being build up.
Header* _header;
/// The file to be parsed
a_util::filesystem::Path _input_file;
/// The string to be parsed
std::string _header_source;
/// A list of already know types
const HeaderTypesVec* _types;
/// The last error that occurred
std::string _last_error;
/// The default integer type that will be used for defines, see also setDefaultIntegerType()
const HeaderType* _default_type;
};
}
#endif //HEADER_IMPORTER_H_INCLUDED

381
ddlgenerators/generator_library/headerrepresentation/header_printer.cpp Normal file
View file

@ -0,0 +1,381 @@
/**
* @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.h>
#include "header_printer.h"
#include "header_header.h"
#include "header_basic_type.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-4, ERR_POINTER)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-11, ERR_INVALID_FILE)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
_MAKE_RESULT(-24, ERR_PATH_NOT_FOUND)
_MAKE_RESULT(-27, ERR_OPEN_FAILED)
_MAKE_RESULT(-38, ERR_FAILED)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderPrinter::HeaderPrinter() : _header(NULL)
{ }
HeaderPrinter::~HeaderPrinter()
{ }
a_util::result::Result HeaderPrinter::writeToFile(const a_util::filesystem::Path &filename)
{
std::string guarded_header_output = addHeaderGuards(filename, _header_output);
if (a_util::filesystem::writeTextFile(filename, guarded_header_output) != a_util::filesystem::OK)
{
return (ERR_OPEN_FAILED);
}
return ERR_NOERROR;
}
const std::string& HeaderPrinter::getHeader()
{
return _header_output;
}
a_util::result::Result HeaderPrinter::visit(const Header* header)
{
_header = header;
_header_output = "";
_header_output.append("// This is a generated file, changes to it may be overwritten in the future.\n\n");
if (_name_space.length() > 0)
{
_header_output.append(a_util::strings::format("namespace %s\n{\n", _name_space.c_str()));
}
HeaderTypedefs typedefs = header->getTypedefs();
for (HeaderTypedefs::iterator iter = typedefs.begin(); iter != typedefs.end(); iter++)
{
if (isFailed((appendType(*iter))))
{
return ERR_FAILED;
}
}
HeaderEnums enums = header->getEnums();
for (auto iter = enums.begin(); iter != enums.end(); iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
HeaderStructs structs = header->getStructs();
for (HeaderStructs::iterator iter = structs.begin(); iter != structs.end(); iter++)
{
if (isFailed((appendType(*iter))))
{
return ERR_FAILED;
}
}
HeaderConstants constants = header->getConstants();
for (HeaderConstants::iterator iter = constants.begin(); iter != constants.end(); iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
if (isFailed((printUnknownTypes())))
{
return ERR_FAILED;
}
if (_name_space.length() > 0)
{
_header_output.append(a_util::strings::format("} // namespace %s\n", _name_space.c_str()));
}
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::visit(const HeaderBasicType* basic_type)
{
CollectType(basic_type, true);
_header_output.append("// The following type is assumed to be known:\n");
_header_output.append("// ");
_header_output.append(basic_type->getName());
_header_output.append("\n\n");
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::visit(const HeaderTypedef* type_def)
{
printDescription(type_def);
// Set known first, so no infinite loop will occur when looking for base type
CollectType(type_def, true);
appendType(type_def->getOriginalType());
_header_output.append(a_util::strings::format("typedef %s %s;\n\n",
type_def->getOriginalType()->getName().c_str(), type_def->getName().c_str()));
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::visit(const HeaderConstant* constant)
{
appendType(constant->getType());
_header_output.append("const ");
_header_output.append(constant->getType()->getName());
_header_output.append(" ");
_header_output.append(constant->getName());
_header_output.append(" = ");
_header_output.append(constant->asString());
_header_output.append(";\n\n");
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::visit(const HeaderStruct* header_struct)
{
printDescription(header_struct);
// Set known first, so no infinite loop will occur when looking for base type
CollectType(header_struct, true);
// Make sure all types are already defined
HeaderStructElementVec elements = header_struct->getElements();
for (HeaderStructElementVec::iterator iter = elements.begin(); iter != elements.end(); iter++)
{
appendType((*iter)->getType());
}
_header_output.append(a_util::strings::format("#pragma pack(push,%d)\n", header_struct->getPacking()));
_header_output.append("typedef struct\n{\n");
for (HeaderStructElementVec::iterator iter = elements.begin(); iter != elements.end(); iter++)
{
if (isFailed(((*iter)->accept(this))))
{
return ERR_FAILED;
}
}
_header_output.append(a_util::strings::format("} %s;\n", header_struct->getName().c_str()));
_header_output.append("#pragma pack(pop)\n\n");
CollectType(header_struct, true);
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::visit(const HeaderStructElement* header_struct)
{
if (!header_struct || !header_struct->getType())
{
return ERR_INVALID_ARG;
}
printDescription(header_struct->getDescription(), header_struct->getComment(), true);
appendType(header_struct->getType());
_header_output.append(" ");
if (header_struct->isStatic())
{
_header_output.append("static ");
}
if (header_struct->isConst())
{
_header_output.append("const ");
}
_header_output.append(header_struct->getType()->getName());
if (header_struct->isPointer())
{
_header_output.append("* ");
}
_header_output.append(" ");
_header_output.append(header_struct->getName());
if (header_struct->getArraySize() > 1)
{
_header_output.append(a_util::strings::format("[%d]", header_struct->getArraySize()));
}
_header_output.append(";\n");
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::visit(const HeaderEnum* header_enum)
{
CollectType(header_enum, true);
printDescription(header_enum);
_header_output.append("typedef enum {\n");
for (auto iter = header_enum->getValues().begin(); iter != header_enum->getValues().end(); iter++)
{
_header_output.append(a_util::strings::format(" %s=%i,\n", iter->second.c_str(), iter->first));
}
if (header_enum->getValues().size() > 0)
{
// remove last ',' since some versions of C/C++ don't allow trailing commas in enums
_header_output.resize(_header_output.length() - 2);
}
_header_output.append(a_util::strings::format("\n} %s;\n\n", header_enum->getName().c_str()));
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::appendType(const HeaderType* type)
{
// See if we already know this type and therefore have printed it already
for (HeaderConstTypes::iterator iter = _known_types.begin(); iter != _known_types.end(); iter++)
{
if (*iter == type)
{
return ERR_NOERROR;
}
}
// Search the header for the type.
if (_header != NULL)
{
for (HeaderTypedefs::const_iterator iter = _header->getTypedefs().begin(); iter != _header->getTypedefs().end(); iter++)
{
if (*iter == type)
{
// Found it, append it
return ((*iter)->accept(this));
}
}
for (HeaderStructs::const_iterator iter = _header->getStructs().begin(); iter != _header->getStructs().end(); iter++)
{
if (*iter == type)
{
// Found it, append it
return ((*iter)->accept(this));
}
}
}
// Nothing found so far, so type is unknown
CollectType(type, false);
return (ERR_NOT_FOUND);
}
a_util::result::Result HeaderPrinter::CollectType(const ddl::HeaderType* type, bool is_known)
{
if (is_known)
{
if (std::find(_known_types.begin(), _known_types.end(), type) ==
_known_types.end())
{
_known_types.push_back(type);
}
}
else
{
if (std::find(_unknown_types.begin(), _unknown_types.end(), type) ==
_unknown_types.end())
{
_unknown_types.push_back(type);
}
}
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::printUnknownTypes()
{
// visit all types that are in the unknown types set but not in the knowN types set
HeaderConstTypes vec = _unknown_types;
for (HeaderConstTypes::iterator iter = vec.begin(); iter != vec.end(); iter++)
{
if (std::find(_known_types.begin(), _known_types.end(), *iter) == _known_types.end())
{
(*iter)->accept(this);
}
}
if (vec.size() != _unknown_types.size())
{
printUnknownTypes();
}
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::printDescription(const std::string& description, const std::string& comment, bool indent)
{
if (description.length() == 0 && comment.length() == 0)
{
return ERR_NOERROR;
}
std::string indent_string;
if (indent)
{
indent_string = " ";
}
_header_output.append(indent_string);
_header_output.append("/**\n");
if (description.length() > 0)
{
_header_output.append(a_util::strings::format("%s * %s\n", indent_string.c_str(), description.c_str()));
}
if (comment.length() > 0)
{
_header_output.append(a_util::strings::format("%s * %s\n", indent_string.c_str(), comment.c_str()));
}
_header_output.append(indent_string);
_header_output.append("*/\n");
return ERR_NOERROR;
}
a_util::result::Result HeaderPrinter::printDescription(const HeaderType* type)
{
return printDescription(type->getDescription(), type->getComment());
}
bool invalidHeaderChar(char c)
{
bool is_num = (c >= '0' && c <= '9');
bool is_uppercase_alpha = (c >= 'A' && c <= 'Z');
bool is_lowercase_alpha = (c >= 'a' && c <= 'z');
bool is_allowed_punctuation = (c == '.' || c == '_' || c == '-');
return !(is_num || is_uppercase_alpha || is_lowercase_alpha || is_allowed_punctuation);
}
std::string HeaderPrinter::addHeaderGuards(const a_util::filesystem::Path &filename, const std::string &unguarded_header_content)
{
std::string guard_name = filename.getLastElement().toString();
guard_name.erase(std::remove_if(guard_name.begin(), guard_name.end(), invalidHeaderChar), guard_name.end());
std::replace(guard_name.begin(), guard_name.end(), '.', '_');
std::transform(guard_name.begin(), guard_name.end(), guard_name.begin(), ::toupper);
std::string output;
output.append("#ifndef ");
output.append(guard_name + "\n");
output.append("#define ");
output.append(guard_name + "\n\n");
output.append(unguarded_header_content);
output.append("\n#endif //");
output.append(guard_name + "\n");
return output;
}
void HeaderPrinter::SetNamespace(std::string name_space)
{
_name_space = name_space;
}
} // namespace ddl

144
ddlgenerators/generator_library/headerrepresentation/header_printer.h Normal file
View file

@ -0,0 +1,144 @@
/**
* @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 "header_type.h"
#include "header_visitor_intf.h"
namespace ddl
{
/**
* Vector type for type objects
*/
typedef std::vector<const HeaderType*> HeaderConstTypes;
/**
* This class creates the header file string.
* @remark The class will not take ownership of any pointers passed.
*/
class HeaderPrinter : public IHeaderVisitor
{
public:
/**
* Constructor
*/
HeaderPrinter();
/**
* Destructor
*/
virtual ~HeaderPrinter();
/**
* The method writeToFile writes the header string to the specified file.
* Existing files will be overwritten.
*
* @param [in] filename The path of the file to write to.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_OPEN_FAILED The file could not be opened.
* @retval ERR_PATH_NOT_FOUND The directory containing the file does not exist.
*/
a_util::result::Result writeToFile(const a_util::filesystem::Path &filename);
/**
* The method getHeader returns the textual representation of the header.
* If no header has been parsed yet, the string will be empty.
*
* @returns The header as a string.
*/
const std::string& getHeader();
public: // implements IHeaderVisitor
a_util::result::Result visit(const Header* header);
a_util::result::Result visit(const HeaderBasicType* basic_type);
a_util::result::Result visit(const HeaderTypedef* type_def);
a_util::result::Result visit(const HeaderConstant* constant);
a_util::result::Result visit(const HeaderStruct* header_struct);
a_util::result::Result visit(const HeaderStructElement* struct_element);
a_util::result::Result visit(const HeaderEnum* header_enum);
void SetNamespace(const std::string name_space);
private:
/**
* The method appendType looks for a type identified by its name.
* If the type is found, it is visited for printing.
*
* @param [in] strName The type.
* @returns Standard result code.
* @retval ERR_NOERROR The type was found and appended
* @retval ERR_NOT_FOUND The type could not be found
*/
a_util::result::Result appendType(const HeaderType* type);
/**
* The method CollectType can be used for collecting types that occur during printing.
* This method is used to fill the list of known and unknown types.
* A type is unknown, if its just used, and known, if its defined.
*
* @param [in] type The type to be collected. The class does not take ownership of the type.
* @param [in] is_known Whether this type is known or not.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result CollectType(const HeaderType* type, bool is_known);
/**
* The method printUnknownTypes prints the names of all types that occured during parsing
* and are not defined inside the header.
*
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result printUnknownTypes();
/**
* Helper method to print the description and/or comment of a type to the header.
* Only prints anything if either description or comment are non empty
*/
a_util::result::Result printDescription(const std::string& description, const std::string& comment, bool indent = false);
/**
* Helper method to print the description and/or comment of a type to the header.
* Only prints anything if either description or comment are non empty
*/
a_util::result::Result printDescription(const HeaderType* type);
/// The header to be parsed
const Header* _header;
/// The string containing the output of the printer
std::string _header_output;
/// The vector of known types
HeaderConstTypes _known_types;
/// The vector of unknown types
HeaderConstTypes _unknown_types;
std::string _name_space;
static std::string addHeaderGuards(const a_util::filesystem::Path &filename, const std::string &ungarded_header_content);
};
}

114
ddlgenerators/generator_library/headerrepresentation/header_struct.cpp Normal file
View file

@ -0,0 +1,114 @@
/**
* @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.h>
#include "header_struct.h"
#include "header_visitor_intf.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-20, ERR_NOT_FOUND)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderStruct::HeaderStruct() : HeaderType()
{ }
HeaderStruct::HeaderStruct( std::string name, size_t packing /*= 4*/, HeaderStructElementVec header_elements /*= tHeaderElementVec()*/ )
: HeaderType(name, packing), _header_elements(header_elements)
{ }
HeaderStruct::HeaderStruct( HeaderStruct& other )
: HeaderType(other)
{
for (HeaderStructElementVec::iterator iter = other._header_elements.begin(); iter != other._header_elements.end(); iter++)
{
_header_elements.push_back(new HeaderStructElement(*(*iter)));
}
}
HeaderStruct::~HeaderStruct()
{
for (HeaderStructElementVec::iterator iter = _header_elements.begin(); iter != _header_elements.end(); iter++)
{
delete *iter;
}
_header_elements.clear();
}
const HeaderStructElementVec& HeaderStruct::getElements() const
{
return _header_elements;
}
a_util::result::Result HeaderStruct::addElement( HeaderStructElement* element )
{
_header_elements.push_back(element);
recalculatePacking();
return ERR_NOERROR;
}
a_util::result::Result HeaderStruct::removeElement( const std::string &name )
{
for (HeaderStructElementVec::iterator iter = _header_elements.begin(); iter != _header_elements.end(); iter++)
{
if ((*iter)->getName() == name)
{
delete *iter;
_header_elements.erase(iter);
return ERR_NOERROR;
}
}
return (ERR_NOT_FOUND);
}
a_util::result::Result HeaderStruct::accept(IHeaderVisitor *visitor) const
{
if (!visitor)
{
return ERR_INVALID_ARG;
}
return (visitor->visit(this));
}
a_util::result::Result HeaderStruct::recalculatePacking()
{
size_t packing = 0;
for (HeaderStructElementVec::const_iterator iter = _header_elements.begin(); iter != _header_elements.end(); iter++)
{
if (NULL != (*iter)->getType() && packing < (*iter)->getType()->getPacking())
{
packing = (*iter)->getType()->getPacking();
}
}
setPacking(packing);
return ERR_NOERROR;
}
} // namespace ddl

112
ddlgenerators/generator_library/headerrepresentation/header_struct.h Normal file
View file

@ -0,0 +1,112 @@
/**
* @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
*/
#ifndef HEADER_STRUCT_H_INCLUDED
#define HEADER_STRUCT_H_INCLUDED
#include "header_struct_element.h"
namespace ddl
{
/**
* Container type of HeaderStructElement objects.
*/
typedef std::vector<HeaderStructElement*> HeaderStructElementVec;
/**
* Representation of a struct in a header.
* The class calculates its own packing from its children
* every time one or more children have been added or removed.
* To override the calculated packing, set the packing value AFTER adding
* children.
*/
class HeaderStruct : public HeaderType
{
public:
/**
* Default CTOR
*/
HeaderStruct();
/**
* CTOR
* @param [in] name The name of the struct.
* @param [in] packing The packing of the struct.
* @param [in] header_elements The elements of the struct.
* The struct takes ownership of the passed elements.
*/
HeaderStruct(std::string name,
size_t packing = 4,
HeaderStructElementVec header_elements = HeaderStructElementVec());
/**
* Copy CTOR
* @param [in] other The other type this instance will be a copy of.
*/
HeaderStruct(HeaderStruct& other);
/**
* DTOR
*/
virtual ~HeaderStruct();
/**
* This method gives access to the elements of the struct.
* @return The packing size of the element.
*/
const HeaderStructElementVec& getElements() const;
/**
* This method adds an element to the internal list of elements of the struct.
* @param [in] element The element to be added. The struct takes ownership of the object.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result addElement(HeaderStructElement* element);
/**
* This method removes an element from the internal list of elements of the struct.
* @param [in] name The name of the element to be removed.
* @return Standard result code.
* @retval ERR_NOERROR Everything is ok.
* @retval ERR_NOT_FOUND No element with this name was found.
*/
a_util::result::Result removeElement(const std::string &name);
public: // implements cHeaderBaseType
a_util::result::Result accept(IHeaderVisitor *visitor) const;
private:
/**
* The method recalculatePacking calculates the pack value according to its child element.
* The biggest pack value of any child is the pack value of this struct.
* This represents the mechanism of a C compiler to calculate the packing of a struct.
*
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result recalculatePacking();
/// The elements of the struct.
HeaderStructElementVec _header_elements;
};
} // namespace ddl
#endif // HEADER_STRUCT_H_INCLUDED

172
ddlgenerators/generator_library/headerrepresentation/header_struct_element.cpp Normal file
View file

@ -0,0 +1,172 @@
/**
* @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.h>
#include "header_struct_element.h"
#include "header_visitor_intf.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderStructElement::HeaderStructElement()
{
_type = NULL;
_array_size = 0;
_is_pointer = false;
_is_static = false;
_is_const = false;
}
HeaderStructElement::HeaderStructElement(const std::string &name,
const HeaderType* type,
size_t array_size,
bool is_pointer,
bool is_static,
bool is_const)
{
_name = name;
_type = type;
_array_size = array_size;
_is_pointer = is_pointer;
_is_static = is_static;
_is_const = is_const;
}
HeaderStructElement::HeaderStructElement( HeaderStructElement& other )
{
_type = other._type;
_array_size = other._array_size;
_is_pointer = other._is_pointer;
_is_static = other._is_static;
_is_const = other._is_const;
}
HeaderStructElement::~HeaderStructElement()
{ }
const HeaderType* HeaderStructElement::getType() const
{
return _type;
}
a_util::result::Result HeaderStructElement::setType( const HeaderType* type )
{
_type = type;
return ERR_NOERROR;
}
const std::string& HeaderStructElement::getName() const
{
return _name;
}
a_util::result::Result HeaderStructElement::setName( const std::string& name )
{
_name = name;
return ERR_NOERROR;
}
size_t HeaderStructElement::getArraySize() const
{
return _array_size;
}
a_util::result::Result HeaderStructElement::setArraySize( size_t array_size )
{
_array_size = array_size;
return ERR_NOERROR;
}
bool HeaderStructElement::isPointer() const
{
return _is_pointer;
}
a_util::result::Result HeaderStructElement::setIsPointer( bool is_pointer )
{
_is_pointer = is_pointer;
return ERR_NOERROR;
}
bool HeaderStructElement::isStatic() const
{
return _is_static;
}
a_util::result::Result HeaderStructElement::setIsStatic( bool is_static )
{
_is_static = is_static;
return ERR_NOERROR;
}
bool HeaderStructElement::isConst() const
{
return _is_const;
}
a_util::result::Result HeaderStructElement::setIsConst(bool is_constant)
{
_is_const = is_constant;
return ERR_NOERROR;
}
a_util::result::Result HeaderStructElement::accept(IHeaderVisitor *visitor) const
{
if (!visitor)
{
return ERR_INVALID_ARG;
}
return (visitor->visit(this));
}
const std::string &HeaderStructElement::getDescription() const
{
return _description;
}
a_util::result::Result HeaderStructElement::setDescription(const std::string& description)
{
_description = description;
return ERR_NOERROR;
}
const std::string &HeaderStructElement::getComment() const
{
return _comment;
}
a_util::result::Result HeaderStructElement::setComment(const std::string& comment)
{
_comment = comment;
return ERR_NOERROR;
}
} // namespace ddl

198
ddlgenerators/generator_library/headerrepresentation/header_struct_element.h Normal file
View file

@ -0,0 +1,198 @@
/**
* @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
*/
#ifndef HEADER_STRUCT_ELEMENT_H_INCLUDED
#define HEADER_STRUCT_ELEMENT_H_INCLUDED
#include "header_base_intf.h"
#include "header_type.h"
#include "header_struct_element.h"
namespace ddl
{
/**
* Representation of in a struct element.
*/
class HeaderStructElement : public IHeaderBase
{
public:
/**
* Default CTOR
*/
HeaderStructElement();
/**
* CTOR
*
* @param [in] name The name of the element.
* @param [in] type A pointer to the type this element is of. An instance of this class will not own the type.
* @param [in] array_size The array size of the element
* @param [in] is_pointer Set true, if the element is an pointer, false otherwise.
* @param [in] is_static Set true, if the element is static, false otherwise.
* @param [in] is_const Set true, if the element is constant, false otherwise.
*/
HeaderStructElement(const std::string &name, const HeaderType* type,
size_t array_size,
bool is_pointer,
bool is_static,
bool is_const);
/**
* Copy CTOR
* @param [in] other The other type this instance will be a copy of.
*/
HeaderStructElement(HeaderStructElement& other);
/**
* DTOR
*/
virtual ~HeaderStructElement();
// Setter and getter for member access
/**
* This method gives access to the type of the element.
* @return The type of the element.
*/
const HeaderType* getType() const;
/**
* This method sets the type of the element.
* @param [in] type The type of the element.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setType(const HeaderType* type);
/**
* This method gives access to the name of the element.
* @return The name of the element.
*/
const std::string& getName() const;
/**
* This method gives access to the name of the element.
* @param [in] name The name of the element.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setName(const std::string& name);
/**
* This method gives access to the array size of the element.
* @return The array size of the element.
*/
size_t getArraySize() const;
/**
* This method sets the array size of the element.
* @param [in] array_size The array size of the element.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setArraySize(size_t array_size);
/**
* This method returns whether the element is a pointer or not.
* @return True if the element is a pointer, false otherwise.
*/
bool isPointer() const;
/**
* This method sets whether the element is a pointer or not.
* @param [in] is_pointer Set true if the element is a pointer, false otherwise.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setIsPointer(bool is_pointer);
/**
* This method returns whether the element is static or not.
* @return True if the element is static, false otherwise.
*/
bool isStatic() const;
/**
* This method sets whether the element is static or not.
* @param [in] is_static Set true if the element is static, false otherwise.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setIsStatic(bool is_static);
/**
* This method returns whether the element is a const.
* @return True if the element is a const, false otherwise.
*/
bool isConst() const;
/**
* This method sets whether the element is a const or not.
* @param [in] is_constant Set true if the element is a const, false otherwise.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setIsConst(bool is_constant);
/**
* This method gives access to the description of the type.
* @return The description of the element.
*/
const std::string& getDescription() const;
/**
* This method gives access to the description of the type.
* @param [in] description The description of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setDescription(const std::string& description);
/**
* This method gives access to the comment of the type.
* @return The comment of the element.
*/
const std::string& getComment() const;
/**
* This method gives access to the comment of the type.
* @param [in] comment The comment of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setComment(const std::string& comment);
public: //implements IHeaderBase
virtual a_util::result::Result accept(IHeaderVisitor *visitor) const;
private:
/// The type of the element.
const HeaderType* _type;
/// The name of the element.
std::string _name;
/// The array size of the element.
size_t _array_size;
// Flags for the element
/// The element is a pointer.
bool _is_pointer;
/// The element is static.
bool _is_static;
/// The element is const.
bool _is_const;
/// The description of the type.
std::string _description;
/// The comment of the type.
std::string _comment;
};
} // namespace ddl
#endif // HEADER_STRUCT_ELEMENT_H_INCLUDED

441
ddlgenerators/generator_library/headerrepresentation/header_to_ddl_converter.cpp Normal file
View file

@ -0,0 +1,441 @@
/**
* @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.h>
#include "header_to_ddl_converter.h"
#include "header_header.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-19, ERR_NOT_SUPPORTED)
_MAKE_RESULT(-16, ERR_NOT_IMPL)
_MAKE_RESULT(-38, ERR_FAILED)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
/**
* This class tries to resolve a typedef down to its original type, following all consecutive typedefs.
* start the process by visiting a typedef and if successfull, either the getStruct() or the getBasicType()
* method will not return a NULL pointer, meaning that this is the found type the typedef is pointing to
* in the end.
* The class will not take ownership of anything. Well thats kinda obvious since it only accepts pointers
* to const types.
*/
class TypeResolver : public IHeaderVisitor {
public:
/**
* CTOR
*/
TypeResolver()
{
reset();
}
/**
* The method Reset resets all internal states so that the class is fresh and shiny as new.
*
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine
*/
a_util::result::Result reset()
{
_basic_type = NULL;
_struct = NULL;
_enum = NULL;
_visited_typedefs.clear();
return ERR_NOERROR;
}
/**
* The method getStruct returns the found struct.
*
* @returns A pointer to the found struct if found, NULL otherwise.
*/
const HeaderStruct* getStruct()
{
return _struct;
}
/**
* The method getBasicType returns the found basic type.
*
* @returns A pointer to the found basic tyoe if found, NULL otherwise.
*/
const HeaderBasicType* getBasicType()
{
return _basic_type;
}
/**
* The method getEnum returns the found enum.
*
* @returns A pointer to the found Enum if found, NULL otherwise.
*/
const HeaderEnum* getEnum()
{
return _enum;
}
public: // Implements IHeaderVisitor
virtual a_util::result::Result visit(const Header* header)
{
return ERR_NOT_IMPL;
}
virtual a_util::result::Result visit(const HeaderBasicType* basic_type)
{
_basic_type = basic_type;
return ERR_NOERROR;
}
virtual a_util::result::Result visit(const HeaderTypedef* type_def)
{
// Check if we have visited that typedef before
if (std::find(_visited_typedefs.begin(), _visited_typedefs.end(), type_def) == _visited_typedefs.end())
{
// Store typedef, so we wont visit it again, in case of a circular connection
_visited_typedefs.push_back(type_def);
return type_def->getOriginalType()->accept(this);
}
return ERR_NOT_SUPPORTED;
}
virtual a_util::result::Result visit(const HeaderConstant* constant)
{
return ERR_NOT_IMPL;
}
virtual a_util::result::Result visit(const HeaderStruct* header_struct)
{
_struct = header_struct;
return ERR_NOERROR;
}
virtual a_util::result::Result visit(const HeaderStructElement* struct_element)
{
return ERR_NOT_IMPL;
}
virtual a_util::result::Result visit(const HeaderEnum* header_enum)
{
_enum = header_enum;
return ERR_NOERROR;
}
private:
const HeaderBasicType *_basic_type;
const HeaderStruct *_struct;
const HeaderEnum *_enum;
HeaderConstTypedefs _visited_typedefs;
};
HeaderToDDLConverter::HeaderToDDLConverter() : _description(NULL), _header(NULL)
{ }
HeaderToDDLConverter::~HeaderToDDLConverter()
{ }
a_util::result::Result HeaderToDDLConverter::visit(const Header* header)
{
_header = header;
for (HeaderTypedefs::const_iterator iter = header->getTypedefs().begin(); iter != header->getTypedefs().end(); iter++)
{
(*iter)->accept(this);
}
for (HeaderStructs::const_iterator iter = header->getStructs().begin(); iter != header->getStructs().end(); iter++)
{
(*iter)->accept(this);
}
for (HeaderConstants::const_iterator iter = header->getConstants().begin(); iter != header->getConstants().end(); iter++)
{
(*iter)->accept(this);
}
for (auto iter = header->getEnums().begin(); iter != header->getEnums().end(); iter++)
{
(*iter)->accept(this);
}
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::visit(const HeaderBasicType* basic_type)
{
_basic_types.insert(basic_type);
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::visit(const HeaderTypedef* type_def)
{
if (std::find(_typedefs.begin(), _typedefs.end(), type_def) == _typedefs.end())
{
_typedefs.push_back(type_def);
type_def->getOriginalType()->accept(this);
}
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::visit(const HeaderConstant* constant)
{
if (std::find(_constants.begin(), _constants.end(), constant) == _constants.end())
{
_constants.push_back(constant);
// Also add the type of the constant
constant->getType()->accept(this);
}
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::visit(const HeaderStruct* header_struct)
{
if (std::find(_structs.begin(), _structs.end(), header_struct) == _structs.end())
{
// Add struct to vector, so if its referenced within other types used in the struct, there wont be an infinite loop.
_structs.push_back(header_struct);
// Take care of the struct elements
for (HeaderStructElementVec::const_iterator iter = header_struct->getElements().begin(); iter != header_struct->getElements().end(); iter++)
{
(*iter)->accept(this);
}
// Now move the struct to the end, so all needed types will be defined before the struct
_structs.erase(std::find(_structs.begin(), _structs.end(), header_struct));
_structs.push_back(header_struct);
}
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::visit(const HeaderStructElement* struct_element)
{
struct_element->getType()->accept(this);
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::visit(const HeaderEnum* header_enum)
{
if (std::find(_enums.begin(), _enums.end(), header_enum) == _enums.end())
{
_enums.push_back(header_enum);
}
return ERR_NOERROR;
}
DDLDescription * HeaderToDDLConverter::getDDL() const
{
return _description;
}
a_util::result::Result HeaderToDDLConverter::createNew(const ddl::DDLVersion& version /*= 0*/)
{
_description = DDLDescription::createDefault(version, 4, false);
buildHeader();
buildUnits();
buildDatatypes();
buildEnums();
buildStructs();
buildStreams();
ddl::DDLInspector inspector(true);
if (isFailed((inspector.visitDDL(_description))))
{
LOG_ERROR(inspector.getLastErrorDesc().c_str());
return ERR_FAILED;
}
return ERR_NOERROR;
}
void HeaderToDDLConverter::destroyDDL()
{
if (_description != NULL)
{
delete _description;
_description = NULL;
}
}
a_util::result::Result HeaderToDDLConverter::buildHeader()
{
DDLHeader* header = _description->getHeader();
a_util::datetime::Date now = a_util::datetime::getCurrentLocalDate();
header->setAuthor(a_util::system::getCurrentUserName());
header->setDateCreation(now);
header->setDateChange(now);
header->setDescription(std::string("Generated by DDL_Editor "));
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::buildUnits()
{
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::buildDatatypes()
{
for (HeaderConstBasicTypes::iterator iter = _basic_types.begin(); iter != _basic_types.end(); iter++)
{
if (_description->getDataTypeByName((*iter)->getName()) == NULL)
{
_description->addDatatype(new DDLDataType((*iter)->getName(), static_cast<unsigned int>((*iter)->getBitsize_t())));
}
}
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::buildStructs()
{
// First all structs will be created but without any members.
// This way, all types are already defined.
// This approach is comparable to a forward declaration known from C++
for (HeaderConstStructs::iterator struct_iter = _structs.begin(); struct_iter != _structs.end(); struct_iter++)
{
DDLComplex* complex = new DDLComplex((*struct_iter)->getName(), 0, "", toAlignment((*struct_iter)->getPacking()));
_description->addStruct(complex);
}
// Second all structs will be filled with elements.
for (HeaderConstStructs::iterator struct_iter = _structs.begin(); struct_iter != _structs.end(); struct_iter++)
{
DDLComplex* complex = _description->getStructByName((*struct_iter)->getName());
for (HeaderStructElementVec::const_iterator element_iter = (*struct_iter)->getElements().begin();
element_iter != (*struct_iter)->getElements().end(); element_iter++)
{
// Resolve the type of the element. Please refer to ticket #19830, comment 48 if you want to know why this is done.
TypeResolver resolver;
if (isFailed(((*element_iter)->getType()->accept(&resolver))))
{
return ERR_FAILED;
}
IDDLDataType* ddl_data_type = NULL;
if (resolver.getBasicType() != NULL)
{
ddl_data_type = _description->getDataTypeByName(resolver.getBasicType()->getName());
}
else if (resolver.getStruct() != NULL)
{
ddl_data_type = _description->getStructByName(resolver.getStruct()->getName());
}
else if (resolver.getEnum() != NULL)
{
ddl_data_type = _description->getEnumByName(resolver.getEnum()->getName());
}
else
{
// Something really went wrong here
return (ERR_FAILED);
}
DDLElement* element = new DDLElement(ddl_data_type,
(*element_iter)->getName(),
0, // See bytepos related comment below
static_cast<unsigned int>((*element_iter)->getArraySize()),
DDLByteorder::e_le,
DDLAlignment::e0); // Alignment will be determined later
// Take the alignment of the whole struct into account.
if ((*element_iter)->getType()->getPacking() > (*struct_iter)->getPacking())
{
element->setAlignment(toAlignment((*struct_iter)->getPacking()));
}
else
{
element->setAlignment(toAlignment((*element_iter)->getType()->getPacking()));
}
// Bytepos will not be set here (to anything but zero), the byte position calculation
// method of the DDL Inspector will be used later.
complex->addElement(element);
}
}
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::buildStreams()
{
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::buildEnums()
{
for (auto iter = _enums.begin(); iter != _enums.end(); iter++)
{
const HeaderEnum* current_enum = *iter;
if (NULL != _description->getEnumByName(current_enum->getName()))
{
continue;
}
EnumNameValueVec enum_values;
for (auto value_iter = current_enum->getValues().begin(); value_iter != current_enum->getValues().end(); value_iter++)
{
std::pair<std::string, std::string> pair(value_iter->second, a_util::strings::format("%d", value_iter->first));
enum_values.push_back(pair);
}
DDLDataType* data_type = _description->getDataTypeByName("tInt32");
DDLEnum* ddl_enum = new DDLEnum(data_type, current_enum->getName(), enum_values);
_description->addEnum(ddl_enum);
}
return ERR_NOERROR;
}
a_util::result::Result HeaderToDDLConverter::buildStreamMetaTypes()
{
return ERR_NOERROR;
}
ddl::DDLAlignment::AlignmentType HeaderToDDLConverter::toAlignment(size_t packing)
{
DDLAlignment::AlignmentType result = DDLAlignment::e1;
switch (packing)
{
case 0:
case 1:
result = DDLAlignment::e1;
break;
case 2:
result = DDLAlignment::e2;
break;
case 4:
result = DDLAlignment::e4;
break;
case 8:
result = DDLAlignment::e8;
break;
case 16:
result = DDLAlignment::e16;
break;
case 32:
result = DDLAlignment::e32;
break;
case 64:
result = DDLAlignment::e64;
break;
}
return result;
}
}

144
ddlgenerators/generator_library/headerrepresentation/header_to_ddl_converter.h Normal file
View file

@ -0,0 +1,144 @@
/**
* @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
*/
#ifndef HEADER_TO_DDL_CONVERTER_H_INCLUDED
#define HEADER_TO_DDL_CONVERTER_H_INCLUDED
#include "header_basic_type.h"
#include "header_typedef.h"
#include "header_constant.h"
#include "header_struct.h"
#include "header_enum.h"
#include "header_visitor_intf.h"
namespace ddl
{
/**
* A Set of basic types
*/
typedef std::set<const HeaderBasicType*> HeaderConstBasicTypes;
/**
* Container type of basic type objects
*/
typedef std::vector<const HeaderTypedef*> HeaderConstTypedefs;
/**
* Container type of constants objects
*/
typedef std::vector<const HeaderConstant*> HeaderConstConstants;
/**
* Container type of struct objects
*/
typedef std::vector<const HeaderStruct*> HeaderConstStructs;
/**
* Container type of enum objects
*/
typedef std::vector<const HeaderEnum*> HeaderConstEnums;
/**
* This class generates a DDL from a header.
* Use this class by first visiting the element(s) of the header you want to be part of your DDL,
* then call createNew() to create the DDL from the previously parsed header elements.
* The generator tries to extract all needed datatypes from the header and stores them in a local
* header as a copy (not the basic types). This copy then will then be converted to DDL.
*/
class HeaderToDDLConverter : public IHeaderVisitor, public IDDLFactoryMethod
{
public:
/**
* CTOR
*/
HeaderToDDLConverter();
/**
* DTOR
*/
virtual ~HeaderToDDLConverter();
public: // implements IHeaderVisitor
virtual a_util::result::Result visit(const Header* header);
virtual a_util::result::Result visit(const HeaderBasicType* basic_type);
virtual a_util::result::Result visit(const HeaderTypedef* type_def);
virtual a_util::result::Result visit(const HeaderConstant* constant);
virtual a_util::result::Result visit(const HeaderStruct* header_struct);
virtual a_util::result::Result visit(const HeaderStructElement* struct_element);
virtual a_util::result::Result visit(const HeaderEnum* header_enum);
public: // implements IDDLFactoryMethod
virtual DDLDescription * getDDL() const;
virtual a_util::result::Result createNew(const DDLVersion& version = DDLVersion::ddl_version_invalid);
virtual void destroyDDL();
virtual a_util::result::Result buildHeader();
virtual a_util::result::Result buildUnits();
virtual a_util::result::Result buildDatatypes();
virtual a_util::result::Result buildStructs();
virtual a_util::result::Result buildStreams();
virtual a_util::result::Result buildEnums();
virtual a_util::result::Result buildStreamMetaTypes();
private:
/**
* The method toAlignment calculates the alignment from an packing value.
*
* @param [in] packing The packing value
* @returns The alignment value, e0 if no matching packing or 0 was found.
*/
ddl::DDLAlignment::AlignmentType toAlignment(size_t packing);
/// The header that was passed.
DDLDescription* _description;
/// The header to be converted
const Header* _header;
/// The basic types found during parsing
HeaderConstBasicTypes _basic_types;
/// The constants found during parsing
HeaderConstConstants _constants;
/// The structs found during parsing
HeaderConstStructs _structs;
/// The typedefs found during parsing
HeaderConstTypedefs _typedefs;
/// The enums found during parsing
HeaderConstEnums _enums;
};
}
#endif // HEADER_TO_DDL_CONVERTER_H_INCLUDED

100
ddlgenerators/generator_library/headerrepresentation/header_type.cpp Normal file
View file

@ -0,0 +1,100 @@
/**
* @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.h>
#include "header_type.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderType::HeaderType() : _packing(0)
{ }
HeaderType::HeaderType(const std::string &name, size_t packing) :
_packing(packing),
_name(name)
{ }
HeaderType::HeaderType(const HeaderType& other) :
_packing(other._packing),
_name(other._name)
{ }
HeaderType::~HeaderType()
{ }
const std::string &HeaderType::getName() const
{
return _name;
}
a_util::result::Result HeaderType::setName(const std::string& name)
{
_name = name;
return ERR_NOERROR;
}
const std::string &HeaderType::getDescription() const
{
return _description;
}
a_util::result::Result HeaderType::setDescription(const std::string& description)
{
_description = description;
return ERR_NOERROR;
}
const std::string &HeaderType::getComment() const
{
return _comment;
}
a_util::result::Result HeaderType::setComment(const std::string& comment)
{
_comment = comment;
return ERR_NOERROR;
}
size_t HeaderType::getPacking() const
{
return _packing;
}
a_util::result::Result HeaderType::setPacking( size_t packing )
{
_packing = packing;
return ERR_NOERROR;
}
} // namespace ddl

127
ddlgenerators/generator_library/headerrepresentation/header_type.h Normal file
View file

@ -0,0 +1,127 @@
/**
* @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
*/
#ifndef HEADER_TYPE_H_INCLUDED
#define HEADER_TYPE_H_INCLUDED
#include "header_base_intf.h"
namespace ddl
{
/**
* Representation of a type in a header.
*/
class HeaderType : public IHeaderBase
{
public:
/**
* Default CTOR
*/
HeaderType();
/**
* CTOR
*
* @param [in] name The name of the type.
* @param [in] packing he packing of the type
*/
HeaderType(const std::string &name, size_t packing);
/**
* Copy CTOR
* @param [in] other The other type this instance will be a copy of.
*/
HeaderType(const HeaderType& other);
/**
* DTOR
*/
virtual ~HeaderType();
/**
* This method gives access to the name of the type.
* @return The name of the element.
*/
const std::string& getName() const;
/**
* This method gives access to the name of the type.
* @param [in] name The name of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setName(const std::string& name);
/**
* This method gives access to the packing size of the type.
* @return The packing size of the struct.
*/
virtual size_t getPacking() const;
/**
* This method sets the packing size of the type.
* @param [in] packing The packing size of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setPacking(size_t packing);
/**
* This method gives access to the description of the type.
* @return The description of the element.
*/
const std::string& getDescription() const;
/**
* This method gives access to the description of the type.
* @param [in] description The description of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setDescription(const std::string& description);
/**
* This method gives access to the comment of the type.
* @return The comment of the element.
*/
const std::string& getComment() const;
/**
* This method gives access to the comment of the type.
* @param [in] comment The comment of the type.
* @return Standard result code. Will always return ERR_NOERROR.
*/
a_util::result::Result setComment(const std::string& comment);
public: //implements IHeaderBase
virtual a_util::result::Result accept(IHeaderVisitor *visitor) const = 0;
protected:
/// The packing of the type.
size_t _packing;
/// The name of the type.
std::string _name;
/// The description of the type.
std::string _description;
/// The comment of the type.
std::string _comment;
};
} // namespace ddl
#endif // HEADER_TYPE_H_INCLUDED

85
ddlgenerators/generator_library/headerrepresentation/header_typedef.cpp Normal file
View file

@ -0,0 +1,85 @@
/**
* @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.h>
#include "header_typedef.h"
#include "header_visitor_intf.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
using namespace ddl;
namespace ddl
{
HeaderTypedef::HeaderTypedef() : HeaderType()
{
_type = NULL;
}
HeaderTypedef::HeaderTypedef(const std::string &name, const HeaderType* type)
: HeaderType(name, 0), _type(type)
{ }
HeaderTypedef::HeaderTypedef(const HeaderTypedef& other)
: HeaderType(other), _type(other._type)
{ }
HeaderTypedef::~HeaderTypedef()
{
_type = NULL;
}
a_util::result::Result HeaderTypedef::accept(IHeaderVisitor *visitor) const
{
if (!visitor)
{
return ERR_INVALID_ARG;
}
return (visitor->visit(this));
}
const HeaderType* HeaderTypedef::getOriginalType() const
{
return _type;
}
a_util::result::Result HeaderTypedef::setOriginalType(const HeaderType *type)
{
_type = type;
return ERR_NOERROR;
}
size_t HeaderTypedef::getPacking() const
{
return _type != NULL ? _type->getPacking() : 0;
}
} // namespace ddl

93
ddlgenerators/generator_library/headerrepresentation/header_typedef.h Normal file
View file

@ -0,0 +1,93 @@
/**
* @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
*/
#ifndef HEADER_TYPEDEF_H_INCLUDED
#define HEADER_TYPEDEF_H_INCLUDED
#include "header_type.h"
namespace ddl
{
/**
* Representation of a typedef in a header.
*
* @remark This class does not support unnamed structs/unions or anonymous unions.
*/
class HeaderTypedef : public HeaderType
{
public:
/**
* Default CTOR
*/
HeaderTypedef();
/**
* CTOR
* @param[in] name The name of the type.
* @param[in] type The original type this type represents. This class is not taking ownership of the type.
*/
HeaderTypedef(const std::string &name, const HeaderType* type);
/**
* Copy CTOR
* @param [in] other The other type this instance will be a copy of.
*/
HeaderTypedef(const HeaderTypedef& other);
/**
* DTOR
*/
virtual ~HeaderTypedef();
/**
* The method getOriginalType gives access to the original type this type is representing.
*
* @returns The original type.
*/
const HeaderType* getOriginalType() const;
/**
* The method setOriginalType sets the original type this type represents.
*
* @param [in] type The original type. This class is not taking ownership of the type.
* @returns Standard result code.
* @retval ERR_NOERROR Everything went fine.
*/
a_util::result::Result setOriginalType(const HeaderType *type);
public: //implements HeaderType
virtual a_util::result::Result accept(IHeaderVisitor *visitor) const;
public: //overrides HeaderType
/**
* @copydoc HeaderType::getPacking()
* @remark The packing information of the mapped type will be inherited.
* If no mapped type is defined, 0 will be returned.
*/
size_t getPacking() const;
private:
/// The original type of this typedef
const HeaderType* _type;
};
} // namespace ddl
#endif // HEADER_TYPEDEF_H_INCLUDED

105
ddlgenerators/generator_library/headerrepresentation/header_visitor_intf.h Normal file
View file

@ -0,0 +1,105 @@
/**
* @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
*/
#ifndef HEADER_VISITOR_H_INCLUDED
#define HEADER_VISITOR_H_INCLUDED
namespace ddl
{
class Header;
class HeaderBasicType;
class HeaderTypedef;
class HeaderConstant;
class HeaderStruct;
class HeaderStructElement;
class HeaderEnum;
/**
* Abstract base class/interface for Visitor design-pattern.
*/
class IHeaderVisitor
{
public:
/**
* Visitor for a whole header.
* @param [in] header pointer to the header object.
* @return Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_POINTER Null-pointer passed.
*/
virtual a_util::result::Result visit(const Header* header) = 0;
/**
* Visitor for a basic type.
* @param [in] basic_type pointer to the basic type object.
* @return Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_POINTER Null-pointer passed.
*/
virtual a_util::result::Result visit(const HeaderBasicType* basic_type) = 0;
/**
* Visitor for a typedef.
* @param [in] type_def pointer to the basic type object.
* @return Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_POINTER Null-pointer passed.
*/
virtual a_util::result::Result visit(const HeaderTypedef* type_def) = 0;
/**
* Visitor for a constant.
* @param [in] constant pointer to the constant object.
* @return Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_POINTER Null-pointer passed.
*/
virtual a_util::result::Result visit(const HeaderConstant* constant) = 0;
/**
* Visitor for a struct.
* @param [in] header_struct pointer to the struct object.
* @return Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_POINTER Null-pointer passed.
*/
virtual a_util::result::Result visit(const HeaderStruct* header_struct) = 0;
/**
* Visitor for a struct element.
* @param [in] struct_element pointer to the struct element object.
* @return Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_POINTER Null-pointer passed.
*/
virtual a_util::result::Result visit(const HeaderStructElement* struct_element) = 0;
/**
* Visitor for a enum element.
* @param [in] header_enum pointer to the enum object.
* @return Standard result code.
* @retval ERR_NOERROR Everything went fine.
* @retval ERR_POINTER Null-pointer passed.
*/
virtual a_util::result::Result visit(const HeaderEnum* header_enum) = 0;
};
} // namespace ddl
#endif // HEADER_VISITOR_H_INCLUDED

253
ddlgenerators/generator_library/headerrepresentation/parserhelper.cpp Normal file
View file

@ -0,0 +1,253 @@
/**
* @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 <cstring>
#include "parserhelper.h"
namespace ddl_generator
{
void skipWhitespace(const char*& p, const char* additional_whitechars)
{
if (nullptr == p)
{
return;
}
if (additional_whitechars != nullptr)
{
while (a_util::strings::white_space.find(*p) != std::string::npos || (*p != '\0' && strchr(additional_whitechars, *p) != nullptr))
{
p++;
}
}
else
{
while (a_util::strings::white_space.find(*p) != std::string::npos)
{
p++;
}
}
}
bool getNextWord(const char*& src, std::string& dest, const char* additional_separator, bool use_escape)
{
if (nullptr == src)
{
return false;
}
dest.clear();
skipWhitespace(src);
if (*src == '\0')
{
return false;
}
char escape_active = false;
char last_char = '\0';
char quote = '\0';
if (*src == '\"' || *src == '\'')
{
quote = *(src++);
const char* strc_start = src;
while (*src != '\0' && (escape_active || *src != quote))
{
escape_active = use_escape && (*src == '\\' && last_char != '\\'); // escape next char?
last_char = *src;
src++;
}
dest.assign(strc_start, src - strc_start);
//dest.set(strc_start, src-strc_start);
if (*src == quote)
{
src++;
}
}
else
{
const char* src_start = src;
if (additional_separator == nullptr)
{
while (*src != '\0' && a_util::strings::white_space.find(*src) == std::string::npos)
{
src++;
size_t n = a_util::strings::white_space.find(*src);
size_t n_m = std::string::npos;
if (*src == '\"' || *src == '\'')
{
quote = *(src);
do
{
escape_active = use_escape && (*src == '\\' && last_char != '\\');
last_char = *src;
src++;
} while (*src != '\0' && (escape_active || *src != quote));
}
}
dest.assign(src_start, src-src_start);
}
else
{
while (*src != '\0' && (a_util::strings::white_space.find(*src) == std::string::npos
&& strchr(additional_separator, *src) == nullptr))
{
src++;
}
dest.assign(src_start, src-src_start);
}
}
return true;
}
void seekChars(const char*& p, const char* chars, bool ignore_quotes)
{
if ((nullptr == p) ||
(nullptr == chars))
{
return;
}
char escape_active = false;
char last_char = '\0';
bool inside_quotes = false;
char quote = '\0';
while (*p != '\0' && (escape_active || inside_quotes || (strchr(chars, *p) == nullptr)))
{
if (!ignore_quotes)
{
if (!escape_active && (*p == '\"' || *p == '\''))
{
if (inside_quotes && quote == *p)
{
quote = '\0';
inside_quotes = false;
}
else
{
quote = *p;
inside_quotes = true;
}
}
}
else
{
if (!escape_active && (*p == '\"' || *p == '\''))
{
quote = '\0';
}
}
escape_active = (*p == '\\' && last_char != '\\'); // escape next char?
last_char = *p;
p++;
}
}
void seekString(const char*& p, const char* seek_string, char* comment, bool ignore_quotes)
{
if ((nullptr == p) ||
(nullptr == seek_string))
{
return;
}
bool escape_active = false;
char last_char = '\0';
bool inside_quotes = false;
char quote = '\0';
size_t str_len = a_util::strings::getLength(seek_string);
int n_char = 0;
if (comment)
{
comment[n_char] = '\0';
}
while (*p != '\0')
{
if (!ignore_quotes)
{
if (!escape_active && !inside_quotes && *p == *seek_string)
{
if (a_util::strings::compare(p, seek_string, str_len) == 0)
{
if (comment)
{
comment[n_char] = '\0';
}
return;
}
}
if (!escape_active && (*p == '\"' || *p == '\''))
{
if (inside_quotes && quote == *p)
{
quote = '\0';
inside_quotes = false;
}
else
{
quote = *p;
inside_quotes = true;
}
}
}
else
{
if (!escape_active && *p == *seek_string)
{
if (a_util::strings::compare(p, seek_string, str_len) == 0)
{
if (comment)
{
comment[n_char] = '\0';
}
return;
}
}
}
escape_active = (*p == '\\' && last_char != '\\'); // escape next char?
last_char = *p;
if (comment)
{
comment[n_char] = *p;
}
++p;
n_char++;
}
if (comment)
{
comment[n_char] = '\0';
}
}
} // namespace A_UTILS_NS

79
ddlgenerators/generator_library/headerrepresentation/parserhelper.h Normal file
View file

@ -0,0 +1,79 @@
/**
* @file
*
* Parser helper functions.
*
* @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 <a_util/strings.h>
#ifndef DDL_GEN_PARSER_HELPER_CLASS_HEADER
#define DDL_GEN_PARSER_HELPER_CLASS_HEADER
namespace ddl_generator
{
/**
* Advances the pointer to point at a position after the next whitespace sequence.
*
* @param p [inout] The current position.
* @param additional_whitechars [in] Additional characters which are to be skipped.
* @return void
* @rtsafe
*/
void skipWhitespace(const char*& p, const char* additional_whitechars=nullptr);
/**
* Copies the next word in a string into a string object.
*
* @param src [in] The source string.
* @param dest [out] The destination string.
* @param additional_separator [in] Additional separator characters.
* @param use_escape [in] Uses the \\ character to detect a word too
*
* @return tTrue if successful, otherwise tFalse.
*/
bool getNextWord(const char*& src,
std::string &dest,
const char* additional_separator=nullptr,
bool use_escape = true);
/**
* Advances a pointer in a string to the next occurance of specified characters.
* @param p [inout] The current position.
* @param chars [in] The characters to look for.
* @param ignore_quotes [in] Whether or not to ignore occurences which occur between quotes.
* @return void
* @rtsafe
*/
void seekChars(const char*& p, const char* chars, bool ignore_quotes=false);
/**
* Advances a pointer in a string to the next occurcance of a string.
* @param p [inout] The current position.
* @param seek_string [in] The string to look for.
* @param comment [out] Optional buffer that will be filled with the skipped characters.
* @param ignore_quotes [in] Whether or not to ignore occurences which occur between quotes.
* @return void
* @rtsafe
*/
void seekString(const char*& p, const char* seek_string, char* comment = nullptr, bool ignore_quotes=false);
} // namespace A_UTILS_NS
#endif // DDL_GEN_PARSER_HELPER_CLASS_HEADER

30
ddlgenerators/header2ddl/CMakeLists.txt Normal file
View file

@ -0,0 +1,30 @@
set(PROJECT_NAME header2ddl)
set(SOURCES
main.cpp
header2ddl_commandline.h
header2ddl_commandline.cpp
${DDL_GENERATOR_COMMON}
${HEADER_PRESENTATION_H}
${HEADER_PRESENTATION_CPP}
)
if (WIN32)
#list(APPEND SOURCES native_resource.rc)
endif (WIN32)
add_executable(${PROJECT_NAME} WIN32 ${SOURCES})
target_link_libraries(${PROJECT_NAME}
ddl
ddl_generator
)
if(MSVC)
set_target_properties(${PROJECT_NAME} PROPERTIES LINK_FLAGS "/SUBSYSTEM:console")
endif(MSVC)
install(TARGETS ${PROJECT_NAME} DESTINATION ./bin/debug CONFIGURATIONS Debug)
install(TARGETS ${PROJECT_NAME} DESTINATION ./bin CONFIGURATIONS Release RelWithDebInfo)
set_target_properties(${PROJECT_NAME} PROPERTIES FOLDER ddl/utils)

82
ddlgenerators/header2ddl/header2ddl_commandline.cpp Normal file
View file

@ -0,0 +1,82 @@
/**
* @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 <iostream>
#include "header2ddl_commandline.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
namespace ddl
{
Header2DDLCommandLine::Header2DDLCommandLine() : CommandLine()
{
_cli |= getDDLVersionOpt();
_cli |= getHeaderFileSetOpt();
}
ddl::DDLVersion Header2DDLCommandLine::getDDLVersion()
{
return DDLVersion::fromString(_opt_DDL_version);
}
std::string Header2DDLCommandLine::getHeaderFileSet()
{
return _opt_header_file_set;
}
void Header2DDLCommandLine::setHeaderFile(std::string header_file)
{
_opt_header_file = header_file;
}
void Header2DDLCommandLine::printExamples()
{
std::cout << "examples: " << std::endl;
std::cout << " --headerfile=c:/myHeaderFile.h " <<
"--descriptionfile=c:/myDescriptionFile.description";
std::cout << std::endl << " or" << std::endl;
std::cout << " --headerfile=c:/myHeaderFile.h " <<
"--descriptionfile=c:/myDescriptionFile.description ";
std::cout << "-struct=tMyStruct" << std::endl;
}
clara::Opt Header2DDLCommandLine::getDDLVersionOpt()
{
return clara::Opt(_opt_DDL_version, "version")
["-v"]["--ddlversion"]
("[Optional] Default value is 4.0. Supported formats are 3.0 and 4.0");
}
clara::Opt Header2DDLCommandLine::getHeaderFileSetOpt()
{
return clara::Opt(_opt_header_file_set, "list,of,files")
["--headerfileset"]
("Can be used instead of the headerfile option. List of comma separated "
"headerfiles (no spaces!) to be merged into a single descriptionfile.");
}
}

49
ddlgenerators/header2ddl/header2ddl_commandline.h Normal file
View file

@ -0,0 +1,49 @@
/**
* @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
*/
#ifndef _HEADER2DDL_COMMAND_LINE_H_
#define _HEADER2DDL_COMMAND_LINE_H_
#include <ddl.h>
#include "commandline.h"
namespace ddl
{
class Header2DDLCommandLine : public ddl::CommandLine
{
public:
Header2DDLCommandLine();
DDLVersion getDDLVersion();
std::string getHeaderFileSet();
void setHeaderFile(std::string headerFile);
protected:
void printExamples() override;
clara::Opt getDDLVersionOpt();
clara::Opt getHeaderFileSetOpt();
std::string _opt_DDL_version = "4.0";
std::string _opt_header_file_set;
};
}
#endif

110
ddlgenerators/header2ddl/main.cpp Normal file
View file

@ -0,0 +1,110 @@
/**
* @file
* Launcher
*
* @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 <iostream>
#include <ddl_generator_core.h>
#include "header2ddl_commandline.h"
namespace ddl_generator
{
namespace oo
{
//define all needed error types and values locally
_MAKE_RESULT(0, ERR_NOERROR)
_MAKE_RESULT(-5, ERR_INVALID_ARG)
}
}
using namespace ddl_generator::oo;
a_util::result::Result HandleInputFileset(std::string strHeaderFileSet, std::string& strMergedHeaderFile)
{
std::vector<std::string> vecHeaderFiles = a_util::strings::split(strHeaderFileSet, ",");
if (vecHeaderFiles.size() == 0)
{
LOG_ERROR("ERROR: Empty header file list");
return ERR_INVALID_ARG.getCode();
}
std::string strMergedHeaderContent;
for (std::string strHeaderpath : vecHeaderFiles)
{
std::string strHeaderContent;
if (!a_util::filesystem::exists(strHeaderpath) || a_util::result::isFailed(a_util::filesystem::readTextFile(strHeaderpath, strHeaderContent)))
{
LOG_ERROR(a_util::strings::format("ERROR: Could not read header file '%s'", strHeaderpath.c_str()).c_str());
return ERR_INVALID_ARG.getCode();
}
strMergedHeaderContent.append(strHeaderContent);
}
a_util::filesystem::Path mergedHeader = a_util::filesystem::getTempDirectory().append("MergedHeader.h");
a_util::filesystem::writeTextFile(mergedHeader, strMergedHeaderContent);
strMergedHeaderFile = mergedHeader.toString();
return ERR_NOERROR.getCode();
}
int main(int argc, char* argv[])
{
ddl::Header2DDLCommandLine cmd_line;
if (a_util::result::isFailed(cmd_line.parseArgs(argc, argv)))
{
return ERR_INVALID_ARG.getCode();
}
if (cmd_line.isHelpRequested())
{
cmd_line.printHelp();
return ERR_NOERROR.getCode();
}
std::string strMergedHeader;
if (!cmd_line.getHeaderFileSet().empty())
{
a_util::result::Result res = HandleInputFileset(cmd_line.getHeaderFileSet(), strMergedHeader);
if (a_util::result::isFailed(res))
{
return res.getErrorCode();
}
cmd_line.setHeaderFile(strMergedHeader);
}
if (a_util::result::isFailed(cmd_line.checkMandatoryArguments()))
{
return ERR_INVALID_ARG.getCode();
}
DDLUtilsCore core;
a_util::result::Result res = core.generateDescriptionFile(cmd_line.getHeaderFile(),
cmd_line.getDescriptionFile(), cmd_line.getDDLVersion(), cmd_line.getStruct());
if (a_util::result::isFailed(res))
{
std::cerr << "Error: An error occured during generating of the description file.";
}
// delete temp file
if (!strMergedHeader.empty())
{
a_util::filesystem::remove(strMergedHeader);
}
return res.getErrorCode();
}

70
ddlrepresentation/ddl_common.h Normal file
View file

@ -0,0 +1,70 @@
/**
* @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
*/
#ifndef DDL_COMMON_HEADER
#define DDL_COMMON_HEADER
// Disables VS warnings about unsafe C functions
#ifdef WIN32
#define _SCL_SECURE_NO_WARNINGS // NOLINT
#endif
// Determine whether move semantics are available
#ifdef _MSC_VER
// On Windows, make the decision using the VS version
#if _MSC_VER >= 1800 // VS 2013 (needs default-generation)
#define DDL_HAS_MOVE 1
#else
#define DDL_HAS_MOVE 0
#endif
#else
// Otherwise use the standard version macro
#if __cplusplus >= 201103L
#define DDL_HAS_MOVE 1
#else
#define DDL_HAS_MOVE 0
#endif
#endif
// Include utils
#include <a_util/base.h>
#include <a_util/filesystem.h>
#include <a_util/xml.h>
#include <a_util/memory.h>
#include <a_util/regex.h>
#include <a_util/strings.h>
#include <a_util/variant.h>
#include <a_util/datetime.h>
#include <a_util/system.h>
#include <a_util/concurrency.h>
#include <a_util/logging.h>
#include <a_util/result.h>
// Include standard headers
#include <stack>
#include <set>
#include <map>
#include <vector>
#include <cassert>
#include <algorithm>
#endif // DDL_COMMON_HEADER

50
ddlrepresentation/ddl_error.cpp Normal file
View file

@ -0,0 +1,50 @@
/**
* @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_error.h"
namespace ddl
{
static DDLError s_last_error;
a_util::result::Result DDLError::setLastDDLError(a_util::result::Result result,
const std::string& error)
{
s_last_error._last_error_code = result;
if (!error.empty())
{
s_last_error._last_error_description = error;
}
return a_util::result::SUCCESS;
}
a_util::result::Result DDLError::getLastDDLErrorCode()
{
return s_last_error._last_error_code;
}
const char* DDLError::getLastDDLErrorDescription()
{
return s_last_error._last_error_description.c_str();
}
} // namespace ddl

77
ddlrepresentation/ddl_error.h Normal file
View file

@ -0,0 +1,77 @@
/**
* @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
*/
#ifndef DDLERROR_H_INCLUDED
#define DDLERROR_H_INCLUDED
#include "ddl_common.h"
namespace ddl
{
/**
* Static DDL Error Handling class.
*
* The parser will use this static Error handling to inform about validation errors.
*/
class DDLError
{
std::string _last_error_description;
a_util::result::Result _last_error_code;
public:
/**
* Gets the last DDL Error Code occured.
* @return the DDL Error.
*/
static a_util::result::Result getLastDDLErrorCode();
/**
* Gets the last DDL Error description occured.
* @return the last DDL Error description.
* @remark not thread safe!
*/
static const char* getLastDDLErrorDescription();
/**
* Sets the last DDL Error and error description.
* @return the last DDL Error description.
* @remark not thread safe!
*/
static a_util::result::Result setLastDDLError(a_util::result::Result result,
const std::string& error);
};
/**
* Helper to set an error description to the DDL error handling and return a DDL Error.
* @param [in] \_\_errCode\_\_ the error code to return
* @param [in] \_\_desc\_\_ the description to set
*/
#define RETURN_DDLERROR_DESC(__errCode__, __desc__) { ddl::DDLError::setLastDDLError(__errCode__, __desc__); return __errCode__; }
/**
* Helper to set an error description to the DDL error handling and return a DDL Error if failed.
* @param [in] \_\_callterm\_\_ statement to execute to.
*/
#define RETURN_DDLERROR_IF_FAILED(__callterm__) { a_util::result::Result ntmpRes = __callterm__; if (isFailed(ntmpRes)) { RETURN_DDLERROR_DESC(ntmpRes, ""); } }
/**
* Helper to set an error description to the DDL error handling and return a DDL Error if failed.
* @param [in] \_\_callterm\_\_ statement to execute to.
* @param [in] \_\_desc\_\_ additional error description to set.
*/
#define RETURN_DDLERROR_IF_FAILED_DESC(__callterm__, __desc__) { a_util::result::Result ntmpRes = __callterm__; if (isFailed(ntmpRes)) { RETURN_DDLERROR_DESC(ntmpRes, __desc__); } }
} // namespace ddl
#endif // DDLERROR_H_INCLUDED

118
ddlrepresentation/ddl_intf.h Normal file
View file

@ -0,0 +1,118 @@
/**
* @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
*/
#ifndef DDL_INTF_H_INCLUDED
#define DDL_INTF_H_INCLUDED
#include "ddl_common.h"
namespace ddl
{
class IDDLVisitor;
class IDDLChangeVisitor;
/**
* Interface class for object representation of DDL descriptions.
* E.g. it provides the accept() method for the Visitor design-pattern.
*/
class IDDL
{
public:
/**
* Virtual DTOR
*/
virtual ~IDDL(){}
/**
* Acceptance method for Visitor design-pattern.
* @param[in] visitor - Pointer to Visitor instance
* @retval ERR_POINTER Null-pointer committed
* @retval ERR_NOT_FOUND Required node not found.
* @retval ERR_NOT_INITIALIZED The object was not or not correctly
* initialized
*/
virtual a_util::result::Result accept (IDDLVisitor * visitor) const = 0;
/**
* Acceptance method for Visitor and Change design-pattern.
* @param[in] visitor - Pointer to Visitor instance
* @retval ERR_POINTER Null-pointer committed
* @retval ERR_NOT_FOUND Required node not found.
* @retval ERR_NOT_INITIALIZED The object was not or not correctly
* initialized
*/
virtual a_util::result::Result accept(IDDLChangeVisitor * visitor) = 0;
/**
* Getter for the initialization flag.
* @retval true The object was initialized correctly
* @retval false The object was not or not correctly initialized
*/
virtual bool isInitialized() const = 0;
/**
* Getter for the name of the representation object.
* @return the name
*/
virtual const std::string& getName() const = 0;
/**
* Getter for the predefinition flag.
* @retval true The object was predefined
* @retval false The object was defined later
*/
virtual bool isPredefined() const = 0;
/**
* Getter for the predefinition flag.
* @retval true The object was predefined
* @retval false The object was defined later
*/
virtual bool isOverwriteable() const = 0;
/**
* Getter for the creation level.
* @return the level at creation time of this representation object
*/
virtual int getCreationLevel() const = 0;
/**
* Getter for complex data type flag.
* @retval true This is a complex data type
*/
virtual bool isComplex() const
{
// default is not complex
return false;
}
/**
* Flags for Merging
*
*/
enum TagMergeFlags
{
ddl_merge_force_overwrite = 0x01
};
};
} // namespace ddl
#endif // DDL_INTF_H_INCLUDED

72
ddlrepresentation/ddl_type.cpp Normal file
View file

@ -0,0 +1,72 @@
/**
* @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_type.h"
namespace ddl
{
bool DDL::isEqual(IDDL *lhs, IDDL *rhs)
{
if (NULL == lhs ||
NULL == rhs)
{
return false;
}
return a_util::strings::isEqualNoCase(lhs->getName().c_str(), rhs->getName().c_str());
}
bool DDL::isSorted(IDDL *lhs, IDDL *rhs)
{
if (NULL == lhs)
{
return false;
}
if (NULL == rhs)
{
return true;
}
return lhs->getName() < rhs->getName();
}
bool DDL::isInitialized() const
{
// default case
return true;
}
bool DDL::isPredefined() const
{
// default case
return false;
}
bool DDL::isOverwriteable() const
{
return getCreationLevel() > 0; // cMediaManager::DL_AlwaysThere
}
int DDL::getCreationLevel() const
{
// default case
// cMediaManager::DL_AlwaysThere
return 0;
}
} // namespace ddl

203
ddlrepresentation/ddl_type.h Normal file
View file

@ -0,0 +1,203 @@
/**
* @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
*/
#ifndef DDL_TYPE_H_INCLUDED
#define DDL_TYPE_H_INCLUDED
#include "ddl_common.h"
#include "ddl_intf.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-49, ERR_OUT_OF_RANGE)
/**
* The abstract helper class for representation classes for DDL descriptions.
*/
class DDL : public IDDL
{
public:
virtual bool isInitialized() const;
virtual bool isPredefined() const;
virtual bool isOverwriteable() const;
virtual int getCreationLevel() const;
/**
* Functor for use with \c std::transform() to delete all objects
* where the elements of a vector point at.
* @param[in] obj - Pointer to the object to delete
* @return Pointer to the predefined object that was not deleted (see remarks).
* @remarks Objects which are declarated as predefined are not deleted.
*/
template<typename T>
static T* deleteChild(T *obj)
{
if (NULL != obj)
{
if (obj->isPredefined())
{
return obj;
}
else
{
delete obj;
}
}
return NULL;
}
/**
* Method moves element within the list.
* @param[in] obj - Pointer to the list object
* @param[in] from - Position of element in the list
* @param[in] to - New position of element in the list
* @return ERR_OUT_OF_RANGE - from and to parameters are out of range.
* @return a_util::result::SUCCESS
*/
template<typename T>
static a_util::result::Result moveChild(T *obj, const int from, const int to)
{
if (NULL == obj) { return a_util::result::Result(-4); } //ERR_POINTER for hackers...
if (-1 == from || -1 == to ||
(int)obj->size() < from || (int)obj->size() < to)
{
return ERR_OUT_OF_RANGE;
}
if (from != to)
{
if (from < to)
{
std::rotate(obj->begin() + from,
obj->begin() + from + 1,
obj->begin() + to + 1);
}
else
{
std::rotate(obj->begin() + to,
obj->begin() + from,
obj->begin() + from + 1);
}
}
return a_util::result::SUCCESS;
}
/**
* Functor for use with \c std::transform() to clone the objects
* where the elements of a vector point at.
* @tparam T - Representation object type (e.g. \c Prefix)
* @param[in] obj - Pointer to the object to clone
* @return Pointer to cloned instance of T or \c NULL if there was
* no original instance (obj == NULL).
*/
template<typename T>
static T* clone(T* obj)
{
if (NULL != obj)
{
if (obj->isPredefined())
{
return ref<T>(obj);
}
return new T(*obj);
}
return NULL;
}
/**
* Functor for use with \c std::transform() to ref the objects
* where the elements of a vector point at, this is for the Always_there.
* @tparam T - Representation object type (e.g. \c Prefix)
* @param[in] obj - Pointer to the object to clone
* @return Pointer to ref instance of T or \c NULL if there was
* no original instance (obj == NULL).
*/
template<typename T>
static T* ref(T* obj)
{
if (NULL != obj)
{
return obj;
}
return NULL;
}
/**
* Predicate to compare 2 DDL representation objects (for use with
* \c std::unique()).
* @param[in] lhs - Pointer to the object on left-hand side
* @param[in] rhs - Pointer to the object on right-hand side
* @retval true if the objects have the same name
* @retval false else
*/
static bool isEqual(IDDL* lhs, IDDL* rhs);
/**
* sort predicate to compare to 2 DDL representation objects (for use
* with \c std::sort()).
* @param[in] lhs - Pointer to the object on left-hand side
* @param[in] rhs - Pointer to the object on right-hand side
* @retval true if the left argument goes before the right one.
* @retval false else
*/
static bool isSorted(IDDL* lhs, IDDL* rhs);
};
/// functional pattern to use std find algorithms
template<typename T = IDDL>
struct DDLCompareFunctor
{
/// the name of the pattern
const std::string& pattern;
/**
* CTR
*
* @param [in] pattern the name of the pattern
*/
DDLCompareFunctor(const std::string& pattern): pattern(pattern)
{
}
/**
* compare function for pattern
*
* @param [in] entry pointer to the DDL object
*
* @return true if equal, false otherwise
*/
bool operator()(const T* entry)
{
if (NULL == entry)
{
return false;
}
return pattern == entry->getName();
}
};
} // namespace ddl
#endif // DDL_TYPE_H_INCLUDED

87
ddlrepresentation/ddlalignment.cpp Normal file
View file

@ -0,0 +1,87 @@
/**
* @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 "ddlalignment.h"
namespace ddl
{
std::string DDLAlignment::toString(AlignmentType const alignment)
{
if (alignment != e_invalid)
{
return a_util::strings::toString((int32_t)alignment);
}
return "";
}
DDLAlignment::AlignmentType DDLAlignment::fromString(const std::string &alignment)
{
if (!a_util::strings::isInt32(alignment))
{
// fallback to default
return e_invalid;
}
int alignment_int = a_util::strings::toInt32(alignment);
if (alignment_int <= 0)
{
return e1;
}
else
{
switch(alignment_int)
{
case 1:
{
return e1;
}
case 2:
{
return e2;
}
case 4:
{
return e4;
}
case 8:
{
return e8;
}
case 16:
{
return e16;
}
case 32:
{
return e32;
}
case 64:
{
return e64;
}
default:
{
break;
}
}
}
return e_invalid;
}
} // namespace ddl

69
ddlrepresentation/ddlalignment.h Normal file
View file

@ -0,0 +1,69 @@
/**
* @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
*/
#ifndef DDLALIGNMENT_H_INCLUDED
#define DDLALIGNMENT_H_INCLUDED
#include "ddl_common.h"
namespace ddl
{
/**
* Abstract wrapper class for the alignment enumeration
*/
class DDLAlignment
{
public:
/**
* Representation of the alignment enumeration
*/
typedef enum
{
e0 = 1, /**< for backward compatibility */
e1 = 1, /**< Default alignment */
e2 = 2,
e4 = 4,
e8 = 8,
e16 = 16,
e32 = 32,
e64 = 64,
e_invalid = 255
} AlignmentType;
/**
* Converts the given alignment to a string.
* @param[in] alignment - The alignment to convert
* @return the alignment as string
*/
static std::string toString(AlignmentType const alignment);
/**
* Extracts the alignment out of a given string.
* @param[in] alignment - String containing the alignment
* @return the extracted alignment
*/
static AlignmentType fromString(const std::string& alignment);
};
} // namespace ddl
#endif // DDLALIGNMENT_H_INCLUDED

136
ddlrepresentation/ddlbaseunit.cpp Normal file
View file

@ -0,0 +1,136 @@
/**
* @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 "ddlbaseunit.h"
#include "ddlvisitor_intf.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-5, ERR_INVALID_ARG)
_MAKE_RESULT(-37, ERR_NOT_INITIALIZED)
DDLBaseunit::DDLBaseunit() :
_name{},
_symbol{},
_description{},
_init_flag{},
_level{1}
{
}
DDLBaseunit::DDLBaseunit(const std::string& name,
const std::string& symbol,
const std::string& description,
int const creation_level) :
_name(name),
_symbol(symbol),
_description(description),
_init_flag(true),
_level(creation_level)
{
}
a_util::result::Result DDLBaseunit::create(const std::string& name,
const std::string& symbol,
const std::string& description,
int const creation_level)
{
if (name.empty())
{
return ERR_INVALID_ARG;
}
_name = name;
_symbol = symbol;
_description = description;
_init_flag = true;
_level = creation_level;
return a_util::result::SUCCESS;
}
a_util::result::Result DDLBaseunit::accept(IDDLVisitor *visitor) const
{
if (!_init_flag)
{
return ERR_NOT_INITIALIZED;
}
return visitor->visit(this);
}
a_util::result::Result DDLBaseunit::accept(IDDLChangeVisitor *visitor)
{
if (!_init_flag)
{
return ERR_NOT_INITIALIZED;
}
return visitor->visit(this);
}
bool DDLBaseunit::isInitialized() const
{
return _init_flag;
}
const std::string& DDLBaseunit::getName() const
{
return _name;
}
void DDLBaseunit::setName(const std::string& name)
{
_name = name;
}
const std::string& DDLBaseunit::getSymbol() const
{
return _symbol;
}
void DDLBaseunit::setSymbol(const std::string& symbol)
{
_symbol = symbol;
}
const std::string& DDLBaseunit::getDescription() const
{
return _description;
}
void DDLBaseunit::setDescription(const std::string& description)
{
_description = description;
}
bool DDLBaseunit::isPredefined() const
{
return _level == -1; // cMediaManager::DL_AlwaysThere
}
bool DDLBaseunit::isOverwriteable() const
{
return _level> 0;
}
int DDLBaseunit::getCreationLevel() const
{
return _level;
}
} // namespace ddl

118
ddlrepresentation/ddlbaseunit.h Normal file
View file

@ -0,0 +1,118 @@
/**
* @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
*/
#ifndef DDLBASE_UNIT_H_INCLUDED
#define DDLBASE_UNIT_H_INCLUDED
#include "ddl_common.h"
#include "ddlunit_intf.h"
namespace ddl
{
/**
* Representation of a base unit inside a DDL description.
*/
class DDLBaseunit : public IDDLUnit
{
public:
/**
* Default CTOR
*/
DDLBaseunit();
/**
* CTOR
* @param[in] name - Name of the base unit (e.g. "metre")
* @param[in] symbol - Symbol of the base unit (e.g. "m")
* @param[in] description - Description of the represented base unit
* @param[in] creation_level - Level at creation time (optional)
*/
DDLBaseunit(const std::string& name,
const std::string& symbol,
const std::string& description,
int const creation_level = 1);
/**
* Creation method to fill the object with data.
* @param[in] name - Name of the base unit (e.g. "metre")
* @param[in] symbol - Symbol of the base unit (e.g. "m")
* @param[in] description - Description of the represented base unit
* @param[in] creation_level - Level at creation time (optional)
* @retval ERR_INVALID_ARG Empty name committed
*/
a_util::result::Result create(const std::string& name,
const std::string& symbol,
const std::string& description,
int const creation_level = 1);
a_util::result::Result accept(IDDLVisitor *visitor) const;
a_util::result::Result accept(IDDLChangeVisitor *visitor);
bool isPredefined() const;
bool isOverwriteable() const;
bool isInitialized() const;
int getCreationLevel() const;
/**
* Getter for the name.
* @return the name
*/
const std::string& getName() const;
/**
* Setter for the name.
*/
void setName(const std::string& name);
/**
* Getter for the symbol.
* @return the symbol
*/
const std::string& getSymbol() const;
/**
* Setter for the description.
*/
void setSymbol(const std::string& symbol);
/**
* Getter for the description.
* @return the description
*/
const std::string& getDescription() const;
/**
* Setter for the description.
*/
void setDescription(const std::string& desc);
private:
std::string _name;
std::string _symbol;
std::string _description;
bool _init_flag;
int _level;
};
} // namespace ddl
#endif // DDLBASE_UNIT_H_INCLUDED

65
ddlrepresentation/ddlbyteorder.cpp Normal file
View file

@ -0,0 +1,65 @@
/**
* @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 "ddlbyteorder.h"
namespace ddl
{
std::string DDLByteorder::toString(DDLByteorder::Byteorder const byteorder)
{
switch(byteorder)
{
case e_le:
{
return std::string("LE");
}
case e_be:
{
return std::string("BE");
}
default:
{
// error case
return a_util::strings::empty_string;
}
}
}
DDLByteorder::Byteorder DDLByteorder::fromString(const std::string& byteorder)
{
if (byteorder == "LE")
{
return e_le;
}
if (byteorder == "BE")
{
return e_be;
}
if (byteorder == "Motorola")
{
return e_be;
}
if (byteorder == "Intel")
{
return e_le;
}
// fallback to default
return e_le;
}
} // namespace ddl

64
ddlrepresentation/ddlbyteorder.h Normal file
View file

@ -0,0 +1,64 @@
/**
* @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
*/
#ifndef BYTEORDER_H_INCLUDED
#define BYTEORDER_H_INCLUDED
#include "ddl_common.h"
#include "ddl_type.h"
namespace ddl
{
/**
* Abstract wrapper class for the byteorder enumeration.
*/
class DDLByteorder : public DDL
{
public:
/**
* Representation of the byteorder enumeration
*/
typedef enum
{
platform_not_supported = 0x00,
plattform_little_endian_8 = 0x01,
platform_big_endian_8 = 0x02,
e_noe = platform_not_supported,
e_le = plattform_little_endian_8,
e_be = platform_big_endian_8
} Byteorder;
/**
* Converts the given byteorder enumeration to a string.
* @param[in] byteorder - Byteorder value to convert
* @return the byteorder as string
*/
static std::string toString(Byteorder const byteorder);
/**
* Extracts the byteorder out of the given string.
* @param[in] byteorder - String containing the byteorder
* @return the extracted byteorder
*/
static Byteorder fromString(const std::string& byteorder);
};
} // namespace ddl
#endif // BYTEORDER_H_INCLUDED

625
ddlrepresentation/ddlcloner.cpp Normal file
View file

@ -0,0 +1,625 @@
/**
* @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 "ddlcloner.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"
#include "ddlimporter.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-4, ERR_POINTER)
_MAKE_RESULT(-16, ERR_NOT_IMPL)
_MAKE_RESULT(-18, ERR_NO_CLASS)
_MAKE_RESULT(-37, ERR_NOT_INITIALIZED)
DDLDescription * DDLCloner::getDDL() const
{
return _ddl_desc;
}
void DDLCloner::destroyDDL()
{
DDLImporter::destroyDDL(_ddl_desc);
_ddl_desc = NULL;
}
a_util::result::Result DDLCloner::createNew(const DDLVersion& version /* = 0 */)
{
if (NULL == _original_desc)
{
return ERR_NOT_INITIALIZED;
}
// The DDL object does not get deleted because the caller/user of this
// object is responsible for it.
_ddl_desc = NULL;
// clone original DDL
RETURN_IF_FAILED(buildHeader());
RETURN_IF_FAILED(buildUnits());
RETURN_IF_FAILED(buildDatatypes());
RETURN_IF_FAILED(buildEnums());
RETURN_IF_FAILED(buildStructs());
RETURN_IF_FAILED(buildStreams());
return a_util::result::SUCCESS;
}
a_util::result::Result DDLCloner::buildHeader()
{
if (NULL == _original_desc)
{
return ERR_NOT_INITIALIZED;
}
// copy header object
DDLHeader *header = new DDLHeader(*_original_desc->getHeader());
// external declarations have to be cloned separately
DDLExtDeclarationVec ext_declarations = header->getExtDeclarations();
std::transform(ext_declarations.begin(), ext_declarations.end(),
ext_declarations.begin(), DDL::clone<DDLExtDeclaration>);
_ddl_desc = new DDLDescription(header);
return a_util::result::SUCCESS;
}
a_util::result::Result DDLCloner::buildUnits()
{
if (NULL == _original_desc)
{
return ERR_NOT_INITIALIZED;
}
// clone baseunit objects
DDLBaseunitVec baseunits = _original_desc->getBaseunits();
std::transform(baseunits.begin(), baseunits.end(), baseunits.begin(),
DDL::clone<DDLBaseunit>);
_ddl_desc->refBaseunits(baseunits);
// clone prefix objects
DDLPrefixVec ddlprefixes = _original_desc->getPrefixes();
std::transform(ddlprefixes.begin(), ddlprefixes.end(),
ddlprefixes.begin(), DDL::clone<DDLPrefix>);
_ddl_desc->refPrefixes(ddlprefixes);
// clone unit objects
DDLUnitVec units = _original_desc->getUnits();
std::transform(units.begin(), units.end(),
units.begin(), DDL::clone<DDLUnit>);
// refunit objects have to be cloned separately
for (DDLUnitIt it_unit = units.begin(); units.end() != it_unit;
++it_unit)
{
DDLRefUnitVec refunits = (*it_unit)->getRefUnits();
for (DDLRefUnitIt it_ru = refunits.begin(); refunits.end() != it_ru;
++it_ru)
{
// find prefix object
DDLPrefixIt it_prefix = std::find_if(ddlprefixes.begin(),
ddlprefixes.end(), DDLCompareFunctor<DDLPrefix>((*it_ru)->getPrefix()));
if (ddlprefixes.end() == it_prefix)
{
return ERR_NO_CLASS;
}
// find unit and create refunit object with appropriate CTOR
DDLBaseunitIt it_bu_found = std::find_if(baseunits.begin(),
baseunits.end(), DDLCompareFunctor<DDLBaseunit>((*it_ru)->getName()));
if (baseunits.end() == it_bu_found)
{
// not found in baseunit vector
DDLUnitIt it_u_found = std::find_if(units.begin(),
units.end(), DDLCompareFunctor<DDLUnit>((*it_ru)->getName()));
if (units.end() == it_u_found)
{
// not found in unit vector
// => not defined at all
return ERR_NO_CLASS;
}
*it_ru = new DDLRefUnit(*it_u_found, (*it_ru)->getPower(),
*it_prefix);
}
else
{
*it_ru = new DDLRefUnit(*it_bu_found, (*it_ru)->getPower(),
*it_prefix);
}
}
(*it_unit)->setRefUnits(refunits);
}
_ddl_desc->refUnits(units);
return a_util::result::SUCCESS;
}
a_util::result::Result DDLCloner::buildDatatypes()
{
if (NULL == _original_desc)
{
return ERR_NOT_INITIALIZED;
}
DDLDTVec datatypes = _original_desc->getDatatypes();
for (DDLDTIt it_dt = datatypes.begin(); datatypes.end() != it_dt; ++it_dt)
{
DDLVersion version = (*it_dt)->getDDLVersion();
if ((*it_dt)->getUnit().empty())
{
// datatype without defined unit
(*it_dt) = new DDLDataType((*it_dt)->getName(),
(*it_dt)->getNumBits(),
NULL,
(*it_dt)->getDescription(),
(*it_dt)->getAlignment(),
(*it_dt)->getArraysize(),
(*it_dt)->getCreationLevel(),
(*it_dt)->getArraySizeSource(),
(*it_dt)->isMinValid(),
(*it_dt)->getMinValue(),
(*it_dt)->isMaxValid(),
(*it_dt)->getMaxValue());
}
else
{
// find unit and clone datatype object with appropriate CTOR
DDLBaseunitVec baseunits = _ddl_desc->getBaseunits();
DDLBaseunitIt it_bu_found = std::find_if(baseunits.begin(),
baseunits.end(), DDLCompareFunctor<DDLBaseunit>((*it_dt)->getUnit()));
if (baseunits.end() == it_bu_found)
{
// not found in baseunit vector
DDLUnitVec units = _ddl_desc->getUnits();
DDLUnitIt it_u_found = std::find_if(units.begin(),
units.end(), DDLCompareFunctor<DDLUnit>((*it_dt)->getUnit()));
if (units.end() == it_u_found)
{
// not found in unit vector
// => not defined at all
return ERR_NO_CLASS;
}
(*it_dt) = new DDLDataType((*it_dt)->getName(),
(*it_dt)->getNumBits(),
*it_u_found,
(*it_dt)->getDescription(),
(*it_dt)->getAlignment(),
(*it_dt)->getArraysize(),
(*it_dt)->getCreationLevel(),
(*it_dt)->getArraySizeSource(),
(*it_dt)->isMinValid(),
(*it_dt)->getMinValue(),
(*it_dt)->isMaxValid(),
(*it_dt)->getMaxValue());
}
else
{
(*it_dt) = new DDLDataType((*it_dt)->getName(),
(*it_dt)->getNumBits(),
*it_bu_found,
(*it_dt)->getDescription(),
(*it_dt)->getAlignment(),
(*it_dt)->getArraysize(),
(*it_dt)->getCreationLevel(),
(*it_dt)->getArraySizeSource(),
(*it_dt)->isMinValid(),
(*it_dt)->getMinValue(),
(*it_dt)->isMaxValid(),
(*it_dt)->getMaxValue());
}
}
(*it_dt)->setDDLVersion(version);
}
_ddl_desc->refDatatypes(datatypes);
return a_util::result::SUCCESS;
}
a_util::result::Result DDLCloner::buildEnums()
{
if (NULL == _original_desc)
{
return ERR_NOT_INITIALIZED;
}
DDLEnumVec enums = _original_desc->getEnums();
// clone enums
std::transform(enums.begin(), enums.end(),
enums.begin(), DDL::clone<DDLEnum>);
_ddl_desc->refEnums(enums);
return a_util::result::SUCCESS;
}
a_util::result::Result DDLCloner::buildStructs()
{
if (NULL == _original_desc)
{
return ERR_NOT_INITIALIZED;
}
// clone structs
DDLComplexVec structs;
structs.cloneFrom(_original_desc->getStructs());
// elements have to be cloned seperately
DDLDTVec datatypes = _ddl_desc->getDatatypes();
DDLUnitVec units = _ddl_desc->getUnits();
DDLBaseunitVec baseunits = _ddl_desc->getBaseunits();
DDLEnumVec ddl_enums = _ddl_desc->getEnums();
for (DDLComplexVec::iterator it_struct = structs.begin();
structs.end() != it_struct; ++it_struct)
{
DDLElementVec elements = (*it_struct)->getElements();
for (DDLElementIt it_element = elements.begin();
elements.end() != it_element; ++it_element)
{
DDLComplex* ddl_struct = NULL;
DDLEnum* ddl_enum = NULL;
DDLDataType* type = datatypes.find((*it_element)->getType());
if (!type)
{
// not found in datatypes vector
ddl_struct = structs.find((*it_element)->getType());
if (!ddl_struct)
{
// not found in structs vector
ddl_enum = ddl_enums.find((*it_element)->getType());
if (!ddl_enum)
{
// not found in enums vector
// => not defined at all
return ERR_NO_CLASS;
}
}
}
if ((*it_element)->getUnit().empty())
{
// no unit defined
if (ddl_enum)
{
*it_element = new DDLElement(ddl_enum,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
NULL,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
else if(ddl_struct)
{
*it_element = new DDLElement(ddl_struct,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
NULL,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
else
{
*it_element = new DDLElement(type,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
NULL,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
}
else
{
// find unit
DDLBaseunitIt it_bu_found = std::find_if(baseunits.begin(),
baseunits.end(), DDLCompareFunctor<DDLBaseunit>((*it_element)->getUnit()));
if (baseunits.end() == it_bu_found)
{
// not found in baseunit vector
DDLUnitIt it_u_found = std::find_if(units.begin(),
units.end(), DDLCompareFunctor<DDLUnit>((*it_element)->getUnit()));
if (units.end() == it_u_found)
{
// not found in units vector
// => not defined at all
return ERR_NO_CLASS;
}
if (ddl_enum)
{
*it_element = new DDLElement(ddl_enum,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
*it_u_found,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
else if (ddl_struct)
{
*it_element = new DDLElement(ddl_struct,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
*it_u_found,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
else
{
*it_element = new DDLElement(type,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
*it_u_found,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
}
else
{
if (ddl_enum)
{
*it_element = new DDLElement(ddl_enum,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
*it_bu_found,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
else if (ddl_struct)
{
*it_element = new DDLElement(ddl_struct,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
*it_bu_found,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
else
{
*it_element = new DDLElement(type,
(*it_element)->getName(),
(*it_element)->getBytepos(),
(*it_element)->getArraysize(),
(*it_element)->getByteorder(),
(*it_element)->getAlignment(),
*it_bu_found,
(*it_element)->getBitpos(),
(*it_element)->getNumBits(),
(*it_element)->getDescription(),
(*it_element)->getComment(),
(*it_element)->getArraySizeSource(),
(*it_element)->getConstantValue(),
(*it_element)->isMinValid(),
(*it_element)->getMinValue(),
(*it_element)->isMaxValid(),
(*it_element)->getMaxValue(),
(*it_element)->isDefaultValid(),
(*it_element)->getDefaultValue(),
(*it_element)->isScaleValid(),
(*it_element)->getScaleValue(),
(*it_element)->isOffsetValid(),
(*it_element)->getOffsetValue());
}
}
}
}
(*it_struct)->setElements(elements);
}
_ddl_desc->refStructs(structs);
return a_util::result::SUCCESS;
}
a_util::result::Result DDLCloner::buildStreams()
{
if (NULL == _original_desc)
{
return ERR_NOT_INITIALIZED;
}
// clone the streams
DDLStreamVec streams = _original_desc->getStreams();
DDLComplexVec structs = _ddl_desc->getStructs();
for (DDLStreamIt it_stream = streams.begin();
streams.end() != it_stream; ++it_stream)
{
// find type
DDLComplexIt it_found = std::find_if(structs.begin(),
structs.end(), DDLCompareFunctor<DDLComplex>((*it_stream)->getType()));
if (structs.end() == it_found)
{
// type not found
return ERR_NO_CLASS;
}
// clone the contained stream structs
DDLStreamStructVec strm_structs = (*it_stream)->getStructs();
DDLVersion version = (*it_stream)->getDDLVersion();
*it_stream = new DDLStream(*it_found, (*it_stream)->getName(),
(*it_stream)->getDescription(), strm_structs,
(*it_stream)->getCreationLevel());
(*it_stream)->setDDLVersion(version);
for (DDLStreamStructIt it_struct = strm_structs.begin();
strm_structs.end() != it_struct; ++it_struct)
{
// find type
it_found = std::find_if(structs.begin(), structs.end(),
DDLCompareFunctor<DDLComplex>((*it_struct)->getType()));
if (structs.end() == it_found)
{
// type not found
return ERR_NO_CLASS;
}
*it_struct = new DDLStreamStruct(*it_found,
(*it_struct)->getBytepos(), (*it_struct)->getName());
}
(*it_stream)->refStructs(strm_structs);
}
_ddl_desc->refStreams(streams);
return a_util::result::SUCCESS;
}
a_util::result::Result DDLCloner::setOriginal(const DDLDescription* original)
{
if (!original) { return ERR_POINTER; }
_original_desc = original;
return a_util::result::SUCCESS;
}
a_util::result::Result ddl::DDLCloner::buildStreamMetaTypes()
{
return ERR_NOT_IMPL; ///@todo
}
} // namespace ddl

69
ddlrepresentation/ddlcloner.h Normal file
View file

@ -0,0 +1,69 @@
/**
* @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
*/
#ifndef DDL_CLONER_H_INCLUDED
#define DDL_CLONER_H_INCLUDED
#include "ddl_common.h"
#include "ddlfactorymethod_intf.h"
#include "ddldescription.h"
namespace ddl
{
/**
* Implementation of IDDLFactorMethod for cloning of DDL representations.
*/
class DDLCloner : public IDDLFactoryMethod
{
public: // implements IDDLFactoryMethod
DDLDescription * getDDL() const;
a_util::result::Result createNew(const DDLVersion& version = DDLVersion::ddl_version_invalid);
void destroyDDL();
a_util::result::Result buildHeader();
a_util::result::Result buildUnits();
a_util::result::Result buildDatatypes();
a_util::result::Result buildEnums();
a_util::result::Result buildStructs();
a_util::result::Result buildStreams();
a_util::result::Result buildStreamMetaTypes();
public:
/**
* Setter method for the original DDL object.
* @param[in] original - Pointer to the DDL object
* @retval ERR_POINTER Null-pointer committed
*/
a_util::result::Result setOriginal(const DDLDescription* original);
private: // members
DDLDescription* _ddl_desc;
const DDLDescription* _original_desc;
};
} // namespace ddl
#endif // DDL_CLONER_H_INCLUDED

1263
ddlrepresentation/ddlcompare.cpp Normal file
View file

File diff suppressed because it is too large Load diff

309
ddlrepresentation/ddlcompare.h Normal file
View file

@ -0,0 +1,309 @@
/**
* @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
*/
#ifndef DDLCOMPARE_H_INCLUDED
#define DDLCOMPARE_H_INCLUDED
#include "ddl_common.h"
#include "ddldescription.h"
#include "ddlunit_intf.h"
#include "ddlelement.h"
namespace ddl
{
/**
* Utility class to compare media descriptions
*/
class DDLCompare
{
public:
/**
* Flags for the description based isEqual methods
*/
enum DescriptionCheckFlags
{
dcf_data_types = 0x01, ///< Compare datatypes
dcf_units = 0x02, ///< Compare units
dcf_enums = 0x04, ///< Compare enums
dcf_structs = 0x08, ///< Compare structs
dcf_streams = 0x10, ///< Compare streams
dcf_base_units = 0x20, ///< Compare baseunits
dcf_prefixes = 0x40, ///< Compare prefixes
dcf_all = 0xFF, ///< Compare all elements (see above)
dcf_subset = 0x0100, ///< Checks whether the first description is a subset of the second
dcf_versions = 0x0200, ///< Compares the version attributes as well
dcf_comments = 0x0400, ///< Compares the comment attributes as well
dcf_descriptions = 0x0800, ///< Compares the description attributes as well
dcf_header = 0x1000, ///< Compare the header as well
dcf_visualization_attributes = 0x2000, ///< Check attributes relevant for visualization (min/max/default/scale/offset)
dcf_no_enum_values_check = 0x010000, ///< Do not compare enum values.
dcf_no_recursion = 0x020000, ///< Do not compare sub-entities (elements, ref units, stream structs, ...)
dcf_no_header_dates = 0x040000, ///< Do not compare header dates (date_creation, date_change)
dcf_everything = 0xFFFF ///< Check everything (all flags except the "No" variants)
};
/**
* Flags for the item based isEqual methods
*/
enum ItemCheckFlags
{
icf_none = 0x00,
icf_memory = 0x01, ///< Compare the in-memory representation
icf_serialized = 0x02, ///< Compare the serialized representation
icf_names = 0x04, ///< Compare the names of structs and their elements
icf_versions = 0x08, ///< Compare the versions of all elements and structs
icf_units = 0x10, ///< Compare the units as well
icf_comments = 0x20, ///< Compare the comments as well
icf_descriptions = 0x40, ///< Compare the comments as well
icf_subset = 0x80, ///< Check if the first item is a subset of the second.
icf_visualizations_attributes = 0x0100, ///< Check attributes relevant for visualization (min/max/default/scale/offset)
icf_no_enum_values_check = 0x0200, ///< Do not compare enum values.
icf_no_recursion = 0x0400 ///< Do not compare sub-entities (elements, ref units, stream structs, ...)
};
public:
/**
* @brief isBinaryEqual checks whether two type descriptions describe the same binary data layout
* @param [in] type1 The name of the first type.
* @param [in] desc1 The description that has type1.
* @param [in] type2 The name of the second type.
* @param [in] desc2 The description that has type2.
* @param [in] is_subset If true then the method checks if the first type is a subset of the second (starting at offset 0, possibly with smaller size).
* @retval a_util::result::SUCCESS The description describe the same layout
* @retval ERR_FAILED The description do NOT describe the same layout
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isBinaryEqual(const std::string& type1, const std::string& desc1,
const std::string& type2, const std::string& desc2,
bool is_subset = true);
/**
* @brief isBinaryEqual checks whether two type descriptions describe the same binary data layout
* @param [in] type1 The name of the first type.
* @param [in] desc1 The description that has type1.
* @param [in] type2 The name of the second type.
* @param [in] desc2 The description that has type2.
* @param [in] is_subset If true then the method checks if the first type is a subset of the second (starting at offset 0, possibly with smaller size).
* @retval a_util::result::SUCCESS The description describe the same layout
* @retval ERR_FAILED The description do NOT describe the same layout
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isBinaryEqual(const std::string& type1, const DDLDescription* desc1,
const std::string& type2, const DDLDescription* desc2,
bool is_subset = true);
// main ddl entities comparisons
/**
* @brief isEqualPrefix checks whether two prefix descriptions are equal.
* @param [in] prefix1 The name of the first prefix.
* @param [in] desc1 The description that has prefix1.
* @param [in] prefix2 The name of the second prefix.
* @param [in] desc2 The description that has prefix2.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqualPrefix(const std::string& prefix1, const std::string& desc1,
const std::string& prefix2, const std::string& desc2,
uint32_t flags = icf_none);
/**
* @brief isEqual checks whether two prefix descriptions are equal.
* @param [in] prefix1 The first prefix.
* @param [in] prefix2 The second prefix.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const DDLPrefix* prefix1, const DDLPrefix* prefix2,
uint32_t flags = icf_none);
/**
* @brief isEqualUnit checks whether two unit descriptions are equal.
* @param [in] unit1 The name of the first type.
* @param [in] desc1 The description that has unit1.
* @param [in] unit2 The name of the second type.
* @param [in] desc2 The description that has unit2.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqualUnit(const std::string& unit1, const std::string& desc1,
const std::string& unit2, const std::string& desc2,
uint32_t flags = icf_none);
/**
* @brief isEqual checks whether two unit descriptions are equal.
* @param [in] unit1 The first unit.
* @param [in] unit2 The second unit.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const IDDLUnit* unit1, const IDDLUnit* unit2,
uint32_t flags = icf_none);
/**
* @brief isEqual checks whether two type (POD/enum/struct) descriptions are equal.
* When this is true for a struct then it also implies @ref isBinaryEqual is true
* @param [in] type1 The name of the first type.
* @param [in] desc1 The description that has type1.
* @param [in] type2 The name of the second type.
* @param [in] desc2 The description that has type2.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqualType(const std::string& type1, const std::string& desc1,
const std::string& type2, const std::string& desc2,
uint32_t flags = icf_memory);
/**
* @brief isEqual checks whether two type (POD/enum/struct) descriptions are equal
* When this is true for a struct then it also implies @ref isBinaryEqual is true
* @param [in] type1 The first type.
* @param [in] type2 The second type.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const IDDLDataType* type1, const IDDLDataType* type2,
uint32_t flags = icf_memory);
/**
* @brief isEqual checks whether two stream descriptions are equal.
* @param [in] stream1 The name of the first stream.
* @param [in] desc1 The description that has stream1.
* @param [in] stream2 The name of the second stream.
* @param [in] desc2 The description that has stream2.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqualStream(const std::string& stream1, const std::string& desc1,
const std::string& stream2, const std::string& desc2,
uint32_t flags = icf_memory);
/**
* @brief isEqual checks whether two stream descriptions are equal.
* @param [in] stream1 The first stream.
* @param [in] stream2 The second stream.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const DDLStream* stream1, const DDLStream* stream2,
uint32_t flags = icf_memory);
// sub-item comparison
/**
* @brief isEqual checks whether two external declarations are equal.
* @param [in] ext1 The first declaration.
* @param [in] ext2 The second declaration.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const DDLExtDeclaration* ext1, const DDLExtDeclaration* ext2,
uint32_t flags = icf_none);
/**
* @brief isEqual checks whether two reference units are equal.
* @param [in] ref_unit1 The first unit.
* @param [in] ref_unit2 The second unit.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const DDLRefUnit* ref_unit1, const DDLRefUnit* ref_unit2,
uint32_t flags = icf_none);
/**
* @brief isEqual checks whether two struct elements are equal.
* Note that in case of dynamic elements only the name of the array size specifier can be checked.
* Compare the whole struct if you need a more tourough comparison.
* @param [in] elem1 The first element.
* @param [in] elem2 The second element.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const DDLElement* elem1, const DDLElement* elem2,
uint32_t flags = icf_none);
/**
* @brief isEqual checks whether two stream structs equal.
* @param [in] stream_struct1 The first struct.
* @param [in] stream_struct2 The second struct.
* @param [in] flags Flags that specifiy what should be checked, see @ref ItemCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const DDLStreamStruct* stream_struct1, const DDLStreamStruct* stream_struct2,
uint32_t flags = icf_none);
// description based methods
/**
* @brief isEqual checks whether two descriptions are equal.
* @param [in] desc1 The first description.
* @param [in] desc2 The second description.
* @param [in] flags Flags that specifiy what should be checked, see @ref DescriptionCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const std::string& desc1,
const std::string& desc2,
uint32_t flags = dcf_all | dcf_subset);
/**
* @brief isEqual checks whether two descriptions are equal.
* @param [in] desc1 The first description.
* @param [in] desc2 The second description.
* @param [in] flags Flags that specifiy what should be checked, see @ref DescriptionCheckFlags.
* @retval a_util::result::SUCCESS The descriptions are equal.
* @retval ERR_FAILED The description are not equal.
* @retval Standard result (other DDL parsing errors etc.)
*/
static a_util::result::Result isEqual(const DDLDescription* desc1,
const DDLDescription* desc2,
uint32_t flags = dcf_all | dcf_subset);
};
}
#endif

303
ddlrepresentation/ddlcomplex.cpp Normal file
View file

@ -0,0 +1,303 @@
/**
* @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 <utility> //std::swap
#include "ddlcomplex.h"
#include "ddlalignment.h"
#include "ddldescription.h"
#include "ddlelement.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-5, ERR_INVALID_ARG);
_MAKE_RESULT(-20, ERR_NOT_FOUND);
DDLComplex::DDLComplex() :
_language_version(DDLVersion::getDefaultVersion()), _init_flag(false), _level(1), _dynamic_elements(false)
{
}
DDLComplex::DDLComplex(const std::string& name,
unsigned int const version,
const std::string& comment,
DDLAlignment::AlignmentType const alignment,
DDLElementVec ddl_elements,
int const creation_level,
DDLVersion language_version) :
_language_version(language_version),
_name(name),
_version(version),
_comment(comment),
_alignment(alignment),
_ddl_elements(),
_init_flag(true),
_level(creation_level),
_dynamic_elements(false)
{
cloneElements(ddl_elements);
}
DDLComplex::DDLComplex(const DDLComplex &other) :
_language_version(other.getDDLVersion()),
_name(other.getName()),
_version(other.getVersion()),
_comment(other.getComment()),
_alignment(other.getAlignment()),
_init_flag(true),
_level(other.getCreationLevel())
{
cloneElements(other.getElements());
}
DDLComplex& DDLComplex::operator=(DDLComplex other)
{
swap(*this, other);
return *this;
}
DDLComplex::DDLComplex(DDLComplex&& other) : DDLComplex()
{
swap(*this, other);
}
DDLComplex::~DDLComplex()
{
std::transform(_ddl_elements.begin(), _ddl_elements.end(),
_ddl_elements.begin(), DDL::deleteChild<DDLElement>);
_ddl_elements.clear();
}
a_util::result::Result DDLComplex::create(const std::string& name,
unsigned int const version,
const std::string& comment,
DDLAlignment::AlignmentType const alignment,
DDLElementVec ddl_elements,
int const creation_level)
{
if (name.empty())
{
return ERR_INVALID_ARG;
}
_name = name;
_version = version;
_comment = comment;
_alignment = alignment;
cloneElements(ddl_elements);
_init_flag = true;
_level = creation_level;
_language_version = DDLVersion::getDefaultVersion();
return a_util::result::SUCCESS;
}
a_util::result::Result DDLComplex::accept(IDDLVisitor *visitor) const
{
return visitor->visit(this);
}
a_util::result::Result DDLComplex::accept(IDDLChangeVisitor *visitor)
{
return visitor->visit(this);
}
const std::string& DDLComplex::getName() const
{
return _name;
}
void DDLComplex::setName(const std::string& name )
{
_name = name;
}
bool DDLComplex::isInitialized() const
{
return _init_flag;
}
bool DDLComplex::isPredefined() const
{
return _level == -1; // cMediaManager::DL_Internal
}
bool DDLComplex::isOverwriteable() const
{
return _level > 0; // cMediaManager::DL_AlwaysThere
}
int DDLComplex::getCreationLevel() const
{
return _level;
}
unsigned int DDLComplex::getVersion() const
{
return _version;
}
void DDLComplex::setVersion(unsigned int const version)
{
_version = version;
}
DDLVersion DDLComplex::getDDLVersion() const
{
return _language_version;
}
a_util::result::Result DDLComplex::setDDLVersion(const DDLVersion& language_version)
{
_language_version = language_version;
return a_util::result::SUCCESS;
}
void DDLComplex::setComment(const std::string& comment)
{
_comment = comment;
}
std::string DDLComplex::getComment() const
{
return _comment;
}
void DDLComplex::setAlignment(DDLAlignment::AlignmentType const alignment)
{
_alignment = alignment;
}
DDLAlignment::AlignmentType DDLComplex::getAlignment() const
{
return _alignment;
}
void DDLComplex::cloneElements(DDLElementVec ddl_elements)
{
std::transform(_ddl_elements.begin(), _ddl_elements.end(), _ddl_elements.begin(), DDLDescription::deleteChild<DDLElement>);
_ddl_elements.clear();
_ddl_elements = ddl_elements;
std::transform(_ddl_elements.begin(), _ddl_elements.end(), _ddl_elements.begin(), DDLDescription::clone<DDLElement>);
_dynamic_elements = false;
for (DDLElementIt itEl = _ddl_elements.begin(); itEl != _ddl_elements.end(); itEl++)
{
if ((*itEl)->isDynamic())
{
_dynamic_elements = true;
break;
}
}
}
void DDLComplex::setElements(DDLElementVec ddl_elements)
{
std::transform(_ddl_elements.begin(), _ddl_elements.end(), _ddl_elements.begin(), DDLDescription::deleteChild<DDLElement>);
_ddl_elements.clear();
_ddl_elements = ddl_elements;
_dynamic_elements = false;
for (DDLElementIt itEl = _ddl_elements.begin(); itEl != _ddl_elements.end(); itEl++)
{
if ((*itEl)->isDynamic())
{
_dynamic_elements = true;
break;
}
}
}
void DDLComplex::addElement(DDLElement* element, int pos)
{
if (NULL != element)
{
const DDLElementVec::size_type size_pos = static_cast<DDLElementVec::size_type>(pos);
if (0 <= size_pos && size_pos < _ddl_elements.size())
{
_ddl_elements.insert(_ddl_elements.begin() + size_pos, element);
}
else
{
_ddl_elements.push_back(element);
}
if (!_dynamic_elements)
{
_dynamic_elements = element->isDynamic();
}
}
}
a_util::result::Result DDLComplex::removeElement(const std::string& element_name)
{
DDLElementIt it = _ddl_elements.begin();
while (_ddl_elements.end() != it)
{
if ((*it)->getName() == element_name)
{
bool itHasDynArr = (*it)->isDynamic();
DDLDescription::deleteChild(*it);
_ddl_elements.erase(it);
if (_dynamic_elements && itHasDynArr)
{
// We have to verify if the structure was dynamic only because of this element
_dynamic_elements = false;
for (DDLElementIt itEl = _ddl_elements.begin(); itEl != _ddl_elements.end(); itEl++)
{
if ((*itEl)->isDynamic())
{
_dynamic_elements = true;
break;
}
}
}
return a_util::result::SUCCESS;
}
it++;
}
return ERR_NOT_FOUND;
}
const DDLElementVec& DDLComplex::getElements() const
{
return _ddl_elements;
}
DDLElementVec& DDLComplex::getElements()
{
return _ddl_elements;
}
bool DDLComplex::hasDynamicElements()
{
return _dynamic_elements;
}
void swap(DDLComplex& lhs, DDLComplex& rhs) noexcept
{
using std::swap; // ADL
swap(lhs._language_version, rhs._language_version);
swap(lhs._name, rhs._name);
swap(lhs._version, rhs._version);
swap(lhs._comment, rhs._comment);
swap(lhs._alignment, rhs._alignment);
swap(lhs._ddl_elements, rhs._ddl_elements);
swap(lhs._init_flag, rhs._init_flag);
swap(lhs._level, rhs._level);
swap(lhs._dynamic_elements, rhs._dynamic_elements);
}
} // namespace ddl

275
ddlrepresentation/ddlcomplex.h Normal file
View file

@ -0,0 +1,275 @@
/**
* @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
*/
#ifndef DDLCOMPLEX_H_INCLUDED
#define DDLCOMPLEX_H_INCLUDED
#include "ddl_common.h"
#include "ddldatatype_intf.h"
#include "ddlvisitor_intf.h"
#include "ddl_type.h"
#include "ddlalignment.h"
#include "ddlversion.h"
namespace ddl
{
class DDLElement;
class DDLAlignment;
/**
* Container type of DDLElement objects
*/
typedef std::vector<DDLElement*> DDLElementVec;
/**
* Iterator type for DDLElementVec
*/
typedef DDLElementVec::iterator DDLElementIt;
/**
* Constant-iterator type for DDLElementVec
*/
typedef DDLElementVec::const_iterator DDLElementItConst;
/**
* Representation for a complex datatype inside a DDL specification.
*/
class DDLComplex : public IDDLDataType
{
public:
/**
* Default CTOR
*/
DDLComplex();
/**
* CTOR
* @param[in] name - Name of the data type
* @param[in] version - Version number of the specified data type
* @param[in] comment - Additional comments (optional)
* @param[in] alignment - Alignment value (optional)
* @param[in] ddl_elements - Vector of sub elements (optional)
* @param[in] creation_level - Level at creation time (optional)
*/
DDLComplex(const std::string& name,
unsigned int const version,
const std::string& comment = a_util::strings::empty_string,
DDLAlignment::AlignmentType const alignment = DDLAlignment::e1,
DDLElementVec ddl_elements = DDLElementVec(),
int const creation_level = 1,
DDLVersion language_version = DDLVersion::getDefaultVersion());
/**
* Copy CTOR
* @param[in] other - Reference to complex datatype object to copy
*/
DDLComplex(const DDLComplex &other);
/**
* Assignment operator (either copies or moves)
* @param[in] other Complex DDL type to copy from
* @return @c *this
*/
DDLComplex& operator=(DDLComplex other);
/**
* Move CTOR
* @param[in,out] other Complex DDL type to move from - empty but valid when finished
*/
DDLComplex(DDLComplex&& other);
/**
* DTOR
*/
virtual ~DDLComplex();
a_util::result::Result accept(IDDLVisitor *visitor) const;
a_util::result::Result accept(IDDLChangeVisitor *visitor);
const std::string& getName() const;
/**
* Setter for the name of the complex datatype.
* @param [in] name - Name of the complex datatype
*
* @return void
*/
void setName(const std::string& name );
bool isInitialized() const;
bool isPredefined() const;
bool isOverwriteable() const;
int getCreationLevel() const;
/**
* Creation method to fill the object with data.
* @param[in] name - Name of the data type
* @param[in] version - Version number of the specified data type
* @param[in] comment - Additional comments (optional)
* @param[in] alignment - Alignment value (optional)
* @param[in] ddl_elements - Vector of sub elements (optional)
* @param[in] creation_level - Level at creation time (optional)
* @retval ERR_INVALID_ARG Empty name committed
*/
a_util::result::Result create(const std::string& name,
unsigned int const version,
const std::string& comment = a_util::strings::empty_string,
DDLAlignment::AlignmentType const alignment = DDLAlignment::e1,
DDLElementVec ddl_elements = DDLElementVec(),
int const creation_level = 1);
/**
* Getter for the version.
* @return the version
*/
unsigned int getVersion() const;
/**
* Setter for the version.
* @param version the version to set
*
* @return void
*/
void setVersion(unsigned int const version);
/**
* Getter for the DDL version.
* @return the DDL version
*/
DDLVersion getDDLVersion() const;
/**
* Setter for the DDL version.
* @param language_version the DDL version to set
* @return Standard result code.
* @retval a_util::result::SUCCESS
*/
a_util::result::Result setDDLVersion(const DDLVersion& language_version);
/**
* Setter for the comment.
* @param[in] comment - Additional comments
*
* @return void
*/
void setComment(const std::string& comment);
/**
* Getter for the comment.
* @return the comment
*/
std::string getComment() const;
/**
* Setter for the alignment.
* @param[in] alignment - Alignment value
*
* @return void
*/
void setAlignment(DDLAlignment::AlignmentType const alignment);
/**
* Setter for the element vector.
* @param[in] ddl_elements - Vector of elements
*
* @return void
*/
void cloneElements(DDLElementVec ddl_elements);
/**
* Setter for the element vector.
* @param[in] ddl_elements - Vector of elements
*
* @return void
*/
void setElements(DDLElementVec ddl_elements);
/**
* Adder for an element.
* @param[in] element - Pointer to the element to add
* @param[in] pos - Position to add the element
*
* @return void
*/
void addElement(DDLElement* element, int pos = -1);
/**
* removal for an element.
* @param[in] element_name - name of the element to remove
* @retval ERR_NOT_FOUND if not found
*/
a_util::result::Result removeElement(const std::string& element_name);
/**
* Getter for the elements.
* @return vector of the elements
*/
const DDLElementVec& getElements() const;
/**
* Getter for the elements.
* @return vector of the elements
*/
DDLElementVec& getElements();
/**
* Getter for the boolean identifying dynamic elements.
* *Note*: this function is not recursive, so to identify structures containing
* structures with dynamic elements, you have to do the recursion yourself.
* @return true if dynamic elements were found
*/
bool hasDynamicElements();
/**
* Getter for the alignment of the complex datatype.
* @return the alignment
*/
DDLAlignment::AlignmentType getAlignment() const;
bool isComplex() const
{
return true;
}
/**
* Add swap functionality, also enabling the copy-swap-idiom
* @param[in,out] lhs Left-hand side ddl type
* @param[in,out] rhs Right-hand side ddl type
*/
friend void swap(DDLComplex& lhs, DDLComplex& rhs) noexcept;
private:
/// The DDL Version this structure was created in
DDLVersion _language_version;
std::string _name;
unsigned int _version;
std::string _comment;
DDLAlignment::AlignmentType _alignment;
DDLElementVec _ddl_elements;
bool _init_flag;
int _level;
bool _dynamic_elements;
};
} // namespace ddl
#endif // _COMPLEX_H_INCLUDED_

445
ddlrepresentation/ddlcontainer.cpp Normal file
View file

@ -0,0 +1,445 @@
/**
* @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 "ddlcontainer.h"
#include "ddl_type.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"
namespace ddl
{
template <typename T>
struct LessCompare
{
bool operator()(const T* obj1, const T* obj2)
{
return obj1->getName() < obj2->getName();
}
bool operator()(const T* obj, const std::string& name)
{
return obj->getName() < name;
}
bool operator()(const std::string& name, const T* obj)
{
return name < obj->getName();
}
};
template <typename T>
DDLContainerNoClone<T>::DDLContainerNoClone(bool sorted): _sorted(sorted)
{
}
template <typename T>
void DDLContainerNoClone<T>::insert(T* elem, int pos)
{
if (_sorted)
{
_pointers.insert(std::lower_bound(_pointers.begin(), _pointers.end(), elem, LessCompare<T>()), elem);
}
else
{
const typename std::vector<T*>::size_type sz_pos =
static_cast<typename std::vector<T*>::size_type>(pos);
if (0 <= sz_pos && sz_pos < _pointers.size())
{
_pointers.insert(_pointers.begin() + sz_pos, elem);
}
else
{
_pointers.push_back(elem);
}
}
}
template <typename T>
typename DDLContainerNoClone<T>::iterator DDLContainerNoClone<T>::findIt(const std::string& name)
{
if (_sorted)
{
iterator it = std::lower_bound(this->begin(), this->end(), name, LessCompare<T>());
if (this->end() == it || name != (*it)->getName())
{
// not found
return this->end();
}
return it;
}
else
{
iterator it = std::find_if(this->begin(), this->end(), DDLCompareFunctor<>(name));
if (this->end() == it)
{
// not found
return this->end();
}
return it;
}
}
template <typename T>
const T* DDLContainerNoClone<T>::find(const std::string& name) const
{
if (_sorted)
{
return find_sorted(name);
}
return find_unsorted(name);
}
template <typename T>
T* DDLContainerNoClone<T>::find(const std::string& name)
{
if (_sorted)
{
return find_sorted(name);
}
return find_unsorted(name);
}
template <typename T>
const T* DDLContainerNoClone<T>::find_unsorted(const std::string& name) const
{
const_iterator it = std::find_if(this->begin(), this->end(), DDLCompareFunctor<>(name));
if (this->end() == it)
{
// not found
return NULL;
}
return *it;
}
template <typename T>
const T* DDLContainerNoClone<T>::find_sorted(const std::string& name) const
{
const_iterator it = std::lower_bound(this->begin(), this->end(), name, LessCompare<T>());
if (this->end() == it || name != (*it)->getName())
{
// not found
return find_unsorted(name);
}
return *it;
}
template <typename T>
T* DDLContainerNoClone<T>::find_unsorted(const std::string& name)
{
iterator it = std::find_if(this->begin(), this->end(), DDLCompareFunctor<>(name));
if (end() == it)
{
// not found
return NULL;
}
return *it;
}
template <typename T>
T* DDLContainerNoClone<T>::find_sorted(const std::string& name)
{
iterator it = std::lower_bound(this->begin(), this->end(), name, LessCompare<T>());
if (end() == it || name != (*it)->getName())
{
// not found
auto obj = find_unsorted(name);
if (obj != nullptr)
{
sort();
}
return obj;
}
return *it;
}
template <typename T>
void DDLContainerNoClone<T>::copyFromRef(DDLContainerNoClone& other)
{
_pointers.resize(other.size());
std::copy(other.begin(), other.end(), _pointers.begin());
if (_sorted && !other._sorted)
{
sort();
}
}
template <typename T>
void DDLContainerNoClone<T>::deleteAll()
{
for (iterator it = begin(); it != end(); ++it)
{
DDL::deleteChild<T>(*it);
}
clear();
}
template <typename T>
void DDLContainerNoClone<T>::sort()
{
std::sort(_pointers.begin(), _pointers.end(), LessCompare<T>());
}
template <typename T>
bool DDLContainerNoClone<T>::isSorted() const
{
return _sorted;
}
// Note on our iterators:
// we do not want to expose the std::vector and std::vector::iterator implementation to the user
// so we use the simplest kind of iterator, a pointer.
template <typename T>
typename DDLContainerNoClone<T>::iterator DDLContainerNoClone<T>::begin()
{
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
// have a look at http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464 and
// http://stackoverflow.com/questions/3829788/using-operator-on-empty-stdvector
// to find out the reason for this special implementation (VS2008 and lower)
if (_pointers.empty())
{
return &_empty_dummy;
}
else
{
return &*_pointers.begin();
}
#else
return &*_pointers.begin();
#endif
}
template <typename T>
typename DDLContainerNoClone<T>::const_iterator DDLContainerNoClone<T>::begin() const
{
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
// have a look at http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464 and
// http://stackoverflow.com/questions/3829788/using-operator-on-empty-stdvector
// to find out the reason for this special implementation (VS2008 and lower)
if (_pointers.empty())
{
return &_empty_dummy;
}
else
{
return &*_pointers.begin();
}
#else
return &*_pointers.begin();
#endif
}
template <typename T>
typename DDLContainerNoClone<T>::iterator DDLContainerNoClone<T>::end()
{
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
// have a look at http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464 and
// http://stackoverflow.com/questions/3829788/using-operator-on-empty-stdvector
// to find out the reason for this special implementation (VS2008 and lower)
if (_pointers.empty())
{
return &_empty_dummy;
}
else
{
return &*_pointers.begin() + _pointers.size();
}
#else
return &*_pointers.end();
#endif
}
template <typename T>
typename DDLContainerNoClone<T>::const_iterator DDLContainerNoClone<T>::end() const
{
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
// have a look at http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464 and
// http://stackoverflow.com/questions/3829788/using-operator-on-empty-stdvector
// to find out the reason for this special implementation (VS2008 and lower)
if (_pointers.empty())
{
return &_empty_dummy;
}
else
{
return &*_pointers.begin() + _pointers.size();
}
#else
return &*_pointers.end();
#endif
}
template <typename T>
void DDLContainerNoClone<T>::clear()
{
_pointers.clear();
}
template <typename T>
typename DDLContainerNoClone<T>::iterator DDLContainerNoClone<T>::erase(iterator it)
{
typename std::vector<T*>::iterator it_helper = _pointers.erase(_pointers.begin() + (it - begin()));
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
// have a look at http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464 and
// http://stackoverflow.com/questions/3829788/using-operator-on-empty-stdvector
// to find out the reason for this special implementation (VS2008 and lower)
if (it_helper == _pointers.end())
{
return &_empty_dummy;
}
else
{
return &*it_helper;
}
#else
return &*it_helper;
#endif
}
template <typename T>
typename DDLContainerNoClone<T>::iterator DDLContainerNoClone<T>::erase(iterator pos_first, iterator pos_last)
{
if (pos_first == pos_last)
{
return end();
}
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
// have a look at http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#464 and
// http://stackoverflow.com/questions/3829788/using-operator-on-empty-stdvector
// to find out the reason for this special implementation (VS2008 and lower)
// another bug in MSVS Debug http://connect.microsoft.com/VisualStudio/feedback/details/557029/visual-c-iterator-debugging-incorrectly-raises-assertion-on-correct-use-of-return-value-of-std-vector-erase
// prevents us from using the erase(start, end) version.
typename std::vector<T*>::iterator it_helper = _pointers.begin() + (pos_first - begin());
for (uint64_t nCount = pos_last - pos_first; nCount > 0; --nCount)
{
it_helper = _pointers.erase(it_helper);
}
if (it_helper == _pointers.end())
{
return &_empty_dummy;
}
else
{
return &*it_helper;
}
#else
typename std::vector<T*>::iterator it_helper = _pointers.erase(_pointers.begin() + (pos_first - begin()),
_pointers.begin() + (pos_last - begin()));
return &*it_helper;
#endif
}
template <typename T>
bool DDLContainerNoClone<T>::empty() const
{
return _pointers.empty();
}
template <typename T>
unsigned int DDLContainerNoClone<T>::size() const
{
return static_cast<unsigned int>(_pointers.size());
}
template <typename T>
T*& DDLContainerNoClone<T>::operator[] (unsigned int pos)
{
return _pointers[pos];
}
template <typename T>
T* const& DDLContainerNoClone<T>::operator[] (unsigned int pos) const
{
return _pointers[pos];
}
template <typename T>
T*& DDLContainerNoClone<T>::at(unsigned int pos)
{
return _pointers.at(pos);
}
template <typename T>
T* const& DDLContainerNoClone<T>::at(unsigned int pos) const
{
return _pointers.at(pos);
}
template <typename T>
DDLContainer<T>::DDLContainer(bool sorted): DDLContainerNoClone<T>(sorted)
{
}
template <typename T>
void DDLContainer<T>::cloneFrom(const DDLContainer& other)
{
this->clear();
for (typename DDLContainer::const_iterator it = other.begin(); it != other.end(); ++it)
{
this->insert(DDL::clone<T>(*it));
}
}
template class DDLContainerNoClone<IDDL>;
template class DDLContainerNoClone<DDLUnit>;
template class DDLContainerNoClone<DDLBaseunit>;
template class DDLContainerNoClone<DDLPrefix>;
template class DDLContainerNoClone<DDLDataType>;
template class DDLContainerNoClone<DDLEnum>;
template class DDLContainerNoClone<DDLComplex>;
template class DDLContainerNoClone<DDLStream>;
template class DDLContainerNoClone<DDLStreamMetaType>;
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
IDDL* DDLContainerNoClone<IDDL>::_empty_dummy = NULL;
DDLUnit* DDLContainerNoClone<DDLUnit>::_empty_dummy = NULL;
DDLBaseunit* DDLContainerNoClone<DDLBaseunit>::_empty_dummy = NULL;
DDLPrefix* DDLContainerNoClone<DDLPrefix>::_empty_dummy = NULL;
DDLDataType* DDLContainerNoClone<DDLDataType>::_empty_dummy = NULL;
DDLEnum* DDLContainerNoClone<DDLEnum>::_empty_dummy = NULL;
DDLComplex* DDLContainerNoClone<DDLComplex>::_empty_dummy = NULL;
DDLStream* DDLContainerNoClone<DDLStream>::_empty_dummy = NULL;
DDLStreamMetaType* DDLContainerNoClone<DDLStreamMetaType>::_empty_dummy = NULL;
#endif
template class DDLContainer<DDLUnit>;
template class DDLContainer<DDLBaseunit>;
template class DDLContainer<DDLPrefix>;
template class DDLContainer<DDLDataType>;
template class DDLContainer<DDLEnum>;
template class DDLContainer<DDLComplex>;
template class DDLContainer<DDLStream>;
template class DDLContainer<DDLStreamMetaType>;
}

335
ddlrepresentation/ddlcontainer.h Normal file
View file

@ -0,0 +1,335 @@
/**
* @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
*/
#ifndef DDL_CONTAINER_H_INCLUDED
#define DDL_CONTAINER_H_INCLUDED
#include "ddl_common.h"
#include "ddl_intf.h"
namespace ddl
{
class DDLUnit;
class DDLBaseunit;
class DDLPrefix;
class DDLDataType;
class DDLEnum;
class DDLComplex;
class DDLStream;
class DDLStreamMetaType;
/**
* Utility class that stores DDL entities
*/
template <typename T>
class DDLContainerNoClone
{
private:
std::vector<T*> _pointers;
bool _sorted;
#if defined(WIN32) && ((_MSC_VER < 1600) || defined(_DEBUG))
static T* _empty_dummy;
#endif
public:
///iterator for DDL container
typedef T** iterator; // NOLINT
///const iterator for DDL container
typedef T* const * const_iterator; // NOLINT
public:
/**
* Constructor
* @param [in] sorted whether the items should be sorted by name (this improves access times)
*/
DDLContainerNoClone(bool sorted = true);
/**
* @brief insert
* @param [in] elem The element to insert.
* @param [in] pos Position to add the element
* @return void
*/
void insert(T* elem, int pos = -1);
/**
* Finds an element by name
* @param [in] name
* @return pointer to the element or NULL
*/
T* find(const std::string& name);
/**
* Finds an element by name
* @param [in] name
* @return iterator to the element or end()
*/
iterator findIt(const std::string& name);
/**
* Finds an element by name
* @param [in] name
* @return pointer to the element or NULL
*/
const T* find(const std::string& name) const;
/**
* Copies the pointers from the other container.
* @param [in] other Thge other container
* @return void
*/
void copyFromRef(DDLContainerNoClone &other);
/**
* Deletes all stored items (by calling delete on the pointers)
*/
void deleteAll();
/**
* sort the items by name.
*/
void sort();
/**
* Returns Whether or not the container is sorted by name or not.
* @return whether or not the container is sorted by name or not.
*/
bool isSorted() const;
/**
* Returns an iterator to the first element.
* @return an iterator to the first element.
*/
iterator begin();
/**
* Returns an iterator to the first element.
* @return an iterator to the first element.
*/
const_iterator begin() const;
/**
* Returns an iterator to the element after the last element.
* @return an iterator to the element after the last element.
*/
iterator end();
/**
* Returns an iterator to the element after the last element.
* @return an iterator to the element after the last element.
*/
const_iterator end() const;
/**
* clears the container (does not destroy the elements)
*/
void clear();
/**
* removes an element from the container
* @param [in] pos The element which should be removed.
* @return iterator to the element after the erased element.
*/
iterator erase(iterator pos);
/**
* @brief removes a sequence of elements from the container
* @param pos_first the first element to erase.
* @param pos_last the first one that should not be erased.
* @return iterator to the element after the erased elements.
*/
iterator erase(iterator pos_first, iterator pos_last);
/**
* Returns whether the container is empty or not.
* @return whether the container is empty or not.
*/
bool empty() const;
/**
* Returns the size of the container.
* @return the size of the container.
*/
unsigned int size() const; // for compatibility reasons
/**
* random access operator.
* @param [in] pos The index of the element.
* @return The element.
*/
T*& operator[] (unsigned int pos);
/**
* random access operator.
* @param [in] pos The index of the element.
* @return The element.
*/
T* const& operator[] (unsigned int pos) const;
/**
* random access method.
* @param [in] pos The index of the element.
* @return The element.
*/
T*& at(unsigned int pos);
/**
* random access method.
* @param [in] pos The index of the element.
* @return The element.
*/
T* const& at(unsigned int pos) const;
private:
/**
* Finds an sorted element by name
* @param [in] name
* @return pointer to the element or NULL
*/
T* find_sorted(const std::string& name);
/**
* Finds an sorted element by name
* @param [in] name
* @return pointer to the element or NULL
*/
const T* find_sorted(const std::string& name) const;
/**
* Finds an unsorted element by name
* @param [in] name
* @return pointer to the element or NULL
*/
T* find_unsorted(const std::string& name);
/**
* Finds an unsorted element by name
* @param [in] name
* @return pointer to the element or NULL
*/
const T* find_unsorted(const std::string& name) const;
};
/**
* Utility class to store DDL elements that can be cloned.
*/
template <typename T>
class DDLContainer: public DDLContainerNoClone<T>
{
public:
/**
* Constructor
* @param [in] sorted Whether the container shall be sorted by name or not.
*/
DDLContainer(bool sorted = true);
/**
* Clones all elements of a given container.
* @param [in] other the container that should be cloned.
* @return void
*/
void cloneFrom(const DDLContainer& other);
};
/**
* Container type of basic DDL objects
*/
typedef DDLContainerNoClone<IDDL> DDLVec;
/**
* Container type of DDLUnit objects
*/
typedef DDLContainer<DDLUnit> DDLUnitVec;
/**
* Container type of DDLBaseunit objects
*/
typedef DDLContainer<DDLBaseunit> DDLBaseunitVec;
/**
* Container type of DDLPrefix objects
*/
typedef DDLContainer<DDLPrefix> DDLPrefixVec;
/**
* Container type of DDLDataType objects
*/
typedef DDLContainer<DDLDataType> DDLDTVec;
/**
* Container type of DDLEnum objects
*/
typedef DDLContainer<DDLEnum> DDLEnumVec;
/**
* Container type of DDLComplex objects
*/
typedef DDLContainer<DDLComplex> DDLComplexVec;
/**
* Container type of DDLStream objects
*/
typedef DDLContainer<DDLStream> DDLStreamVec;
/**
* Container type of DDLStreamMetaType objects
*/
typedef DDLContainer<DDLStreamMetaType> DDLStreamMetaTypeVec;
/**
* Iterator type for DDLUnitVec
*/
typedef DDLUnitVec::iterator DDLUnitIt;
/**
* Iterator type for DDLBaseunitVec
*/
typedef DDLBaseunitVec::iterator DDLBaseunitIt;
/**
* Iterator type for DDLPrefixVec
*/
typedef DDLPrefixVec::iterator DDLPrefixIt;
/**
* Iterator type for DDLDTVec
*/
typedef DDLDTVec::iterator DDLDTIt;
/**
* Iterator type for tDDLConstVec
*/
typedef DDLEnumVec::iterator DDLEnumIt;
/**
* Iterator type for DDLComplexVec
*/
typedef DDLComplexVec::iterator DDLComplexIt;
/**
* Iterator type for DDLStreamVec
*/
typedef DDLStreamVec::iterator DDLStreamIt;
/**
* Associative container type for DDLStream objects
*/
typedef std::map<std::string, DDLStream*> DDLStreamMap;
/**
* Iterator type for DDLStreamMap
*/
typedef DDLStreamMap::iterator DDLStreamMapIt;
}
#endif

300
ddlrepresentation/ddldatatype.cpp Normal file
View file

@ -0,0 +1,300 @@
/**
* @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 "ddldatatype.h"
namespace ddl
{
//define all needed error types and values locally
_MAKE_RESULT(-4, ERR_POINTER)
DDLDataType::DDLDataType() :
_language_version{DDLVersion::ddl_version_invalid},
_name{},
_num_bits{},
_byte_size{},
_aligned_size{},
_unit{},
_description{},
_array_size{},
_array_size_source{},
_alignment{},
_init_flag{},
_level{1},
_min_valid{},
_min_val{},
_max_valid{},
_max_val{},
_default_valid{},
_default_val{}
{
}
DDLDataType::DDLDataType(const std::string& name,
unsigned int const num_bits,
IDDLUnit* unit,
const std::string& description,
DDLAlignment::AlignmentType const alignment,
unsigned int const array_size,
int const creation_level,
const std::string& array_size_source,
bool const min_valid,
const std::string& min_value,
bool const max_valid,
const std::string& max_value) :
_language_version(DDLVersion::ddl_version_invalid),
_name(name),
_num_bits(num_bits),
_unit(unit),
_description(description),
_array_size(array_size),
_array_size_source(array_size_source),
_alignment(alignment),
_init_flag(true),
_level(creation_level),
_min_valid(min_valid),
_min_val(min_value),
_max_valid(max_valid),
_max_val(max_value)
{
}
a_util::result::Result DDLDataType::accept(IDDLVisitor *visitor) const
{
return visitor->visit(this);
}
a_util::result::Result DDLDataType::accept(IDDLChangeVisitor *visitor)
{
return visitor->visit(this);
}
const std::string& DDLDataType::getName() const
{
return _name;
}
void DDLDataType::setName(const std::string& name)
{
_name = name;
}
bool DDLDataType::isInitialized() const
{
return _init_flag;
}
int DDLDataType::getCreationLevel() const
{
return _level;
}
a_util::result::Result DDLDataType::create(const std::string& name,
unsigned int const num_bits,
IDDLUnit* unit,
const std::string& description,
DDLAlignment::AlignmentType const alignment,
unsigned int const array_size,
int const creation_level,
const std::string& array_size_source,
bool const min_valid,
const std::string& min_value,
bool const max_valid,
const std::string& max_value)
{
if (!unit) { return ERR_POINTER; }
_name = name;
_num_bits = num_bits;
_unit = unit;
_description = description;
_array_size = array_size;
_init_flag = true;
_level = creation_level;
_alignment = alignment;
_array_size_source = array_size_source;
_language_version = DDLVersion::ddl_version_invalid;
_min_valid = min_valid;
_min_val = min_value;
_max_valid = max_valid;
_max_val = max_value;
return a_util::result::SUCCESS;
}
unsigned int DDLDataType::getNumBits() const
{
return _num_bits;
}
void DDLDataType::setNumBits(unsigned int const num_bits)
{
_num_bits = num_bits;
}
void DDLDataType::setDescription(const std::string& description)
{
_description = description;
}
std::string DDLDataType::getDescription() const
{
return _description;
}
void DDLDataType::setArraysize(unsigned int const array_size)
{
if (array_size > 0)
{
_array_size = array_size;
}
}
unsigned int DDLDataType::getArraysize() const
{
return _array_size;
}
void DDLDataType::setUnit(IDDLUnit* unit)
{
_unit = unit;
}
std::string DDLDataType::getUnit() const
{
if (NULL == _unit)
{
return a_util::strings::empty_string;
}
return _unit->getName();
}
const IDDLUnit* DDLDataType::getUnitObject() const
{
if (!_init_flag)
{
return NULL;
}
return _unit;
}
IDDLUnit* DDLDataType::getUnitObject()
{
if (!_init_flag)
{
return NULL;
}
return _unit;
}
bool DDLDataType::isPredefined() const
{
return _level == -1; // cMediaManager::DL_AlwaysThere
}
bool DDLDataType::isOverwriteable() const
{
return _level > 0;
}
void DDLDataType::setAlignment(DDLAlignment::AlignmentType const alignment)
{
_alignment = alignment;
}
DDLAlignment::AlignmentType DDLDataType::getAlignment() const
{
return _alignment;
}
std::string DDLDataType::getArraySizeSource() const
{
return _array_size_source;
}
void DDLDataType::setArraySizeSource( const std::string& array_size_source )
{
_array_size_source = array_size_source;
}
bool DDLDataType::isDynamic() const
{
if (getArraysize() == 0 ||
(!getArraySizeSource().empty() && !a_util::strings::isInt64(getArraySizeSource())))
{
return true;
}
return false;
}
DDLVersion DDLDataType::getDDLVersion() const
{
return _language_version;
}
a_util::result::Result DDLDataType::setDDLVersion(DDLVersion& language_version)
{
_language_version = language_version;
return a_util::result::SUCCESS;
}
const std::string & DDLDataType::getMinValue () const
{
return _min_val;
}
a_util::result::Result DDLDataType::setMinValue (const std::string& min_value)
{
// TODO validate new min value
_min_val = min_value;
return a_util::result::SUCCESS;
}
const std::string & DDLDataType::getMaxValue () const
{
return _max_val;
}
a_util::result::Result DDLDataType::setMaxValue (const std::string& max_value)
{
// TODO validate new max value
_max_val = max_value;
return a_util::result::SUCCESS;
}
void DDLDataType::setMinValidity (bool const min_valid)
{
_min_valid = min_valid;
}
bool DDLDataType::isMinValid () const
{
return _min_valid;
}
void DDLDataType::setMaxValidity (bool const max_valid)
{
_max_valid = max_valid;
}
bool DDLDataType::isMaxValid () const
{
return _max_valid;
}
} // namespace ddl

330
ddlrepresentation/ddldatatype.h Normal file
View file

@ -0,0 +1,330 @@
/**
* @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
*/
#ifndef DDLDATATYPE_H_INCLUDED
#define DDLDATATYPE_H_INCLUDED
#include "ddl_common.h"
#include "ddldatatype_intf.h"
#include "ddlvisitor_intf.h"
#include "ddlunit_intf.h"
#include "ddlalignment.h"
#include "ddlversion.h"
namespace ddl
{
/**
* Representation for a (simple) data type inside a DDL description.
*/
class DDLDataType : public IDDLDataType
{
public:
/**
* Default CTOR
*/
DDLDataType();
/**
* CTOR
* @param[in] name - Name of the primitive data type
* @param[in] size - Size in bit
* @param[in] unit - Pointer to the unit of the data type (optional)
* @param[in] description - Description of the primitive data type (optional)
* @param[in] alignment - Alignment of the primitive data type (optional)
* @param[in] array_size - Array size of the primitive data type (optional)
* @param[in] creation_level - Level at creation time (optional)
* @param[in] array_size_source - Name of the element that represents
* the arrays size (optional)
* @param [in] min_valid - Validity flag for the minimum value (optional)
* @param[in] min_val - Minimum value of the data type (optional)
* @param [in] max_valid - Validity flag for the maximum value (optional)
* @param[in] max_val - Maximum value of the data type (optional)
*/
DDLDataType(const std::string& name,
unsigned int const size,
IDDLUnit* unit = NULL,
const std::string& description = a_util::strings::empty_string,
DDLAlignment::AlignmentType const alignment = DDLAlignment::e1,
unsigned int const array_size = 1,
int const creation_level = 1,
const std::string& array_size_source = a_util::strings::empty_string,
bool const min_valid = false,
const std::string& min_val = a_util::strings::empty_string,
bool const max_valid = false,
const std::string& max_val = a_util::strings::empty_string);
a_util::result::Result accept(IDDLVisitor *visitor) const;
a_util::result::Result accept(IDDLChangeVisitor *visitor);
bool isPredefined() const;
bool isOverwriteable() const;
const std::string& getName() const;
/**
* Setter for the name of the data type.
* @param [in] name Name of the data type
*
* @return void
*/
void setName(const std::string& name);
int getCreationLevel() const;
bool isInitialized() const;
/**
* Creation method to fill the object with data.
* @param[in] name - Name of the primitive data type
* @param[in] size - Size in bit
* @param[in] unit - Pointer to the unit of the data type
* @param[in] description - Description of the primitive data type (optional)
* @param[in] alignment - Alignment of the primitive data type (optional)
* @param[in] array_size - Array size of the primitive data type (optional)
* @param[in] creation_level - Level at creation time (optional)
* @param[in] array_size_source - Name of the element that represents the arrays size
* @param [in] min_valid - Validity flag for the minimum value (optional)
* @param[in] min_val - Minimum value of the data type (optional)
* @param [in] max_valid - Validity flag for the maximum value (optional)
* @param[in] max_val - Maximum value of the data type (optional)
* @retval ERR_POINTER Null-pointer committed
*/
a_util::result::Result create(const std::string& name,
unsigned int const size,
IDDLUnit* unit = NULL,
const std::string& description = a_util::strings::empty_string,
DDLAlignment::AlignmentType const alignment = DDLAlignment::e1,
unsigned int const array_size = 1,
int const creation_level = 1,
const std::string& array_size_source = a_util::strings::empty_string,
bool const min_valid = false,
const std::string& min_val = a_util::strings::empty_string,
bool const max_valid = false,
const std::string& max_val = a_util::strings::empty_string);
/**
* Setter for the description.
* @param[in] description - Description of the primitive data type
*
* @return void
*/
void setDescription(const std::string& description);
/**
* Getter for the description.
* @return the description
*/
std::string getDescription() const;
/**
* Setter for the array size.
* @param[in] array_size - Array size of the data type<br>
* = 1 -> primitve presentation<br>\> 1 -> array with the amount of elements
*
* @return void
*/
void setArraysize(unsigned int const array_size);
/**
* Getter for the array size.
* @return the array size
*/
unsigned int getArraysize() const;
/**
* Setter for the unit.
* @param[in] unit - Pointer to the unit object of the data type
*
* @return void
*/
void setUnit(IDDLUnit* unit);
/**
* Getter for the unit name.
* @return name of the referenced unit (\c a_util::strings::empty_string if there is none)
*/
std::string getUnit() const;
/**
* Getter for the unit object.
* @return pointer to the unit object (\c NULL if there is none)
*/
const IDDLUnit * getUnitObject() const;
/**
* Getter for the unit object.
* @return pointer to the unit object (\c NULL if there is none)
*/
IDDLUnit * getUnitObject();
/**
* Setter for the alignment.
* @param[in] alignment - Alignment value
*
* @return void
*/
void setAlignment(DDLAlignment::AlignmentType const alignment);
/**
* Getter for the alignment of the primitive data type.
* @return the alignment
*/
DDLAlignment::AlignmentType getAlignment() const;
/**
* Getter for the size of the primitive data type.
* @return the size in [bit]
*/
unsigned int getNumBits() const;
/**
* Setter for the size of the primitive data type.
* @param [in] num_bits - Size in [bit]
*
* @return void
*/
void setNumBits(unsigned int const num_bits);
/**
* Getter for the array size source.
* @return the array size source
*/
std::string getArraySizeSource() const;
/**
* Setter for the array size source.
* @param[in] array_size_source - the array size source element
*
* @return void
*/
void setArraySizeSource(const std::string& array_size_source);
/**
* Checks if element is dynamic
* @return true if it is a dynamic array
*/
bool isDynamic() const;
/**
* Getter for the DDL version.
* @return the DDL version
*/
DDLVersion getDDLVersion() const;
/**
* Setter for the DDL version.
* @param language_version the DDL version to set
* @return Standard result code.
* @retval a_util::result::SUCCESS Everything is fine.
*/
a_util::result::Result setDDLVersion(DDLVersion& language_version);
/**
* Setter for the validity flag for the minimum value.
*
* @param [in] min_valid Validity flag for the minimum value.
*
* @return void
*/
void setMinValidity (bool const min_valid);
/**
* Getter for the validity flag for the minimum value.
*
* @return the validity flag for the minimum value
*/
bool isMinValid () const;
/**
* Getter for the minimum value of the data type.
*
* @return the minimum value
*/
const std::string &getMinValue () const;
/**
* Setter for the minimum value of the data type.
*
* @param [in] min_val The new minimum value
*
* @retval a_util::result::SUCCESS Everything went fine.
*/
a_util::result::Result setMinValue (const std::string& min_val);
/**
* Setter for the validity flag for the maximum value.
*
* @param [in] max_valid Validity flag for the maximum value.
*
* @return void
*/
void setMaxValidity (bool const max_valid);
/**
* Getter for the validity flag for the maximum value.
*
* @return the validity flag for the maximum value
*/
bool isMaxValid () const;
/**
* Getter for the maximum value of the data type.
*
* @return the maximum value
*/
const std::string &getMaxValue () const;
/**
* Setter for the maximum value of the data type.
*
* @param [in] max_val The new maximum value
*
* @retval a_util::result::SUCCESS Everything went fine.
*/
a_util::result::Result setMaxValue (const std::string& max_val);
private: // members
/// The DDL Version this structure was created in
DDLVersion _language_version;
std::string _name;
unsigned int _num_bits;
size_t _byte_size;
size_t _aligned_size;
IDDLUnit* _unit;
std::string _description;
unsigned int _array_size;
std::string _array_size_source;
DDLAlignment::AlignmentType _alignment;
bool _init_flag;
int _level;
bool _min_valid;
std::string _min_val;
bool _max_valid;
std::string _max_val;
bool _default_valid;
std::string _default_val;
};
} // namespace ddl
#endif // DDLDATATYPE_H_INCLUDED

45
ddlrepresentation/ddldatatype_intf.h Normal file
View file

@ -0,0 +1,45 @@
/**
* @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
*/
#ifndef DDLDATATYPE_INTF_H_INCLUDED
#define DDLDATATYPE_INTF_H_INCLUDED
#include "ddl_common.h"
#include "ddl_intf.h"
namespace ddl
{
class DDLAlignment;
/**
* Common interface for DDL datatypes.
*/
class IDDLDataType : public IDDL
{
public:
/**
* Virtual DTOR
*/
virtual ~IDDLDataType(){}
};
} // namespace ddl
#endif // _DATATYPE_INTF_H_INCLUDED_

1613
ddlrepresentation/ddldescription.cpp Normal file
View file

File diff suppressed because it is too large Load diff

Some files were not shown because too many files have changed in this diff Show more