diff options
80 files changed, 3588 insertions, 1229 deletions
diff --git a/.travis.yml b/.travis.yml index 96a10bc..48c84b7 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,8 +8,7 @@ env: compiler: - gcc - # clang not supported yet - # - clang + - clang # Install a recent gcc and gcov, # it will not be necessary once travis worker is based on ubuntu > 12.04. @@ -1,5 +1,5 @@ # Recursive call sub-folder Android.mk # -ifeq ($(HOST_OS),linux) + include $(call all-subdir-makefiles) -endif + diff --git a/CMakeLists.txt b/CMakeLists.txt index 6bf533c..66602d7 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -36,6 +36,11 @@ endif(COMMAND cmake_policy) project(parameter-framework) +# find and set the Parameter Framework's version +execute_process(COMMAND git describe --tags --dirty + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + OUTPUT_VARIABLE PARAMETER_FRAMEWORK_VERSION OUTPUT_STRIP_TRAILING_WHITESPACE) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wall -Wextra") set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) @@ -67,3 +72,5 @@ add_subdirectory(tools/xmlGenerator) add_subdirectory(tools/xmlValidator) add_subdirectory(bindings) + +add_subdirectory(doc) diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt index 36b6aa9..3f00434 100644 --- a/bindings/c/CMakeLists.txt +++ b/bindings/c/CMakeLists.txt @@ -48,6 +48,7 @@ if(BUILD_TESTING) # copy it in a standard location (/usr/include on most linux distribution). find_path(CATCH_HEADER catch.hpp) include_directories(${CATCH_HEADER}) + include_directories("${PROJECT_SOURCE_DIR}/utility") # Add unit test add_executable(cparameterUnitTest Test.cpp) @@ -57,7 +58,7 @@ if(BUILD_TESTING) # proper failure. set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-nonnull") - target_link_libraries(cparameterUnitTest cparameter) + target_link_libraries(cparameterUnitTest cparameter pfw_utility) add_test(NAME cparameterUnitTest COMMAND cparameterUnitTest) diff --git a/bindings/c/Test.cpp b/bindings/c/Test.cpp index c450e60..8cbaa90 100644 --- a/bindings/c/Test.cpp +++ b/bindings/c/Test.cpp @@ -29,6 +29,7 @@ */ #include "ParameterFramework.h" +#include "FullIo.hpp" #define CATCH_CONFIG_MAIN // This tells Catch to provide a main() #include <catch.hpp> @@ -84,7 +85,7 @@ struct Test CAPTURE(errno); REQUIRE(mFd != -1); mPath = tmpName; - write(mFd, content.c_str(), content.length()); + REQUIRE(utility::fullWrite(mFd, content.c_str(), content.length())); } ~TmpFile() { CHECK(close(mFd) != -1); diff --git a/bindings/python/Android.mk b/bindings/python/Android.mk index fa5b7b8..b4b6277 100644 --- a/bindings/python/Android.mk +++ b/bindings/python/Android.mk @@ -38,26 +38,25 @@ include $(CLEAR_VARS) LOCAL_MODULE := _PyPfw LOCAL_CPP_EXTENSION := .cxx -# As long as the parameter-framework is compiled with gcc, we must avoid -# compiling the bindings with clang and compile with gcc instead. -LOCAL_CLANG := false # Android only provides a 32bit version of python. LOCAL_32_BIT_ONLY := true -LOCAL_SHARED_LIBRARIES := libparameter_host -LOCAL_STATIC_LIBRARIES := libxmlserializer_host +LOCAL_SHARED_LIBRARIES := libxmlserializer_host libparameter_host + +# python is only available in 32bits for now, thus arch is forced to 32bits +PYTHON_INSTALL_PATH := prebuilts/python/$(HOST_OS)-x86/2.7.5/ +PYTHON_INCLUDES_PATH := $(PYTHON_INSTALL_PATH)/include/python2.7 +PYTHON_BIN_PATH := $(PYTHON_INSTALL_PATH)/bin LOCAL_C_INCLUDES := \ - prebuilts/python/$(HOST_PREBUILT_TAG)/2.7.5/include/python2.7 \ + $(PYTHON_INCLUDES_PATH) \ $(HOST_OUT_HEADERS)/parameter -# The 'unused-but-set-variable' warning must be disabled because SWIG generates -# files that do not respect that constraint. # '-DSWIG_PYTHON_SILENT_MEMLEAK' is needed because the "memleak" warning # pollutes the standard output. At the time of writing, the only warning is # spurious anyway, as it relates to "ILogger *" which is an abstract # class/interface class and as such cannot be destroyed. -LOCAL_CFLAGS := -Wno-unused-but-set-variable -fexceptions -DSWIG_PYTHON_SILENT_MEMLEAK +LOCAL_CFLAGS := -fexceptions -DSWIG_PYTHON_SILENT_MEMLEAK # Undefined symbols will be resolved at runtime LOCAL_ALLOW_UNDEFINED_SYMBOLS := true @@ -74,6 +73,26 @@ LOCAL_GENERATED_SOURCES := $(generated-sources-dir)/pfw_wrap.cxx $(generated-sou LOCAL_EXPORT_C_INCLUDE_DIRS := $(generated-sources-dir) +# Get the interpreter ld options. +ifeq ($(HOST_OS), darwin) + # Contrary to linux, on darwin, a python 64 bit executable is installed + # in the x86 prebuild directory, + # As all host libraries are 32 bit in android. We can not link and host + # python module against the prebuild python library. + # + # As a *dirty* workaround, use the system's python configuration and hope + # it will be compatible with the prebuild python interpreter used at runtime. + # To summarize the prebuild python (64 bit?) interpreter will load a + # python native module (32bit) linked with the host (32 bit ?) python library. + LOCAL_LDLIBS += $(shell python-config --ldflags) +else + # Careful, we need to invoke the android python config not the host's one. + # Unfortunately, the internal install directory of python is hardcoded to a dummy value, + # As a workaround, we need to manually add the correct path to libs to the library list. + LOCAL_LDLIBS += $(shell $(PYTHON_BIN_PATH)/python $(PYTHON_BIN_PATH)/python-config --ldflags) \ + -L $(PYTHON_INSTALL_PATH)/lib/ +endif + $(generated-sources-dir)/pfw_wrap.h: $(generated-sources-dir)/pfw_wrap.cxx # The PyPfw.py file is generated in the directory given by -outdir switch, thus diff --git a/bindings/python/CMakeLists.txt b/bindings/python/CMakeLists.txt index a885feb..5663301 100644 --- a/bindings/python/CMakeLists.txt +++ b/bindings/python/CMakeLists.txt @@ -54,13 +54,13 @@ swig_link_libraries(PyPfw parameter ${PYTHON_LIBRARIES}) # ${CMAKE_CURRENT_BINARY_DIR}. set_property(TARGET _PyPfw PROPERTY LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}) -# The 'unused-but-set-variable' warning must be disabled because SWIG generates -# files that do not respect that contraint. # '-DSWIG_PYTHON_SILENT_MEMLEAK' is needed because the "memleak" warning # pollutes the standard output. At the time of writing, the only warning is # spurious anyway, as it relates to "ILogger *" which is an abstract # class/interface class and as such cannot be destroyed. -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-but-set-variable -DSWIG_PYTHON_SILENT_MEMLEAK") +# -Wno-error is set to prevent compilation failure in case of the code +# generated by swig generates warnings +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSWIG_PYTHON_SILENT_MEMLEAK -Wno-error") # Find the python modules install path. diff --git a/bindings/python/pfw.i b/bindings/python/pfw.i index 2d39228..bf1330b 100644 --- a/bindings/python/pfw.i +++ b/bindings/python/pfw.i @@ -159,6 +159,8 @@ public: std::string& strError); bool importSingleDomainXml(const std::string& strXmlSource, bool bOverwrite, std::string& strError); + bool importSingleDomainXml(const std::string& xmlSource, bool overwrite, bool withSettings, + bool fromFile, std::string& strError); // Tells swig that "strXmlDest" in the two following methods are "inout" // parameters diff --git a/doc/CMakeLists.txt b/doc/CMakeLists.txt new file mode 100644 index 0000000..06804bd --- /dev/null +++ b/doc/CMakeLists.txt @@ -0,0 +1,60 @@ +# Copyright (c) 2015, Intel Corporation +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation and/or +# other materials provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors +# may be used to endorse or promote products derived from this software without +# specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + +option(DOXYGEN + "Enable doxygen generation (you still have to run 'make doc')" + OFF) + +include(CMakeDependentOption) +# Only present DOXYGEN_GRAPHS if DOXYGEN is ON and if so, default to ON. +# Else, set to OFF. +cmake_dependent_option(DOXYGEN_GRAPHS + "Generate graphs in the doxygen documentation (you need the 'dot' + utility)" + ON + "DOXYGEN" OFF) + +if(DOXYGEN) + find_package(Doxygen REQUIRED) + + if(DOXYGEN_GRAPHS AND (NOT DOXYGEN_DOT_FOUND)) + message(SEND_ERROR " + The 'dot' utility was not found;" + " install it or deactivate graph generation (DOXYGEN_GRAPHS=OFF).") + endif() + + configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in + ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile + @ONLY) + add_custom_target(doc + ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Generating documentation with Doxygen" + VERBATIM) +endif() diff --git a/doc/Doxyfile.in b/doc/Doxyfile.in new file mode 100644 index 0000000..34b80a5 --- /dev/null +++ b/doc/Doxyfile.in @@ -0,0 +1,2320 @@ +# Doxyfile 1.8.7 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the config file +# that follow. The default is UTF-8 which is also the encoding used for all text +# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv +# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv +# for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "parameter-framework" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = @PARAMETER_FRAMEWORK_VERSION@ + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = "Plugin-based and rule-based framework for describing and controlling parameters" + +# With the PROJECT_LOGO tag one can specify an logo or icon that is included in +# the documentation. The maximum height of the logo should not exceed 55 pixels +# and the maximum width should not exceed 200 pixels. Doxygen will copy the logo +# to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = doxygen + +# If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = YES + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = YES + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = @PROJECT_SOURCE_DIR@ + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = YES + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = Yes + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a +# new page for each member. If set to NO, the documentation of a member will be +# part of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines. + +ALIASES = + +# This tag can be used to specify a number of word-keyword mappings (TCL only). +# A mapping has the form "name=value". For example adding "class=itcl::class" +# will allow you to use the command class in the itcl::class meaning. + +TCL_SUBST = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, Javascript, +# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: +# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: +# Fortran. In the later case the parser tries to guess whether the code is fixed +# or free formatted code, this is the default for Fortran type files), VHDL. For +# instance to make doxygen treat .inc files as Fortran files (default is PHP), +# and .f files as C (default is Fortran), use: inc=Fortran f=C. +# +# Note For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See http://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by by putting a % sign in front of the word +# or globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = YES + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES, then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = YES + +# If the EXTRACT_PRIVATE tag is set to YES all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PACKAGE tag is set to YES all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = YES + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. When set to YES local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO these classes will be included in the various overviews. This option has +# no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# (class|struct|union) declarations. If set to NO these declarations will be +# included in the documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# and Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = YES + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = YES + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the +# todo list. This list is created by putting \todo commands in the +# documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the +# test list. This list is created by putting \test commands in the +# documentation. +# The default value is: YES. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if <section_label> ... \endif and \cond <section_label> +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES the list +# will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = YES + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. Do not use file names with spaces, bibtex cannot handle them. See +# also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO doxygen will only warn about wrong or incomplete parameter +# documentation, but not about the absence of documentation. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. +# Note: If this tag is empty the current directory is searched. + +INPUT = @PROJECT_SOURCE_DIR@ \ + @PROJECT_SOURCE_DIR@/bindings \ + @PROJECT_SOURCE_DIR@/parameter \ + @PROJECT_SOURCE_DIR@/remote-process \ + @PROJECT_SOURCE_DIR@/remote-processor \ + @PROJECT_SOURCE_DIR@/Schemas + @PROJECT_SOURCE_DIR@/test/test-platform \ + @PROJECT_SOURCE_DIR@/utility \ + @PROJECT_SOURCE_DIR@/xmlserializer \ + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: http://www.gnu.org/software/libiconv) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank the +# following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, +# *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, +# *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, +# *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, +# *.qsf, *.as and *.js. + +FILE_PATTERNS = + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = NO + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# <filter> <input-file> +# +# where <filter> is the value of the INPUT_FILTER tag, and <input-file> is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER ) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = README.md + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = YES + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# function all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES, then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see http://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the config file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = YES + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 4 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- +# defined cascading style sheet that is included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefor more robust against future updates. +# Doxygen will copy the style sheet file to the output directory. For an example +# see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the stylesheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# http://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to NO can help when comparing the output of multiple runs. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = NO + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: http://developer.apple.com/tools/xcode/), introduced with +# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html +# for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler ( hhc.exe). If non-empty +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated ( +# YES) or that it should be included in the master .chm file ( NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated ( +# YES) or a normal table of contents ( NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = NO + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = NO + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# http://www.mathjax.org) which uses client side Javascript for the rendering +# instead of using prerendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from http://www.mathjax.org before deployment. +# The default value is: http://cdn.mathjax.org/mathjax/latest. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = http://www.mathjax.org/mathjax + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use <access key> + S +# (what the <access key> is depends on the OS and browser, but it is typically +# <CTRL>, <ALT>/<option>, or both). Inside the search box use the <cursor down +# key> to jump into the search results window, the results can be navigated +# using the <cursor keys>. Press <Enter> to select an item or <escape> to cancel +# the search. The filter options can be selected when the cursor is inside the +# search box by pressing <Shift>+<cursor down>. Also here use the <cursor keys> +# to select a filter and <Enter> or <escape> to activate or cancel the filter +# option. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +SEARCHENGINE = YES + +# When the SERVER_BASED_SEARCH tag is enabled the search engine will be +# implemented using a web server instead of a web client using Javascript. There +# are two flavors of web server based searching depending on the EXTERNAL_SEARCH +# setting. When disabled, doxygen will generate a PHP script for searching and +# an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing +# and searching needs to be provided by external tools. See the section +# "External Indexing and Searching" for details. +# The default value is: NO. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SERVER_BASED_SEARCH = NO + +# When EXTERNAL_SEARCH tag is enabled doxygen will no longer generate the PHP +# script for searching. Instead the search results are written to an XML file +# which needs to be processed by an external indexer. Doxygen will invoke an +# external search engine pointed to by the SEARCHENGINE_URL option to obtain the +# search results. +# +# Doxygen ships with an example indexer ( doxyindexer) and search engine +# (doxysearch.cgi) which are based on the open source search engine library +# Xapian (see: http://xapian.org/). +# +# See the section "External Indexing and Searching" for details. +# The default value is: NO. +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTERNAL_SEARCH = NO + +# The SEARCHENGINE_URL should point to a search engine hosted by a web server +# which will return the search results when EXTERNAL_SEARCH is enabled. +# +# Doxygen ships with an example indexer ( doxyindexer) and search engine +# (doxysearch.cgi) which are based on the open source search engine library +# Xapian (see: http://xapian.org/). See the section "External Indexing and +# Searching" for details. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SEARCHENGINE_URL = + +# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed +# search data is written to a file for indexing by an external tool. With the +# SEARCHDATA_FILE tag the name of this file can be specified. +# The default file is: searchdata.xml. +# This tag requires that the tag SEARCHENGINE is set to YES. + +SEARCHDATA_FILE = searchdata.xml + +# When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the +# EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is +# useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple +# projects and redirect the results back to the right project. +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTERNAL_SEARCH_ID = + +# The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen +# projects other than the one defined by this configuration file, but that are +# all added to the same external search index. Each project needs to have a +# unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id of +# to a relative location where the documentation can be found. The format is: +# EXTRA_SEARCH_MAPPINGS = tagname1=loc1 tagname2=loc2 ... +# This tag requires that the tag SEARCHENGINE is set to YES. + +EXTRA_SEARCH_MAPPINGS = + +#--------------------------------------------------------------------------- +# Configuration options related to the LaTeX output +#--------------------------------------------------------------------------- + +# If the GENERATE_LATEX tag is set to YES doxygen will generate LaTeX output. +# The default value is: YES. + +GENERATE_LATEX = NO + +# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: latex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_OUTPUT = latex + +# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be +# invoked. +# +# Note that when enabling USE_PDFLATEX this option is only used for generating +# bitmaps for formulas in the HTML output, but not in the Makefile that is +# written to the output directory. +# The default file is: latex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_CMD_NAME = latex + +# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate +# index for LaTeX. +# The default file is: makeindex. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +MAKEINDEX_CMD_NAME = makeindex + +# If the COMPACT_LATEX tag is set to YES doxygen generates more compact LaTeX +# documents. This may be useful for small projects and may help to save some +# trees in general. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +COMPACT_LATEX = NO + +# The PAPER_TYPE tag can be used to set the paper type that is used by the +# printer. +# Possible values are: a4 (210 x 297 mm), letter (8.5 x 11 inches), legal (8.5 x +# 14 inches) and executive (7.25 x 10.5 inches). +# The default value is: a4. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +PAPER_TYPE = a4 + +# The EXTRA_PACKAGES tag can be used to specify one or more LaTeX package names +# that should be included in the LaTeX output. To get the times font for +# instance you can specify +# EXTRA_PACKAGES=times +# If left blank no extra packages will be included. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +EXTRA_PACKAGES = + +# The LATEX_HEADER tag can be used to specify a personal LaTeX header for the +# generated LaTeX document. The header should contain everything until the first +# chapter. If it is left blank doxygen will generate a standard header. See +# section "Doxygen usage" for information on how to let doxygen write the +# default header to a separate file. +# +# Note: Only use a user-defined header if you know what you are doing! The +# following commands have a special meaning inside the header: $title, +# $datetime, $date, $doxygenversion, $projectname, $projectnumber. Doxygen will +# replace them by respectively the title of the page, the current date and time, +# only the current date, the version number of doxygen, the project name (see +# PROJECT_NAME), or the project number (see PROJECT_NUMBER). +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_HEADER = + +# The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for the +# generated LaTeX document. The footer should contain everything after the last +# chapter. If it is left blank doxygen will generate a standard footer. +# +# Note: Only use a user-defined footer if you know what you are doing! +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_FOOTER = + +# The LATEX_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the LATEX_OUTPUT output +# directory. Note that the files will be copied as-is; there are no commands or +# markers available. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_EXTRA_FILES = + +# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated is +# prepared for conversion to PDF (using ps2pdf or pdflatex). The PDF file will +# contain links (just like the HTML output) instead of page references. This +# makes the output suitable for online browsing using a PDF viewer. +# The default value is: YES. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +PDF_HYPERLINKS = YES + +# If the LATEX_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate +# the PDF file directly from the LaTeX files. Set this option to YES to get a +# higher quality PDF documentation. +# The default value is: YES. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +USE_PDFLATEX = YES + +# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \batchmode +# command to the generated LaTeX files. This will instruct LaTeX to keep running +# if errors occur, instead of asking the user for help. This option is also used +# when generating formulas in HTML. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_BATCHMODE = NO + +# If the LATEX_HIDE_INDICES tag is set to YES then doxygen will not include the +# index chapters (such as File Index, Compound Index, etc.) in the output. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_HIDE_INDICES = NO + +# If the LATEX_SOURCE_CODE tag is set to YES then doxygen will include source +# code with syntax highlighting in the LaTeX output. +# +# Note that which sources are shown also depends on other settings such as +# SOURCE_BROWSER. +# The default value is: NO. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_SOURCE_CODE = NO + +# The LATEX_BIB_STYLE tag can be used to specify the style to use for the +# bibliography, e.g. plainnat, or ieeetr. See +# http://en.wikipedia.org/wiki/BibTeX and \cite for more info. +# The default value is: plain. +# This tag requires that the tag GENERATE_LATEX is set to YES. + +LATEX_BIB_STYLE = plain + +#--------------------------------------------------------------------------- +# Configuration options related to the RTF output +#--------------------------------------------------------------------------- + +# If the GENERATE_RTF tag is set to YES doxygen will generate RTF output. The +# RTF output is optimized for Word 97 and may not look too pretty with other RTF +# readers/editors. +# The default value is: NO. + +GENERATE_RTF = NO + +# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: rtf. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_OUTPUT = rtf + +# If the COMPACT_RTF tag is set to YES doxygen generates more compact RTF +# documents. This may be useful for small projects and may help to save some +# trees in general. +# The default value is: NO. +# This tag requires that the tag GENERATE_RTF is set to YES. + +COMPACT_RTF = NO + +# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated will +# contain hyperlink fields. The RTF file will contain links (just like the HTML +# output) instead of page references. This makes the output suitable for online +# browsing using Word or some other Word compatible readers that support those +# fields. +# +# Note: WordPad (write) and others do not support links. +# The default value is: NO. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_HYPERLINKS = NO + +# Load stylesheet definitions from file. Syntax is similar to doxygen's config +# file, i.e. a series of assignments. You only have to provide replacements, +# missing definitions are set to their default value. +# +# See also section "Doxygen usage" for information on how to generate the +# default style sheet that doxygen normally uses. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_STYLESHEET_FILE = + +# Set optional variables used in the generation of an RTF document. Syntax is +# similar to doxygen's config file. A template extensions file can be generated +# using doxygen -e rtf extensionFile. +# This tag requires that the tag GENERATE_RTF is set to YES. + +RTF_EXTENSIONS_FILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the man page output +#--------------------------------------------------------------------------- + +# If the GENERATE_MAN tag is set to YES doxygen will generate man pages for +# classes and files. +# The default value is: NO. + +GENERATE_MAN = NO + +# The MAN_OUTPUT tag is used to specify where the man pages will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. A directory man3 will be created inside the directory specified by +# MAN_OUTPUT. +# The default directory is: man. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_OUTPUT = man + +# The MAN_EXTENSION tag determines the extension that is added to the generated +# man pages. In case the manual section does not start with a number, the number +# 3 is prepended. The dot (.) at the beginning of the MAN_EXTENSION tag is +# optional. +# The default value is: .3. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_EXTENSION = .3 + +# The MAN_SUBDIR tag determines the name of the directory created within +# MAN_OUTPUT in which the man pages are placed. If defaults to man followed by +# MAN_EXTENSION with the initial . removed. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_SUBDIR = + +# If the MAN_LINKS tag is set to YES and doxygen generates man output, then it +# will generate one additional man file for each entity documented in the real +# man page(s). These additional files only source the real man page, but without +# them the man command would be unable to find the correct page. +# The default value is: NO. +# This tag requires that the tag GENERATE_MAN is set to YES. + +MAN_LINKS = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the XML output +#--------------------------------------------------------------------------- + +# If the GENERATE_XML tag is set to YES doxygen will generate an XML file that +# captures the structure of the code including all documentation. +# The default value is: NO. + +GENERATE_XML = NO + +# The XML_OUTPUT tag is used to specify where the XML pages will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: xml. +# This tag requires that the tag GENERATE_XML is set to YES. + +XML_OUTPUT = xml + +# If the XML_PROGRAMLISTING tag is set to YES doxygen will dump the program +# listings (including syntax highlighting and cross-referencing information) to +# the XML output. Note that enabling this will significantly increase the size +# of the XML output. +# The default value is: YES. +# This tag requires that the tag GENERATE_XML is set to YES. + +XML_PROGRAMLISTING = YES + +#--------------------------------------------------------------------------- +# Configuration options related to the DOCBOOK output +#--------------------------------------------------------------------------- + +# If the GENERATE_DOCBOOK tag is set to YES doxygen will generate Docbook files +# that can be used to generate PDF. +# The default value is: NO. + +GENERATE_DOCBOOK = NO + +# The DOCBOOK_OUTPUT tag is used to specify where the Docbook pages will be put. +# If a relative path is entered the value of OUTPUT_DIRECTORY will be put in +# front of it. +# The default directory is: docbook. +# This tag requires that the tag GENERATE_DOCBOOK is set to YES. + +DOCBOOK_OUTPUT = docbook + +#--------------------------------------------------------------------------- +# Configuration options for the AutoGen Definitions output +#--------------------------------------------------------------------------- + +# If the GENERATE_AUTOGEN_DEF tag is set to YES doxygen will generate an AutoGen +# Definitions (see http://autogen.sf.net) file that captures the structure of +# the code including all documentation. Note that this feature is still +# experimental and incomplete at the moment. +# The default value is: NO. + +GENERATE_AUTOGEN_DEF = NO + +#--------------------------------------------------------------------------- +# Configuration options related to the Perl module output +#--------------------------------------------------------------------------- + +# If the GENERATE_PERLMOD tag is set to YES doxygen will generate a Perl module +# file that captures the structure of the code including all documentation. +# +# Note that this feature is still experimental and incomplete at the moment. +# The default value is: NO. + +GENERATE_PERLMOD = NO + +# If the PERLMOD_LATEX tag is set to YES doxygen will generate the necessary +# Makefile rules, Perl scripts and LaTeX code to be able to generate PDF and DVI +# output from the Perl module output. +# The default value is: NO. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_LATEX = NO + +# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be nicely +# formatted so it can be parsed by a human reader. This is useful if you want to +# understand what is going on. On the other hand, if this tag is set to NO the +# size of the Perl module output will be much smaller and Perl will parse it +# just the same. +# The default value is: YES. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_PRETTY = YES + +# The names of the make variables in the generated doxyrules.make file are +# prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. This is useful +# so different doxyrules.make files included by the same Makefile don't +# overwrite each other's variables. +# This tag requires that the tag GENERATE_PERLMOD is set to YES. + +PERLMOD_MAKEVAR_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the preprocessor +#--------------------------------------------------------------------------- + +# If the ENABLE_PREPROCESSING tag is set to YES doxygen will evaluate all +# C-preprocessor directives found in the sources and include files. +# The default value is: YES. + +ENABLE_PREPROCESSING = YES + +# If the MACRO_EXPANSION tag is set to YES doxygen will expand all macro names +# in the source code. If set to NO only conditional compilation will be +# performed. Macro expansion can be done in a controlled way by setting +# EXPAND_ONLY_PREDEF to YES. +# The default value is: NO. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +MACRO_EXPANSION = NO + +# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then +# the macro expansion is limited to the macros specified with the PREDEFINED and +# EXPAND_AS_DEFINED tags. +# The default value is: NO. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +EXPAND_ONLY_PREDEF = NO + +# If the SEARCH_INCLUDES tag is set to YES the includes files in the +# INCLUDE_PATH will be searched if a #include is found. +# The default value is: YES. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +SEARCH_INCLUDES = YES + +# The INCLUDE_PATH tag can be used to specify one or more directories that +# contain include files that are not input files but should be processed by the +# preprocessor. +# This tag requires that the tag SEARCH_INCLUDES is set to YES. + +INCLUDE_PATH = + +# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard +# patterns (like *.h and *.hpp) to filter out the header-files in the +# directories. If left blank, the patterns specified with FILE_PATTERNS will be +# used. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +INCLUDE_FILE_PATTERNS = + +# The PREDEFINED tag can be used to specify one or more macro names that are +# defined before the preprocessor is started (similar to the -D option of e.g. +# gcc). The argument of the tag is a list of macros of the form: name or +# name=definition (no spaces). If the definition and the "=" are omitted, "=1" +# is assumed. To prevent a macro definition from being undefined via #undef or +# recursively expanded use the := operator instead of the = operator. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +PREDEFINED = + +# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then this +# tag can be used to specify a list of macro names that should be expanded. The +# macro definition that is found in the sources will be used. Use the PREDEFINED +# tag if you want to use a different macro definition that overrules the +# definition found in the source code. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +EXPAND_AS_DEFINED = + +# If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will +# remove all references to function-like macros that are alone on a line, have +# an all uppercase name, and do not end with a semicolon. Such function macros +# are typically used for boiler-plate code, and will confuse the parser if not +# removed. +# The default value is: YES. +# This tag requires that the tag ENABLE_PREPROCESSING is set to YES. + +SKIP_FUNCTION_MACROS = YES + +#--------------------------------------------------------------------------- +# Configuration options related to external references +#--------------------------------------------------------------------------- + +# The TAGFILES tag can be used to specify one or more tag files. For each tag +# file the location of the external documentation should be added. The format of +# a tag file without this location is as follows: +# TAGFILES = file1 file2 ... +# Adding location for the tag files is done as follows: +# TAGFILES = file1=loc1 "file2 = loc2" ... +# where loc1 and loc2 can be relative or absolute paths or URLs. See the +# section "Linking to external documentation" for more information about the use +# of tag files. +# Note: Each tag file must have a unique name (where the name does NOT include +# the path). If a tag file is not located in the directory in which doxygen is +# run, you must also specify the path to the tagfile here. + +TAGFILES = + +# When a file name is specified after GENERATE_TAGFILE, doxygen will create a +# tag file that is based on the input files it reads. See section "Linking to +# external documentation" for more information about the usage of tag files. + +GENERATE_TAGFILE = + +# If the ALLEXTERNALS tag is set to YES all external class will be listed in the +# class index. If set to NO only the inherited external classes will be listed. +# The default value is: NO. + +ALLEXTERNALS = NO + +# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed in +# the modules index. If set to NO, only the current project's groups will be +# listed. +# The default value is: YES. + +EXTERNAL_GROUPS = YES + +# If the EXTERNAL_PAGES tag is set to YES all external pages will be listed in +# the related pages index. If set to NO, only the current project's pages will +# be listed. +# The default value is: YES. + +EXTERNAL_PAGES = YES + +# The PERL_PATH should be the absolute path and name of the perl script +# interpreter (i.e. the result of 'which perl'). +# The default file (with absolute path) is: /usr/bin/perl. + +PERL_PATH = /usr/bin/perl + +#--------------------------------------------------------------------------- +# Configuration options related to the dot tool +#--------------------------------------------------------------------------- + +# If the CLASS_DIAGRAMS tag is set to YES doxygen will generate a class diagram +# (in HTML and LaTeX) for classes with base or super classes. Setting the tag to +# NO turns the diagrams off. Note that this option also works with HAVE_DOT +# disabled, but it is recommended to install and use dot, since it yields more +# powerful graphs. +# The default value is: YES. + +CLASS_DIAGRAMS = NO + +# You can define message sequence charts within doxygen comments using the \msc +# command. Doxygen will then run the mscgen tool (see: +# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the +# documentation. The MSCGEN_PATH tag allows you to specify the directory where +# the mscgen tool resides. If left empty the tool is assumed to be found in the +# default search path. + +MSCGEN_PATH = + +# You can include diagrams made with dia in doxygen documentation. Doxygen will +# then run dia to produce the diagram and insert it in the documentation. The +# DIA_PATH tag allows you to specify the directory where the dia binary resides. +# If left empty dia is assumed to be found in the default search path. + +DIA_PATH = + +# If set to YES, the inheritance and collaboration graphs will hide inheritance +# and usage relations if the target is undocumented or is not a class. +# The default value is: YES. + +HIDE_UNDOC_RELATIONS = YES + +# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is +# available from the path. This tool is part of Graphviz (see: +# http://www.graphviz.org/), a graph visualization toolkit from AT&T and Lucent +# Bell Labs. The other options in this section have no effect if this option is +# set to NO +# The default value is: YES. + +HAVE_DOT = @DOXYGEN_DOT_FOUND@ + +# The DOT_NUM_THREADS specifies the number of dot invocations doxygen is allowed +# to run in parallel. When set to 0 doxygen will base this on the number of +# processors available in the system. You can set it explicitly to a value +# larger than 0 to get control over the balance between CPU load and processing +# speed. +# Minimum value: 0, maximum value: 32, default value: 0. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_NUM_THREADS = 0 + +# When you want a differently looking font n the dot files that doxygen +# generates you can specify the font name using DOT_FONTNAME. You need to make +# sure dot is able to find the font, which can be done by putting it in a +# standard location or by setting the DOTFONTPATH environment variable or by +# setting DOT_FONTPATH to the directory containing the font. +# The default value is: Helvetica. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTNAME = Verdana + +# The DOT_FONTSIZE tag can be used to set the size (in points) of the font of +# dot graphs. +# Minimum value: 4, maximum value: 24, default value: 10. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTSIZE = 10 + +# By default doxygen will tell dot to use the default font as specified with +# DOT_FONTNAME. If you specify a different font using DOT_FONTNAME you can set +# the path where dot can find it using this tag. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_FONTPATH = + +# If the CLASS_GRAPH tag is set to YES then doxygen will generate a graph for +# each documented class showing the direct and indirect inheritance relations. +# Setting this tag to YES will force the CLASS_DIAGRAMS tag to NO. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +CLASS_GRAPH = YES + +# If the COLLABORATION_GRAPH tag is set to YES then doxygen will generate a +# graph for each documented class showing the direct and indirect implementation +# dependencies (inheritance, containment, and class references variables) of the +# class with other documented classes. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +COLLABORATION_GRAPH = NO + +# If the GROUP_GRAPHS tag is set to YES then doxygen will generate a graph for +# groups, showing the direct groups dependencies. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GROUP_GRAPHS = YES + +# If the UML_LOOK tag is set to YES doxygen will generate inheritance and +# collaboration diagrams in a style similar to the OMG's Unified Modeling +# Language. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +UML_LOOK = NO + +# If the UML_LOOK tag is enabled, the fields and methods are shown inside the +# class node. If there are many fields or methods and many nodes the graph may +# become too big to be useful. The UML_LIMIT_NUM_FIELDS threshold limits the +# number of items for each type to make the size more manageable. Set this to 0 +# for no limit. Note that the threshold may be exceeded by 50% before the limit +# is enforced. So when you set the threshold to 10, up to 15 fields may appear, +# but if the number exceeds 15, the total amount of fields shown is limited to +# 10. +# Minimum value: 0, maximum value: 100, default value: 10. +# This tag requires that the tag HAVE_DOT is set to YES. + +UML_LIMIT_NUM_FIELDS = 0 + +# If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and +# collaboration graphs will show the relations between templates and their +# instances. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +TEMPLATE_RELATIONS = YES + +# If the INCLUDE_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are set to +# YES then doxygen will generate a graph for each documented file showing the +# direct and indirect include dependencies of the file with other documented +# files. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +INCLUDE_GRAPH = YES + +# If the INCLUDED_BY_GRAPH, ENABLE_PREPROCESSING and SEARCH_INCLUDES tags are +# set to YES then doxygen will generate a graph for each documented file showing +# the direct and indirect include dependencies of the file with other documented +# files. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +INCLUDED_BY_GRAPH = YES + +# If the CALL_GRAPH tag is set to YES then doxygen will generate a call +# dependency graph for every global function or class method. +# +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable call graphs for selected +# functions only using the \callgraph command. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +CALL_GRAPH = YES + +# If the CALLER_GRAPH tag is set to YES then doxygen will generate a caller +# dependency graph for every global function or class method. +# +# Note that enabling this option will significantly increase the time of a run. +# So in most cases it will be better to enable caller graphs for selected +# functions only using the \callergraph command. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +CALLER_GRAPH = YES + +# If the GRAPHICAL_HIERARCHY tag is set to YES then doxygen will graphical +# hierarchy of all classes instead of a textual one. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GRAPHICAL_HIERARCHY = YES + +# If the DIRECTORY_GRAPH tag is set to YES then doxygen will show the +# dependencies a directory has on other directories in a graphical way. The +# dependency relations are determined by the #include relations between the +# files in the directories. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +DIRECTORY_GRAPH = YES + +# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images +# generated by dot. +# Note: If you choose svg you need to set HTML_FILE_EXTENSION to xhtml in order +# to make the SVG files visible in IE 9+ (other browsers do not have this +# requirement). +# Possible values are: png, png:cairo, png:cairo:cairo, png:cairo:gd, png:gd, +# png:gd:gd, jpg, jpg:cairo, jpg:cairo:gd, jpg:gd, jpg:gd:gd, gif, gif:cairo, +# gif:cairo:gd, gif:gd, gif:gd:gd and svg. +# The default value is: png. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_IMAGE_FORMAT = svg + +# If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to +# enable generation of interactive SVG images that allow zooming and panning. +# +# Note that this requires a modern browser other than Internet Explorer. Tested +# and working are Firefox, Chrome, Safari, and Opera. +# Note: For IE 9+ you need to set HTML_FILE_EXTENSION to xhtml in order to make +# the SVG files visible. Older versions of IE do not have SVG support. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +INTERACTIVE_SVG = NO + +# The DOT_PATH tag can be used to specify the path where the dot tool can be +# found. If left blank, it is assumed the dot tool can be found in the path. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_PATH = @DOXYGEN_DOT_PATH@ + +# The DOTFILE_DIRS tag can be used to specify one or more directories that +# contain dot files that are included in the documentation (see the \dotfile +# command). +# This tag requires that the tag HAVE_DOT is set to YES. + +DOTFILE_DIRS = + +# The MSCFILE_DIRS tag can be used to specify one or more directories that +# contain msc files that are included in the documentation (see the \mscfile +# command). + +MSCFILE_DIRS = + +# The DIAFILE_DIRS tag can be used to specify one or more directories that +# contain dia files that are included in the documentation (see the \diafile +# command). + +DIAFILE_DIRS = + +# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of nodes +# that will be shown in the graph. If the number of nodes in a graph becomes +# larger than this value, doxygen will truncate the graph, which is visualized +# by representing a node as a red box. Note that doxygen if the number of direct +# children of the root node in a graph is already larger than +# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note that +# the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. +# Minimum value: 0, maximum value: 10000, default value: 50. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_GRAPH_MAX_NODES = 100 + +# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the graphs +# generated by dot. A depth value of 3 means that only nodes reachable from the +# root by following a path via at most 3 edges will be shown. Nodes that lay +# further from the root node will be omitted. Note that setting this option to 1 +# or 2 may greatly reduce the computation time needed for large code bases. Also +# note that the size of a graph can be further restricted by +# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. +# Minimum value: 0, maximum value: 1000, default value: 0. +# This tag requires that the tag HAVE_DOT is set to YES. + +MAX_DOT_GRAPH_DEPTH = 0 + +# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent +# background. This is disabled by default, because dot on Windows does not seem +# to support this out of the box. +# +# Warning: Depending on the platform used, enabling this option may lead to +# badly anti-aliased labels on the edges of a graph (i.e. they become hard to +# read). +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_TRANSPARENT = NO + +# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output +# files in one run (i.e. multiple -o and -T options on the command line). This +# makes dot run faster, but since only newer versions of dot (>1.8.10) support +# this, this feature is disabled by default. +# The default value is: NO. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_MULTI_TARGETS = YES + +# If the GENERATE_LEGEND tag is set to YES doxygen will generate a legend page +# explaining the meaning of the various boxes and arrows in the dot generated +# graphs. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +GENERATE_LEGEND = NO + +# If the DOT_CLEANUP tag is set to YES doxygen will remove the intermediate dot +# files that are used to generate the various graphs. +# The default value is: YES. +# This tag requires that the tag HAVE_DOT is set to YES. + +DOT_CLEANUP = YES diff --git a/parameter/Android.mk b/parameter/Android.mk index 4ce29f1..2f4b483 100644 --- a/parameter/Android.mk +++ b/parameter/Android.mk @@ -126,16 +126,13 @@ common_cflags := \ -Werror \ -Wextra \ -Wno-unused-parameter \ - -Wno-maybe-uninitialized \ + -Wno-maybe-uninitialized common_c_includes := \ $(LOCAL_PATH)/include/ \ $(LOCAL_PATH)/../utility/ \ - $(LOCAL_PATH)/../xmlserializer/ \ $(LOCAL_PATH)/../remote-processor/ -common_shared_libraries := libicuuc - ############################# # Target build @@ -144,6 +141,8 @@ include $(CLEAR_VARS) LOCAL_COPY_HEADERS_TO := $(common_copy_headers_to) LOCAL_COPY_HEADERS := $(common_copy_headers) +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) + LOCAL_CFLAGS := $(common_cflags) LOCAL_SRC_FILES := $(common_src_files) @@ -154,12 +153,11 @@ LOCAL_MODULE_TAGS := $(common_module_tags) LOCAL_C_INCLUDES := $(common_c_includes) -LOCAL_SHARED_LIBRARIES := $(common_shared_libraries) libdl -LOCAL_STATIC_LIBRARIES := libxmlserializer libpfw_utility libxml2 +LOCAL_SHARED_LIBRARIES := libxmlserializer libdl +LOCAL_STATIC_LIBRARIES := libpfw_utility LOCAL_REQUIRED_MODULES := libremote-processor -LOCAL_CLANG := false include $(BUILD_SHARED_LIBRARY) ############################## @@ -170,6 +168,8 @@ include $(CLEAR_VARS) LOCAL_COPY_HEADERS_TO := $(common_copy_headers_to) LOCAL_COPY_HEADERS := $(common_copy_headers) +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) + LOCAL_CFLAGS := $(common_cflags) -O0 -ggdb LOCAL_SRC_FILES := $(common_src_files) @@ -181,11 +181,9 @@ LOCAL_MODULE_TAGS := $(common_module_tags) LOCAL_C_INCLUDES += \ $(common_c_includes) -LOCAL_SHARED_LIBRARIES := $(common_shared_libraries)-host -LOCAL_STATIC_LIBRARIES := libxmlserializer_host libpfw_utility_host libxml2 +LOCAL_SHARED_LIBRARIES := libxmlserializer_host +LOCAL_STATIC_LIBRARIES := libpfw_utility_host libxml2 LOCAL_LDLIBS += -ldl -LOCAL_CLANG := false include $(BUILD_HOST_SHARED_LIBRARY) - diff --git a/parameter/ArrayParameter.cpp b/parameter/ArrayParameter.cpp index 8561410..291b6a1 100644 --- a/parameter/ArrayParameter.cpp +++ b/parameter/ArrayParameter.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -34,6 +34,7 @@ #include "ParameterAccessContext.h" #include "ConfigurationAccessContext.h" #include "ParameterBlackboard.h" +#include "Utility.h" #include <assert.h> #define base CParameter @@ -62,7 +63,7 @@ void CArrayParameter::showProperties(string& strResult) const // Array length strResult += "Array length: "; - strResult += toString(getArrayLength()); + strResult += CUtility::toString(getArrayLength()); strResult += "\n"; } @@ -281,7 +282,8 @@ bool CArrayParameter::setValues(uint32_t uiStartIndex, uint32_t uiBaseOffset, co if (!doSetValue(astrValues[uiValueIndex], uiOffset, parameterAccessContext)) { // Append parameter path to error - parameterAccessContext.appendToError(" " + getPath() + "/" + toString(uiValueIndex + uiStartIndex)); + parameterAccessContext.appendToError(" " + getPath() + "/" + + CUtility::toString(uiValueIndex + uiStartIndex)); return false; } diff --git a/parameter/BitParameter.cpp b/parameter/BitParameter.cpp index fb853e4..2a53afd 100644 --- a/parameter/BitParameter.cpp +++ b/parameter/BitParameter.cpp @@ -87,7 +87,7 @@ bool CBitParameter::accessAsBoolean(bool& bValue, bool bSet, CParameterAccessCon } // Rely on integer access - uint64_t uiValue; + uint32_t uiValue; if (bSet) { @@ -108,7 +108,7 @@ bool CBitParameter::accessAsBoolean(bool& bValue, bool bSet, CParameterAccessCon } // Integer Access -bool CBitParameter::accessAsInteger(uint64_t& uiValue, bool bSet, CParameterAccessContext& parameterAccessContext) const +bool CBitParameter::accessAsInteger(uint32_t& uiValue, bool bSet, CParameterAccessContext& parameterAccessContext) const { uint32_t uiOffset = getOffset(); diff --git a/parameter/BitParameter.h b/parameter/BitParameter.h index 436f321..f9e2b9d 100644 --- a/parameter/BitParameter.h +++ b/parameter/BitParameter.h @@ -49,7 +49,7 @@ public: virtual bool accessAsBoolean(bool& bValue, bool bSet, CParameterAccessContext& parameterAccessContext) const; // Integer Access - virtual bool accessAsInteger(uint64_t& uiValue, bool bSet, CParameterAccessContext& parameterAccessContext) const; + virtual bool accessAsInteger(uint32_t& uiValue, bool bSet, CParameterAccessContext& parameterAccessContext) const; // AreaConfiguration creation virtual CAreaConfiguration* createAreaConfiguration(const CSyncerSet* pSyncerSet) const; diff --git a/parameter/BitParameterBlockType.cpp b/parameter/BitParameterBlockType.cpp index 2016b3b..0d344f2 100644 --- a/parameter/BitParameterBlockType.cpp +++ b/parameter/BitParameterBlockType.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -29,6 +29,7 @@ */ #include "BitParameterBlockType.h" #include "BitParameterBlock.h" +#include "Utility.h" #define base CTypeElement @@ -74,7 +75,7 @@ CInstanceConfigurableElement* CBitParameterBlockType::doInstantiate() const void CBitParameterBlockType::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const { // Size - xmlElement.setAttributeString("Size", toString(_uiSize * 8)); + xmlElement.setAttributeString("Size", CUtility::toString(_uiSize * 8)); base::toXml(xmlElement, serializingContext); } diff --git a/parameter/BitParameterType.cpp b/parameter/BitParameterType.cpp index 2a400d4..14fe901 100644 --- a/parameter/BitParameterType.cpp +++ b/parameter/BitParameterType.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -33,6 +33,7 @@ #include <sstream> #include "ParameterAccessContext.h" #include "BitParameterBlockType.h" +#include "Utility.h" #define base CTypeElement @@ -55,17 +56,17 @@ void CBitParameterType::showProperties(string& strResult) const // Bit Pos strResult += "Bit pos: "; - strResult += toString(_uiBitPos); + strResult += CUtility::toString(_uiBitPos); strResult += "\n"; // Bit size strResult += "Bit size: "; - strResult += toString(_uiBitSize); + strResult += CUtility::toString(_uiBitSize); strResult += "\n"; // Max strResult += "Max: "; - strResult += toString(_uiMax); + strResult += CUtility::toString(_uiMax); strResult += "\n"; } @@ -191,7 +192,7 @@ bool CBitParameterType::toBlackboard(uint64_t uiUserValue, uint64_t& uiValue, CP return true; } -void CBitParameterType::fromBlackboard(uint64_t& uiUserValue, uint64_t uiValue, CParameterAccessContext& parameterAccessContext) const +void CBitParameterType::fromBlackboard(uint32_t& uiUserValue, uint64_t uiValue, CParameterAccessContext& parameterAccessContext) const { (void)parameterAccessContext; @@ -245,13 +246,13 @@ bool CBitParameterType::isEncodable(uint64_t uiData) const void CBitParameterType::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const { // Position - xmlElement.setAttributeString("Pos", toString(_uiBitPos)); + xmlElement.setAttributeString("Pos", CUtility::toString(_uiBitPos)); // Size - xmlElement.setAttributeString("Size", toString(_uiBitSize)); + xmlElement.setAttributeString("Size", CUtility::toString(_uiBitSize)); // Maximum - xmlElement.setAttributeString("Max", toString(_uiMax)); + xmlElement.setAttributeString("Max", CUtility::toString(_uiMax)); base::toXml(xmlElement, serializingContext); diff --git a/parameter/BitParameterType.h b/parameter/BitParameterType.h index 8f147e6..4c91a1a 100644 --- a/parameter/BitParameterType.h +++ b/parameter/BitParameterType.h @@ -53,7 +53,7 @@ public: void fromBlackboard(std::string& strValue, const uint64_t& uiValue, CParameterAccessContext& parameterAccessContext) const; // Integer bool toBlackboard(uint64_t uiUserValue, uint64_t& uiValue, CParameterAccessContext& parameterAccessContext) const; - void fromBlackboard(uint64_t& uiUserValue, uint64_t uiValue, CParameterAccessContext& parameterAccessContext) const; + void fromBlackboard(uint32_t& uiUserValue, uint64_t uiValue, CParameterAccessContext& parameterAccessContext) const; // Access from area configuration uint64_t merge(uint64_t uiOriginData, uint64_t uiNewData) const; diff --git a/parameter/ConfigurableDomain.cpp b/parameter/ConfigurableDomain.cpp index aa9da51..346b1f9 100644 --- a/parameter/ConfigurableDomain.cpp +++ b/parameter/ConfigurableDomain.cpp @@ -847,7 +847,7 @@ void CConfigurableDomain::validate(const CParameterBlackboard* pMainBlackboard) // Ensure validity on areas related to configurable element void CConfigurableDomain::validateAreas(const CConfigurableElement* pConfigurableElement, const CParameterBlackboard* pMainBlackboard) { - log_info("Validating domain \"" + getName() + "\" against main blackboard for configurable element \"" + pConfigurableElement->getPath() + "\""); + log_info("Validating domain \"%s\" against main blackboard for configurable element \"%s\"", getName().c_str(), pConfigurableElement->getPath().c_str()); // Propagate size_t uiNbConfigurations = getNbChildren(); diff --git a/parameter/ConfigurableDomains.cpp b/parameter/ConfigurableDomains.cpp index 844ade7..bfa9271 100644 --- a/parameter/ConfigurableDomains.cpp +++ b/parameter/ConfigurableDomains.cpp @@ -145,7 +145,7 @@ bool CConfigurableDomains::addDomain(CConfigurableDomain& domain, bool bOverwrit deleteDomain(*pExistingDomain); } - log_info("Adding configurable domain \"" + strDomainName + "\""); + log_info("Adding configurable domain \"%s\"", strDomainName.c_str()); addChild(&domain); @@ -154,7 +154,7 @@ bool CConfigurableDomains::addDomain(CConfigurableDomain& domain, bool bOverwrit void CConfigurableDomains::deleteDomain(CConfigurableDomain& configurableDomain) { - log_info("Deleting configurable domain \"" + configurableDomain.getName() + "\""); + log_info("Deleting configurable domain \"%s\"", configurableDomain.getName().c_str() ); removeChild(&configurableDomain); diff --git a/parameter/ConfigurableElement.cpp b/parameter/ConfigurableElement.cpp index 754f207..08a0122 100644 --- a/parameter/ConfigurableElement.cpp +++ b/parameter/ConfigurableElement.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -34,6 +34,7 @@ #include "ConfigurationAccessContext.h" #include "ConfigurableElementAggregator.h" #include "AreaConfiguration.h" +#include "Utility.h" #include <assert.h> #define base CElement @@ -360,7 +361,7 @@ bool CConfigurableElement::isRogue() const std::string CConfigurableElement::getFootprintAsString() const { // Get size as string - return toString(getFootPrint()) + " byte(s)"; + return CUtility::toString(getFootPrint()) + " byte(s)"; } // Matching check for no domain association diff --git a/parameter/Element.cpp b/parameter/Element.cpp index cacf49b..afd1f33 100644 --- a/parameter/Element.cpp +++ b/parameter/Element.cpp @@ -35,10 +35,11 @@ #include <stdio.h> #include <stdarg.h> #include <stdlib.h> -#include <sstream> using std::string; +const std::string CElement::gDescriptionPropertyName = "Description"; + CElement::CElement(const string& strName) : _strName(strName), _pParent(NULL) { } @@ -49,14 +50,14 @@ CElement::~CElement() } // Logging -void CElement::log_info(const string& strMessage, ...) const +void CElement::log_info(const char* strMessage, ...) const { char *pacBuffer; va_list listPointer; va_start(listPointer, strMessage); - vasprintf(&pacBuffer, strMessage.c_str(), listPointer); + vasprintf(&pacBuffer, strMessage, listPointer); va_end(listPointer); @@ -67,14 +68,14 @@ void CElement::log_info(const string& strMessage, ...) const free(pacBuffer); } -void CElement::log_warning(const string& strMessage, ...) const +void CElement::log_warning(const char* strMessage, ...) const { char *pacBuffer; va_list listPointer; va_start(listPointer, strMessage); - vasprintf(&pacBuffer, strMessage.c_str(), listPointer); + vasprintf(&pacBuffer, strMessage, listPointer); va_end(listPointer); @@ -200,43 +201,14 @@ void CElement::showProperties(string& strResult) const { strResult = "\n"; strResult += "Kind: " + getKind() + "\n"; + showDescriptionProperty(strResult); } -// Conversion utilities -string CElement::toString(uint32_t uiValue) +void CElement::showDescriptionProperty(std::string &strResult) const { - std::ostringstream ostr; - - ostr << uiValue; - - return ostr.str(); -} - -string CElement::toString(uint64_t uiValue) -{ - std::ostringstream ostr; - - ostr << uiValue; - - return ostr.str(); -} - -string CElement::toString(int32_t iValue) -{ - std::ostringstream ostr; - - ostr << iValue; - - return ostr.str(); -} - -string CElement::toString(double dValue) -{ - std::ostringstream ostr; - - ostr << dValue; - - return ostr.str(); + if (!getDescription().empty()) { + strResult += gDescriptionPropertyName + ": " + getDescription() + "\n"; + } } // Content dumping @@ -249,6 +221,8 @@ void CElement::logValue(string& strValue, CErrorContext& errorContext) const // From IXmlSink bool CElement::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) { + setDescription(getXmlDescriptionAttribute(xmlElement)); + // Propagate through children CXmlElement::CChildIterator childIterator(xmlElement); @@ -316,9 +290,23 @@ void CElement::childrenToXml(CXmlElement& xmlElement, void CElement::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const { setXmlNameAttribute(xmlElement); + setXmlDescriptionAttribute(xmlElement); childrenToXml(xmlElement, serializingContext); } +void CElement::setXmlDescriptionAttribute(CXmlElement& xmlElement) const +{ + const string &description = getDescription(); + if (!description.empty()) { + xmlElement.setAttributeString(gDescriptionPropertyName, description); + } +} + +string CElement::getXmlDescriptionAttribute(const CXmlElement& xmlElement) const +{ + return xmlElement.getAttributeString(gDescriptionPropertyName); +} + void CElement::setXmlNameAttribute(CXmlElement& xmlElement) const { // By default, set Name attribute if any @@ -712,17 +700,3 @@ uint8_t CElement::computeStructureChecksum() const return uiChecksum; } - -// Utility to underline -void CElement::appendTitle(string& strTo, const string& strTitle) -{ - strTo += "\n" + strTitle + "\n"; - - string::size_type uiLength = strTitle.size(); - - while (uiLength--) { - - strTo += "="; - } - strTo += "\n"; -} diff --git a/parameter/Element.h b/parameter/Element.h index 8423e32..d3844e6 100644 --- a/parameter/Element.h +++ b/parameter/Element.h @@ -49,8 +49,8 @@ public: virtual ~CElement(); // Logging - void log_info(const std::string& strMessage, ...) const; - void log_warning(const std::string& strMessage, ...) const; + void log_info(const char* strMessage, ...) const; + void log_warning(const char* strMessage, ...) const; void log_table(bool bIsWarning, const std::list<std::string> lstrMessage) const; // Description @@ -133,22 +133,38 @@ public: // Element properties virtual void showProperties(std::string& strResult) const; - // Conversion utilities - static std::string toString(uint32_t uiValue); - static std::string toString(uint64_t uiValue); - static std::string toString(int32_t iValue); - static std::string toString(double dValue); - // Checksum for integrity checks uint8_t computeStructureChecksum() const; // Class kind virtual std::string getKind() const = 0; + + /** + * Fill the Description field of the Xml Element during XML composing. + * + * @param[in,out] xmlElement to fill with the description + */ + void setXmlDescriptionAttribute(CXmlElement& xmlElement) const; + + /** + * Extract the Description field from the Xml Element during XML decomposing. + * + * @param[in] xmlElement to extract the description from. + * + * @return description represented as a string, empty if not found + */ + std::string getXmlDescriptionAttribute(const CXmlElement &xmlElement) const; + + /** + * Appends if found human readable description property. + * + * @param[out] strResult in which the description is wished to be appended. + */ + void showDescriptionProperty(std::string &strResult) const; + protected: // Content dumping virtual void logValue(std::string& strValue, CErrorContext& errorContext) const; - // Utility to underline - static void appendTitle(std::string& strTo, const std::string& strTitle); // Hierarchy CElement* getParent(); @@ -193,4 +209,6 @@ private: std::vector<CElement*> _childArray; // Parent CElement* _pParent; + + static const std::string gDescriptionPropertyName; }; diff --git a/parameter/EnumParameterType.cpp b/parameter/EnumParameterType.cpp index 8cca7d7..147ee95 100644 --- a/parameter/EnumParameterType.cpp +++ b/parameter/EnumParameterType.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -35,6 +35,7 @@ #include <assert.h> #include "ParameterAccessContext.h" #include "EnumValuePair.h" +#include "Utility.h" #include <errno.h> #define base CParameterType @@ -344,7 +345,7 @@ bool CEnumParameterType::isValid(int iNumerical, CParameterAccessContext& parame void CEnumParameterType::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const { // Size - xmlElement.setAttributeString("Size", toString(getSize() * 8)); + xmlElement.setAttributeString("Size", CUtility::toString(getSize() * 8)); base::toXml(xmlElement, serializingContext); } diff --git a/parameter/EnumValuePair.cpp b/parameter/EnumValuePair.cpp index 81febdd..35f4cd2 100644 --- a/parameter/EnumValuePair.cpp +++ b/parameter/EnumValuePair.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -28,6 +28,7 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "EnumValuePair.h" +#include "Utility.h" #define base CElement @@ -51,7 +52,7 @@ int32_t CEnumValuePair::getNumerical() const string CEnumValuePair::getNumericalAsString() const { - return toString(_iNumerical); + return CUtility::toString(_iNumerical); } // From IXmlSink diff --git a/parameter/FixedPointParameterType.cpp b/parameter/FixedPointParameterType.cpp index e7779a9..5189a07 100644 --- a/parameter/FixedPointParameterType.cpp +++ b/parameter/FixedPointParameterType.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -36,6 +36,7 @@ #include "Parameter.h" #include "ParameterAccessContext.h" #include "ConfigurationAccessContext.h" +#include "Utility.h" #include <errno.h> #include <convert.hpp> @@ -59,9 +60,9 @@ void CFixedPointParameterType::showProperties(string& strResult) const // Notation strResult += "Notation: Q"; - strResult += toString(_uiIntegral); + strResult += CUtility::toString(_uiIntegral); strResult += "."; - strResult += toString(_uiFractional); + strResult += CUtility::toString(_uiFractional); strResult += "\n"; } @@ -363,13 +364,13 @@ double CFixedPointParameterType::binaryQnmToDouble(int32_t iValue) const void CFixedPointParameterType::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const { // Size - xmlElement.setAttributeString("Size", toString(getSize() * 8)); + xmlElement.setAttributeString("Size", CUtility::toString(getSize() * 8)); // Integral - xmlElement.setAttributeString("Integral", toString(_uiIntegral)); + xmlElement.setAttributeString("Integral", CUtility::toString(_uiIntegral)); // Fractional - xmlElement.setAttributeString("Fractional", toString(_uiFractional)); + xmlElement.setAttributeString("Fractional", CUtility::toString(_uiFractional)); base::toXml(xmlElement, serializingContext); } diff --git a/parameter/InstanceConfigurableElement.cpp b/parameter/InstanceConfigurableElement.cpp index 89e9266..b59cffd 100644 --- a/parameter/InstanceConfigurableElement.cpp +++ b/parameter/InstanceConfigurableElement.cpp @@ -216,3 +216,10 @@ bool CInstanceConfigurableElement::checkPathExhausted(CPathNavigator& pathNaviga } return true; } + +void CInstanceConfigurableElement::toXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const +{ + base::toXml(xmlElement, serializingContext); + // Since Description belongs to the Type of Element, delegate it to the type element. + getTypeElement()->setXmlDescriptionAttribute(xmlElement); +} diff --git a/parameter/InstanceConfigurableElement.h b/parameter/InstanceConfigurableElement.h index b3cdf62..eea3df6 100644 --- a/parameter/InstanceConfigurableElement.h +++ b/parameter/InstanceConfigurableElement.h @@ -102,6 +102,9 @@ public: */ virtual void getListOfElementsWithMapping(std::list<const CConfigurableElement*>& configurableElementPath) const; + + virtual void toXml(CXmlElement &xmlElement, CXmlSerializingContext &serializingContext) const; + protected: // Syncer virtual ISyncer* getSyncer() const; diff --git a/parameter/IntegerParameterType.cpp b/parameter/IntegerParameterType.cpp index edc3d46..2d48d53 100644 --- a/parameter/IntegerParameterType.cpp +++ b/parameter/IntegerParameterType.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -34,6 +34,7 @@ #include "ParameterAccessContext.h" #include <assert.h> #include "ParameterAdaptation.h" +#include "Utility.h" #include <errno.h> #define base CParameterType @@ -69,12 +70,12 @@ void CIntegerParameterType::showProperties(string& strResult) const // Min strResult += "Min: "; - strResult += _bSigned ? toString((int32_t)_uiMin) : toString(_uiMin); + strResult += _bSigned ? CUtility::toString((int32_t)_uiMin) : CUtility::toString(_uiMin); strResult += "\n"; // Max strResult += "Max: "; - strResult += _bSigned ? toString((int32_t)_uiMax) : toString(_uiMax); + strResult += _bSigned ? CUtility::toString((int32_t)_uiMax) : CUtility::toString(_uiMax); strResult += "\n"; // Check if there's an adaptation object available @@ -439,22 +440,22 @@ void CIntegerParameterType::toXml(CXmlElement& xmlElement, CXmlSerializingContex if (_bSigned) { // Mininmum - xmlElement.setAttributeString("Min", toString((int32_t)_uiMin)); + xmlElement.setAttributeString("Min", CUtility::toString((int32_t)_uiMin)); // Maximum - xmlElement.setAttributeString("Max", toString((int32_t)_uiMax)); + xmlElement.setAttributeString("Max", CUtility::toString((int32_t)_uiMax)); } else { // Minimum - xmlElement.setAttributeString("Min", toString(_uiMin)); + xmlElement.setAttributeString("Min", CUtility::toString(_uiMin)); // Maximum - xmlElement.setAttributeString("Max", toString(_uiMax)); + xmlElement.setAttributeString("Max", CUtility::toString(_uiMax)); } // Size - xmlElement.setAttributeString("Size", toString(getSize() * 8)); + xmlElement.setAttributeString("Size", CUtility::toString(getSize() * 8)); base::toXml(xmlElement, serializingContext); diff --git a/parameter/LinearParameterAdaptation.cpp b/parameter/LinearParameterAdaptation.cpp index ea833b3..ae925a7 100644 --- a/parameter/LinearParameterAdaptation.cpp +++ b/parameter/LinearParameterAdaptation.cpp @@ -28,6 +28,7 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "LinearParameterAdaptation.h" +#include "Utility.h" #define base CParameterAdaptation @@ -49,12 +50,12 @@ void CLinearParameterAdaptation::showProperties(string& strResult) const // SlopeNumerator strResult += " - SlopeNumerator: "; - strResult += toString(_dSlopeNumerator); + strResult += CUtility::toString(_dSlopeNumerator); strResult += "\n"; // SlopeDenominator strResult += " - SlopeDenominator: "; - strResult += toString(_dSlopeDenominator); + strResult += CUtility::toString(_dSlopeDenominator); strResult += "\n"; } diff --git a/parameter/LogarithmicParameterAdaptation.cpp b/parameter/LogarithmicParameterAdaptation.cpp index 688527d..bca4948 100644 --- a/parameter/LogarithmicParameterAdaptation.cpp +++ b/parameter/LogarithmicParameterAdaptation.cpp @@ -29,6 +29,7 @@ */ #include "LogarithmicParameterAdaptation.h" +#include "Utility.h" #include <math.h> #define base CLinearParameterAdaptation @@ -45,10 +46,10 @@ void CLogarithmicParameterAdaptation::showProperties(std::string& strResult) con base::showProperties(strResult); strResult += " - LogarithmBase: "; - strResult += toString(_dLogarithmBase); + strResult += CUtility::toString(_dLogarithmBase); strResult += "\n"; strResult += " - FloorValue: "; - strResult += toString(_dFloorValue); + strResult += CUtility::toString(_dFloorValue); strResult += "\n"; } diff --git a/parameter/ParameterAdaptation.cpp b/parameter/ParameterAdaptation.cpp index f1e73c1..99955f1 100644 --- a/parameter/ParameterAdaptation.cpp +++ b/parameter/ParameterAdaptation.cpp @@ -28,6 +28,7 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "ParameterAdaptation.h" +#include "Utility.h" #define base CElement @@ -58,7 +59,7 @@ void CParameterAdaptation::showProperties(string& strResult) const // Offset strResult += " - Offset: "; - strResult += toString(_iOffset); + strResult += CUtility::toString(_iOffset); strResult += "\n"; } diff --git a/parameter/ParameterBlockType.cpp b/parameter/ParameterBlockType.cpp index aafa7ca..ad94888 100644 --- a/parameter/ParameterBlockType.cpp +++ b/parameter/ParameterBlockType.cpp @@ -29,6 +29,7 @@ */ #include "ParameterBlockType.h" #include "ParameterBlock.h" +#include "Utility.h" #define base CTypeElement @@ -62,7 +63,8 @@ void CParameterBlockType::populate(CElement* pElement) const for (uiChild = 0; uiChild < uiArrayLength; uiChild++) { - CParameterBlock* pChildParameterBlock = new CParameterBlock(toString(uiChild), this); + CParameterBlock* pChildParameterBlock = new CParameterBlock(CUtility::toString(uiChild), + this); pElement->addChild(pChildParameterBlock); diff --git a/parameter/ParameterMgr.cpp b/parameter/ParameterMgr.cpp index 45f1ac2..b42c7de 100644 --- a/parameter/ParameterMgr.cpp +++ b/parameter/ParameterMgr.cpp @@ -82,15 +82,14 @@ #include "LogarithmicParameterAdaptation.h" #include "EnumValuePair.h" #include "Subsystem.h" -#include "XmlFileDocSink.h" -#include "XmlFileDocSource.h" -#include "XmlStringDocSink.h" -#include "XmlStringDocSource.h" +#include "XmlStreamDocSink.h" #include "XmlMemoryDocSink.h" +#include "XmlDocSource.h" #include "XmlMemoryDocSource.h" #include "SelectionCriteriaDefinition.h" #include "Utility.h" #include <sstream> +#include <fstream> #include <algorithm> #include <ctype.h> #include <memory> @@ -110,6 +109,8 @@ using std::string; using std::list; using std::vector; using std::ostringstream; +using std::ofstream; +using std::ifstream; // Used for remote processor server creation typedef IRemoteProcessorServerInterface* (*CreateRemoteProcessorServer)(uint16_t uiPort, IRemoteCommandHandler* pCommandHandler); @@ -146,157 +147,173 @@ const CParameterMgr::SRemoteCommandParserItem CParameterMgr::gastRemoteCommandPa "Show current status" }, /// Tuning Mode - { "setTuningMode", &CParameterMgr::setTuningModeCommmandProcess, 1, + { "setTuningMode", &CParameterMgr::setTuningModeCommandProcess, 1, "on|off*", "Turn on or off Tuning Mode" }, - { "getTuningMode", &CParameterMgr::getTuningModeCommmandProcess, 0, + { "getTuningMode", &CParameterMgr::getTuningModeCommandProcess, 0, "", "Show Tuning Mode" }, /// Value Space - { "setValueSpace", &CParameterMgr::setValueSpaceCommmandProcess, 1, + { "setValueSpace", &CParameterMgr::setValueSpaceCommandProcess, 1, "raw|real*", "Assigns Value Space used for parameter value interpretation" }, - { "getValueSpace", &CParameterMgr::getValueSpaceCommmandProcess, 0, + { "getValueSpace", &CParameterMgr::getValueSpaceCommandProcess, 0, "", "Show Value Space" }, /// Output Raw Format - { "setOutputRawFormat", &CParameterMgr::setOutputRawFormatCommmandProcess, 1, + { "setOutputRawFormat", &CParameterMgr::setOutputRawFormatCommandProcess, 1, "dec*|hex", "Assigns format used to output parameter values when in raw Value Space" }, - { "getOutputRawFormat", &CParameterMgr::getOutputRawFormatCommmandProcess, 0, + { "getOutputRawFormat", &CParameterMgr::getOutputRawFormatCommandProcess, 0, "", "Show Output Raw Format" }, /// Sync - { "setAutoSync", &CParameterMgr::setAutoSyncCommmandProcess, 1, + { "setAutoSync", &CParameterMgr::setAutoSyncCommandProcess, 1, "on*|off", "Turn on or off automatic synchronization to hardware while in Tuning Mode" }, - { "getAutoSync", &CParameterMgr::getAutoSyncCommmandProcess, 0, + { "getAutoSync", &CParameterMgr::getAutoSyncCommandProcess, 0, "", "Show Auto Sync state" }, - { "sync", &CParameterMgr::syncCommmandProcess, 0, + { "sync", &CParameterMgr::syncCommandProcess, 0, "", "Synchronize current settings to hardware while in Tuning Mode and Auto Sync off" }, /// Criteria - { "listCriteria", &CParameterMgr::listCriteriaCommmandProcess, 0, + { "listCriteria", &CParameterMgr::listCriteriaCommandProcess, 0, "[CSV|XML]", "List selection criteria" }, /// Domains - { "listDomains", &CParameterMgr::listDomainsCommmandProcess, 0, + { "listDomains", &CParameterMgr::listDomainsCommandProcess, 0, "", "List configurable domains" }, - { "dumpDomains", &CParameterMgr::dumpDomainsCommmandProcess, 0, + { "dumpDomains", &CParameterMgr::dumpDomainsCommandProcess, 0, "", "Show all domains and configurations, including applicability conditions" }, - { "createDomain", &CParameterMgr::createDomainCommmandProcess, 1, + { "createDomain", &CParameterMgr::createDomainCommandProcess, 1, "<domain>", "Create new configurable domain" }, - { "deleteDomain", &CParameterMgr::deleteDomainCommmandProcess, 1, + { "deleteDomain", &CParameterMgr::deleteDomainCommandProcess, 1, "<domain>", "Delete configurable domain" }, - { "deleteAllDomains", &CParameterMgr::deleteAllDomainsCommmandProcess, 0, + { "deleteAllDomains", &CParameterMgr::deleteAllDomainsCommandProcess, 0, "", "Delete all configurable domains" }, - { "renameDomain", &CParameterMgr::renameDomainCommmandProcess, 2, + { "renameDomain", &CParameterMgr::renameDomainCommandProcess, 2, "<domain> <new name>", "Rename configurable domain" }, - { "setSequenceAwareness", &CParameterMgr::setSequenceAwarenessCommmandProcess, 1, + { "setSequenceAwareness", &CParameterMgr::setSequenceAwarenessCommandProcess, 1, "<domain> true|false*", "Set configurable domain sequence awareness" }, - { "getSequenceAwareness", &CParameterMgr::getSequenceAwarenessCommmandProcess, 1, + { "getSequenceAwareness", &CParameterMgr::getSequenceAwarenessCommandProcess, 1, "<domain>", "Get configurable domain sequence awareness" }, - { "listDomainElements", &CParameterMgr::listDomainElementsCommmandProcess, 1, + { "listDomainElements", &CParameterMgr::listDomainElementsCommandProcess, 1, "<domain>", "List elements associated to configurable domain" }, - { "addElement", &CParameterMgr::addElementCommmandProcess, 2, + { "addElement", &CParameterMgr::addElementCommandProcess, 2, "<domain> <elem path>", "Associate element at given path to configurable domain" }, - { "removeElement", &CParameterMgr::removeElementCommmandProcess, 2, + { "removeElement", &CParameterMgr::removeElementCommandProcess, 2, "<domain> <elem path>", "Dissociate element at given path from configurable domain" }, - { "splitDomain", &CParameterMgr::splitDomainCommmandProcess, 2, + { "splitDomain", &CParameterMgr::splitDomainCommandProcess, 2, "<domain> <elem path>", "Split configurable domain at given associated element path" }, /// Configurations - { "listConfigurations", &CParameterMgr::listConfigurationsCommmandProcess, 1, + { "listConfigurations", &CParameterMgr::listConfigurationsCommandProcess, 1, "<domain>", "List domain configurations" }, - { "createConfiguration", &CParameterMgr::createConfigurationCommmandProcess, 2, + { "createConfiguration", &CParameterMgr::createConfigurationCommandProcess, 2, "<domain> <configuration>", "Create new domain configuration" }, - { "deleteConfiguration", &CParameterMgr::deleteConfigurationCommmandProcess, 2, + { "deleteConfiguration", &CParameterMgr::deleteConfigurationCommandProcess, 2, "<domain> <configuration>", "Delete domain configuration" }, - { "renameConfiguration", &CParameterMgr::renameConfigurationCommmandProcess, 3, + { "renameConfiguration", &CParameterMgr::renameConfigurationCommandProcess, 3, "<domain> <configuration> <new name>", "Rename domain configuration" }, - { "saveConfiguration", &CParameterMgr::saveConfigurationCommmandProcess, 2, + { "saveConfiguration", &CParameterMgr::saveConfigurationCommandProcess, 2, "<domain> <configuration>", "Save current settings into configuration" }, - { "restoreConfiguration", &CParameterMgr::restoreConfigurationCommmandProcess, 2, + { "restoreConfiguration", &CParameterMgr::restoreConfigurationCommandProcess, 2, "<domain> <configuration>", "Restore current settings from configuration" }, - { "setElementSequence", &CParameterMgr::setElementSequenceCommmandProcess, 3, + { "setElementSequence", &CParameterMgr::setElementSequenceCommandProcess, 3, "<domain> <configuration> <elem path list>", "Set element application order for configuration" }, - { "getElementSequence", &CParameterMgr::getElementSequenceCommmandProcess, 2, + { "getElementSequence", &CParameterMgr::getElementSequenceCommandProcess, 2, "<domain> <configuration>", "Get element application order for configuration" }, - { "setRule", &CParameterMgr::setRuleCommmandProcess, 3, + { "setRule", &CParameterMgr::setRuleCommandProcess, 3, "<domain> <configuration> <rule>", "Set configuration application rule" }, - { "clearRule", &CParameterMgr::clearRuleCommmandProcess, 2, + { "clearRule", &CParameterMgr::clearRuleCommandProcess, 2, "<domain> <configuration>", "Clear configuration application rule" }, - { "getRule", &CParameterMgr::getRuleCommmandProcess, 2, + { "getRule", &CParameterMgr::getRuleCommandProcess, 2, "<domain> <configuration>", "Get configuration application rule" }, /// Elements/Parameters - { "listElements", &CParameterMgr::listElementsCommmandProcess, 1, + { "listElements", &CParameterMgr::listElementsCommandProcess, 1, "<elem path>|/", "List elements under element at given path or root" }, - { "listParameters", &CParameterMgr::listParametersCommmandProcess, 1, + { "listParameters", &CParameterMgr::listParametersCommandProcess, 1, "<elem path>|/", "List parameters under element at given path or root" }, - { "dumpElement", &CParameterMgr::dumpElementCommmandProcess, 1, + { "dumpElement", &CParameterMgr::dumpElementCommandProcess, 1, "<elem path>", "Dump structure and content of element at given path" }, - { "getElementSize", &CParameterMgr::getElementSizeCommmandProcess, 1, + { "getElementSize", &CParameterMgr::getElementSizeCommandProcess, 1, "<elem path>", "Show size of element at given path" }, - { "showProperties", &CParameterMgr::showPropertiesCommmandProcess, 1, + { "showProperties", &CParameterMgr::showPropertiesCommandProcess, 1, "<elem path>", "Show properties of element at given path" }, - { "getParameter", &CParameterMgr::getParameterCommmandProcess, 1, + { "getParameter", &CParameterMgr::getParameterCommandProcess, 1, "<param path>", "Get value for parameter at given path" }, - { "setParameter", &CParameterMgr::setParameterCommmandProcess, 2, + { "setParameter", &CParameterMgr::setParameterCommandProcess, 2, "<param path> <value>", "Set value for parameter at given path" }, - { "listBelongingDomains", &CParameterMgr::listBelongingDomainsCommmandProcess, 1, + { "listBelongingDomains", &CParameterMgr::listBelongingDomainsCommandProcess, 1, "<elem path>", "List domain(s) element at given path belongs to" }, - { "listAssociatedDomains", &CParameterMgr::listAssociatedDomainsCommmandProcess, 1, + { "listAssociatedDomains", &CParameterMgr::listAssociatedDomainsCommandProcess, 1, "<elem path>", "List domain(s) element at given path is associated to" }, - { "getConfigurationParameter", &CParameterMgr::getConfigurationParameterCommmandProcess, 3, + { "getConfigurationParameter", &CParameterMgr::getConfigurationParameterCommandProcess, 3, "<domain> <configuration> <param path>", "Get value for parameter at given path from configuration" }, - { "setConfigurationParameter", &CParameterMgr::setConfigurationParameterCommmandProcess, 4, + { "setConfigurationParameter", &CParameterMgr::setConfigurationParameterCommandProcess, 4, "<domain> <configuration> <param path> <value>", "Set value for parameter at given path to configuration" }, - { "showMapping", &CParameterMgr::showMappingCommmandProcess, 1, + { "showMapping", &CParameterMgr::showMappingCommandProcess, 1, "<elem path>", "Show mapping for an element at given path" }, /// Browse - { "listAssociatedElements", &CParameterMgr::listAssociatedElementsCommmandProcess, 0, + { "listAssociatedElements", &CParameterMgr::listAssociatedElementsCommandProcess, 0, "", "List element sub-trees associated to at least one configurable domain" }, - { "listConflictingElements", &CParameterMgr::listConflictingElementsCommmandProcess, 0, + { "listConflictingElements", &CParameterMgr::listConflictingElementsCommandProcess, 0, "", "List element sub-trees contained in more than one configurable domain" }, - { "listRogueElements", &CParameterMgr::listRogueElementsCommmandProcess, 0, + { "listRogueElements", &CParameterMgr::listRogueElementsCommandProcess, 0, "", "List element sub-trees owned by no configurable domain" }, /// Settings Import/Export - { "exportDomainsXML", &CParameterMgr::exportConfigurableDomainsToXMLCommmandProcess, 1, - "<file path> ", "Export domains to XML file" }, - { "importDomainsXML", &CParameterMgr::importConfigurableDomainsFromXMLCommmandProcess, 1, - "<file path>", "Import domains from XML file" }, + { "exportDomainsXML", &CParameterMgr::exportDomainsXMLCommandProcess, 1, + "<file path> ", "Export domains to an XML file (provide an absolute path or relative" + "to the client's working directory)" }, + { "importDomainsXML", &CParameterMgr::importDomainsXMLCommandProcess, 1, + "<file path>", "Import domains from an XML file (provide an absolute path or relative" + "to the client's working directory)" }, { "exportDomainsWithSettingsXML", - &CParameterMgr::exportConfigurableDomainsWithSettingsToXMLCommmandProcess, 1, - "<file path> ", "Export domains including settings to XML file" }, + &CParameterMgr::exportDomainsWithSettingsXMLCommandProcess, 1, + "<file path> ", "Export domains including settings to XML file (provide an absolute path or relative" + "to the client's working directory)" }, + { "exportDomainWithSettingsXML", + &CParameterMgr::exportDomainWithSettingsXMLCommandProcess, 2, + "<domain> <file path> ", "Export a single given domain including settings to XML file" + " (provide an absolute path or relative to the client's" + " working directory)" }, { "importDomainsWithSettingsXML", - &CParameterMgr::importConfigurableDomainsWithSettingsFromXMLCommmandProcess, 1, - "<file path>", "Import domains including settings from XML file" }, + &CParameterMgr::importDomainsWithSettingsXMLCommandProcess, 1, + "<file path>", "Import domains including settings from XML file (provide an absolute path or relative" + "to the client's working directory)" }, { "importDomainWithSettingsXML", - &CParameterMgr::importConfigurableDomainWithSettingsFromXMLCommmandProcess, 1, + &CParameterMgr::importDomainWithSettingsXMLCommandProcess, 1, "<file path> [overwrite]", "Import a single domain including settings from XML file." " Does not overwrite an existing domain unless 'overwrite' is passed as second" - " argument" }, - { "exportSettings", &CParameterMgr::exportSettingsCommmandProcess, 1, - "<file path>", "Export settings to binary file" }, - { "importSettings", &CParameterMgr::importSettingsCommmandProcess, 1, - "<file path>", "Import settings from binary file" }, + " argument. Provide an absolute path or relative to the client's working directory)" }, + { "exportSettings", &CParameterMgr::exportSettingsCommandProcess, 1, + "<file path>", "Export settings to binary file (provide an absolute path or relative" + "to the client's working directory)" }, + { "importSettings", &CParameterMgr::importSettingsCommandProcess, 1, + "<file path>", "Import settings from binary file (provide an absolute path or relative" + "to the client's working directory)" }, { "getDomainsWithSettingsXML", - &CParameterMgr::getConfigurableDomainsWithSettingsXMLCommmandProcess, 0, + &CParameterMgr::getDomainsWithSettingsXMLCommandProcess, 0, "", "Print domains including settings as XML" }, { "getDomainWithSettingsXML", - &CParameterMgr::getConfigurableDomainWithSettingsXMLCommmandProcess, 1, + &CParameterMgr::getDomainWithSettingsXMLCommandProcess, 1, "<domain>", "Print the given domain including settings as XML" }, { "setDomainsWithSettingsXML", - &CParameterMgr::setConfigurableDomainsWithSettingsXMLCommmandProcess, 1, + &CParameterMgr::setDomainsWithSettingsXMLCommandProcess, 1, "<xml configurable domains>", "Import domains including settings from XML string" }, + { "setDomainWithSettingsXML", + &CParameterMgr::setDomainWithSettingsXMLCommandProcess, 1, + "<xml configurable domain> [overwrite]", "Import domains including settings from XML" + " string. Does not overwrite an existing domain unless 'overwrite' is passed as second" + " argument" }, /// Structure Export - { "getSystemClassXML", &CParameterMgr::getSystemClassXMLCommmandProcess, 0 , + { "getSystemClassXML", &CParameterMgr::getSystemClassXMLCommandProcess, 0 , "", "Print parameter structure as XML" }, /// Deprecated Commands { "getDomainsXML", - &CParameterMgr::getConfigurableDomainsWithSettingsXMLCommmandProcess, 0, + &CParameterMgr::getDomainsWithSettingsXMLCommandProcess, 0, "", "DEPRECATED COMMAND, please use getDomainsWithSettingsXML" }, }; @@ -430,11 +447,11 @@ string CParameterMgr::getVersion() const string strVersion; // Major - strVersion = toString(guiEditionMajor) + "."; + strVersion = CUtility::toString(guiEditionMajor) + "."; // Minor - strVersion += toString(guiEditionMinor) + "."; + strVersion += CUtility::toString(guiEditionMinor) + "."; // Revision - strVersion += toString(guiRevision); + strVersion += CUtility::toString(guiRevision); return strVersion; } @@ -519,7 +536,13 @@ bool CParameterMgr::loadFrameworkConfiguration(string& strError) // Parse Structure XML file CXmlElementSerializingContext elementSerializingContext(strError); - if (!xmlParse(elementSerializingContext, getFrameworkConfiguration(), _strXmlConfigurationFilePath, _strXmlConfigurationFolderPath, EFrameworkConfigurationLibrary)) { + _xmlDoc *doc = CXmlDocSource::mkXmlDoc(_strXmlConfigurationFilePath, true, true, strError); + if (doc == NULL) { + return false; + } + + if (!xmlParse(elementSerializingContext, getFrameworkConfiguration(), doc, + _strXmlConfigurationFolderPath, EFrameworkConfigurationLibrary)) { return false; } @@ -548,7 +571,7 @@ bool CParameterMgr::loadStructure(string& strError) // Retrieve system to load structure to CSystemClass* pSystemClass = getSystemClass(); - log_info("Loading " + pSystemClass->getName() + " system class structure"); + log_info("Loading %s system class structure", pSystemClass->getName().c_str()); // Get structure description element const CFrameworkConfigurationLocation* pStructureDescriptionFileLocation = static_cast<const CFrameworkConfigurationLocation*>(getConstFrameworkConfiguration()->findChildOfKind("StructureDescriptionFileLocation")); @@ -571,7 +594,12 @@ bool CParameterMgr::loadStructure(string& strError) CAutoLog autolog(pSystemClass, "Importing system structure from file " + strXmlStructureFilePath); - if (!xmlParse(parameterBuildContext, pSystemClass, strXmlStructureFilePath, strXmlStructureFolder, EParameterCreationLibrary)) { + _xmlDoc *doc = CXmlDocSource::mkXmlDoc(strXmlStructureFilePath, true, true, strError); + if (doc == NULL) { + return false; + } + + if (!xmlParse(parameterBuildContext, pSystemClass, doc, strXmlStructureFolder, EParameterCreationLibrary)) { return false; } @@ -592,7 +620,7 @@ bool CParameterMgr::loadSettings(string& strError) if (!success && !_bFailOnFailedSettingsLoad) { // Load can not fail, ie continue but log the load errors - log_info(strLoadError); + log_info("%s", strLoadError.c_str()); log_info("Failed to load settings, continue without domains."); success = true; } @@ -660,8 +688,12 @@ bool CParameterMgr::loadSettingsFromConfigFile(string& strError) log_info("Importing configurable domains from file %s %s settings", strXmlConfigurationDomainsFilePath.c_str(), pBinarySettingsFileLocation ? "without" : "with"); - // Do parse - if (!xmlParse(xmlDomainImportContext, pConfigurableDomains, strXmlConfigurationDomainsFilePath, strXmlConfigurationDomainsFolder, EParameterConfigurationLibrary, "SystemClassName")) { + _xmlDoc *doc = CXmlDocSource::mkXmlDoc(strXmlConfigurationDomainsFilePath, true, true, strError); + if (doc == NULL) { + return false; + } + + if (!xmlParse(xmlDomainImportContext, pConfigurableDomains, doc, strXmlConfigurationDomainsFolder, EParameterConfigurationLibrary, "SystemClassName")) { return false; } @@ -678,40 +710,12 @@ bool CParameterMgr::loadSettingsFromConfigFile(string& strError) return true; } -bool CParameterMgr::importDomainFromFile(const string& strXmlFilePath, bool bOverwrite, - string& strError) -{ - CXmlDomainImportContext xmlDomainImportContext(strError, true, *getSystemClass()); - - // Selection criteria definition for rule creation - xmlDomainImportContext.setSelectionCriteriaDefinition( - getConstSelectionCriteria()->getSelectionCriteriaDefinition()); - - // Auto validation of configurations - xmlDomainImportContext.setAutoValidationRequired(true); - - // We initialize the domain with an empty name but since we have set the isDomainStandalone - // context, the name will be retrieved during de-serialization - std::auto_ptr<CConfigurableDomain> standaloneDomain(new CConfigurableDomain()); - bool bSuccess = xmlParse(xmlDomainImportContext, standaloneDomain.get(), - strXmlFilePath, "", EParameterConfigurationLibrary, ""); - - if (!bSuccess) { - return false; - } - - bSuccess = getConfigurableDomains()->addDomain(*standaloneDomain, bOverwrite, strError); - if (!bSuccess) { - return false; - } - - // ownership has been transfered to the ConfigurableDomains object - standaloneDomain.release(); - return true; -} - // XML parsing -bool CParameterMgr::xmlParse(CXmlElementSerializingContext& elementSerializingContext, CElement* pRootElement, const string& strXmlFilePath, const string& strXmlFolder, CParameterMgr::ElementLibrary eElementLibrary, const string& strNameAttrituteName) +bool CParameterMgr::xmlParse(CXmlElementSerializingContext& elementSerializingContext, + CElement* pRootElement, _xmlDoc* doc, + const string& strXmlFolder, + CParameterMgr::ElementLibrary eElementLibrary, + const string& strNameAttributeName) { // Init serializing context elementSerializingContext.set(_pElementLibrarySet->getElementLibrary( @@ -720,25 +724,18 @@ bool CParameterMgr::xmlParse(CXmlElementSerializingContext& elementSerializingCo // Get Schema file associated to root element string strXmlSchemaFilePath = _strSchemaFolderLocation + "/" + pRootElement->getKind() + ".xsd"; - std::auto_ptr<CXmlFileDocSource> fileDocSource(NULL); - - if (strNameAttrituteName.empty()) { - fileDocSource.reset(new CXmlFileDocSource(strXmlFilePath, strXmlSchemaFilePath, - pRootElement->getKind(), - _bValidateSchemasOnStart)); - } else { - fileDocSource.reset(new CXmlFileDocSource(strXmlFilePath, strXmlSchemaFilePath, - pRootElement->getKind(), - pRootElement->getName(), strNameAttrituteName, - _bValidateSchemasOnStart)); - } + CXmlDocSource docSource(doc, _bValidateSchemasOnStart, + strXmlSchemaFilePath, + pRootElement->getKind(), + pRootElement->getName(), + strNameAttributeName); // Start clean pRootElement->clean(); CXmlMemoryDocSink memorySink(pRootElement); - if (!memorySink.process(*fileDocSource, elementSerializingContext)) { + if (!memorySink.process(docSource, elementSerializingContext)) { //Cleanup pRootElement->clean(); @@ -905,7 +902,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::statusCommandProces // Show status /// General section - appendTitle(strResult, "General:"); + CUtility::appendTitle(strResult, "General:"); // System class strResult += "System Class: "; strResult += pSystemClass->getName(); @@ -932,19 +929,19 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::statusCommandProces strResult += "\n"; /// Subsystem list - appendTitle(strResult, "Subsystems:"); + CUtility::appendTitle(strResult, "Subsystems:"); string strSubsystemList; pSystemClass->listChildrenPaths(strSubsystemList); strResult += strSubsystemList; /// Last applied configurations - appendTitle(strResult, "Last Applied [Pending] Configurations:"); + CUtility::appendTitle(strResult, "Last Applied [Pending] Configurations:"); string strLastAppliedConfigurations; getConfigurableDomains()->listLastAppliedConfigurations(strLastAppliedConfigurations); strResult += strLastAppliedConfigurations; /// Criteria states - appendTitle(strResult, "Selection Criteria:"); + CUtility::appendTitle(strResult, "Selection Criteria:"); list<string> lstrSelectionCriteria; getSelectionCriteria()->listSelectionCriteria(lstrSelectionCriteria, false, true); // Concatenate the criterion list as the command result @@ -956,7 +953,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::statusCommandProces } /// Tuning Mode -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setTuningModeCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setTuningModeCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { if (remoteCommand.getArgument(0) == "on") { @@ -977,7 +974,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setTuningModeCommma return CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getTuningModeCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getTuningModeCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -987,7 +984,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getTuningModeCommma } /// Value Space -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setValueSpaceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)strResult; @@ -1010,7 +1007,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setValueSpaceCommma return CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getValueSpaceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1020,7 +1017,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getValueSpaceCommma } /// Output Raw Format -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setOutputRawFormatCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)strResult; @@ -1043,7 +1040,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setOutputRawFormatC return CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getOutputRawFormatCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1053,7 +1050,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getOutputRawFormatC } /// Sync -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setAutoSyncCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { if (remoteCommand.getArgument(0) == "on") { @@ -1074,7 +1071,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setAutoSyncCommmand return CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getAutoSyncCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1083,7 +1080,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getAutoSyncCommmand return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::syncCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::syncCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1091,7 +1088,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::syncCommmandProcess } /// Criteria -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listCriteriaCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listCriteriaCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { if (remoteCommand.getArgumentCount() > 1) { @@ -1143,7 +1140,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listCriteriaCommman } /// Domains -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1152,30 +1149,30 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainsCommmand return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return createDomain(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return deleteDomain(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteAllDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteAllDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; return deleteAllDomains(strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return renameDomain(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setSequenceAwarenessCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Set property bool bSequenceAware; @@ -1197,7 +1194,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setSequenceAwarenes CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getSequenceAwarenessCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Get property bool bSequenceAware; @@ -1212,33 +1209,33 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getSequenceAwarenes return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listDomainElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return getConfigurableDomains()->listDomainElements(remoteCommand.getArgument(0), strResult) ? CCommandHandler::ESucceeded : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::addElementCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::addElementCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return addConfigurableElementToDomain(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::removeElementCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::removeElementCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return removeConfigurableElementFromDomain(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::splitDomainCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::splitDomainCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return split(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } /// Configurations -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConfigurationsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConfigurationsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return getConstConfigurableDomains()->listConfigurations(remoteCommand.getArgument(0), strResult) ? CCommandHandler::ESucceeded : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1252,29 +1249,29 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpDomainsCommmand return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::createConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return createConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::deleteConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return deleteConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::renameConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return renameConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), remoteCommand.getArgument(2), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::saveConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::saveConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return saveConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::restoreConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::restoreConfigurationCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { list<string> lstrResult; if (!restoreConfiguration(remoteCommand.getArgument(0), remoteCommand.getArgument(1), lstrResult)) { @@ -1286,7 +1283,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::restoreConfiguratio return CCommandHandler::EDone; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setElementSequenceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Build configurable element path list std::vector<string> astrNewElementSequence; @@ -1304,13 +1301,13 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setElementSequenceC CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSequenceCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Delegate to configurable domains return getConfigurableDomains()->getElementSequence(remoteCommand.getArgument(0), remoteCommand.getArgument(1), strResult) ? CCommandHandler::ESucceeded : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setRuleCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setRuleCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Delegate to configurable domains return setApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1), @@ -1318,7 +1315,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setRuleCommmandProc CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::clearRuleCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::clearRuleCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Delegate to configurable domains return clearApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1), @@ -1326,7 +1323,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::clearRuleCommmandPr CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getRuleCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getRuleCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Delegate to configurable domains return getApplicationRule(remoteCommand.getArgument(0), remoteCommand.getArgument(1), @@ -1335,7 +1332,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getRuleCommmandProc } /// Elements/Parameters -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { CElementLocator elementLocator(getSystemClass(), false); @@ -1363,7 +1360,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listElementsCommman } /// Elements/Parameters -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listParametersCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listParametersCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { CElementLocator elementLocator(getSystemClass(), false); @@ -1390,7 +1387,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listParametersCommm return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpElementCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpElementCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { CElementLocator elementLocator(getSystemClass()); @@ -1411,7 +1408,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::dumpElementCommmand return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSizeCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSizeCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { CElementLocator elementLocator(getSystemClass()); @@ -1431,7 +1428,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getElementSizeCommm return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showPropertiesCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showPropertiesCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { CElementLocator elementLocator(getSystemClass()); @@ -1451,7 +1448,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showPropertiesCommm return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { string strValue; @@ -1465,7 +1462,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getParameterCommman return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Get value to set string strValue = remoteCommand.packArguments(1, remoteCommand.getArgumentCount() - 1); @@ -1473,7 +1470,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setParameterCommman return accessParameterValue(remoteCommand.getArgument(0), strValue, true, strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listBelongingDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listBelongingDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { CElementLocator elementLocator(getSystemClass()); @@ -1493,7 +1490,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listBelongingDomain return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedDomainsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedDomainsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { CElementLocator elementLocator(getSystemClass()); @@ -1513,7 +1510,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedDomai return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1522,7 +1519,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listAssociatedEleme return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConflictingElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConflictingElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1531,7 +1528,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listConflictingElem return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listRogueElementsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listRogueElementsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1540,7 +1537,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::listRogueElementsCo return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getConfigurationParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { string strOutputValue; string strError; @@ -1556,7 +1553,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::getConfigurationPar return CCommandHandler::ESucceeded; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setConfigurationParameterCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { // Get value to set string strValue = remoteCommand.packArguments(3, remoteCommand.getArgumentCount() - 3); @@ -1569,7 +1566,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::setConfigurationPar return bSuccess ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showMappingCommmandProcess( +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showMappingCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { @@ -1583,7 +1580,7 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::showMappingCommmand /// Settings Import/Export CParameterMgr::CCommandHandler::CommandStatus - CParameterMgr::exportConfigurableDomainsToXMLCommmandProcess( + CParameterMgr::exportDomainsXMLCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { string strFileName = remoteCommand.getArgument(0); @@ -1592,7 +1589,7 @@ CParameterMgr::CCommandHandler::CommandStatus } CParameterMgr::CCommandHandler::CommandStatus - CParameterMgr::importConfigurableDomainsFromXMLCommmandProcess( + CParameterMgr::importDomainsXMLCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { return importDomainsXml(remoteCommand.getArgument(0), false, true, strResult) ? @@ -1600,7 +1597,7 @@ CParameterMgr::CCommandHandler::CommandStatus } CParameterMgr::CCommandHandler::CommandStatus - CParameterMgr::exportConfigurableDomainsWithSettingsToXMLCommmandProcess( + CParameterMgr::exportDomainsWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { string strFileName = remoteCommand.getArgument(0); @@ -1608,12 +1605,22 @@ CParameterMgr::CCommandHandler::CommandStatus CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importConfigurableDomainsWithSettingsFromXMLCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus + CParameterMgr::exportDomainWithSettingsXMLCommandProcess( + const IRemoteCommand& remoteCommand, string& result) +{ + string domainName = remoteCommand.getArgument(0); + string fileName = remoteCommand.getArgument(1); + return exportSingleDomainXml(fileName, domainName, true, true, result) ? + CCommandHandler::EDone : CCommandHandler::EFailed; +} + +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importDomainsWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return importDomainsXml(remoteCommand.getArgument(0), true, true, strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importConfigurableDomainWithSettingsFromXMLCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importDomainWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { bool bOverwrite = false; @@ -1629,22 +1636,22 @@ CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importConfigurableD } } - return importSingleDomainXml(remoteCommand.getArgument(0), bOverwrite, strResult) ? + return importSingleDomainXml(remoteCommand.getArgument(0), bOverwrite, true, true, strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::exportSettingsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::exportSettingsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return exportDomainsBinary(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } -CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importSettingsCommmandProcess(const IRemoteCommand& remoteCommand, string& strResult) +CParameterMgr::CCommandHandler::CommandStatus CParameterMgr::importSettingsCommandProcess(const IRemoteCommand& remoteCommand, string& strResult) { return importDomainsBinary(remoteCommand.getArgument(0), strResult) ? CCommandHandler::EDone : CCommandHandler::EFailed; } CParameterMgr::CCommandHandler::CommandStatus - CParameterMgr::getConfigurableDomainsWithSettingsXMLCommmandProcess( + CParameterMgr::getDomainsWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -1658,7 +1665,7 @@ CParameterMgr::CCommandHandler::CommandStatus } CParameterMgr::CCommandHandler::CommandStatus - CParameterMgr::getConfigurableDomainWithSettingsXMLCommmandProcess( + CParameterMgr::getDomainWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { string strDomainName = remoteCommand.getArgument(0); @@ -1668,7 +1675,7 @@ CParameterMgr::CCommandHandler::CommandStatus } CParameterMgr::CCommandHandler::CommandStatus - CParameterMgr::setConfigurableDomainsWithSettingsXMLCommmandProcess( + CParameterMgr::setDomainsWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { return importDomainsXml(remoteCommand.getArgument(0), true, false, strResult) ? @@ -1676,7 +1683,28 @@ CParameterMgr::CCommandHandler::CommandStatus } CParameterMgr::CCommandHandler::CommandStatus - CParameterMgr::getSystemClassXMLCommmandProcess( + CParameterMgr::setDomainWithSettingsXMLCommandProcess( + const IRemoteCommand& remoteCommand, string& result) +{ + bool overwrite = false; + + if (remoteCommand.getArgumentCount() > 1) { + + if (remoteCommand.getArgument(1) == "overwrite") { + + overwrite = true; + } else { + // Show usage + return CCommandHandler::EShowUsage; + } + } + + return importSingleDomainXml(remoteCommand.getArgument(0), overwrite, true, false, result) ? + CCommandHandler::EDone : CCommandHandler::EFailed; +} + +CParameterMgr::CCommandHandler::CommandStatus + CParameterMgr::getSystemClassXMLCommandProcess( const IRemoteCommand& remoteCommand, string& strResult) { (void)remoteCommand; @@ -2181,184 +2209,178 @@ bool CParameterMgr::clearApplicationRule(const string& strDomain, const string& return getConfigurableDomains()->clearApplicationRule(strDomain, strConfiguration, strError); } -bool CParameterMgr::importDomainsXml(const string& strXmlSource, bool bWithSettings, - bool bFromFile, string& strError) +bool CParameterMgr::importDomainsXml(const string& xmlSource, bool withSettings, + bool fromFile, string& errorMsg) { // Check tuning mode - if (!checkTuningModeOn(strError)) { + if (!checkTuningModeOn(errorMsg)) { return false; } - // check path is absolute - if (bFromFile && strXmlSource[0] != '/') { - - strError = "Please provide absolute path"; + CAutoLog autoLog(this, string("Importing domains from ") + + (fromFile ? ("\"" + xmlSource + "\"") : "a user-provided buffer")); - return false; - } // Root element CConfigurableDomains* pConfigurableDomains = getConfigurableDomains(); - // Context - CXmlDomainImportContext xmlDomainImportContext(strError, bWithSettings, *getSystemClass()); - - // Selection criteria definition for rule creation - xmlDomainImportContext.setSelectionCriteriaDefinition( - getConstSelectionCriteria()->getSelectionCriteriaDefinition()); - - // Init serializing context - xmlDomainImportContext.set( - _pElementLibrarySet->getElementLibrary(EParameterConfigurationLibrary), - "", _strSchemaFolderLocation); - - // Get Schema file associated to root element - string strXmlSchemaFilePath = _strSchemaFolderLocation + "/" + - pConfigurableDomains->getKind() + ".xsd"; + bool importSuccess = wrapLegacyXmlImport(xmlSource, fromFile, withSettings, + *pConfigurableDomains, "SystemClassName", errorMsg); - // Xml Source - CXmlDocSource* pSource; - - if (bFromFile) { - - // when importing from a file strXmlSource is the file name - pSource = new CXmlFileDocSource(strXmlSource, strXmlSchemaFilePath, - pConfigurableDomains->getKind(), - pConfigurableDomains->getName(), "SystemClassName", - _bValidateSchemasOnStart); - - } else { - - // when importing from an xml string, strXmlSource contains the string - pSource = new CXmlStringDocSource(strXmlSource, strXmlSchemaFilePath, - pConfigurableDomains->getKind(), - pConfigurableDomains->getName(), "SystemClassName", - _bValidateSchemasOnStart); - - } - // Start clean - pConfigurableDomains->clean(); - - // Use a doc sink that instantiate Configurable Domains from the given doc source - CXmlMemoryDocSink memorySink(pConfigurableDomains); - - bool bProcessSuccess = memorySink.process(*pSource, xmlDomainImportContext); - - if (!bProcessSuccess) { - - //Cleanup - pConfigurableDomains->clean(); - - } else { + if (importSuccess) { // Validate domains after XML import pConfigurableDomains->validate(_pMainParameterBlackboard); - } - delete pSource; - - return bProcessSuccess; + return importSuccess; } -bool CParameterMgr::importSingleDomainXml(const string& strXmlSource, bool bOverwrite, - string& strError) +bool CParameterMgr::importSingleDomainXml(const string& xmlSource, bool overwrite, + bool withSettings, bool fromFile, string& errorMsg) { - if (!checkTuningModeOn(strError)) { + if (!checkTuningModeOn(errorMsg)) { return false; } - // check path is absolute - if (strXmlSource[0] != '/') { + CAutoLog autoLog(this, string("Importing a single domain from ") + + (fromFile ? ("\"" + xmlSource + "\"") : "a user-provided buffer")); - strError = "Please provide absolute path"; + // We initialize the domain with an empty name but since we have set the isDomainStandalone + // context, the name will be retrieved during de-serialization + std::auto_ptr<CConfigurableDomain> standaloneDomain(new CConfigurableDomain()); + if (!wrapLegacyXmlImport(xmlSource, fromFile, withSettings, *standaloneDomain, "", errorMsg)) { return false; } - return importDomainFromFile(strXmlSource, bOverwrite, strError); + if (!getConfigurableDomains()->addDomain(*standaloneDomain, overwrite, errorMsg)) { + return false; + } + + // ownership has been transfered to the ConfigurableDomains object + standaloneDomain.release(); + return true; } -bool CParameterMgr::serializeElement(string& strXmlDest, - CXmlSerializingContext& xmlSerializingContext, bool bToFile, - const CElement& element, string& strError) const +bool CParameterMgr::wrapLegacyXmlImport(const string& xmlSource, bool fromFile, + bool withSettings, CElement& element, + const string& nameAttributeName, string& errorMsg) { - // check path is absolute - if (bToFile && strXmlDest[0] != '/') { + CXmlDomainImportContext xmlDomainImportContext(errorMsg, withSettings, *getSystemClass()); - strError = "Please provide absolute path"; + // Selection criteria definition for rule creation + xmlDomainImportContext.setSelectionCriteriaDefinition( + getConstSelectionCriteria()->getSelectionCriteriaDefinition()); + // It doesn't make sense to resolve XIncludes on an imported file because + // we can't reliably decide of a "base url" + _xmlDoc *doc = CXmlDocSource::mkXmlDoc(xmlSource, fromFile, false, errorMsg); + if (doc == NULL) { + return false; + } + + return xmlParse(xmlDomainImportContext, &element, doc, "", EParameterConfigurationLibrary, nameAttributeName); +} + +bool CParameterMgr::serializeElement(std::ostream& output, + CXmlSerializingContext& xmlSerializingContext, + const CElement& element) const +{ + if (!output.good()) { + xmlSerializingContext.setError("Can't write XML: the output is in a bad state."); return false; } // Get Schema file associated to root element - string strXmlSchemaFilePath = _strSchemaFolderLocation + "/" + + string xmlSchemaFilePath = _strSchemaFolderLocation + "/" + element.getKind() + ".xsd"; // Use a doc source by loading data from instantiated Configurable Domains - CXmlMemoryDocSource memorySource(&element, element.getKind(), - strXmlSchemaFilePath, "parameter-framework", - getVersion(), _bValidateSchemasOnStart); - - // Xml Sink - CXmlDocSink* pSink; + CXmlMemoryDocSource memorySource(&element, _bValidateSchemasOnStart, + element.getKind(), + xmlSchemaFilePath, + "parameter-framework", + getVersion()); - if (bToFile) { + // Use a doc sink to write the doc data in a stream + CXmlStreamDocSink sink(output); - // Use a doc sink to write the doc data in a file - pSink = new CXmlFileDocSink(strXmlDest); + bool processSuccess = sink.process(memorySource, xmlSerializingContext); - } else { + return processSuccess; +} - // Use a doc sink to write the doc data in a string - // TODO: use a stream rather than a string - pSink = new CXmlStringDocSink(strXmlDest); - } +bool CParameterMgr::exportDomainsXml(string& xmlDest, bool withSettings, bool toFile, + string& errorMsg) const +{ + CAutoLog autoLog(this, string("Exporting domains to ") + + (toFile ? ("\"" + xmlDest + "\"") : " a user-provided buffer")); - bool bProcessSuccess = pSink->process(memorySource, xmlSerializingContext); + const CConfigurableDomains* configurableDomains = getConstConfigurableDomains(); - delete pSink; - return bProcessSuccess; + return wrapLegacyXmlExport(xmlDest, toFile, withSettings, *configurableDomains, errorMsg); } -bool CParameterMgr::exportDomainsXml(string& strXmlDest, bool bWithSettings, bool bToFile, - string& strError) const +bool CParameterMgr::exportSingleDomainXml(string& xmlDest, const string& domainName, + bool withSettings, bool toFile, string& errorMsg) const { - const CConfigurableDomains* pConfigurableDomains = getConstConfigurableDomains(); + CAutoLog autoLog(this, string("Exporting single domain '") + domainName + "' to " + + (toFile ? ("\"" + xmlDest + "\"") : " a user-provided buffer")); - CXmlDomainExportContext xmlDomainExportContext(strError, bWithSettings); + // Element to be serialized + const CConfigurableDomain* requestedDomain = + getConstConfigurableDomains()->findConfigurableDomain(domainName, errorMsg); - xmlDomainExportContext.setValueSpaceRaw(_bValueSpaceIsRaw); + if (requestedDomain == NULL) { + return false; + } - xmlDomainExportContext.setOutputRawFormat(_bOutputRawFormatIsHex); + return wrapLegacyXmlExport(xmlDest, toFile, withSettings, *requestedDomain, errorMsg); +} +bool CParameterMgr::wrapLegacyXmlExport(string& xmlDest, bool toFile, bool withSettings, + const CElement& element, string& errorMsg) const +{ + CXmlDomainExportContext context(errorMsg, withSettings, _bValueSpaceIsRaw, + _bOutputRawFormatIsHex); - return serializeElement(strXmlDest, xmlDomainExportContext, bToFile, - *pConfigurableDomains, strError); + if (toFile) { + return wrapLegacyXmlExportToFile(xmlDest, element, context); + } else { + return wrapLegacyXmlExportToString(xmlDest, element, context); + } } -bool CParameterMgr::exportSingleDomainXml(string& strXmlDest, const string& strDomainName, - bool bWithSettings, bool bToFile, string& strError) const +bool CParameterMgr::wrapLegacyXmlExportToFile(string& xmlDest, + const CElement& element, + CXmlDomainExportContext &context) const { - const CConfigurableDomains* pAllDomains = getConstConfigurableDomains(); - - // Element to be serialized - const CConfigurableDomain* pRequestedDomain = - pAllDomains->findConfigurableDomain(strDomainName, strError); + std::ofstream output(xmlDest.c_str()); - if (!pRequestedDomain) { + if (output.fail()) { + context.setError("Failed to open \"" + xmlDest + "\" for writing."); return false; } - CXmlDomainExportContext xmlDomainExportContext(strError, bWithSettings); + return serializeElement(output, context, element); - xmlDomainExportContext.setValueSpaceRaw(_bValueSpaceIsRaw); +} + +bool CParameterMgr::wrapLegacyXmlExportToString(string& xmlDest, + const CElement& element, + CXmlDomainExportContext &context) const +{ + std::ostringstream output; - xmlDomainExportContext.setOutputRawFormat(_bOutputRawFormatIsHex); + if (!serializeElement(output, context, element)) { + return false; + } - return serializeElement(strXmlDest, xmlDomainExportContext, bToFile, - *pRequestedDomain, strError); + xmlDest = output.str(); + + return true; } // Binary Import/Export @@ -2369,13 +2391,8 @@ bool CParameterMgr::importDomainsBinary(const string& strFileName, string& strEr return false; } - // check path is absolute - if (strFileName[0] != '/') { - strError = "Please provide absolute path"; - - return false; - } + CAutoLog autoLog(this, string("Importing domains from binary file \"") + strFileName + "\""); // Root element CConfigurableDomains* pConfigurableDomains = getConfigurableDomains(); @@ -2385,14 +2402,7 @@ bool CParameterMgr::importDomainsBinary(const string& strFileName, string& strEr bool CParameterMgr::exportDomainsBinary(const string& strFileName, string& strError) { - // check path is absolute - if (strFileName[0] != '/') { - - strError = "Please provide absolute path"; - - return false; - } - + CAutoLog autoLog(this, string("Exporting domains to binary file \"") + strFileName + "\""); // Root element CConfigurableDomains* pConfigurableDomains = getConfigurableDomains(); @@ -2531,12 +2541,12 @@ bool CParameterMgr::handleRemoteProcessingInterface(string& strError) log_info("Starting remote processor server on port %d", getConstFrameworkConfiguration()->getServerPort()); // Start - if (!_pRemoteProcessorServer->start()) { + if (!_pRemoteProcessorServer->start(strError)) { ostringstream oss; oss << "ParameterMgr: Unable to start remote processor server on port " << getConstFrameworkConfiguration()->getServerPort(); - strError = oss.str(); + strError = oss.str() + ": " + strError; return false; } @@ -2617,16 +2627,18 @@ bool CParameterMgr::exportElementToXMLString(const IXmlSource* pXmlSource, CXmlSerializingContext xmlSerializingContext(strError); // Use a doc source by loading data from instantiated Configurable Domains - CXmlMemoryDocSource memorySource(pXmlSource, strRootElementType, false); + CXmlMemoryDocSource memorySource(pXmlSource, false, strRootElementType); // Use a doc sink that write the doc data in a string - CXmlStringDocSink stringSink(strResult); + ostringstream output; + CXmlStreamDocSink streamSink(output); // Do the export - bool bProcessSuccess = stringSink.process(memorySource, xmlSerializingContext); - - if (!bProcessSuccess) { + bool bProcessSuccess = streamSink.process(memorySource, xmlSerializingContext); + if (bProcessSuccess) { + strResult = output.str(); + } else { strResult = strError; } diff --git a/parameter/ParameterMgr.h b/parameter/ParameterMgr.h index ef834eb..cd2f664 100644 --- a/parameter/ParameterMgr.h +++ b/parameter/ParameterMgr.h @@ -40,8 +40,11 @@ #include "Element.h" #include "XmlDocSink.h" #include "XmlDocSource.h" +#include "XmlDomainExportContext.h" #include <string> +#include <ostream> +#include <istream> class CElementLibrarySet; class CSubsystemLibrary; @@ -86,9 +89,9 @@ class CParameterMgr : private CElement const char* _pcDescription; }; // Version - static const uint32_t guiEditionMajor = 0x2; - static const uint32_t guiEditionMinor = 0x4; - static const uint32_t guiRevision = 0x3; + static const uint32_t guiEditionMajor = 2; + static const uint32_t guiEditionMinor = 6; + static const uint32_t guiRevision = 0; // Parameter handle friendship friend class CParameterHandle; @@ -275,63 +278,65 @@ public: /** * Method that imports Configurable Domains from an Xml source. * - * @param[in] strXmlSource a std::string containing an xml description or a path to an xml file - * @param[in] bWithSettings a boolean that determines if the settings should be used in the + * @param[in] xmlSource a std::string containing an xml description or a path to an xml file + * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description - * @param[in] bFromFile a boolean that determines if the source is an xml description in - * strXmlSource or contained in a file. In that case strXmlSource is just the file path. - * @param[out] strError is used as the error output + * @param[in] fromFile a boolean that determines if the source is an xml description in + * xmlSource or contained in a file. In that case xmlSource is just the file path. + * @param[out] errorMsg is used as the error output * * @return false if any error occures */ - bool importDomainsXml(const std::string& strXmlSource, bool bWithSettings, bool bFromFile, - std::string& strError); + bool importDomainsXml(const std::string& xmlSource, bool withSettings, bool fromFile, + std::string& errorMsg); /** * Method that imports a single Configurable Domain from an Xml source. * - * @param[in] strXmlSource a string containing an xml description or a path to an xml file - * @param[in] bWithSettings a boolean that determines if the settings should be used in the + * @param[in] xmlSource a string containing an xml description or a path to an xml file + * @param[in] overwrite when importing an existing domain, allow + * overwriting or return an error + * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description - * @param[in] bFromFile a boolean that determines if the source is an xml description in - * strXmlSource or contained in a file. In that case strXmlSource is just the file path. - * @param[out] strError is used as the error output + * @param[in] fromFile a boolean that determines if the source is an xml description in + * xmlSource or contained in a file. In that case xmlSource is just the file path. + * @param[out] errorMsg is used as the error output * * @return false if any error occurs */ - bool importSingleDomainXml(const std::string& strXmlSource, bool bOverwrite, - std::string& strError); + bool importSingleDomainXml(const std::string& xmlSource, bool overwrite, bool withSettings, + bool fromFile, std::string& errorMsg); /** * Method that exports Configurable Domains to an Xml destination. * - * @param[in,out] strXmlDest a string containing an xml description or a path to an xml file - * @param[in] bWithSettings a boolean that determines if the settings should be used in the + * @param[in,out] xmlDest a string containing an xml description or a path to an xml file + * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description - * @param[in] bToFile a boolean that determines if the destination is an xml description in - * strXmlDest or contained in a file. In that case strXmlDest is just the file path. - * @param[out] strError is used as the error output + * @param[in] toFile a boolean that determines if the destination is an xml description in + * xmlDest or contained in a file. In that case xmlDest is just the file path. + * @param[out] errorMsg is used as the error output * * @return false if any error occurs, true otherwise. */ - bool exportDomainsXml(std::string& strXmlDest, bool bWithSettings, bool bToFile, - std::string& strError) const; + bool exportDomainsXml(std::string& xmlDest, bool withSettings, bool toFile, + std::string& errorMsg) const; /** * Method that exports a given Configurable Domain to an Xml destination. * - * @param[in,out] strXmlDest a string containing an xml description or a path to an xml file - * @param[in] strDomainName the name of the domain to be exported - * @param[in] bWithSettings a boolean that determines if the settings should be used in the + * @param[in,out] xmlDest a string containing an xml description or a path to an xml file + * @param[in] domainName the name of the domain to be exported + * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description - * @param[in] bToFile a boolean that determines if the destination is an xml description in - * strXmlDest or contained in a file. In that case strXmlDest is just the file path. - * @param[out] strError is used as the error output + * @param[in] toFile a boolean that determines if the destination is an xml description in + * xmlDest or contained in a file. In that case xmlDest is just the file path. + * @param[out] errorMsg is used as the error output * * @return false if any error occurs, true otherwise. */ - bool exportSingleDomainXml(std::string& strXmlDest, const std::string& strDomainName, - bool bWithSettings, bool bToFile, std::string& strError) const; + bool exportSingleDomainXml(std::string& xmlDest, const std::string& domainName, + bool withSettings, bool toFile, std::string& errorMsg) const; // Binary Import/Export bool importDomainsBinary(const std::string& strFileName, std::string& strError); @@ -374,74 +379,84 @@ private: /// Status CCommandHandler::CommandStatus statusCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Tuning Mode - CCommandHandler::CommandStatus setTuningModeCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getTuningModeCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setTuningModeCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getTuningModeCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Value Space - CCommandHandler::CommandStatus setValueSpaceCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getValueSpaceCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getValueSpaceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Output Raw Format - CCommandHandler::CommandStatus setOutputRawFormatCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getOutputRawFormatCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getOutputRawFormatCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Sync - CCommandHandler::CommandStatus setAutoSyncCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getAutoSyncCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus syncCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getAutoSyncCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus syncCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Criteria - CCommandHandler::CommandStatus listCriteriaCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listCriteriaCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Domains - CCommandHandler::CommandStatus listDomainsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus createDomainCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus deleteDomainCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus deleteAllDomainsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus renameDomainCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus setSequenceAwarenessCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getSequenceAwarenessCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus listDomainElementsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus addElementCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus removeElementCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus splitDomainCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus createDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus deleteDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus deleteAllDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus renameDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getSequenceAwarenessCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listDomainElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus addElementCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus removeElementCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus splitDomainCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Configurations - CCommandHandler::CommandStatus listConfigurationsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus dumpDomainsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus createConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus deleteConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus renameConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus saveConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus restoreConfigurationCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus setElementSequenceCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getElementSequenceCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus setRuleCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus clearRuleCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getRuleCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listConfigurationsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus dumpDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus createConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus deleteConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus renameConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus saveConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus restoreConfigurationCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getElementSequenceCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setRuleCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus clearRuleCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getRuleCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Elements/Parameters - CCommandHandler::CommandStatus listElementsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus listParametersCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus dumpElementCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getElementSizeCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus showPropertiesCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getParameterCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus setParameterCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus getConfigurationParameterCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus setConfigurationParameterCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus listBelongingDomainsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus listAssociatedDomainsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus showMappingCommmandProcess(const IRemoteCommand& remoteCommand, + CCommandHandler::CommandStatus listElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listParametersCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus dumpElementCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getElementSizeCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus showPropertiesCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus getConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus setConfigurationParameterCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listBelongingDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listAssociatedDomainsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus showMappingCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Browse - CCommandHandler::CommandStatus listAssociatedElementsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus listConflictingElementsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus listRogueElementsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listAssociatedElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listConflictingElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus listRogueElementsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /// Settings Import/Export - CCommandHandler::CommandStatus exportConfigurableDomainsToXMLCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus importConfigurableDomainsFromXMLCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus exportConfigurableDomainsWithSettingsToXMLCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus importConfigurableDomainsWithSettingsFromXMLCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus importConfigurableDomainWithSettingsFromXMLCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus exportSettingsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); - CCommandHandler::CommandStatus importSettingsCommmandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus exportDomainsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus importDomainsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus exportDomainsWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus importDomainsWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + /** + * Command handler method for exportDomainWithSettingsXML command. + * + * @param[in] remoteCommand contains the arguments of the received command. + * @param[out] result a std::string containing the result of the command + * + * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed + * in the other case + */ + CCommandHandler::CommandStatus exportDomainWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& result); + CCommandHandler::CommandStatus importDomainWithSettingsXMLCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus exportSettingsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); + CCommandHandler::CommandStatus importSettingsCommandProcess(const IRemoteCommand& remoteCommand, std::string& strResult); /** - * Command handler method for getConfigurableDomainsWithSettings command. + * Command handler method for getDomainsWithSettings command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] strResult a std::string containing the result of the command @@ -449,11 +464,11 @@ private: * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ - CCommandHandler::CommandStatus getConfigurableDomainsWithSettingsXMLCommmandProcess( + CCommandHandler::CommandStatus getDomainsWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); /** - * Command handler method for getConfigurableDomainWithSettings command. + * Command handler method for getDomainWithSettings command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] strResult a string containing the result of the command @@ -461,11 +476,11 @@ private: * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ - CCommandHandler::CommandStatus getConfigurableDomainWithSettingsXMLCommmandProcess( + CCommandHandler::CommandStatus getDomainWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); /** - * Command handler method for setConfigurableDomainWithSettings command. + * Command handler method for setDomainsWithSettings command. * * @param[in] remoteCommand contains the arguments of the received command. * @param[out] strResult a std::string containing the result of the command @@ -473,10 +488,22 @@ private: * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ - CCommandHandler::CommandStatus setConfigurableDomainsWithSettingsXMLCommmandProcess( + CCommandHandler::CommandStatus setDomainsWithSettingsXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); /** + * Command handler method for setDomainWithSettings command. + * + * @param[in] remoteCommand contains the arguments of the received command. + * @param[out] result a std::string containing the result of the command + * + * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed + * in the other case + */ + CCommandHandler::CommandStatus setDomainWithSettingsXMLCommandProcess( + const IRemoteCommand& remoteCommand, std::string& result); + + /** * Command handler method for getSystemClass command. * * @param[in] remoteCommand contains the arguments of the received command. @@ -485,7 +512,7 @@ private: * @return CCommandHandler::ESucceeded if command succeeded or CCommandHandler::EFailed * in the other case */ - CCommandHandler::CommandStatus getSystemClassXMLCommmandProcess( + CCommandHandler::CommandStatus getSystemClassXMLCommandProcess( const IRemoteCommand& remoteCommand, std::string& strResult); // Max command usage length, use for formatting @@ -515,35 +542,104 @@ private: bool loadSettings(std::string& strError); bool loadSettingsFromConfigFile(std::string& strError); - // Parse XML file into Root element - bool xmlParse(CXmlElementSerializingContext& elementSerializingContext, CElement* pRootElement, const std::string& strXmlFilePath, const std::string& strXmlFolder, ElementLibrary eElementLibrary, const std::string& strNameAttrituteName = "Name"); + /** Parse an XML stream into an element + * + * @param[in] elementSerializingContext serializing context + * @param[out] pRootElement the receiving element + * @param[in] input the input XML stream + * @param[in] strXmlFolder the folder containing the XML input file (if applicable) or "" + * @param[in] eElementLibrary which element library to be used + * @param[in] strNameAttributeName the name of the element's XML "name" attribute + * + * @returns true if parsing succeeded, false otherwise + */ + bool xmlParse(CXmlElementSerializingContext& elementSerializingContext, CElement* pRootElement, + _xmlDoc* doc, const std::string& strXmlFolder, + ElementLibrary eElementLibrary, const std::string& strNameAttributeName = "Name"); + + /** Wrapper for converting public APIs semantics to internal API + * + * Public APIs have a string argument that can either contain: + * - a path to an XML file or; + * - an actual XML document. + * They also have a boolean argument specifying which of the two cases it + * is. + * + * Instead, the internal APIs only take an std::istream argument. This + * method opens the file as a stream if applicable or simply wrap the + * string in a stream. It then passes the stream to the internal methods. + * + * @param[in] xmlSource the XML source (either a path or an actual xml + * document) + * @param[in] fromFile specifies whether xmlSource is a path or an + * actual XML document + * @param[in] withSettings if false, only import the configurations + * applicability rules; if true, also import their settings + * @param[out] element the receiving element + * @param[in] nameAttributeName the name of the element's XML "name" + * attribute + * @param[out] errorMsg string used as output for any error message + * + * @returns true if the import succeeded, false otherwise + */ + bool wrapLegacyXmlImport(const std::string& xmlSource, bool fromFile, bool withSettings, + CElement& element, const std::string& nameAttributeName, + std::string& errorMsg); /** * Export an element object to an Xml destination. * * - * @param[in,out] strXmlDest a string containing an xml description or a path to an xml file. + * @param[out] output the stream to output the XML to * @param[in] xmlSerializingContext the serializing context - * @param[in] bToFile a boolean that determines if the destination is an xml description in - * strXmlDest or contained in a file. In that case strXmlDest is just the file path. * @param[in] element object to be serialized. - * @param[out] strError is used as the error output. * * @return false if any error occurs, true otherwise. */ - bool serializeElement(std::string& strXmlDest, CXmlSerializingContext& xmlSerializingContext, - bool bToFile, const CElement& element, std::string& strError) const; + bool serializeElement(std::ostream& output, CXmlSerializingContext& xmlSerializingContext, + const CElement& element) const; - /** - * Method that imports a single Configurable Domain, with settings, from an Xml file. - * - * @param[in] strXmlFilePath absolute path to the xml file containing the domain - * @param[out] strError is used as the error output - * - * @return false if any error occurs - */ - bool importDomainFromFile(const std::string& strXmlFilePath, bool bOverwrite, - std::string& strError); + /** Wrapper for converting public APIs semantics to internal API + * + * Public APIs have a string argument that can either: + * - contain a path to an XML file or; + * - receive an actual XML document. + * They also have a boolean argument specifying which of the two cases it + * is. + * + * Instead, the internal APIs only take an std::ostream argument. This + * method opens the file as a stream if applicable or simply wrap the + * string in a stream. It then passes the stream to the internal methods. + * + * @param[in] xmlDest the XML sink (either a path or any string that + * will be filled) + * @param[in] toFile specifies whether xmlSource is a path or a + * string that will receive an actual XML document + * @param[in] withSettings if false, only export the configurations + * applicability rules; if true, also export their settings + * @param[out] element the element to be exported + * @param[out] errorMsg string used as output for any error message + * + * @returns true if the export succeeded, false otherwise + */ + bool wrapLegacyXmlExport(std::string& xmlDest, bool toFile, bool withSettings, + const CElement& element, std::string& errorMsg) const; + + /** Wrapper for converting public APIs semantics to internal API + * + * @see wrapLegacyXmlExport + */ + bool wrapLegacyXmlExportToFile(std::string& xmlDest, + const CElement& element, + CXmlDomainExportContext &context) const; + + /** Wrapper for converting public APIs semantics to internal API + * + * @see wrapLegacyXmlExport + */ + bool wrapLegacyXmlExportToString(std::string& xmlDest, + const CElement& element, + CXmlDomainExportContext &context) const; // Framework Configuration diff --git a/parameter/ParameterMgrFullConnector.cpp b/parameter/ParameterMgrFullConnector.cpp index 0991475..30d2780 100644 --- a/parameter/ParameterMgrFullConnector.cpp +++ b/parameter/ParameterMgrFullConnector.cpp @@ -349,10 +349,19 @@ bool CParameterMgrFullConnector::exportDomainsXml(string& strXmlDest, bool bWith return _pParameterMgr->exportDomainsXml(strXmlDest, bWithSettings, bToFile, strError); } +// deprecated, use the other version of importSingleDomainXml instead bool CParameterMgrFullConnector::importSingleDomainXml(const string& strXmlSource, bool bOverwrite, string& strError) { - return _pParameterMgr->importSingleDomainXml(strXmlSource, bOverwrite, strError); + return importSingleDomainXml(strXmlSource, bOverwrite, true, false, strError); +} + +bool CParameterMgrFullConnector::importSingleDomainXml(const string& xmlSource, bool overwrite, + bool withSettings, bool fromFile, + string& errorMsg) +{ + return _pParameterMgr->importSingleDomainXml(xmlSource, overwrite, withSettings, fromFile, + errorMsg); } bool CParameterMgrFullConnector::exportSingleDomainXml(string& strXmlDest, diff --git a/parameter/ParameterType.cpp b/parameter/ParameterType.cpp index 01d94aa..eb9fd3d 100644 --- a/parameter/ParameterType.cpp +++ b/parameter/ParameterType.cpp @@ -31,11 +31,14 @@ #include "Parameter.h" #include "ArrayParameter.h" #include "ParameterAccessContext.h" +#include "Utility.h" #define base CTypeElement using std::string; +const std::string CParameterType::gUnitPropertyName = "Unit"; + CParameterType::CParameterType(const string& strName) : base(strName), _uiSize(0) { } @@ -68,15 +71,33 @@ string CParameterType::getUnit() const return _strUnit; } +void CParameterType::setUnit(const std::string& strUnit) +{ + _strUnit = strUnit; +} + // From IXmlSink bool CParameterType::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) { - // Unit - _strUnit = xmlElement.getAttributeString("Unit"); - + setUnit(xmlElement.getAttributeString(gUnitPropertyName)); return base::fromXml(xmlElement, serializingContext); } +// From IXmlSource +void CParameterType::toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const +{ + base::toXml(xmlElement, serializingContext); + setXmlUnitAttribute(xmlElement); +} + +void CParameterType::setXmlUnitAttribute(CXmlElement& xmlElement) const +{ + const string& unit = getUnit(); + if (!unit.empty()) { + xmlElement.setAttributeString(gUnitPropertyName, unit); + } +} + // XML Serialization value space handling // Value space handling for configuration import/export void CParameterType::handleValueSpaceAttribute(CXmlElement& xmlConfigurableElementSettingsElement, CConfigurationAccessContext& configurationAccessContext) const @@ -91,14 +112,13 @@ void CParameterType::showProperties(string& strResult) const { base::showProperties(strResult); - // Unit - if (!_strUnit.empty()) { - - strResult += "Unit: " + _strUnit + "\n"; + // Add Unit property if found + if (!getUnit().empty()) { + strResult += gUnitPropertyName + ": " + getUnit() + "\n"; } // Scalar size - strResult += "Scalar size: " + toString(getSize()) + " byte(s) \n"; + strResult += "Scalar size: " + CUtility::toString(getSize()) + " byte(s) \n"; } // Default value handling (simulation only) diff --git a/parameter/ParameterType.h b/parameter/ParameterType.h index 7d7caf7..cf58f7b 100644 --- a/parameter/ParameterType.h +++ b/parameter/ParameterType.h @@ -50,10 +50,14 @@ public: // Unit std::string getUnit() const; + void setUnit(const std::string& strUnit); // From IXmlSink virtual bool fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext); + // From IXmlSource + virtual void toXml(CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) const; + /// Conversions // String virtual bool toBlackboard(const std::string& strValue, uint32_t& uiValue, CParameterAccessContext& parameterAccessContext) const = 0; @@ -118,6 +122,8 @@ protected: } private: + void setXmlUnitAttribute(CXmlElement& xmlElement) const; + // Instantiation virtual CInstanceConfigurableElement* doInstantiate() const; // Generic Access @@ -130,4 +136,6 @@ private: uint32_t _uiSize; // Unit std::string _strUnit; + + static const std::string gUnitPropertyName; }; diff --git a/parameter/SelectionCriterion.cpp b/parameter/SelectionCriterion.cpp index 7818924..e45c993 100644 --- a/parameter/SelectionCriterion.cpp +++ b/parameter/SelectionCriterion.cpp @@ -30,6 +30,7 @@ #include "SelectionCriterion.h" #include "AutoLog.h" +#include "Utility.h" #define base CElement @@ -125,7 +126,7 @@ std::string CSelectionCriterion::getFormattedDescription(bool bWithTypeInfo, boo if (bWithTypeInfo) { // Display type info - appendTitle(strFormattedDescription, getName() + ":"); + CUtility::appendTitle(strFormattedDescription, getName() + ":"); // States strFormattedDescription += "Possible states "; diff --git a/parameter/StringParameterType.cpp b/parameter/StringParameterType.cpp index d47895d..321dc97 100644 --- a/parameter/StringParameterType.cpp +++ b/parameter/StringParameterType.cpp @@ -29,6 +29,7 @@ */ #include "StringParameterType.h" #include "StringParameter.h" +#include "Utility.h" #define base CTypeElement @@ -51,7 +52,7 @@ void CStringParameterType::showProperties(string& strResult) const // Max length strResult += "Max length: "; - strResult += toString(_uiMaxLength); + strResult += CUtility::toString(_uiMaxLength); strResult += "\n"; } diff --git a/parameter/Subsystem.cpp b/parameter/Subsystem.cpp index 5dbe3a0..6b0264b 100644 --- a/parameter/Subsystem.cpp +++ b/parameter/Subsystem.cpp @@ -35,6 +35,7 @@ #include "ConfigurationAccessContext.h" #include "SubsystemObjectCreator.h" #include "MappingData.h" +#include "Utility.h" #include <assert.h> #include <sstream> @@ -104,6 +105,10 @@ bool CSubsystem::needResync(bool bClear) // From IXmlSink bool CSubsystem::fromXml(const CXmlElement& xmlElement, CXmlSerializingContext& serializingContext) { + // Subsystem class does not rely on generic fromXml algorithm of Element class. + // So, setting here the description if found as XML attribute. + setDescription(getXmlDescriptionAttribute(xmlElement)); + // Context CXmlParameterSerializingContext& parameterBuildContext = static_cast<CXmlParameterSerializingContext&>(serializingContext); @@ -440,7 +445,8 @@ bool CSubsystem::handleSubsystemObjectCreation( pSubsystemObjectCreator->getMaxConfigurableElementSize()) { string strSizeError = "Size should not exceed " + - toString(pSubsystemObjectCreator->getMaxConfigurableElementSize()); + CUtility::toString( + pSubsystemObjectCreator->getMaxConfigurableElementSize()); strError = getMappingError(strKey, strSizeError, pInstanceConfigurableElement); diff --git a/parameter/SubsystemObject.cpp b/parameter/SubsystemObject.cpp index 76b9549..e6b7b44 100644 --- a/parameter/SubsystemObject.cpp +++ b/parameter/SubsystemObject.cpp @@ -149,7 +149,7 @@ bool CSubsystemObject::sync(CParameterBlackboard& parameterBlackboard, bool bBac strError = string("Unable to ") + (bBack ? "back" : "forward") + " synchronize configurable element " + _pInstanceConfigurableElement->getPath() + ": " + strError; - log_warning(strError); + log_warning("%s", strError.c_str()); // Fall back to parameter default initialization if (bBack) { @@ -213,37 +213,37 @@ void CSubsystemObject::blackboardWrite(const void* pvData, uint32_t uiSize) } // Logging -void CSubsystemObject::log_info(const string& strMessage, ...) const +void CSubsystemObject::log_info(std::string strMessage, ...) const { char *pacBuffer; va_list listPointer; va_start(listPointer, strMessage); - vasprintf(&pacBuffer, strMessage.c_str(), listPointer); + vasprintf(&pacBuffer, strMessage.c_str(), listPointer); va_end(listPointer); if (pacBuffer != NULL) { - _pInstanceConfigurableElement->log_info(pacBuffer); + _pInstanceConfigurableElement->log_info("%s", pacBuffer); } free(pacBuffer); } -void CSubsystemObject::log_warning(const string& strMessage, ...) const +void CSubsystemObject::log_warning(std::string strMessage, ...) const { char *pacBuffer; va_list listPointer; va_start(listPointer, strMessage); - vasprintf(&pacBuffer, strMessage.c_str(), listPointer); + vasprintf(&pacBuffer, strMessage.c_str(), listPointer); va_end(listPointer); if (pacBuffer != NULL) { - _pInstanceConfigurableElement->log_warning(pacBuffer); + _pInstanceConfigurableElement->log_warning("%s", pacBuffer); } free(pacBuffer); diff --git a/parameter/SubsystemObject.h b/parameter/SubsystemObject.h index ab085bc..2ba2123 100644 --- a/parameter/SubsystemObject.h +++ b/parameter/SubsystemObject.h @@ -83,8 +83,12 @@ protected: void blackboardRead(void* pvData, uint32_t uiSize); void blackboardWrite(const void* pvData, uint32_t uiSize); // Logging - void log_info(const std::string& strMessage, ...) const; - void log_warning(const std::string& strMessage, ...) const; + // Copy the string format because: + // - passing char * would break compatibility + // - passing a const std::string & in forbiden by the c++ standard + // as va_start second argument must not be a reference. + void log_info(std::string strMessage, ...) const; + void log_warning(std::string strMessage, ...) const; // Belonging Subsystem retrieval const CSubsystem* getSubsystem() const; diff --git a/parameter/TypeElement.cpp b/parameter/TypeElement.cpp index 37228d7..01b7137 100644 --- a/parameter/TypeElement.cpp +++ b/parameter/TypeElement.cpp @@ -76,8 +76,11 @@ bool CTypeElement::hasMappingData() const // Element properties void CTypeElement::showProperties(std::string& strResult) const { - (void)strResult; - // Prevent base from being called in that context! + // The description attribute may be found in the type and not from instance. + showDescriptionProperty(strResult); + // Prevent base from being called from the Parameter Type context as + // it would lead to duplicate the name attribute (duplicated in the type and instance + // which have a common base Element) } void CTypeElement::populate(CElement* pElement) const diff --git a/parameter/XmlDomainExportContext.h b/parameter/XmlDomainExportContext.h index 6a95d97..22ad995 100644 --- a/parameter/XmlDomainExportContext.h +++ b/parameter/XmlDomainExportContext.h @@ -35,8 +35,14 @@ class CXmlDomainExportContext : public CXmlDomainSerializingContext { public: - CXmlDomainExportContext(std::string& strError, bool bWithSettings): - base(strError, bWithSettings) {} + CXmlDomainExportContext(std::string& strError, + bool bWithSettings = true, + bool bValueSpaceIsRaw = true, + bool bOutputRawFormatIsHex = true): + base(strError, bWithSettings), + _bValueSpaceIsRaw(bValueSpaceIsRaw), + _bOutputRawFormatIsHex(bOutputRawFormatIsHex) + {} // Value interpretation as Real or Raw void setValueSpaceRaw(bool bIsRaw) diff --git a/parameter/XmlFileIncluderElement.cpp b/parameter/XmlFileIncluderElement.cpp index 674a331..d20a624 100644 --- a/parameter/XmlFileIncluderElement.cpp +++ b/parameter/XmlFileIncluderElement.cpp @@ -28,12 +28,13 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "XmlFileIncluderElement.h" -#include "XmlFileDocSource.h" +#include "XmlDocSource.h" #include "XmlMemoryDocSink.h" #include "XmlElementSerializingContext.h" #include "ElementLibrary.h" #include "AutoLog.h" #include <assert.h> +#include <fstream> #define base CKindElement CXmlFileIncluderElement::CXmlFileIncluderElement(const std::string& strName, @@ -68,12 +69,20 @@ bool CXmlFileIncluderElement::fromXml(const CXmlElement& xmlElement, CXmlSeriali std::string strPathToXsdFile = elementSerializingContext.getXmlSchemaPathFolder() + "/" + strIncludedElementType + ".xsd"; - CXmlFileDocSource fileDocSource(strPath, - strPathToXsdFile, - strIncludedElementType, - _bValidateSchemasOnStart); + std::string xmlErrorMsg; + _xmlDoc *doc = CXmlDocSource::mkXmlDoc(strPath, true, true, xmlErrorMsg); + if (doc == NULL) { + elementSerializingContext.setError(xmlErrorMsg); + return false; + } + + CXmlDocSource docSource(doc, _bValidateSchemasOnStart, + strPathToXsdFile, + strIncludedElementType); + + if (!docSource.isParsable()) { - if (!fileDocSource.isParsable(elementSerializingContext)) { + elementSerializingContext.setError("Could not parse document \"" + strPath + "\""); return false; } @@ -81,7 +90,7 @@ bool CXmlFileIncluderElement::fromXml(const CXmlElement& xmlElement, CXmlSeriali // Get top level element CXmlElement childElement; - fileDocSource.getRootElement(childElement); + docSource.getRootElement(childElement); // Create child element CElement* pChild = elementSerializingContext.getElementLibrary()->createElement(childElement); @@ -100,7 +109,7 @@ bool CXmlFileIncluderElement::fromXml(const CXmlElement& xmlElement, CXmlSeriali // Use a doc sink that instantiate the structure from the doc source CXmlMemoryDocSink memorySink(pChild); - if (!memorySink.process(fileDocSource, elementSerializingContext)) { + if (!memorySink.process(docSource, elementSerializingContext)) { return false; } diff --git a/parameter/include/ParameterMgrFullConnector.h b/parameter/include/ParameterMgrFullConnector.h index 31022a6..4ee3b4f 100644 --- a/parameter/include/ParameterMgrFullConnector.h +++ b/parameter/include/ParameterMgrFullConnector.h @@ -215,11 +215,28 @@ public: /** * Method that imports a single Configurable Domain from an Xml source. * - * @param[in] strXmlSource a string containing an xml description or a path to an xml file - * @param[in] bWithSettings a boolean that determines if the settings should be used in the + * @param[in] xmlSource a string containing an xml description or a path to an xml file + * @param[in] overwrite when importing an existing domain, allow overwriting or return an + * error + * @param[in] withSettings a boolean that determines if the settings should be used in the * xml description - * @param[in] bFromFile a boolean that determines if the source is an xml description in + * @param[in] fromFile a boolean that determines if the source is an xml description in * strXmlSource or contained in a file. In that case strXmlSource is just the file path. + * @param[out] errorMsg is used as the error output + * + * @return false if any error occurs + */ + bool importSingleDomainXml(const std::string& xmlSource, bool overwrite, bool withSettings, + bool toFile, std::string& errorMsg); + /** + * Method that imports a single Configurable Domain from an string + * describing an Xml source. + * + * @deprecated use the other versions of importSingleDomainXml instead + * + * @param[in] strXmlSource a string containing an xml description + * @param[in] bOverwrite when importing an existing domain, allow overwriting or return an + * error * @param[out] strError is used as the error output * * @return false if any error occurs diff --git a/remote-process/Android.mk b/remote-process/Android.mk index 53d3ae6..015c8ec 100644 --- a/remote-process/Android.mk +++ b/remote-process/Android.mk @@ -67,7 +67,6 @@ LOCAL_C_INCLUDES := $(common_c_includes) LOCAL_SHARED_LIBRARIES := $(common_shared_libraries) LOCAL_STATIC_LIBRARIES := $(common_static_libraries) - include $(BUILD_EXECUTABLE) ############################## diff --git a/remote-processor/Android.mk b/remote-processor/Android.mk index b8050b1..784a917 100644 --- a/remote-processor/Android.mk +++ b/remote-processor/Android.mk @@ -49,9 +49,6 @@ common_cflags := \ -Werror \ -Wextra \ -Wno-unused-parameter \ - -pthread - -common_ldlibs := -pthread ############################# # Target build @@ -60,8 +57,9 @@ include $(CLEAR_VARS) LOCAL_SRC_FILES := $(common_src_files) +LOCAL_STATIC_LIBRARIES := libpfw_utility + LOCAL_CFLAGS := $(common_cflags) -LOCAL_LDLIBS := $(common_ldlibs) LOCAL_MODULE := $(common_module) LOCAL_MODULE_OWNER := intel @@ -76,8 +74,10 @@ include $(CLEAR_VARS) LOCAL_SRC_FILES := $(common_src_files) -LOCAL_CFLAGS := $(common_cflags) -LOCAL_LDLIBS := $(common_ldlibs) +LOCAL_STATIC_LIBRARIES := libpfw_utility_host + +LOCAL_CFLAGS := $(common_cflags) -pthread +LOCAL_LDLIBS := -lpthread LOCAL_MODULE := $(common_module)_host LOCAL_MODULE_OWNER := intel diff --git a/remote-processor/CMakeLists.txt b/remote-processor/CMakeLists.txt index 598bd4f..27a41f9 100644 --- a/remote-processor/CMakeLists.txt +++ b/remote-processor/CMakeLists.txt @@ -1,4 +1,4 @@ -# Copyright (c) 2014, Intel Corporation +# Copyright (c) 2014-2015, Intel Corporation # All rights reserved. # # Redistribution and use in source and binary forms, with or without modification, @@ -39,6 +39,8 @@ add_library(remote-processor SHARED set(CMAKE_THREAD_PREFER_PTHREAD 1) find_package(Threads REQUIRED) -target_link_libraries(remote-processor ${CMAKE_THREAD_LIBS_INIT}) +include_directories("${PROJECT_SOURCE_DIR}/utility") + +target_link_libraries(remote-processor pfw_utility ${CMAKE_THREAD_LIBS_INIT}) install(TARGETS remote-processor LIBRARY DESTINATION lib) diff --git a/remote-processor/ListeningSocket.cpp b/remote-processor/ListeningSocket.cpp index 1677d71..191d412 100644 --- a/remote-processor/ListeningSocket.cpp +++ b/remote-processor/ListeningSocket.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -39,6 +39,7 @@ #include <stdio.h> #include <errno.h> +#include <cstring> #define base CSocket @@ -52,7 +53,7 @@ CListeningSocket::CListeningSocket() } // Listen -bool CListeningSocket::listen(uint16_t uiPort) +bool CListeningSocket::listen(uint16_t uiPort, string &strError) { struct sockaddr_in server_addr; @@ -62,19 +63,17 @@ bool CListeningSocket::listen(uint16_t uiPort) // Bind if (bind(getFd(), (struct sockaddr*)&server_addr, sizeof(struct sockaddr)) == -1) { - std::ostringstream oss; - oss << "CListeningSocket::listen::bind port " << uiPort; - perror(oss.str().c_str()); - + std::ostringstream oss; + oss << uiPort; + strError = "Could not bind socket to port " + oss.str() + ": " + strerror(errno); return false; } if (::listen(getFd(), 5) == -1) { - std::ostringstream oss; - oss << "CListeningSocket::listen::bind port " << uiPort; - perror(oss.str().c_str()); - + std::ostringstream oss; + oss << uiPort; + strError = "Could not listen to port " + oss.str() + ": " + strerror(errno); return false; } return true; diff --git a/remote-processor/ListeningSocket.h b/remote-processor/ListeningSocket.h index 8aa0608..3b5b614 100644 --- a/remote-processor/ListeningSocket.h +++ b/remote-processor/ListeningSocket.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -37,7 +37,7 @@ public: CListeningSocket(); // Listen - bool listen(uint16_t uiPort); + bool listen(uint16_t uiPort, std::string &strError); // Accept CSocket* accept(); diff --git a/remote-processor/RemoteProcessorServer.cpp b/remote-processor/RemoteProcessorServer.cpp index c1d87e5..e289d4e 100644 --- a/remote-processor/RemoteProcessorServer.cpp +++ b/remote-processor/RemoteProcessorServer.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -29,12 +29,14 @@ */ #include "RemoteProcessorServer.h" #include "ListeningSocket.h" +#include "FullIo.hpp" #include <iostream> #include <memory> #include <assert.h> #include <poll.h> #include <unistd.h> -#include <strings.h> +#include <string.h> +#include <errno.h> #include "RequestMessage.h" #include "AnswerMessage.h" #include "RemoteCommandHandler.h" @@ -44,8 +46,6 @@ using std::string; CRemoteProcessorServer::CRemoteProcessorServer(uint16_t uiPort, IRemoteCommandHandler* pCommandHandler) : _uiPort(uiPort), _pCommandHandler(pCommandHandler), _bIsStarted(false), _pListeningSocket(NULL), _ulThreadId(0) { - // Create inband pipe - pipe(_aiInbandPipe); } CRemoteProcessorServer::~CRemoteProcessorServer() @@ -54,27 +54,38 @@ CRemoteProcessorServer::~CRemoteProcessorServer() } // State -bool CRemoteProcessorServer::start() +bool CRemoteProcessorServer::start(string &error) { assert(!_bIsStarted); - // Create server socket - _pListeningSocket = new CListeningSocket; + if (pipe(_aiInbandPipe) == -1) { + error = "Could not create a pipe for remote processor communication: "; + error += strerror(errno); + return false; + } - if (!_pListeningSocket->listen(_uiPort)) { + // Create server socket + std::auto_ptr<CListeningSocket> pListeningSocket(new CListeningSocket); - // Remove listening socket - delete _pListeningSocket; - _pListeningSocket = NULL; + if (!pListeningSocket->listen(_uiPort, error)) { return false; } + // Thread needs to access to the listning socket. + _pListeningSocket = pListeningSocket.get(); // Create thread - pthread_create(&_ulThreadId, NULL, thread_func, this); + errno = pthread_create(&_ulThreadId, NULL, thread_func, this); + if (errno != 0) { + + error = "Could not create a remote processor thread: "; + error += strerror(errno); + return false; + } // State _bIsStarted = true; + pListeningSocket.release(); return true; } @@ -89,10 +100,20 @@ void CRemoteProcessorServer::stop() // Cause exiting of the thread uint8_t ucData = 0; - write(_aiInbandPipe[1], &ucData, sizeof(ucData)); + if (not utility::fullWrite(_aiInbandPipe[1], &ucData, sizeof(ucData))) { + std::cerr << "Could not query command processor thread to terminate: " + "fail to write on inband pipe: " + << strerror(errno) << std::endl; + assert(false); + } // Join thread - pthread_join(_ulThreadId, NULL); + errno = pthread_join(_ulThreadId, NULL); + if (errno != 0) { + std::cout << "Could not join with remote processor thread: " + << strerror(errno) << std::endl; + assert(false); + } _bIsStarted = false; @@ -139,7 +160,11 @@ void CRemoteProcessorServer::run() // Consume exit request uint8_t ucData; - read(_aiInbandPipe[0], &ucData, sizeof(ucData)); + if (not utility::fullRead(_aiInbandPipe[0], &ucData, sizeof(ucData))) { + std::cerr << "Remote processor could not receive exit request" + << strerror(errno) << std::endl; + assert(false); + } // Exit return; diff --git a/remote-processor/RemoteProcessorServer.h b/remote-processor/RemoteProcessorServer.h index 202364b..08f93e4 100644 --- a/remote-processor/RemoteProcessorServer.h +++ b/remote-processor/RemoteProcessorServer.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -43,7 +43,7 @@ public: virtual ~CRemoteProcessorServer(); // State - virtual bool start(); + virtual bool start(std::string &error); virtual void stop(); virtual bool isStarted() const; diff --git a/remote-processor/RemoteProcessorServerInterface.h b/remote-processor/RemoteProcessorServerInterface.h index 19a799c..3ca3b76 100644 --- a/remote-processor/RemoteProcessorServerInterface.h +++ b/remote-processor/RemoteProcessorServerInterface.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2011-2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -30,11 +30,12 @@ #pragma once #include "RequestMessage.h" +#include <string> class IRemoteProcessorServerInterface { public: - virtual bool start() = 0; + virtual bool start(std::string &strError) = 0; virtual void stop() = 0; virtual bool isStarted() const = 0; diff --git a/remote-processor/Socket.cpp b/remote-processor/Socket.cpp index b36d32f..0aec7a2 100644 --- a/remote-processor/Socket.cpp +++ b/remote-processor/Socket.cpp @@ -39,8 +39,9 @@ #include <netinet/in.h> #include <netinet/tcp.h> #include <sys/time.h> +#include <signal.h> -CSocket::CSocket() : _iSockFd(socket(AF_INET, SOCK_STREAM, 0)) +CSocket::CSocket() : _iSockFd(socket(AF_INET, SOCK_STREAM, 0)), mSendFlag(0) { assert(_iSockFd != -1); @@ -50,6 +51,19 @@ CSocket::CSocket() : _iSockFd(socket(AF_INET, SOCK_STREAM, 0)) // they are ready to be sent, instead of waiting for more data on the // socket. setsockopt(_iSockFd, IPPROTO_TCP, TCP_NODELAY, (char *)&iNoDelay, sizeof(iNoDelay)); + + // Disable sigpipe reception on send +# if not defined(SIGPIPE) + // Pipe signal does not exist, there no sigpipe to ignore on send +# elif defined(SO_NOSIGPIPE) + const int set = 1; + setsockopt(_iSockFd, SOL_SOCKET, SO_NOSIGPIPE, &set, sizeof(set)); +# elif defined(MSG_NOSIGNAL) + // Use flag NOSIGNAL on send call + mSendFlag = MSG_NOSIGNAL; +# else +# error Can not disable SIGPIPE +# endif } CSocket::CSocket(int iSockId) : _iSockFd(iSockId) @@ -59,7 +73,11 @@ CSocket::CSocket(int iSockId) : _iSockFd(iSockId) CSocket::~CSocket() { - close(_iSockFd); + // fd might be invalide if send had an error. + // valgrind displays a warning if closing an invalid fd. + if (_iSockFd != -1) { + close(_iSockFd); + } } // Socket address init @@ -108,7 +126,7 @@ bool CSocket::read(void* pvData, uint32_t uiSize) while (uiSize) { - int32_t iAccessedSize = ::recv(_iSockFd, &pucData[uiOffset], uiSize, MSG_NOSIGNAL); + int32_t iAccessedSize = ::recv(_iSockFd, &pucData[uiOffset], uiSize, 0); switch (iAccessedSize) { case 0: @@ -140,17 +158,19 @@ bool CSocket::write(const void* pvData, uint32_t uiSize) while (uiSize) { - int32_t iAccessedSize = ::send(_iSockFd, &pucData[uiOffset], uiSize, MSG_NOSIGNAL); + int32_t iAccessedSize = ::send(_iSockFd, &pucData[uiOffset], uiSize, mSendFlag); if (iAccessedSize == -1) { - if (errno == ECONNRESET) { - // Peer has disconnected - _disconnected = true; - } - // errno == EINTR => The send system call was interrupted, try again - if (errno != EINTR) { - return false; + if (errno == EINTR) { + // The send system call was interrupted, try again + continue; } + + // An error occured, forget this socket + _disconnected = true; + close(_iSockFd); + _iSockFd = -1; // Avoid writing again on the same socket + return false; } else { uiSize -= iAccessedSize; uiOffset += iAccessedSize; diff --git a/remote-processor/Socket.h b/remote-processor/Socket.h index 00bd8bc..8c3fb9f 100644 --- a/remote-processor/Socket.h +++ b/remote-processor/Socket.h @@ -108,4 +108,5 @@ private: * See hasPeerDisconnected for more details. */ bool _disconnected; + int mSendFlag; }; diff --git a/support/android/build_pfw_settings.mk b/support/android/build_pfw_settings.mk index 482c56d..e51adfd 100644 --- a/support/android/build_pfw_settings.mk +++ b/support/android/build_pfw_settings.mk @@ -35,7 +35,8 @@ $(LOCAL_BUILT_MODULE): MY_TOOL := $(HOST_OUT)/bin/domainGenerator.py # As of Android K, python is available as prebuilt. We can't reliably use the # host's default python because the low-level python binding has been compiled # against Android's Python headers. -$(LOCAL_BUILT_MODULE): MY_PYTHON := prebuilts/python/linux-x86/2.7.5/bin/python +# BTW, python is only available in 32bits for now, thus arch is forced to 32bits +$(LOCAL_BUILT_MODULE): MY_PYTHON := prebuilts/python/$(HOST_OS)-x86/2.7.5/bin/python # The parameter-framework binding module is installed on these locations on # Android (On 64bit machines, PyPfw.py is installed in the 'lib64' directory # and _PyPfw.so is installed in the 'lib' directory, hence the need for these diff --git a/test/test-platform/Android.mk b/test/test-platform/Android.mk index e46ad57..04b1b90 100644 --- a/test/test-platform/Android.mk +++ b/test/test-platform/Android.mk @@ -43,8 +43,6 @@ common_c_includes := \ $(LOCAL_PATH)/../../parameter/include \ $(LOCAL_PATH)/../../remote-processor/ -common_ldlibs := -pthread - common_shared_libraries := libparameter libremote-processor ############################# # Target build @@ -58,7 +56,6 @@ LOCAL_MODULE_OWNER := intel LOCAL_MODULE_TAGS := $(common_module_tags) LOCAL_C_INCLUDES := $(common_c_includes) -LOCAL_LDLIBS := $(common_ldlibs) LOCAL_STATIC_LIBRARIES := libpfw_utility LOCAL_SHARED_LIBRARIES := $(common_shared_libraries) @@ -77,7 +74,8 @@ LOCAL_MODULE_OWNER := intel LOCAL_MODULE_TAGS := $(common_module_tags) LOCAL_C_INCLUDES += $(common_c_includes) -LOCAL_LDLIBS := $(common_ldlibs) +LOCAL_CFLAGS := -pthread +LOCAL_LDLIBS := -lpthread LOCAL_STATIC_LIBRARIES := libpfw_utility_host LOCAL_SHARED_LIBRARIES := $(foreach shared_library, $(common_shared_libraries), \ diff --git a/test/test-platform/TestPlatform.cpp b/test/test-platform/TestPlatform.cpp index 9cb45f7..6e67b3a 100644 --- a/test/test-platform/TestPlatform.cpp +++ b/test/test-platform/TestPlatform.cpp @@ -63,7 +63,6 @@ public: CTestPlatform::CTestPlatform(const string& strClass, int iPortNumber, sem_t& exitSemaphore) : _pParameterMgrPlatformConnector(new CParameterMgrPlatformConnector(strClass)), _pParameterMgrPlatformConnectorLogger(new CParameterMgrPlatformConnectorLogger), - _portNumber(iPortNumber), _exitSemaphore(exitSemaphore) { _pCommandHandler = new CCommandHandler(this); @@ -163,12 +162,9 @@ CTestPlatform::CommandReturn CTestPlatform::exit( bool CTestPlatform::load(std::string& strError) { // Start remote processor server - if (!_pRemoteProcessorServer->start()) { - - std::ostringstream oss; - oss << "TestPlatform: Unable to start remote processor server on port " << _portNumber; - strError = oss.str(); + if (!_pRemoteProcessorServer->start(strError)) { + strError = "TestPlatform: Unable to start remote processor server: " + strError; return false; } diff --git a/test/test-platform/TestPlatform.h b/test/test-platform/TestPlatform.h index e9d1dd4..fae8386 100644 --- a/test/test-platform/TestPlatform.h +++ b/test/test-platform/TestPlatform.h @@ -153,9 +153,6 @@ private: // Remote Processor Server CRemoteProcessorServer* _pRemoteProcessorServer; - // Port number for the server socket - int _portNumber; - // Semaphore used by calling thread to avoid exiting sem_t& _exitSemaphore; }; diff --git a/test/test-platform/main.cpp b/test/test-platform/main.cpp index a3f50be..6a79597 100644 --- a/test/test-platform/main.cpp +++ b/test/test-platform/main.cpp @@ -29,12 +29,15 @@ */ #include "TestPlatform.h" +#include "FullIo.hpp" #include <iostream> #include <cstdlib> #include <semaphore.h> #include <string.h> #include <unistd.h> +#include <cerrno> +#include <cassert> using namespace std; @@ -68,6 +71,16 @@ static bool startBlockingTestPlatform(const char *filePath, int portNumber, stri return true; } +static void notifyParent(int parentFd, bool success) +{ + if (not utility::fullWrite(parentFd, &success, sizeof(success))) { + cerr << "Unable to warn parent process of load " + << (success ? "success" : "failure") << ": " + << strerror(errno) << endl; + assert(false); + } +} + // Starts test-platform in daemon mode static bool startDaemonTestPlatform(const char *filePath, int portNumber, string &strError) { @@ -106,31 +119,26 @@ static bool startDaemonTestPlatform(const char *filePath, int portNumber, string CTestPlatform testPlatform(filePath, portNumber, sem); // Message to send to parent process - bool msgToParent; + bool loadSuccess = testPlatform.load(strError); - // Start platformmgr - if (!testPlatform.load(strError)) { + if (!loadSuccess) { cerr << strError << endl; // Notify parent of failure; - msgToParent = false; - write(pipefd[1], &msgToParent, sizeof(msgToParent)); + notifyParent(pipefd[1], false); - sem_destroy(&sem); } else { // Notify parent of success - msgToParent = true; - write(pipefd[1], &msgToParent, sizeof(msgToParent)); + notifyParent(pipefd[1], true); // Block here sem_wait(&sem); - - sem_destroy(&sem); } + sem_destroy(&sem); - return msgToParent; + return loadSuccess; } else { @@ -143,9 +151,9 @@ static bool startDaemonTestPlatform(const char *filePath, int portNumber, string // Message received from the child process bool msgFromChild = false; - if (read(pipefd[0], &msgFromChild, sizeof(msgFromChild)) <= 0) { - + if (not utility::fullRead(pipefd[0], &msgFromChild, sizeof(msgFromChild))) { strError = "Read pipe failed"; + return false; } // return success/failure in exit status diff --git a/tools/xmlGenerator/domainGenerator.py b/tools/xmlGenerator/domainGenerator.py index 3e840f0..427c8d5 100755 --- a/tools/xmlGenerator/domainGenerator.py +++ b/tools/xmlGenerator/domainGenerator.py @@ -304,7 +304,8 @@ if __name__ == "__main__": # Import each standalone domain files for domain_file in args.xml_domain_files: logging.info("Importing single domain file {}".format(domain_file)) - ok, error = pfw.importSingleDomainXml(os.path.realpath(domain_file), False) + ok, error = pfw.importSingleDomainXml(os.path.realpath(domain_file), + False, True, True) if not ok: logging.critical(error) exit(1) diff --git a/utility/Android.mk b/utility/Android.mk index 09f3de7..168c423 100644 --- a/utility/Android.mk +++ b/utility/Android.mk @@ -34,7 +34,8 @@ LOCAL_PATH := $(call my-dir) common_src_files := \ Tokenizer.cpp \ Utility.cpp \ - NaiveTokenizer.cpp + NaiveTokenizer.cpp \ + FullIo.cpp \ common_module := libpfw_utility common_module_tags := optional diff --git a/utility/CMakeLists.txt b/utility/CMakeLists.txt index 9f81027..5386f5b 100644 --- a/utility/CMakeLists.txt +++ b/utility/CMakeLists.txt @@ -29,6 +29,7 @@ add_library(pfw_utility STATIC Tokenizer.cpp Utility.cpp + FullIo.cpp NaiveTokenizer.cpp) # '-fPIC' needed for linking against shared libraries (e.g. libparameter) diff --git a/xmlserializer/XmlFileDocSink.cpp b/utility/FullIo.cpp index f73860c..59765b5 100644 --- a/xmlserializer/XmlFileDocSink.cpp +++ b/utility/FullIo.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -28,27 +28,53 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "XmlFileDocSink.h" -#include <libxml/parser.h> +#include "FullIo.hpp" -#define base CXmlDocSink +#include <cerrno> +#include <unistd.h> -CXmlFileDocSink::CXmlFileDocSink(const std::string& strXmlInstanceFile): - _strXmlInstanceFile(strXmlInstanceFile) +namespace utility { + +/** Workaround c++ `void *` arithmetic interdiction. */ +template <class Ptr> +Ptr *add(Ptr *ptr, size_t count) { + return (char *)ptr + count; } -bool CXmlFileDocSink::doProcess(CXmlDocSource& xmlDocSource, - CXmlSerializingContext& serializingContext) -{ - // Write file (formatted) - if (xmlSaveFormatFileEnc(_strXmlInstanceFile.c_str(), - xmlDocSource.getDoc(), "UTF-8", 1) == -1) { +template <class Buff> +static bool fullAccess(ssize_t (&accessor)(int, Buff, size_t), + bool (&accessFailed)(ssize_t), + int fd, Buff buf, size_t count) { + size_t done = 0; // Bytes already access in previous iterations + while (done < count) { + ssize_t accessed = accessor(fd, add(buf, done), count - done); + if (accessFailed(accessed)) { + return false; + } + done += accessed; + } + return true; +} - serializingContext.setError("Could not write file " + _strXmlInstanceFile); +static bool accessFailed(ssize_t accessRes) { + return accessRes == -1 and errno != EAGAIN and errno != EINTR; +} - return false; +bool fullWrite(int fd, const void *buf, size_t count) { + return fullAccess(::write, accessFailed, fd, buf, count); +} + +static bool readFailed(ssize_t readRes) { + if (readRes == 0) { // read should not return 0 (EOF) + errno = 0; + return true; } - return true; + return accessFailed(readRes); } +bool fullRead(int fd, void *buf, size_t count) { + return fullAccess(::read, readFailed, fd, buf, count); +} + +} // namespace utility diff --git a/xmlserializer/XmlFileDocSink.h b/utility/FullIo.hpp index 6063e6a..353551d 100644 --- a/xmlserializer/XmlFileDocSink.h +++ b/utility/FullIo.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -29,38 +29,40 @@ */ #pragma once -#include "XmlDocSink.h" -#include <string> -/** - * Sink class that save the content of any CXmlDocSource into a file. - * The file path is defined in the constructor. - */ -class CXmlFileDocSink : public CXmlDocSink +#include <cstddef> + +namespace utility { -public: - /** - * Constructor - * - * @param[in] strXmlInstanceFile defines the path used to save the file. - */ - CXmlFileDocSink(const std::string& strXmlInstanceFile); -private: - /** - * Implementation of CXmlDocSink::doProcess() - * Write the content of the xmlDocSource to the file opened in strXmlInstanceFile using - * UTF-8 encoding - * - * @param[in] xmlDocSource is the source containing the Xml document - * @param[out] serializingContext is used as error output - * - * @return false if any error occurs - */ - virtual bool doProcess(CXmlDocSource& xmlDocSource, CXmlSerializingContext& serializingContext); +/** Write *completely* a buffer in a file descriptor. + * + * A wrapper around unistd::write that resumes write on incomplete access + * and EAGAIN/EINTR error. + * + * @see man 2 write for the parameters. + * + * @return true if the buffer could be completely written, + * false on failure (see write's man errno section). + */ +bool fullWrite(int fd, const void *buf, size_t count); + +/** Fill a buffer from a file descriptor. + * + * A wrapper around unistd::read that resumes read on incomplete access + * and EAGAIN/EINTR error. + * + * @see man 2 read for the parameters. + * + * @return true if the buffer could be completely fill, + * false on failure (see read's man errno section). + * + * If the buffer could not be filled due to an EOF, return false but set + * errno to 0. + * @TODO Add a custom strerror to prevent logging "success" (`sterror(0)`) on + * EOF errors ? + */ +bool fullRead(int fd, void *buf, size_t count); + +} // namespace utility - /** - * Name of the instance file - */ - std::string _strXmlInstanceFile; -}; diff --git a/utility/Utility.cpp b/utility/Utility.cpp index dc0bce1..e5f689a 100644 --- a/utility/Utility.cpp +++ b/utility/Utility.cpp @@ -32,6 +32,7 @@ #include <sstream> #include <iterator> +#include <stdint.h> using std::string; @@ -72,3 +73,15 @@ void CUtility::asString(const std::map<std::string, std::string>& mapStr, CUtility::asString(listKeysValues, strOutput, strItemSeparator); } +void CUtility::appendTitle(string& strTo, const string& strTitle) +{ + strTo += "\n" + strTitle + "\n"; + + uint32_t uiLength = strTitle.size(); + + while (uiLength--) { + + strTo += "="; + } + strTo += "\n"; +} diff --git a/utility/Utility.h b/utility/Utility.h index 51f796f..93acd82 100644 --- a/utility/Utility.h +++ b/utility/Utility.h @@ -33,6 +33,7 @@ #include <string> #include <list> #include <map> +#include <sstream> class CUtility { @@ -62,5 +63,21 @@ public: std::string& strOutput, const std::string& strItemSeparator = ", ", const std::string& strKeyValueSeparator = ":"); -}; + /** Utility to easily convert a builtin type into string + * + * FIXME: Should be replaced by std::to_string after C++11 introduction + */ + template <class T> + static std::string toString(T uiValue) + { + std::ostringstream ostr; + + ostr << uiValue; + + return ostr.str(); + } + + /** Utility to underline */ + static void appendTitle(std::string& strTo, const std::string& strTitle); +}; diff --git a/xmlserializer/Android.mk b/xmlserializer/Android.mk index eedf48b..67b9bf7 100644 --- a/xmlserializer/Android.mk +++ b/xmlserializer/Android.mk @@ -37,10 +37,7 @@ common_src_files := \ XmlDocSource.cpp \ XmlMemoryDocSink.cpp \ XmlMemoryDocSource.cpp \ - XmlStringDocSink.cpp \ - XmlFileDocSink.cpp \ - XmlFileDocSource.cpp \ - XmlStringDocSource.cpp + XmlStreamDocSink.cpp \ common_module := libxmlserializer @@ -66,6 +63,8 @@ include $(CLEAR_VARS) LOCAL_SRC_FILES := $(common_src_files) +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) + LOCAL_MODULE := $(common_module) LOCAL_MODULE_OWNER := intel LOCAL_MODULE_TAGS := $(common_module_tags) @@ -79,7 +78,7 @@ LOCAL_STATIC_LIBRARIES := $(common_static_libraries) LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) -include $(BUILD_STATIC_LIBRARY) +include $(BUILD_SHARED_LIBRARY) ############################## # Host build @@ -88,6 +87,8 @@ include $(CLEAR_VARS) LOCAL_SRC_FILES := $(common_src_files) +LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) + LOCAL_MODULE := $(common_module)_host LOCAL_MODULE_OWNER := intel LOCAL_MODULE_TAGS := $(common_module_tags) @@ -101,5 +102,5 @@ LOCAL_STATIC_LIBRARIES := libxml2 LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH) -include $(BUILD_HOST_STATIC_LIBRARY) +include $(BUILD_HOST_SHARED_LIBRARY) diff --git a/xmlserializer/CMakeLists.txt b/xmlserializer/CMakeLists.txt index 074bbcc..be068c9 100644 --- a/xmlserializer/CMakeLists.txt +++ b/xmlserializer/CMakeLists.txt @@ -32,10 +32,7 @@ add_library(xmlserializer SHARED XmlDocSource.cpp XmlMemoryDocSink.cpp XmlMemoryDocSource.cpp - XmlStringDocSink.cpp - XmlFileDocSink.cpp - XmlFileDocSource.cpp - XmlStringDocSource.cpp) + XmlStreamDocSink.cpp) include(FindLibXml2) if(NOT LIBXML2_FOUND) diff --git a/xmlserializer/XmlDocSource.cpp b/xmlserializer/XmlDocSource.cpp index 35a8f4e..90a30ac 100644 --- a/xmlserializer/XmlDocSource.cpp +++ b/xmlserializer/XmlDocSource.cpp @@ -31,6 +31,9 @@ #include "XmlDocSource.h" #include <libxml/tree.h> #include <libxml/xmlschemas.h> +#include <libxml/parser.h> +#include <libxml/xinclude.h> +#include <libxml/xmlerror.h> #include <stdlib.h> using std::string; @@ -38,65 +41,30 @@ using std::string; // Schedule for libxml2 library bool CXmlDocSource::_bLibXml2CleanupScheduled; -CXmlDocSource::CXmlDocSource(_xmlDoc *pDoc, _xmlNode *pRootNode, - bool bValidateWithSchema) : +CXmlDocSource::CXmlDocSource(_xmlDoc *pDoc, bool bValidateWithSchema, + _xmlNode *pRootNode) : _pDoc(pDoc), _pRootNode(pRootNode), _strXmlSchemaFile(""), _strRootElementType(""), _strRootElementName(""), - _strNameAttrituteName(""), - _bNameCheck(false), + _strNameAttributeName(""), _bValidateWithSchema(bValidateWithSchema) { init(); } -CXmlDocSource::CXmlDocSource(_xmlDoc *pDoc, +CXmlDocSource::CXmlDocSource(_xmlDoc *pDoc, bool bValidateWithSchema, const string& strXmlSchemaFile, const string& strRootElementType, const string& strRootElementName, - const string& strNameAttrituteName) : + const string& strNameAttributeName) : _pDoc(pDoc), - _pRootNode(NULL), + _pRootNode(xmlDocGetRootElement(pDoc)), _strXmlSchemaFile(strXmlSchemaFile), _strRootElementType(strRootElementType), _strRootElementName(strRootElementName), - _strNameAttrituteName(strNameAttrituteName), - _bNameCheck(true), - _bValidateWithSchema(false) -{ - init(); -} - -CXmlDocSource::CXmlDocSource(_xmlDoc* pDoc, - const string& strXmlSchemaFile, - const string& strRootElementType, - bool bValidateWithSchema) : - _pDoc(pDoc), _pRootNode(NULL), - _strXmlSchemaFile(strXmlSchemaFile), - _strRootElementType(strRootElementType), - _strRootElementName(""), - _strNameAttrituteName(""), - _bNameCheck(false), - _bValidateWithSchema(bValidateWithSchema) -{ - init(); -} - -CXmlDocSource::CXmlDocSource(_xmlDoc *pDoc, - const string& strXmlSchemaFile, - const string& strRootElementType, - const string& strRootElementName, - const string& strNameAttrituteName, - bool bValidateWithSchema) : - _pDoc(pDoc), - _pRootNode(NULL), - _strXmlSchemaFile(strXmlSchemaFile), - _strRootElementType(strRootElementType), - _strRootElementName(strRootElementName), - _strNameAttrituteName(strNameAttrituteName), - _bNameCheck(true), + _strNameAttributeName(strNameAttributeName), _bValidateWithSchema(bValidateWithSchema) { init(); @@ -133,6 +101,18 @@ _xmlDoc* CXmlDocSource::getDoc() const return _pDoc; } +bool CXmlDocSource::isParsable() const +{ + // Check that the doc has been created + return _pDoc != NULL; +} + +bool CXmlDocSource::populate(CXmlSerializingContext& serializingContext) +{ + return validate(serializingContext); + +} + bool CXmlDocSource::validate(CXmlSerializingContext& serializingContext) { // Check that the doc has been created @@ -164,9 +144,9 @@ bool CXmlDocSource::validate(CXmlSerializingContext& serializingContext) return false; } - if (_bNameCheck) { + if (!_strNameAttributeName.empty()) { - string strRootElementNameCheck = getRootElementAttributeString(_strNameAttrituteName); + string strRootElementNameCheck = getRootElementAttributeString(_strNameAttributeName); // Check Root element name attribute (if any) if (!_strRootElementName.empty() && strRootElementNameCheck != _strRootElementName) { @@ -193,11 +173,6 @@ void CXmlDocSource::init() _bLibXml2CleanupScheduled = true; } - - if (!_pRootNode) { - - _pRootNode = xmlDocGetRootElement(_pDoc); - } } bool CXmlDocSource::isInstanceDocumentValid() @@ -264,3 +239,40 @@ void CXmlDocSource::schemaValidityStructuredErrorFunc(void* pUserData, _xmlError puts(pError->message); #endif } + +_xmlDoc* CXmlDocSource::mkXmlDoc(const string& source, bool fromFile, bool xincludes, string& errorMsg) +{ + _xmlDoc* doc = NULL; + if (fromFile) { + doc = xmlReadFile(source.c_str(), NULL, 0); + } else { + doc = xmlReadMemory(source.c_str(), (int)source.size(), "", NULL, 0); + } + + if (doc == NULL) { + errorMsg = "libxml failed to read"; + if (fromFile) { + errorMsg += " \"" + source + "\""; + } + + xmlError* details = xmlGetLastError(); + if (details != NULL) { + errorMsg += ": " + string(details->message); + } + + return NULL; + } + + if (xincludes and (xmlXIncludeProcess(doc) < 0)) { + errorMsg = "libxml failed to resolve XIncludes"; + xmlError* details = xmlGetLastError(); + if (details != NULL) { + errorMsg += ": " + string(details->message); + } + + xmlFreeDoc(doc); + doc = NULL; + } + + return doc; +} diff --git a/xmlserializer/XmlDocSource.h b/xmlserializer/XmlDocSource.h index e7be8f3..e41923e 100644 --- a/xmlserializer/XmlDocSource.h +++ b/xmlserializer/XmlDocSource.h @@ -54,22 +54,7 @@ public: * @param[in] pRootNode a pointer to the root element of the document. * @param[in] bValidateWithSchema a boolean that toggles schema validation */ - CXmlDocSource(_xmlDoc* pDoc, _xmlNode* pRootNode = NULL, bool bValidateWithSchema = false); - - /** - * Constructor - * - * @param[out] pDoc a pointer to the xml document that will be filled by the class - * @param[in] strXmlSchemaFile a std::string containing the path to the schema file - * @param[in] strRootElementType a std::string containing the root element type - * @param[in] strRootElementName a std::string containing the root element name - * @param[in] strNameAttributeName a std::string containing the name of the root name attribute - */ - CXmlDocSource(_xmlDoc* pDoc, - const std::string& strXmlSchemaFile, - const std::string& strRootElementType, - const std::string& strRootElementName, - const std::string& strNameAttrituteName); + CXmlDocSource(_xmlDoc* pDoc, bool bValidateWithSchema = false, _xmlNode* pRootNode = NULL); /** * Constructor @@ -81,22 +66,11 @@ public: * @param[in] strNameAttributeName a string containing the name of the root name attribute * @param[in] bValidateWithSchema a boolean that toggles schema validation */ - CXmlDocSource(_xmlDoc* pDoc, - const std::string& strXmlSchemaFile, - const std::string& strRootElementType, - const std::string& strRootElementName, - const std::string& strNameAttrituteName, - bool bValidateWithSchema); - - /** - * Constructor - * - * @param[out] pDoc a pointer to the xml document that will be filled by the class - * @param[in] strXmlSchemaFile a string containing the path to the schema file - * @param[in] strRootElementType a string containing the root element type - */ - CXmlDocSource(_xmlDoc* pDoc, const std::string& strXmlSchemaFile, const std::string& strRootElementType, - bool bValidateWithSchema); + CXmlDocSource(_xmlDoc* pDoc, bool bValidateWithSchema, + const std::string& strXmlSchemaFile = "", + const std::string& strRootElementType = "", + const std::string& strRootElementName = "", + const std::string& strNameAttributeName = ""); /** * Destructor @@ -110,7 +84,7 @@ public: * * @return false if there are any error */ - virtual bool populate(CXmlSerializingContext& serializingContext) = 0; + virtual bool populate(CXmlSerializingContext& serializingContext); /** * Method that returns the root element of the Xml tree. @@ -154,6 +128,24 @@ public: */ virtual bool validate(CXmlSerializingContext& serializingContext); + /** + * Method that checks that the xml document has been correctly parsed. + * + * @return false if any error occurs during the parsing + */ + virtual bool isParsable() const; + + /** + * Helper method for creating an xml document from either a file or a + * string. + * + * @param[in] source either a filename or a string representing an xml document + * @param[in] fromFile true if source is a filename, false if source is an xml + * represents an xml document + * @param[in] xincludes if true, process xincludes tags + * @param[out] errorMsg used as error output + */ + static _xmlDoc* mkXmlDoc(const std::string& source, bool fromFile, bool xincludes, std::string& errorMsg); protected: @@ -210,12 +202,7 @@ private: /** * Element name attribute info */ - std::string _strNameAttrituteName; - - /** - * Boolean that enables the root element name attribute check - */ - bool _bNameCheck; + std::string _strNameAttributeName; /** * Boolean that enables the validation via xsd files diff --git a/xmlserializer/XmlFileDocSource.cpp b/xmlserializer/XmlFileDocSource.cpp deleted file mode 100644 index f980c39..0000000 --- a/xmlserializer/XmlFileDocSource.cpp +++ /dev/null @@ -1,109 +0,0 @@ -/* - * Copyright (c) 2011-2014, Intel Corporation - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation and/or - * other materials provided with the distribution. - * - * 3. Neither the name of the copyright holder nor the names of its contributors - * may be used to endorse or promote products derived from this software without - * specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR - * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON - * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "XmlFileDocSource.h" -#include <libxml/parser.h> -#include <libxml/xinclude.h> - -#define base CXmlDocSource - -CXmlFileDocSource::CXmlFileDocSource(const std::string& strXmlInstanceFile, - const std::string& strXmlSchemaFile, - const std::string& strRootElementType, - const std::string& strRootElementName, - const std::string& strNameAttrituteName, - bool bValidateWithSchema) : - base(readFile(strXmlInstanceFile), - strXmlSchemaFile, - strRootElementType, - strRootElementName, - strNameAttrituteName, - bValidateWithSchema), - _strXmlInstanceFile(strXmlInstanceFile) -{ -} - -CXmlFileDocSource::CXmlFileDocSource(const std::string& strXmlInstanceFile, - const std::string& strXmlSchemaFile, - const std::string& strRootElementType, - bool bValidateWithSchema) : - base(readFile(strXmlInstanceFile), - strXmlSchemaFile, - strRootElementType, - bValidateWithSchema), - _strXmlInstanceFile(strXmlInstanceFile) -{ -} - -bool CXmlFileDocSource::isParsable(CXmlSerializingContext& serializingContext) const -{ - // Check that the doc has been created - if (!_pDoc) { - - serializingContext.setError("Could not parse file " + _strXmlInstanceFile); - - return false; - } - - return true; -} - -bool CXmlFileDocSource::populate(CXmlSerializingContext& serializingContext) -{ - if (!validate(serializingContext)) { - - // Add the file's name in the error message - serializingContext.appendLineToError("File : " + _strXmlInstanceFile); - - return false; - } - - return true; -} - -_xmlDoc* CXmlFileDocSource::readFile(const std::string& strFileName) -{ - // Read xml file - xmlDocPtr pDoc = xmlReadFile(strFileName.c_str(), NULL, 0); - - if (!pDoc) { - - return NULL; - } - // Process file inclusion - // WARNING: this symbol is available if libxml2 has been compiled with LIBXML_XINCLUDE_ENABLED - if (xmlXIncludeProcess(pDoc) < 0) { - - xmlFreeDoc(pDoc); - return NULL; - } - - return pDoc; -} diff --git a/xmlserializer/XmlFileDocSource.h b/xmlserializer/XmlFileDocSource.h deleted file mode 100644 index f7b2e30..0000000 --- a/xmlserializer/XmlFileDocSource.h +++ /dev/null @@ -1,104 +0,0 @@ -/* - * Copyright (c) 2011-2014, Intel Corporation - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation and/or - * other materials provided with the distribution. - * - * 3. Neither the name of the copyright holder nor the names of its contributors - * may be used to endorse or promote products derived from this software without - * specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR - * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON - * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#pragma once -#include "XmlDocSource.h" -#include <string> - -/** - * Source class that read a file to get an xml document. - * Its base class will validate the document. - */ -class CXmlFileDocSource : public CXmlDocSource -{ -public: - /** - * Constructor - * - * @param[in] strXmlInstanceFile a string containing the path to the xml file - * @param[in] strXmlSchemaFile a string containing the path to the schema file - * @param[in] strRootElementType a string containing the root element type - * @param[in] strRootElementName a string containing the root element name - * @param[in] strNameAttributeName a string containing the name of the root name attribute - * @param[in] bValidateWithSchema a boolean that toggles schema validation - */ - CXmlFileDocSource(const std::string& strXmlInstanceFile, - const std::string& strXmlSchemaFile, - const std::string& strRootElementType, - const std::string& strRootElementName, - const std::string& strNameAttrituteName, - bool bValidateWithSchema); - /** - * Constructor - * - * @param[in] strXmlInstanceFile a string containing the path to the xml file - * @param[in] strXmlSchemaFile a string containing the path to the schema file - * @param[in] strRootElementType a string containing the root element type - * @param[in] bValidateWithSchema a boolean that toggles schema validation - */ - CXmlFileDocSource(const std::string& strXmlInstanceFile, const std::string& strXmlSchemaFile, const std::string& strRootElementType, - bool bValidateWithSchema); - - /** - * CXmlDocSource method implementation. - * - * @param[out] serializingContext is used as error output - * - * @return false if any error occurs - */ - virtual bool populate(CXmlSerializingContext& serializingContext); - - /** - * Method that checks that the file exists and is readable. - * - * @param[out] serializingContext is used as error output - * - * @return false if any error occurs during the parsing - */ - virtual bool isParsable(CXmlSerializingContext& serializingContext) const; - -private: - /** - * Read xml file - * - * This function reads an xml file and processes eventual included files - * WARNING: to compile this function, libxml2 has to be compiled with LIBXML_XINCLUDE_ENABLED - * - * @param[in] strFileName the file name - * - * @return a pointer to generated xml document object - */ - static _xmlDoc* readFile(const std::string& strFileName); - - /** - * Instance file - */ - std::string _strXmlInstanceFile; -}; diff --git a/xmlserializer/XmlMemoryDocSource.cpp b/xmlserializer/XmlMemoryDocSource.cpp index 411d98a..2929b79 100644 --- a/xmlserializer/XmlMemoryDocSource.cpp +++ b/xmlserializer/XmlMemoryDocSource.cpp @@ -34,26 +34,17 @@ #define base CXmlDocSource -CXmlMemoryDocSource::CXmlMemoryDocSource(const IXmlSource* pXmlSource, +CXmlMemoryDocSource::CXmlMemoryDocSource(const IXmlSource* pXmlSource, bool bValidateWithSchema, const std::string& strRootElementType, const std::string& strXmlSchemaFile, const std::string& strProduct, - const std::string& strVersion, - bool bValidateWithSchema): - base(xmlNewDoc(BAD_CAST "1.0"), xmlNewNode(NULL, BAD_CAST strRootElementType.c_str()), - bValidateWithSchema), - _pXmlSource(pXmlSource), _strXmlSchemaFile(strXmlSchemaFile), _bWithHeader(true), - _strProduct(strProduct), _strVersion(strVersion) -{ - init(); -} - -CXmlMemoryDocSource::CXmlMemoryDocSource(const IXmlSource* pXmlSource, - const std::string& strRootElementType, - bool bValidateWithSchema): - base(xmlNewDoc(BAD_CAST "1.0"), xmlNewNode(NULL, BAD_CAST strRootElementType.c_str()), - bValidateWithSchema), - _pXmlSource(pXmlSource), _bWithHeader(false) + const std::string& strVersion): + base(xmlNewDoc(BAD_CAST "1.0"), bValidateWithSchema, + xmlNewNode(NULL, BAD_CAST strRootElementType.c_str())), + _pXmlSource(pXmlSource), + _strXmlSchemaFile(strXmlSchemaFile), + _strProduct(strProduct), + _strVersion(strVersion) { init(); } @@ -80,7 +71,7 @@ bool CXmlMemoryDocSource::populate(CXmlSerializingContext& serializingContext) // Create Xml element with the Doc CXmlElement docElement(_pRootNode); - if (_bWithHeader) { + if (!_strXmlSchemaFile.empty()) { // Schema namespace docElement.setAttributeString("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"); diff --git a/xmlserializer/XmlMemoryDocSource.h b/xmlserializer/XmlMemoryDocSource.h index 3266782..bc5fdb5 100644 --- a/xmlserializer/XmlMemoryDocSource.h +++ b/xmlserializer/XmlMemoryDocSource.h @@ -50,20 +50,11 @@ public: * @param[in] strVersion a string containing the version number * @param[in] bValidateWithSchema a boolean that toggles schema validation */ - CXmlMemoryDocSource(const IXmlSource* pXmlSource, const std::string& strRootElementType, - const std::string& strXmlSchemaFile, const std::string& strProduct, - const std::string& strVersion, - bool bValidateWithSchema); - - /** - * Constructor - * - * @param[in] pXmlSource a pointer to a parameter-framework structure that can generate - * an xml description of itself - * @param[in] strRootElementType a string containing the root element type - * @param[in] bValidateWithSchema a boolean that toggles schema validation - */ - CXmlMemoryDocSource(const IXmlSource* pXmlSource, const std::string& strRootElementType, bool bValidateWithSchema); + CXmlMemoryDocSource(const IXmlSource* pXmlSource, bool bValidateWithSchema, + const std::string& strRootElementType, + const std::string& strXmlSchemaFile = "", + const std::string& strProduct = "", + const std::string& strVersion = ""); /** * Implementation of CXmlDocSource::populate() method. @@ -91,11 +82,6 @@ private: */ std::string _strXmlSchemaFile; - /** - * Boolean used to specify if a header should be added in the Xml Doc - */ - bool _bWithHeader; - // Product and version info std::string _strProduct; std::string _strVersion; diff --git a/xmlserializer/XmlStringDocSink.cpp b/xmlserializer/XmlStreamDocSink.cpp index caec545..f1a2524 100644 --- a/xmlserializer/XmlStringDocSink.cpp +++ b/xmlserializer/XmlStreamDocSink.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -27,36 +27,34 @@ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "XmlStringDocSink.h" +#include "XmlStreamDocSink.h" #include <libxml/parser.h> #define base CXmlDocSink -CXmlStringDocSink::CXmlStringDocSink(std::string& strResult): - _strResult(strResult) +CXmlStreamDocSink::CXmlStreamDocSink(std::ostream& output): + _output(output) { } -bool CXmlStringDocSink::doProcess(CXmlDocSource& xmlDocSource, +bool CXmlStreamDocSink::doProcess(CXmlDocSource& xmlDocSource, CXmlSerializingContext& serializingContext) { - (void)serializingContext; - - xmlChar* pcDumpedDoc = NULL; + xmlChar* dumpedDoc = NULL; int iSize; - xmlDocDumpFormatMemoryEnc(xmlDocSource.getDoc(), &pcDumpedDoc, &iSize, "UTF-8", 1); + xmlDocDumpFormatMemoryEnc(xmlDocSource.getDoc(), &dumpedDoc, &iSize, "UTF-8", 1); - if (!pcDumpedDoc) { + if (!dumpedDoc) { serializingContext.setError("Unable to encode XML document in memory"); return false; } - _strResult.append((const char*)pcDumpedDoc); + _output << static_cast<unsigned char*>(dumpedDoc); - xmlFree(pcDumpedDoc); + xmlFree(dumpedDoc); return true; } diff --git a/xmlserializer/XmlStringDocSink.h b/xmlserializer/XmlStreamDocSink.h index 22fa3a1..08b81cb 100644 --- a/xmlserializer/XmlStringDocSink.h +++ b/xmlserializer/XmlStreamDocSink.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2011-2014, Intel Corporation + * Copyright (c) 2015, Intel Corporation * All rights reserved. * * Redistribution and use in source and binary forms, with or without modification, @@ -29,7 +29,7 @@ */ #pragma once -#include <string> +#include <ostream> #include "XmlDocSink.h" #include "XmlSource.h" @@ -37,14 +37,14 @@ * Sink class that writes the content of any CXmlDocSource into a std::string. * A reference to an empty std::string is given in the constructor. */ -class CXmlStringDocSink : public CXmlDocSink +class CXmlStreamDocSink : public CXmlDocSink { public: /** Constructor * - * @param[out] strResult a reference to a std::string that will be filled by the doProcess method + * @param[out] output a reference to a ostream that will be filled by the doProcess method */ - CXmlStringDocSink(std::string& strResult); + CXmlStreamDocSink(std::ostream& output); private: /** Implementation of CXmlDocSink::doProcess() @@ -58,8 +58,8 @@ private: virtual bool doProcess(CXmlDocSource& xmlDocSource, CXmlSerializingContext& serializingContext); /** - * Result std::string containing the XML informations + * Result ostream containing the XML informations */ - std::string& _strResult; + std::ostream& _output; }; diff --git a/xmlserializer/XmlStringDocSource.cpp b/xmlserializer/XmlStringDocSource.cpp deleted file mode 100644 index 8d420b6..0000000 --- a/xmlserializer/XmlStringDocSource.cpp +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2011-2014, Intel Corporation - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation and/or - * other materials provided with the distribution. - * - * 3. Neither the name of the copyright holder nor the names of its contributors - * may be used to endorse or promote products derived from this software without - * specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR - * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON - * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "XmlStringDocSource.h" -#include <libxml/parser.h> - -#define base CXmlDocSource - -CXmlStringDocSource::CXmlStringDocSource(const std::string& strXmlInput, - const std::string& strXmlSchemaFile, - const std::string& strRootElementType, - const std::string& strRootElementName, - const std::string& strNameAttrituteName, - bool bValidateWithSchema) : - base(xmlReadMemory(strXmlInput.c_str(), (int)strXmlInput.size(), "", NULL, 0), - strXmlSchemaFile, - strRootElementType, - strRootElementName, - strNameAttrituteName, - bValidateWithSchema) -{ -} - -bool CXmlStringDocSource::populate(CXmlSerializingContext &serializingContext) -{ - return validate(serializingContext); -} diff --git a/xmlserializer/XmlStringDocSource.h b/xmlserializer/XmlStringDocSource.h deleted file mode 100644 index 06a0337..0000000 --- a/xmlserializer/XmlStringDocSource.h +++ /dev/null @@ -1,69 +0,0 @@ -/* - * Copyright (c) 2011-2014, Intel Corporation - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * - * 1. Redistributions of source code must retain the above copyright notice, this - * list of conditions and the following disclaimer. - * - * 2. Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation and/or - * other materials provided with the distribution. - * - * 3. Neither the name of the copyright holder nor the names of its contributors - * may be used to endorse or promote products derived from this software without - * specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR - * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; - * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON - * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#pragma once -#include "XmlDocSource.h" -#include <string> - -/** - * Source class that get an xml document from a std::string. - * Its base class will check the validity of the document. - */ -class CXmlStringDocSource : public CXmlDocSource -{ -public: - /** - * Constructor - * - * @param[in] strXmlInput a string containing an xml description - * @param[in] strXmlSchemaFile a string containing the path to the schema file - * @param[in] strRootElementType a string containing the root element type - * @param[in] strRootElementName a string containing the root element name - * @param[in] strNameAttributeName a string containing the name of the root name attribute - * @param[in] bValidateWithSchema a boolean that toggles schema validation - */ - CXmlStringDocSource(const std::string& strXmlInput, - const std::string& strXmlSchemaFile, - const std::string& strRootElementType, - const std::string& strRootElementName, - const std::string& strNameAttrituteName, - bool bValidateWithSchema); - - /** - * CXmlDocSource method implementation. - * - * @param[out] serializingContext is used as error output - * - * @return false if any error occurs - */ - virtual bool populate(CXmlSerializingContext& serializingContext); -}; - - |