diff --git a/Makefile b/Makefile index b4ee747e..1f37a8f7 100644 --- a/Makefile +++ b/Makefile @@ -58,12 +58,14 @@ SIM_SERV_DIRS = \ ${TRICK_HOME}/trick_source/sim_services/Zeroconf \ ${TRICK_HOME}/trick_source/sim_services/include \ ${TRICK_HOME}/trick_source/sim_services/mains +ifeq ($(USE_ER7_UTILS), 0) +SIM_SERV_DIRS += ${TRICK_HOME}/trick_source/sim_services/Integrator/trick_algorithms +endif SIM_SERV_OBJS = $(addsuffix /object_$(TRICK_HOST_CPU)/*.o ,$(SIM_SERV_DIRS)) SIM_SERV_OBJS := $(filter-out ${TRICK_HOME}/trick_source/sim_services/MemoryManager/%, $(SIM_SERV_OBJS)) ER7_UTILS_DIRS = \ - ${ER7_UTILS_HOME}/CheckpointHelper \ ${ER7_UTILS_HOME}/integration/abm4 \ ${ER7_UTILS_HOME}/integration/beeman \ ${ER7_UTILS_HOME}/integration/core \ @@ -83,6 +85,9 @@ ER7_UTILS_DIRS = \ ${ER7_UTILS_HOME}/interface \ ${ER7_UTILS_HOME}/math \ ${ER7_UTILS_HOME}/trick/integration +ifeq ($(USE_ER7_UTILS_CHECKPOINTHELPER), 1) +ER7_UTILS_DIRS += ${ER7_UTILS_HOME}/CheckpointHelper +endif ER7_UTILS_OBJS = $(addsuffix /object_$(TRICK_HOST_CPU)/*.o ,$(ER7_UTILS_DIRS)) UTILS_DIRS := \ @@ -118,7 +123,7 @@ UNIT_TEST_DIRS := \ $(wildcard ${TRICK_HOME}/trick_source/sim_services/*/test) \ $(wildcard ${TRICK_HOME}/trick_source/trick_utils/*/test) \ ${TRICK_HOME}/trick_source/data_products/DPX/test/unit_test -ifeq ($(USE_ER7_UTILS_INTEGRATORS), 0) +ifeq ($(USE_ER7_UTILS), 0) UNIT_TEST_DIRS := $(filter-out %Integrator/test,$(UNIT_TEST_DIRS)) endif @@ -174,7 +179,7 @@ no_dp: $(TRICK_LIB) $(TRICK_SWIG_LIB) $(TRICK_LIB): $(SIM_SERV_DIRS) $(UTILS_DIRS) | $(TRICK_LIB_DIR) ar crs $@ $(SIM_SERV_OBJS) $(UTILS_OBJS) -ifeq ($(USE_ER7_UTILS_INTEGRATORS), 1) +ifeq ($(USE_ER7_UTILS), 1) ER7_UTILS_LIB = $(TRICK_LIB_DIR)/liber7_utils.a no_dp: $(ER7_UTILS_LIB) @@ -204,7 +209,7 @@ make_er7_makefiles: $(CP) ${TRICK_HOME}/trick_source/sim_services/Executive/Makefile $$i; \ done -ifeq ($(USE_ER7_UTILS_INTEGRATORS), 1) +ifeq ($(USE_ER7_UTILS), 1) icg_sim_serv: | make_er7_makefiles endif @@ -292,7 +297,7 @@ clean: clean_sim_serv clean_utils clean_swig clean_dp clean_ICG clean_java @/bin/rm -rf $(TRICK_BIN_DIR) @/bin/rm -rf $(TRICK_LIB_DIR) -ifeq ($(USE_ER7_UTILS_INTEGRATORS), 1) +ifeq ($(USE_ER7_UTILS), 1) clean: clean_er7_utils endif @@ -318,7 +323,7 @@ clean_swig: $(MAKE) -C $$i real_clean ; \ done -ifeq ($(USE_ER7_UTILS_INTEGRATORS), 1) +ifeq ($(USE_ER7_UTILS), 1) clean_swig: make_er7_makefiles endif @@ -403,13 +408,8 @@ ICG: $(ICG_EXE) ${TRICK_HOME}/bin/trick-ICG -f -s -m ${TRICK_CXXFLAGS} ${TRICK_SYSTEM_CXXFLAGS} ${TRICK_HOME}/include/trick/files_to_ICG.hh # This builds a tricklib share library. -ifeq ($(USE_ER7_UTILS_INTEGRATORS), 1) -trick_lib: $(SIM_SERV_DIRS) $(ER7_UTILS_DIRS) $(UTILS_DIRS) | $(TRICK_LIB_DIR) - ${TRICK_CPPC} $(SHARED_LIB_OPT) -o ${TRICK_LIB_DIR}/libtrick.so $(SIM_SERV_OBJS) $(ER7_UTILS_OBJS) $(UTILS_OBJS) -else trick_lib: $(SIM_SERV_DIRS) $(UTILS_DIRS) | $(TRICK_LIB_DIR) ${TRICK_CPPC} $(SHARED_LIB_OPT) -o ${TRICK_LIB_DIR}/libtrick.so $(SIM_SERV_OBJS) $(UTILS_OBJS) -endif # For NASA/JSC developers include optional rules -include Makefile_jsc_dirs diff --git a/autoconf/configure.ac b/autoconf/configure.ac index 0041cbfd..3abd9710 100644 --- a/autoconf/configure.ac +++ b/autoconf/configure.ac @@ -100,6 +100,16 @@ AC_DEFUN([AX_GTEST_HOME],[ AC_SUBST([GTEST_HOME]) ]) +dnl test if we want to use er7_utils, default to yes +AC_DEFUN([AX_ER7_UTILS],[ + AC_ARG_ENABLE([er7utils], + AS_HELP_STRING([--enable-er7utils], [use er7_utils (default is yes)]), + AS_IF([test "x$enable_er7utils" = xyes], [USE_ER7_UTILS="1"], [USE_ER7_UTILS="0"]), + [USE_ER7_UTILS="1"] + ) + AC_SUBST([USE_ER7_UTILS]) +]) + dnl if fermi-ware directory exists, test for motif. AC_DEFUN([AX_JSC_DIRS],[ AC_CHECK_FILE([trick_source/data_products/fermi-ware], @@ -170,6 +180,7 @@ AX_TPRO_HOME([]) AX_BC635_HOME([]) AX_GSL_HOME([]) AX_GTEST_HOME([]) +AX_ER7_UTILS([]) AC_OUTPUT([share/trick/makefiles/config_user.mk]) diff --git a/configure b/configure index c0afc2ab..c45acb86 100755 --- a/configure +++ b/configure @@ -620,6 +620,7 @@ ac_includes_default="\ ac_subst_vars='LTLIBOBJS LIBOBJS +USE_ER7_UTILS GTEST_HOME GSL_HOME BC635_HOME @@ -725,6 +726,7 @@ with_tpro with_bc635 with_gsl with_gtest +enable_er7utils ' ac_precious_vars='build_alias host_alias @@ -1355,6 +1357,12 @@ if test -n "$ac_init_help"; then esac cat <<\_ACEOF +Optional Features: + --disable-option-checking ignore unrecognized --enable/--with options + --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no) + --enable-FEATURE[=ARG] include FEATURE [ARG=yes] + --enable-er7utils use er7_utils (default is yes) + Optional Packages: --with-PACKAGE[=ARG] use PACKAGE [ARG=yes] --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no) @@ -2235,6 +2243,8 @@ ac_configure="$SHELL $ac_aux_dir/configure" # Please don't use this var. + + XTRAINCPATHS="-I/usr/include/libxml2/ -I/usr/X11/include" CFLAGS="$CFLAGS $XTRAINCPATHS" @@ -5712,6 +5722,21 @@ fi + # Check whether --enable-er7utils was given. +if test "${enable_er7utils+set}" = set; then : + enableval=$enable_er7utils; if test "x$enable_er7utils" = xyes; then : + USE_ER7_UTILS="1" +else + USE_ER7_UTILS="0" +fi +else + USE_ER7_UTILS="1" + +fi + + + + ac_config_files="$ac_config_files share/trick/makefiles/config_user.mk" cat >confcache <<\_ACEOF diff --git a/include/trick/files_to_ICG.hh b/include/trick/files_to_ICG.hh index 64e0312c..9ec09805 100644 --- a/include/trick/files_to_ICG.hh +++ b/include/trick/files_to_ICG.hh @@ -57,6 +57,13 @@ #include "er7_utils/trick/include/files_to_ICG.hh" #endif +#ifdef USE_ER7_UTILS_CHECKPOINTHELPER +#include "er7_utils/CheckpointHelper/Manager.hh" +#include "er7_utils/CheckpointHelper/DoublePtrCollect.hh" +#include "er7_utils/CheckpointHelper/CheckpointItem.hh" +#include "er7_utils/CheckpointHelper/InputAllocsChkptRestart.hh" +#endif + #include "trick/DataRecordDispatcher.hh" #include "trick/DRAscii.hh" #include "trick/DRBinary.hh" diff --git a/share/trick/makefiles/Makefile.common b/share/trick/makefiles/Makefile.common index f3666b7a..656a8709 100644 --- a/share/trick/makefiles/Makefile.common +++ b/share/trick/makefiles/Makefile.common @@ -86,17 +86,20 @@ TRICK_SYSTEM_CFLAGS += -DHAVE_ZEROCONF TRICK_SYSTEM_CXXFLAGS += -DHAVE_ZEROCONF endif -export USE_ER7_UTILS_INTEGRATORS := 0 -ifneq ("$(wildcard $(TRICK_HOME)/trick_source/er7_utils)","") # if the er7_utils directory exists +ifeq ($(USE_ER7_UTILS), 1) ER7_UTILS_HOME := $(TRICK_HOME)/trick_source/er7_utils - USE_ER7_UTILS_INTEGRATORS := 1 TRICK_SYSTEM_CFLAGS += -DUSE_ER7_UTILS_INTEGRATORS TRICK_SYSTEM_CXXFLAGS += -DUSE_ER7_UTILS_INTEGRATORS +ifneq ($(wildcard ${ER7_UTILS_HOME}/CheckpointHelper),) + USE_ER7_UTILS_CHECKPOINTHELPER = 1 + TRICK_SYSTEM_CFLAGS += -DUSE_ER7_UTILS_CHECKPOINTHELPER + TRICK_SYSTEM_CXXFLAGS += -DUSE_ER7_UTILS_CHECKPOINTHELPER +endif endif endif # MAKELEVEL = 0 -ifeq ($(USE_ER7_UTILS_INTEGRATORS), 1) +ifeq ($(USE_ER7_UTILS), 1) TRICK_LIBS += -ler7_utils endif diff --git a/share/trick/makefiles/config_user.mk.in b/share/trick/makefiles/config_user.mk.in index 43209864..ce14414a 100644 --- a/share/trick/makefiles/config_user.mk.in +++ b/share/trick/makefiles/config_user.mk.in @@ -25,6 +25,7 @@ TPROCTE = @TPROCTE_HOME@ BC635 = @BC635_HOME@ GSL_HOME = @GSL_HOME@ GTEST_HOME = @GTEST_HOME@ +USE_ER7_UTILS = @USE_ER7_UTILS@ LIBXML = @LIBXML@ diff --git a/trick_source/.gitignore b/trick_source/.gitignore index 32e7b8d7..e69de29b 100644 --- a/trick_source/.gitignore +++ b/trick_source/.gitignore @@ -1 +0,0 @@ -er7_utils diff --git a/trick_source/er7_utils/CheckpointHelper/.gitignore b/trick_source/er7_utils/CheckpointHelper/.gitignore new file mode 100644 index 00000000..115034af --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/.gitignore @@ -0,0 +1 @@ +libSTLHelper.a diff --git a/trick_source/er7_utils/CheckpointHelper/Alloc.cpp b/trick_source/er7_utils/CheckpointHelper/Alloc.cpp new file mode 100644 index 00000000..0b5ccdd8 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Alloc.cpp @@ -0,0 +1,198 @@ +/* + * Alloc.cpp + * + * Created on: Aug 24, 2015 + * Author: tbrain + */ + +#include "Alloc.hh" + +namespace CheckpointHelper +{ +#if (defined TRICK_VER) && (TRICK_VER >= 10) +std::string treatAllocName(const std::string & nameIn) +{ + std::string treatedName(nameIn); + + // Always remove "&" + std::size_t found = treatedName.find('&'); + if (found != std::string::npos) + { + treatedName.erase(0, 1); + } + + found = treatedName.find('.'); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find('.'); + } + found = treatedName.find('['); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find('['); + } + found = treatedName.find(']'); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find(']'); + } + found = treatedName.find(' '); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find(' '); + } + found = treatedName.find('+'); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find('+'); + } + found = treatedName.find(':'); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find(':'); + } + found = treatedName.find('('); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find('('); + } + found = treatedName.find(')'); + while (found != std::string::npos) + { + treatedName.replace(found, 1, "_"); + found = treatedName.find(')'); + } + + // Check for linked-list, we want to prevent very long names + found = treatedName.rfind("AUTOLIST"); + if (found == std::string::npos) + { + found = treatedName.rfind("_0__"); + if (found != std::string::npos) + { + size_t newParamNamePos = found + 4; + std::string newParamName = treatedName.substr(newParamNamePos); + size_t remChars = treatedName.length() - newParamNamePos; + if (remChars <= found) + { + std::string prevParamName = treatedName.substr(found - remChars, remChars); + if (prevParamName.compare(newParamName) == 0) + { + treatedName = treatedName.substr(0, found); + treatedName += "_AUTOLIST1"; + } + } + } + } + else + { + size_t afterListPos = treatedName.rfind("_0__"); + std::stringstream iss(treatedName.substr(found + 8, afterListPos)); + int currIdx = 0; + iss >> currIdx; + ++currIdx; + iss.str(""); + iss << currIdx; + treatedName = treatedName.substr(0, found + 8); + treatedName += iss.str(); + } + + return treatedName; +} + +bool updateAllocName(void * parentPtr, void * ptr, const std::string & name, const std::string & funcName, + bool printError) +{ + bool success = false; + if (parentPtr != 0x0) + { + ALLOC_INFO * info = trick_MM->get_alloc_info_of(parentPtr); + if (info != 0x0) + { + if (info->name != 0x0) + { + std::string pathName = trick_MM->ref_name_from_address(parentPtr); + pathName = treatAllocName(pathName); + std::stringstream ss; + std::string treatedName = treatAllocName(name); + ss << pathName << "_" << treatedName; + trick_MM->set_name_at(ptr, ss.str().c_str()); + success = true; + } + else + { + if (printError) + { + if (ptr == 0x0) + { + std::stringstream ss; + ss << "Could not name an allocation with name " << name << " because the allocated ptr is NULL. " + << "Allocation call invoked from " << funcName << std::endl; + message_publish(1, ss.str().c_str()); + } + else + { + std::stringstream ss; + ss << "Could not name the allocation at " << ptr << " because it's parent data structure at " + << parentPtr + << " has no name registered with Trick MemoryManager. Allocation call invoked from " << funcName + << std::endl; + message_publish(1, ss.str().c_str()); + } + } + } + } + else + { + if (printError) + { + if (ptr == 0x0) + { + std::stringstream ss; + ss << "Could not name an allocation with name " << name << " because the allocated ptr is NULL. " + << "Allocation call invoked from " << funcName << std::endl; + message_publish(1, ss.str().c_str()); + } + else + { + std::stringstream ss; + ss << "Could not name the allocation at " << ptr << " because it's parent data structure at " + << parentPtr << " was not found by Trick MemoryManagerAllocation call invoked from " << funcName + << std::endl; + message_publish(1, ss.str().c_str()); + } + } + } + } + else + { + if (printError) + { + if (ptr == 0x0) + { + std::stringstream ss; + ss << "Could not name an allocation with name " << name + << " because the parent and allocated pointers are NULL. " << "Allocation call invoked from " + << funcName << std::endl; + message_publish(1, ss.str().c_str()); + } + else + { + std::stringstream ss; + ss << "Could not name the allocation at " << ptr << " because it's parent pointer is NULL. " + << "Allocation call invoked from " << funcName << std::endl; + message_publish(1, ss.str().c_str()); + } + } + } + return success; +} +#endif +} diff --git a/trick_source/er7_utils/CheckpointHelper/Alloc.hh b/trick_source/er7_utils/CheckpointHelper/Alloc.hh new file mode 100644 index 00000000..b539f5f2 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Alloc.hh @@ -0,0 +1,472 @@ +/******************************************************************************* + + PURPOSE: + (alloc template for allocating and reallocating elements.) + + LIBRARY DEPENDENCY: + ((Alloc.cpp)) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_alloc_HH_ +#define CHECKPOINTHELPER_alloc_HH_ +#if (defined TRICK_VER) && (TRICK_VER >= 10) +#include "sim_services/MemoryManager/include/MemoryManager.hh" +#include "sim_services/Message/include/message_proto.h" +#endif +#include +#include +#include +#include "Manager.hh" + +namespace CheckpointHelper +{ + +extern Manager * helperManager; + +#if (defined TRICK_VER) && (TRICK_VER >= 10) +typedef TRICK_TYPE MM_TYPE; + +std::string treatAllocName(const std::string & nameIn); +bool updateAllocName(void * parentPtr, void * ptr, const std::string & name, const std::string & funcName, + bool printError); + +template +void delete_alloc(T ** x, const std::string & whereAt, bool external) +{ + if (!external) + { + if (trick_MM->is_alloced(*x)) + { + trick_MM->delete_var((void *) *x); + if (helperManager != 0x0) + { + helperManager->removeConstructorAlloc(*x); + } + *x = 0x0; + } + else if (*x != 0x0) + { + std::stringstream ss; + ss << "CheckpointHelper::delete_alloc ERROR attempting to delete ptr at " << whereAt + << " that is not allocated.\n"; + message_publish(MSG_WARNING, ss.str().c_str()); + *x = 0x0; + } + } + else + { + if (trick_MM->is_alloced(*x)) + { + trick_MM->delete_extern_var((void *) *x); + if (helperManager != 0x0) + { + helperManager->removeConstructorAlloc(*x); + size_t numEntries = helperManager->getExternNum(*x); + helperManager->removeExternAlloc(*x); + for (int ii = numEntries - 1; ii >= 0; --ii) + { + (*x)[ii].~T(); + } + free(*x); + *x = 0x0; + } + } + else if (*x != 0x0) + { + std::stringstream ss; + ss << "CheckpointHelper::delete_alloc ERROR attempting to delete external ptr at " << whereAt + << " that is not allocated.\n"; + message_publish(MSG_WARNING, ss.str().c_str()); + *x = 0x0; + } + } +} + +template +void operatornew_alloc(void * parentPtr, T ** x, int n, const std::string & TYPE, const std::string & name, + const std::string & funcNameIn) +{ + if (n) + { + if (trick_MM->is_alloced(*x)) + { + int orig_size = trick_MM->get_size((char *) *x); + if (n > orig_size) + { + helperManager->removeConstructorAlloc(*x); + *x = (U *) trick_MM->resize_array((void *) *x, n); + helperManager->addConstructorAlloc(parentPtr, *x, name, funcNameIn); + } + } + else + { + ALLOC_INFO * info = trick_MM->get_alloc_info_of(x); + if (info != 0x0) + { + if (info->name != 0x0) + { + *x = static_cast(trick_MM->declare_operatornew_var(TYPE, sizeof(U) * n, sizeof(U))); + std::string pathName = trick_MM->ref_name_from_address(x); + pathName = treatAllocName(pathName); + trick_MM->set_name_at(*x, pathName.c_str()); + } + else + { + *x = static_cast(trick_MM->declare_operatornew_var(TYPE, sizeof(U) * n, sizeof(U))); + if (helperManager != 0x0) + { + helperManager->addConstructorAlloc(parentPtr, *x, name, funcNameIn); + } + } + } + else + { + *x = static_cast(trick_MM->declare_operatornew_var(TYPE, sizeof(U) * n, sizeof(U))); + if (helperManager != 0x0) + { + helperManager->addConstructorAlloc(parentPtr, *x, name, funcNameIn); + } + } + } + } + else + { + *x = 0; + } +} + +template +void alloc(void * parentPtr, T ** x, TRICK_TYPE type, const std::string & TYPE_NAME, int n_stars, + const std::string & name, int n_cdims, int cdims[8], bool external, const std::string & funcNameIn) +{ + if (cdims[0]) + { + if (trick_MM->is_alloced(*x)) + { + int orig_size = trick_MM->get_size((char *) *x); + if (cdims[0] > orig_size) + { + helperManager->removeConstructorAlloc(*x); + *x = (U *) trick_MM->resize_array((void *) *x, cdims[0]); + helperManager->addConstructorAlloc(parentPtr, *x, name, funcNameIn); + } + } + else + { + ALLOC_INFO * info = trick_MM->get_alloc_info_of(x); + if (info != 0x0) + { + if (info->name != 0x0) + { + std::string pathName = trick_MM->ref_name_from_address(x); + pathName = treatAllocName(pathName); + if (external) + { + if (*x == 0x0) + { + *x = reinterpret_cast(calloc(cdims[0], sizeof(U))); + new (*x) U[cdims[0]](); + if (helperManager != 0x0) + { + helperManager->addExternAlloc(*x, cdims[0]); + } + } + trick_MM->declare_extern_var(*x, type, TYPE_NAME, n_stars, pathName, n_cdims, cdims); + } + else + { + *x = (U *) trick_MM->declare_var(type, TYPE_NAME, n_stars, pathName, n_cdims, cdims); + } + } + else + { + if (external) + { + if (*x == 0x0) + { + *x = reinterpret_cast(calloc(cdims[0], sizeof(U))); + new (*x) U[cdims[0]](); + if (helperManager != 0x0) + { + helperManager->addExternAlloc(*x, cdims[0]); + } + } + trick_MM->declare_extern_var(*x, type, TYPE_NAME, n_stars, "", n_cdims, cdims); + } + else + { + *x = (U *) trick_MM->declare_var(type, TYPE_NAME, n_stars, "", n_cdims, cdims); + } + if (helperManager != 0x0) + { + helperManager->addConstructorAlloc(parentPtr, *x, name, funcNameIn); + } + } + } + else + { + if (external) + { + if (*x == 0x0) + { + *x = reinterpret_cast(calloc(cdims[0], sizeof(U))); + new (*x) U[cdims[0]](); + if (helperManager != 0x0) + { + helperManager->addExternAlloc(*x, cdims[0]); + } + } + trick_MM->declare_extern_var(*x, type, TYPE_NAME, n_stars, "", n_cdims, cdims); + } + else + { + *x = (U *) trick_MM->declare_var(type, TYPE_NAME, n_stars, "", n_cdims, cdims); + } + if (helperManager != 0x0) + { + helperManager->addConstructorAlloc(parentPtr, *x, name, funcNameIn); + } + } + } + } + else + { + *x = 0; + } +} + +template +void alloc(void * parentPtr, T ** x, int n, const std::string & TYPE, const std::string & name, bool external, + const std::string & funcNameIn) +{ + int cdims[8] = + { n, 0, 0, 0, 0, 0, 0, 0 }; + std::string treatedTYPE = TYPE; + size_t ret; + while ((ret = treatedTYPE.find(' ')) != std::string::npos) + { + treatedTYPE.erase(ret); + } + while ((ret = treatedTYPE.find('*')) != std::string::npos) + { + treatedTYPE.erase(ret); + } + CheckpointHelper::alloc(parentPtr, x, TRICK_OPAQUE_TYPE, treatedTYPE, 0, name, 1, cdims, external, funcNameIn); +} + +template +void alloc(void * parentPtr, T *** x, int n, const std::string & TYPE, const std::string & name, bool external, + const std::string & funcNameIn) +{ + int cdims[8] = + { n, 0, 0, 0, 0, 0, 0, 0 }; + std::string treatedTYPE = TYPE; + size_t ret; + while ((ret = treatedTYPE.find(' ')) != std::string::npos) + { + treatedTYPE.erase(ret); + } + while ((ret = treatedTYPE.find('*')) != std::string::npos) + { + treatedTYPE.erase(ret); + } + CheckpointHelper::alloc(parentPtr, x, TRICK_OPAQUE_TYPE, treatedTYPE, 1, name, 1, cdims, external, funcNameIn); +} + +template +void alloc(void * parentPtr, T **** x, int n, const std::string & TYPE, const std::string & name, bool external, + const std::string & funcNameIn) +{ + int cdims[8] = + { n, 0, 0, 0, 0, 0, 0, 0 }; + std::string treatedTYPE = TYPE; + size_t ret; + while ((ret = treatedTYPE.find(' ')) != std::string::npos) + { + treatedTYPE.erase(ret); + } + while ((ret = treatedTYPE.find('*')) != std::string::npos) + { + treatedTYPE.erase(ret); + } + CheckpointHelper::alloc(parentPtr, x, TRICK_OPAQUE_TYPE, treatedTYPE, 2, name, 1, cdims, external, funcNameIn); +} + +#define CHECKPOINTHELPER_PRIM_ALLOC_TEMPS( primType, trickType ) \ +template<> \ +inline void alloc(void * parentPtr, primType ** x, int n, const std::string & TYPE, const std::string & name, \ + bool external, const std::string & funcNameIn) \ +{ \ + int cdims[8] = { n, 0, 0, 0, 0, 0, 0, 0 }; \ + CheckpointHelper::alloc(parentPtr, x, trickType, "", 0, name, 1, cdims, external, funcNameIn); \ +} \ +\ +template<> \ +inline void alloc(void * parentPtr, primType *** x, int n, const std::string & TYPE, const std::string & name, \ + bool external, const std::string & funcNameIn) \ +{ \ + int cdims[8] = { n, 0, 0, 0, 0, 0, 0, 0 }; \ + CheckpointHelper::alloc(parentPtr, x, trickType, "", 1, name, 1, cdims, external, funcNameIn); \ +} \ +\ +template<> \ +inline void alloc(void * parentPtr, primType **** x, int n, const std::string & TYPE, const std::string & name, \ + bool external, const std::string & funcNameIn) \ +{ \ + int cdims[8] = { n, 0, 0, 0, 0, 0, 0, 0 }; \ + CheckpointHelper::alloc(parentPtr, x, trickType, "", 2, name, 1, cdims, external, funcNameIn); \ +} + +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(double, TRICK_DOUBLE) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(char, TRICK_CHARACTER) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(unsigned char, TRICK_UNSIGNED_CHARACTER) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(std::string, TRICK_STRING) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(int, TRICK_INTEGER) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(unsigned int, TRICK_UNSIGNED_INTEGER) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(long, TRICK_LONG) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(unsigned long, TRICK_UNSIGNED_LONG) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(float, TRICK_FLOAT) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(long long, TRICK_LONG_LONG) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(unsigned long long, TRICK_UNSIGNED_LONG_LONG) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(bool, TRICK_BOOLEAN) +CHECKPOINTHELPER_PRIM_ALLOC_TEMPS(wchar_t, TRICK_WCHAR) + +#else + +typedef int MM_TYPE; + +template +void alloc( void * parentPtr, T ** x, int n, std::string TYPE, std::string name ) +{ + (void) parentPtr; + (void) x; + (void) n; + (void) TYPE; + (void) name; + + *x = new T[n]; +} + +template +void delete_alloc(T ** x) +{ + if (x != 0x0) + { + if(*x != 0x0) + { + delete[] *x; + } + } +} +#endif + +#ifndef CHECKPOINTHELPER_STRINGIFY +#define CHECKPOINTHELPER_STRINGIFY(x) #x +#endif +#ifndef CHECKPOINTHELPER_TOSTRING +#define CHECKPOINTHELPER_TOSTRING(x) CHECKPOINTHELPER_STRINGIFY(x) +#endif + +#ifndef CHECKPOINTHELPER_FILELINE +#define CHECKPOINTHELPER_FILELINE __FILE__ ":" CHECKPOINTHELPER_TOSTRING(__LINE__) +#endif + +// get number of arguments with __NARG__ +#define __NARG__(...) __NARG_I_(__VA_ARGS__,__RSEQ_N()) +#define __NARG_I_(...) __ARG_N(__VA_ARGS__) +#define __ARG_N( \ + _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \ + _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \ + _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \ + _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \ + _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \ + _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \ + _61,_62,_63,N,...) N +#define __RSEQ_N() \ + 63,62,61,60, \ + 59,58,57,56,55,54,53,52,51,50, \ + 49,48,47,46,45,44,43,42,41,40, \ + 39,38,37,36,35,34,33,32,31,30, \ + 29,28,27,26,25,24,23,22,21,20, \ + 19,18,17,16,15,14,13,12,11,10, \ + 9,8,7,6,5,4,3,2,1,0 + +// general definition for any function name +#define _VFUNC_(name, n) name##n +#define _VFUNC(name, n) _VFUNC_(name, n) +#define VFUNC(func, ...) _VFUNC(func, __NARG__(__VA_ARGS__)) (__VA_ARGS__) + +// definition our overloaded macros +#define CHECKPOINTHELPER_ALLOC_WCSTR6(parent, item, num, type, name, cstr) \ + CheckpointHelper::operatornew_alloc(parent, &item, num, #type, name, CHECKPOINTHELPER_FILELINE); \ + for(int ii = 0; ii < num; ++ii) { \ + new (&item[ii]) type cstr; \ + } + +#define CHECKPOINTHELPER_ALLOC_WCSTR5(item, num, type, name, cstr) \ + CheckpointHelper::operatornew_alloc(this, &item, num, #type, name, CHECKPOINTHELPER_FILELINE); \ + for(int ii = 0; ii < num; ++ii) { \ + new (&item[ii]) type cstr; \ + } + +#define CHECKPOINTHELPER_ALLOC_WCSTR4(item, num, type, cstr) \ + CheckpointHelper::operatornew_alloc(this, &item, num, #type, #item, CHECKPOINTHELPER_FILELINE); \ + for(int ii = 0; ii < num; ++ii) { \ + new (&item[ii]) type cstr; \ + } + +#define CHECKPOINTHELPER_ALLOC_WCSTR3(item, type, cstr) \ + CheckpointHelper::operatornew_alloc(this, &item, 1, #type, #item, CHECKPOINTHELPER_FILELINE); \ + new (item) type cstr; + +#define CHECKPOINTHELPER_ALLOC5(parent, item, num, type, name) CheckpointHelper::alloc(parent, &item, num, #type, name, false, CHECKPOINTHELPER_FILELINE) +#define CHECKPOINTHELPER_ALLOC4(item, num, type, name) CheckpointHelper::alloc(this, &item, num, #type, name, false, CHECKPOINTHELPER_FILELINE) +#define CHECKPOINTHELPER_ALLOC3(item, num, type) CheckpointHelper::alloc(this, &item, num, #type, #item, false, CHECKPOINTHELPER_FILELINE) +#define CHECKPOINTHELPER_ALLOC2(item, type) CheckpointHelper::alloc(this, &item, 1, #type, #item, false, CHECKPOINTHELPER_FILELINE) + +#define CHECKPOINTHELPER_EXTERN_ALLOC_WCSTR6(parent, item, num, type, name, cstr) \ + item = reinterpret_cast(calloc(num, sizeof(type))); \ + for(int ii = 0; ii < num; ++ii) { \ + new (&item[ii]) type cstr; \ + } \ + CheckpointHelper::alloc(parent, &item, num, #type, name, true, CHECKPOINTHELPER_FILELINE) + +#define CHECKPOINTHELPER_EXTERN_ALLOC_WCSTR5(item, num, type, name, cstr) \ + item = reinterpret_cast(calloc(num, sizeof(type))); \ + for(int ii = 0; ii < num; ++ii) { \ + new (&item[ii]) type cstr; \ + } \ + CheckpointHelper::alloc(this, &item, num, #type, name, true, CHECKPOINTHELPER_FILELINE) + +#define CHECKPOINTHELPER_EXTERN_ALLOC_WCSTR4(item, num, type, cstr) \ + item = reinterpret_cast(calloc(num, sizeof(type))); \ + for(int ii = 0; ii < num; ++ii) { \ + new (&item[ii]) type cstr; \ + } \ + CheckpointHelper::alloc(this, &item, num, #type, #item, true, CHECKPOINTHELPER_FILELINE) + +#define CHECKPOINTHELPER_EXTERN_ALLOC_WCSTR3(item, type, cstr) \ + item = reinterpret_cast(calloc(1, sizeof(type))); \ + new (item) type cstr; \ + CheckpointHelper::alloc(this, &item, 1, #type, #item, true, CHECKPOINTHELPER_FILELINE) + +#define CHECKPOINTHELPER_EXTERN_ALLOC5(parent, item, num, type, name) CheckpointHelper::alloc(parent, &item, num, #type, name, true, CHECKPOINTHELPER_FILELINE) +#define CHECKPOINTHELPER_EXTERN_ALLOC4(item, num, type, name) CheckpointHelper::alloc(this, &item, num, #type, name, true, CHECKPOINTHELPER_FILELINE) +#define CHECKPOINTHELPER_EXTERN_ALLOC3(item, num, type) CheckpointHelper::alloc(this, &item, num, #type, #item, true, CHECKPOINTHELPER_FILELINE) +#define CHECKPOINTHELPER_EXTERN_ALLOC2(item, type) CheckpointHelper::alloc(this, &item, 1, #type, #item, true, CHECKPOINTHELPER_FILELINE) + +#define CHECKPOINTHELPER_ALLOC_WCSTR(...) VFUNC(CHECKPOINTHELPER_ALLOC_WCSTR, __VA_ARGS__) +#define CHECKPOINTHELPER_ALLOC(...) VFUNC(CHECKPOINTHELPER_ALLOC, __VA_ARGS__) +#define CHECKPOINTHELPER_EXTERN_ALLOC_WCSTR(...) VFUNC(CHECKPOINTHELPER_EXTERN_ALLOC_WCSTR, __VA_ARGS__) +#define CHECKPOINTHELPER_EXTERN_ALLOC(...) VFUNC(CHECKPOINTHELPER_EXTERN_ALLOC, __VA_ARGS__) + +#define CHECKPOINTHELPER_DELETE(item) CheckpointHelper::delete_alloc(&item, CHECKPOINTHELPER_FILELINE " " #item, false) +#define CHECKPOINTHELPER_EXTERN_DELETE(item) CheckpointHelper::delete_alloc(&item, CHECKPOINTHELPER_FILELINE " " #item, true) + +} + +#endif /* STLHELPER_alloc_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/CheckpointHelper.sm b/trick_source/er7_utils/CheckpointHelper/CheckpointHelper.sm new file mode 100644 index 00000000..eb1c6b3b --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/CheckpointHelper.sm @@ -0,0 +1,24 @@ +##include "er7_utils/CheckpointHelper/Manager.hh" +##include "er7_utils/CheckpointHelper/CheckpointItem.hh" +##include "er7_utils/CheckpointHelper/InputAllocsChkptRestart.hh" + +class CheckpointHelperSimObject : public Trick::SimObject { + public: + CheckpointHelper::Manager manager; + CheckpointHelper::InputAllocsChkptRestart inputAllocs; + + CheckpointHelperSimObject() { + P1 ("initialization") manager.processConstructorAllocs(); + + ("checkpoint") manager.checkpoint(); + ("checkpoint") inputAllocs.writeChkptFile(); + + P59000 ("preload_checkpoint") inputAllocs.loadChkptFile(); + ("preload_checkpoint") manager.processConstructorAllocs(); + ("restart") manager.restart(); + } +}; + +CheckpointHelperSimObject checkpointHelper; + + diff --git a/trick_source/er7_utils/CheckpointHelper/CheckpointItem.cpp b/trick_source/er7_utils/CheckpointHelper/CheckpointItem.cpp new file mode 100644 index 00000000..ffadb9b4 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/CheckpointItem.cpp @@ -0,0 +1,39 @@ +/******************************************************************************* + + PURPOSE: + (CheckpointItem is the abstract class to be used for automatic registration and + checkpointing of items. This package provides STL container equivalents deriving + from this classn.) + + LIBRARY DEPENDENCY: + ((CheckpointItem.cpp) + (Manager.cpp)) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#include "Manager.hh" +#include "CheckpointItem.hh" + +namespace CheckpointHelper +{ + +CheckpointItem::CheckpointItem() +{ + if (helperManager != NULL) + { + helperManager->addItem(*this); + } +} + +CheckpointItem::~CheckpointItem() +{ + if (helperManager != NULL) + { + helperManager->removeItem(*this); + } +} + +} diff --git a/trick_source/er7_utils/CheckpointHelper/CheckpointItem.hh b/trick_source/er7_utils/CheckpointHelper/CheckpointItem.hh new file mode 100644 index 00000000..089b8530 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/CheckpointItem.hh @@ -0,0 +1,287 @@ +/******************************************************************************* + + PURPOSE: + (CheckpointItem is the abstract class to be used for automatic registration and + checkpointing of items. This package provides STL container equivalents deriving + from this classn.) + + LIBRARY DEPENDENCY: + ((CheckpointItem.cpp)) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_CHECKPOINTITEM_HH_ +#define CHECKPOINTHELPER_CHECKPOINTITEM_HH_ + +#include +#include +#include "Alloc.hh" + +namespace CheckpointHelper +{ + +class Manager; + +extern Manager * helperManager; + +class CheckpointItem +{ + friend class InputProcessor; + friend void init_attrCheckpointHelper__CheckpointItem(); +public: + CheckpointItem(); + virtual ~CheckpointItem(); + + virtual void checkpoint() = 0; + virtual void restart() = 0; +}; + +#if (defined TRICK_VER) && (TRICK_VER >= 10) +template +void chkpt_seq(T & obj) +{ + int numObjs = obj.size(); + if (numObjs) + { + CheckpointHelper::alloc(0x0, obj.chkpt, obj.size(), obj.mmstr, "", false, CHECKPOINTHELPER_FILELINE); + int ii = 0; + for (U it = obj.begin(), end = obj.end(); it != end; ++it, ++ii) + { + (*obj.chkpt)[ii] = *it; + } + } +} + +template +void chkpt_unsafevec(T & obj) +{ + int numObjs = obj.size(); + if (numObjs) + { + CheckpointHelper::alloc(0x0, obj.chkpt, obj.size(), obj.mmstr, "", false, CHECKPOINTHELPER_FILELINE); + for (int ii = 0; ii != numObjs; ++ii) + { + (*obj.chkpt)[ii] = obj[ii]; + } + } +} + +template +void restart_seq(T & obj) +{ + obj.clear(); + if ((*obj.chkpt) != NULL) + { + int numObjs = trick_MM->get_size((char *) (*obj.chkpt)); + for (int ii = 0; ii < numObjs; ++ii) + { + U it = obj.end(); + obj.insert(it, (*obj.chkpt)[ii]); + } + } +} + +template +void restart_unsafevec(T & obj) +{ + obj.clear(); + if ((*obj.chkpt) != 0x0) + { + int numObjs = trick_MM->get_size((char *) (*obj.chkpt)); + for (int ii = 0; ii != numObjs; ++ii) + { + obj.addElement((*obj.chkpt)[ii]); + } + } +} + +template +void chkpt_queue(T & obj) +{ + U temp_queue(obj); + int numObjs = temp_queue.size(); + if (numObjs) + { + CheckpointHelper::alloc(0x0, obj.chkpt, temp_queue.size(), obj.mmstr, "", false, CHECKPOINTHELPER_FILELINE); + for (int ii = 0, end = temp_queue.size(); ii != end; ++ii) + { + (*obj.chkpt)[ii] = temp_queue.front(); + temp_queue.pop(); + } + } +} + +template +void restart_queue(T & obj) +{ + while (!obj.empty()) + { + obj.pop(); + } + if ((*obj.chkpt) != NULL) + { + int numObjs = trick_MM->get_size((char *) (*obj.chkpt)); + for (int ii = 0; ii < numObjs; ++ii) + { + obj.push((*obj.chkpt)[ii]); + } + } +} + +template +void chkpt_stack(T & obj) +{ + U temp_stack(obj); + int numObjs = temp_stack.size(); + if (numObjs) + { + CheckpointHelper::alloc(0x0, obj.chkpt, temp_stack.size(), obj.mmstr, "", false, CHECKPOINTHELPER_FILELINE); + for (int ii = 0, end = temp_stack.size(); ii != end; ++ii) + { + (*obj.chkpt)[ii] = temp_stack.top(); + temp_stack.pop(); + } + } +} + +template +void restart_stack(T & obj) +{ + while (!obj.empty()) + { + obj.pop(); + } + if ((*obj.chkpt) != NULL) + { + int numObjs = trick_MM->get_size((char *) (*obj.chkpt)); + for (int ii = numObjs - 1; ii != -1; --ii) + { + obj.push((*obj.chkpt)[ii]); + } + } +} + +template +void chkpt_pair(T & obj) +{ + (*obj.chkptFirst) = obj.first; + (*obj.chkptSecond) = obj.second; +} + +template +void restart_pair(T & obj) +{ + obj.first = (*obj.chkptFirst); + obj.second = (*obj.chkptSecond); +} + +template +void chkpt_map(T &obj) +{ + int numObjs = obj.size(); + if (numObjs) + { + CheckpointHelper::alloc(0x0, obj.chkptKeys, obj.size(), obj.mmstrKey, "", false, CHECKPOINTHELPER_FILELINE); + CheckpointHelper::alloc(0x0, obj.chkptValues, obj.size(), obj.mmstrValue, "", false, + CHECKPOINTHELPER_FILELINE); + int ii = 0; + for (U it = obj.begin(), end = obj.end(); it != end; ++it, ++ii) + { + (*obj.chkptKeys)[ii] = it->first; + (*obj.chkptValues)[ii] = it->second; + } + } +} + +template +void restart_map(T &obj) +{ + obj.clear(); + if ((*obj.chkptKeys) != NULL) + { + int numObjs = trick_MM->get_size((char*) (*obj.chkptKeys)); + for (int ii = 0; ii < numObjs; ++ii) + { + obj.insert(std::make_pair((*obj.chkptKeys)[ii], (*obj.chkptValues)[ii])); + } + } +} +#else +template +void chkpt_seq( T & obj ) +{ + (void) obj; +} + +template +void chkpt_unsafevec( T & obj ) +{ + (void) obj; +} + +template +void restart_seq( T & obj ) +{ + (void) obj; +} + +template +void restart_unsafevec( T & obj ) +{ + (void) obj; +} + +template +void chkpt_queue( T & obj ) +{ + (void) obj; +} + +template +void restart_queue( T & obj ) +{ + (void) obj; +} + +template +void chkpt_stack( T & obj ) +{ + (void) obj; +} + +template +void restart_stack( T & obj ) +{ + (void) obj; +} + +template +void chkpt_pair( T & obj ) +{ + (void) obj; +} + +template +void restart_pair( T & obj ) +{ + (void) obj; +} + +template +void chkpt_map( T & obj ) +{ + (void) obj; +} + +template +void restart_map( T &obj ) +{ + (void) obj; +} +#endif +} + +#endif /* STLHELPER_STL_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Deque.hh b/trick_source/er7_utils/CheckpointHelper/Deque.hh new file mode 100644 index 00000000..25e3ed6f --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Deque.hh @@ -0,0 +1,78 @@ +/******************************************************************************* + + PURPOSE: + (List for checkpointable deque container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_DEQUE_HH_ +#define CHECKPOINTHELPER_DEQUE_HH_ + +#include "CheckpointItem.hh" +#include + +namespace CheckpointHelper +{ + +template +class deque: public CheckpointItem, public std::deque +{ +public: + T ** chkpt; + std::string mmstr; + + deque(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + deque& operator=(const std::deque& pr) + { + std::deque::operator=(pr); + return *this; + } + + virtual ~deque() + { + } + + virtual void checkpoint() + { + chkpt_seq::iterator, T>(*this); + } + virtual void restart() + { + restart_seq::iterator>(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLDEQUE( type, varName ) \ + type* _##varName; \ + CheckpointHelper::deque varName +#else +#define STLDEQUE( type, varName ) \ + type* _##varName +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + varName( &_##varName, #type ) +#endif +#else +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + _##varName() +#endif +#endif + +#define STLDEQUECSTR STL_CSTR1 + +#endif /* STLHELPER_DEQUE_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/DoublePtrCollect.hh b/trick_source/er7_utils/CheckpointHelper/DoublePtrCollect.hh new file mode 100644 index 00000000..357b3f9b --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/DoublePtrCollect.hh @@ -0,0 +1,54 @@ +/******************************************************************************* + + PURPOSE: + (DoublePtrCollect is a checkpointable dynamic collect to replace Trick's + collect mechanism for collected "double *"'s.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (Aug 2012) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_CHECKPOINTABLECOLLECT_HH_ +#define CHECKPOINTHELPER_CHECKPOINTABLECOLLECT_HH_ +#include "Vector.hh" +#include + +namespace CheckpointHelper +{ + +class DoublePtrCollect +{ +public: + DoublePtrCollect() : STLVECTORCSTR( collect, double *) + { + } + + virtual ~DoublePtrCollect() + { + } + + void add_collect(double * vIn) + { +#if (!defined(SWIG) && !defined(TRICK_ICG)) + collect.push_back(vIn); +#endif + } + + void remove_collect(double * vIn) + { +#if (!defined(SWIG) && !defined(TRICK_ICG)) + std::vector::iterator it = std::find(collect.begin(), collect.end(), vIn); + if (it != collect.end()) + { + collect.erase(it); + } +#endif + } + + STLVECTOR( double *, collect); +}; + +} + +#endif /* STLHELPER_CHECKPOINTABLECOLLECT_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/InputAllocsChkptRestart.hh b/trick_source/er7_utils/CheckpointHelper/InputAllocsChkptRestart.hh new file mode 100644 index 00000000..5313431b --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/InputAllocsChkptRestart.hh @@ -0,0 +1,65 @@ +/******************************************************************************* + + PURPOSE: + (Jobs to call python routine to checkpoint/restart input file allocations.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (March 2014) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_INPUTALLOCSCHKPTRESTART_HH_ +#define CHECKPOINTHELPER_INPUTALLOCSCHKPTRESTART_HH_ + +#include + +#include "sim_services/InputProcessor/include/InputProcessor.hh" +#include "sim_services/CheckPointRestart/include/CheckPointRestart.hh" + +extern Trick::InputProcessor * the_ip; +extern Trick::CheckPointRestart * the_cpr; + +namespace CheckpointHelper +{ + +class InputAllocsChkptRestart +{ +public: + InputAllocsChkptRestart() + { + } + virtual ~InputAllocsChkptRestart() + { + } + + void writeChkptFile() + { + std::string cFile = the_cpr->get_output_file(); + cFile += "_inputAllocs.py"; + std::stringstream ss; + ss << "if \"externAllocs\" in globals():" << std::endl; + ss << " externAllocs.writeChkptFile(\"" << cFile << "\")" << std::endl; + ss << " trick.message_publish(1, \"Dumped input allocations checkpoint " << cFile << ".\\n\")" << std::endl; + ss << "else:" << std::endl; + ss << " trick.message_publish(1, \"externAllocs not defined: skipping input allocations checkpoint\\n\")" + << std::endl; + the_ip->parse(ss.str().c_str()); + } + + void loadChkptFile() + { + std::string cFile = the_cpr->get_load_file(); + cFile += "_inputAllocs.py"; + std::stringstream ss; + ss << "try:" << std::endl; + ss << " execfile(\"" << cFile << "\")" << std::endl; + ss << " trick.message_publish(1, \"Loaded " << cFile << " input allocations checkpoint.\\n\")" << std::endl; + ss << "except IOError:" << std::endl; + ss << " trick.message_publish(1, \"" << cFile << " was not found. Skipping input allocations restoration.\\n\")" + << std::endl; + the_ip->parse(ss.str().c_str()); + } +}; + +} /* namespace STLHelper */ +#endif /* STLHELPER_INPUTALLOCSCHKPTRESTART_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/List.hh b/trick_source/er7_utils/CheckpointHelper/List.hh new file mode 100644 index 00000000..89bf9bd7 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/List.hh @@ -0,0 +1,78 @@ +/******************************************************************************* + + PURPOSE: + (List for checkpointable list container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_LIST_HH_ +#define CHECKPOINTHELPER_LIST_HH_ + +#include "CheckpointItem.hh" +#include + +namespace CheckpointHelper +{ + +template +class list: public CheckpointItem, public std::list +{ +public: + T ** chkpt; + std::string mmstr; + + list(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + list& operator=(const std::list& pr) + { + std::list::operator=(pr); + return *this; + } + + virtual ~list() + { + } + + virtual void checkpoint() + { + chkpt_seq::iterator, T>(*this); + } + virtual void restart() + { + restart_seq::iterator>(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLLIST( type, varName ) \ + type* _##varName; \ + CheckpointHelper::list varName +#else +#define STLLIST( type, varName ) \ + type* _##varName +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + varName( &_##varName, #type ) +#endif +#else +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + _##varName() +#endif +#endif + +#define STLLISTCSTR STL_CSTR1 + +#endif /* STLHELPER_LIST_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Manager.cpp b/trick_source/er7_utils/CheckpointHelper/Manager.cpp new file mode 100644 index 00000000..8cbb35a1 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Manager.cpp @@ -0,0 +1,236 @@ +/******************************************************************************* + + PURPOSE: + (Manager for globally calling checkpoint and restart methods of STLs) + + LIBRARY DEPENDENCY: + ((Manager.cpp) + (CheckpointItem.cpp)) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#include "Alloc.hh" +#include "Manager.hh" +#if (defined TRICK_VER) && (TRICK_VER >= 10) +#include "sim_services/Message/include/message_proto.h" +#endif +#include "CheckpointItem.hh" +#include +#include + +namespace CheckpointHelper +{ + +Manager * helperManager = 0x0; + +Manager::Manager() +{ + _checkpointObjects = NULL; + if (helperManager == 0x0) + { + helperManager = this; + } + else + { + std::cerr << "WARNING: Only one instance of CheckpointHelper::Manager is allowed. Invalid Manager instance at " + << this << std::endl; + } + pthread_mutex_init(&allocQueueMutex, 0x0); + pthread_mutex_init(&objListMutex, 0x0); + pthread_mutex_init(&externMapMutex, 0x0); +} + +Manager::~Manager() +{ + if (helperManager != 0x0) + { + helperManager = 0x0; + } +} +#if (defined TRICK_VER) && (TRICK_VER >= 10) + +void Manager::checkpoint() +{ + processConstructorAllocs(); + pthread_mutex_lock(&objListMutex); + int numObjs = checkpointObjects.size(); + if (numObjs) + { + alloc(this, &_checkpointObjects, numObjs, "CheckpointHelper::CheckpointItem", "", false, + CHECKPOINTHELPER_FILELINE); + int ii = 0; + for (std::list::iterator it = checkpointObjects.begin(), end = checkpointObjects.end(); + it != end; ++it, ++ii) + { + CheckpointItem * item = *it; + item->checkpoint(); + _checkpointObjects[ii] = item; + } + } + pthread_mutex_unlock(&objListMutex); +} +void Manager::restart() +{ + pthread_mutex_lock(&allocQueueMutex); + constructorAllocs.clear(); + pthread_mutex_unlock(&allocQueueMutex); + pthread_mutex_lock(&objListMutex); + checkpointObjects.clear(); + if (_checkpointObjects != NULL) + { + int numObjs = trick_MM->get_size((char *) _checkpointObjects); + for (int ii = 0; ii < numObjs; ++ii) + { + CheckpointItem * item = _checkpointObjects[ii]; + checkpointObjects.push_back(_checkpointObjects[ii]); + item->restart(); + } + } + pthread_mutex_unlock(&objListMutex); +} + +#else +void Manager::checkpoint() +{ +} +void Manager::restart() +{ +} + +#endif + +void Manager::addItem(CheckpointItem & stlIn) +{ + pthread_mutex_lock(&objListMutex); + std::list::iterator it = find(checkpointObjects.begin(), checkpointObjects.end(), &stlIn); + if (it == checkpointObjects.end()) + { + checkpointObjects.push_back(&stlIn); + } + pthread_mutex_unlock(&objListMutex); +} + +void Manager::removeItem(CheckpointItem & stlIn) +{ + pthread_mutex_lock(&objListMutex); + std::list::iterator it = find(checkpointObjects.begin(), checkpointObjects.end(), &stlIn); + if (it != checkpointObjects.end()) + { + checkpointObjects.erase(it); + } + pthread_mutex_unlock(&objListMutex); +} + +Manager::AllocEntry::AllocEntry(void * parentPtrIn, void * ptrIn, const std::string nameIn, + const std::string funcNameIn) : + parentPtr(parentPtrIn), ptr(ptrIn), name(nameIn), funcName(funcNameIn) +{ +} + +void Manager::addConstructorAlloc(void* parentPtr, void* ptr, const std::string name, const std::string funcNameIn) +{ + pthread_mutex_lock(&allocQueueMutex); + constructorAllocs.push_back(AllocEntry(parentPtr, ptr, name, funcNameIn)); + pthread_mutex_unlock(&allocQueueMutex); +} + +void Manager::removeConstructorAlloc(void * ptrIn) +{ + pthread_mutex_lock(&allocQueueMutex); + std::deque::iterator it = std::find(constructorAllocs.begin(), constructorAllocs.end(), ptrIn); + if (it != constructorAllocs.end()) + { + constructorAllocs.erase(it); + } + pthread_mutex_unlock(&allocQueueMutex); +} + +void Manager::processConstructorAllocs() +{ + pthread_mutex_lock(&allocQueueMutex); + std::deque preQueue; + std::deque postQueue; + while (!constructorAllocs.empty()) + { +#if (defined TRICK_VER) && (TRICK_VER >= 10) + AllocEntry & entry = constructorAllocs.front(); + + if (!updateAllocName(entry.parentPtr, entry.ptr, entry.name, entry.funcName, false)) + { + postQueue.push_back(AllocEntry(entry.parentPtr, entry.ptr, entry.name, entry.funcName)); + } +#endif + constructorAllocs.pop_front(); + } + pthread_mutex_unlock(&allocQueueMutex); + + size_t preSize = preQueue.size(); + size_t postSize = postQueue.size(); + + while (preSize != postSize) + { + preQueue = postQueue; + preSize = preQueue.size(); + postQueue.clear(); + while (!preQueue.empty()) + { +#if (defined TRICK_VER) && (TRICK_VER >= 10) + AllocEntry & entry = preQueue.front(); + + if (!updateAllocName(entry.parentPtr, entry.ptr, entry.name, entry.funcName, false)) + { + postQueue.push_back(AllocEntry(entry.parentPtr, entry.ptr, entry.name, entry.funcName)); + } +#endif + preQueue.pop_front(); + } + postSize = postQueue.size(); + } + + while (!postQueue.empty()) + { +#if (defined TRICK_VER) && (TRICK_VER >= 10) + AllocEntry & entry = postQueue.front(); + + updateAllocName(entry.parentPtr, entry.ptr, entry.name, entry.funcName, true); +#endif + postQueue.pop_front(); + } +} + +void Manager::addExternAlloc(void* ptr, size_t numElems) +{ + pthread_mutex_lock(&externMapMutex); + externMemAllocs[ptr] = numElems; + pthread_mutex_unlock(&externMapMutex); +} + +void Manager::removeExternAlloc(void* ptr) +{ + pthread_mutex_lock(&externMapMutex); + externMemAllocs.erase(ptr); + pthread_mutex_unlock(&externMapMutex); +} + +size_t Manager::getExternNum(void* ptr) +{ + pthread_mutex_lock(&externMapMutex); + size_t num; + std::map::iterator it = externMemAllocs.find(ptr); + if (it != externMemAllocs.end()) + { + num = it->second; + } + else + { + num = 0; + } + pthread_mutex_unlock(&externMapMutex); + return num; +} + +} + diff --git a/trick_source/er7_utils/CheckpointHelper/Manager.hh b/trick_source/er7_utils/CheckpointHelper/Manager.hh new file mode 100644 index 00000000..c6f92933 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Manager.hh @@ -0,0 +1,78 @@ +/******************************************************************************* + + PURPOSE: + (Manager for globally calling checkpoint and restart methods of STLs) + + LIBRARY DEPENDENCY: + ((Manager.cpp)) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_MANAGER_HH_ +#define CHECKPOINTHELPER_MANAGER_HH_ + +#include +#include +#include +#include +#include + +namespace CheckpointHelper +{ + +class CheckpointItem; + +class Manager +{ + friend class InputProcessor; + friend void init_attrCheckpointHelper__Manager(); +public: + Manager(); + virtual ~Manager(); + + class AllocEntry + { + public: + AllocEntry(void * parentPtrIn, void * ptrIn, const std::string nameIn, const std::string funcNameIn); + void * parentPtr; + void * ptr; + std::string name; + std::string funcName; + + bool operator==(void * ptrComp) + { + return this->ptr == ptrComp; + } + }; + + void addConstructorAlloc(void * parentPtr, void * ptr, const std::string name, const std::string funcNameIn); + void removeConstructorAlloc(void * ptr); + void processConstructorAllocs(); + + void checkpoint(); + void restart(); + + void addItem(CheckpointItem & stlIn); + void removeItem(CheckpointItem & stlIn); + + void addExternAlloc(void * ptr, size_t numElems); + void removeExternAlloc(void * ptr); + size_t getExternNum(void * ptr); + +protected: + std::list checkpointObjects; + CheckpointItem ** _checkpointObjects; + std::deque constructorAllocs; + pthread_mutex_t allocQueueMutex; /* ** Do not checkpoint */ + pthread_mutex_t objListMutex; /* ** Do not checkpoint */ + pthread_mutex_t externMapMutex; /* ** Do not checkpoint */ + std::map externMemAllocs; + +}; + +} + +#endif /* STLHELPER_MANAGER_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Map.hh b/trick_source/er7_utils/CheckpointHelper/Map.hh new file mode 100644 index 00000000..1fad84e4 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Map.hh @@ -0,0 +1,121 @@ +/******************************************************************************* + + PURPOSE: + (Map for checkpointable map container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_MAP_HH_ +#define CHECKPOINTHELPER_MAP_HH_ + +#include "CheckpointItem.hh" +#include + +namespace CheckpointHelper +{ + +template +class map: public CheckpointItem, public std::map +{ +public: + T ** chkptKeys; + U ** chkptValues; + std::string mmstrKey; + std::string mmstrValue; + + map(T ** chkptKeysIn, U **chkptValuesIn, std::string mmstrKeyIn, std::string mmstrValueIn) : + chkptKeys(chkptKeysIn), chkptValues(chkptValuesIn), mmstrKey(mmstrKeyIn), mmstrValue(mmstrValueIn) + { + *chkptKeys = 0x0; + *chkptValues = 0x0; + } + + map& operator=(const std::map& pr) + { + std::map::operator=(pr); + return *this; + } + + virtual ~map() + { + } + + virtual void checkpoint() + { + chkpt_map::iterator, T, U>(*this); + } + virtual void restart() + { + restart_map::iterator>(*this); + } +}; + +template +class multimap: public CheckpointHelper::CheckpointItem, public std::multimap +{ +public: + T ** chkptKeys; + U ** chkptValues; + std::string mmstrKey; + std::string mmstrValue; + + multimap(T ** chkptKeysIn, U **chkptValuesIn, std::string mmstrKeyIn, std::string mmstrValueIn) : + chkptKeys(chkptKeysIn), chkptValues(chkptValuesIn), mmstrKey(mmstrKeyIn), mmstrValue(mmstrValueIn) + { + *chkptKeys = 0x0; + *chkptValues = 0x0; + } + + virtual ~multimap() + { + } + + virtual void checkpoint() + { + chkpt_map::iterator, T, U>(*this); + } + virtual void restart() + { + restart_map::iterator>(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLMAP( type1, type2, varName ) \ + type1* _##varName##T1; \ + type2* _##varName##T2; \ + CheckpointHelper::map varName +#define STLMULTIMAP( type1, type2, varName ) \ + type1* _##varName##T1; \ + type2* _##varName##T2; \ + CheckpointHelper::multimap varName +#else +#define STLMAP( type1, type2, varName ) \ + type1* _##varName##T1; \ + type2* _##varName##T2; +#define STLMULTIMAP( type1, type2, varName ) \ + type1* _##varName##T1; \ + type2* _##varName##T2; +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR2 +#define STL_CSTR2( varName, type1, type2 ) \ + varName( &_##varName##T1, &_##varName##T2, #type1, #type2 ) +#endif +#else +#ifndef STL_CSTR2 +#define STL_CSTR2( varName, type1, type2 ) \ + _##varName##T1(), _##varName##T2() +#endif +#endif + +#define STLMAPCSTR STL_CSTR2 +#define STLMULTIMAPCSTR STL_CSTR2 + +#endif /* STLHELPER_MAP_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Pair.hh b/trick_source/er7_utils/CheckpointHelper/Pair.hh new file mode 100644 index 00000000..9d26092b --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Pair.hh @@ -0,0 +1,83 @@ +/******************************************************************************* + + PURPOSE: + (Pair for checkpointable pair container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_PAIR_HH_ +#define CHECKPOINTHELPER_PAIR_HH_ + +#include "CheckpointItem.hh" +#include + +namespace CheckpointHelper +{ + +template +class pair: public CheckpointItem, public std::pair +{ +public: + T * chkptFirst; + U * chkptSecond; + std::string mmstrKey; + std::string mmstrValue; + + pair(T * chkptKeysIn, U * chkptValuesIn, std::string mmstrKeyIn, std::string mmstrValueIn) : + chkptFirst(chkptKeysIn), chkptSecond(chkptValuesIn), mmstrKey(mmstrKeyIn), mmstrValue(mmstrValueIn) + { + *chkptFirst = 0x0; + *chkptSecond = 0x0; + } + + pair& operator=(const std::pair& pr) + { + std::pair::operator=(pr); + return *this; + } + + virtual ~pair() + { + } + + virtual void checkpoint() + { + chkpt_pair(*this); + } + virtual void restart() + { + restart_pair(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLPAIR( type1, type2, varName ) \ + type1 _##varName##T1; \ + type2 _##varName##T2; \ + CheckpointHelper::pair varName +#else +#define STLPAIR( type1, type2, varName ) \ + type1 _##varName##T1; \ + type2 _##varName##T2; +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR2 +#define STL_CSTR2( varName, type1, type2 ) \ + varName( &_##varName##T1, &_##varName##T2, #type1, #type2 ) +#endif +#else +#ifndef STL_CSTR2 +#define STL_CSTR2( varName, type1, type2 ) \ + _##varName##T1(), _##varName##T2() +#endif +#endif + +#define STLPAIRCSTR STL_CSTR2 + +#endif /* STLHELPER_PAIR_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Queue.hh b/trick_source/er7_utils/CheckpointHelper/Queue.hh new file mode 100644 index 00000000..86dc985a --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Queue.hh @@ -0,0 +1,78 @@ +/******************************************************************************* + + PURPOSE: + (Queue for checkpointable queue container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_QUEUE_HH_ +#define CHECKPOINTHELPER_QUEUE_HH_ + +#include "CheckpointItem.hh" +#include + +namespace CheckpointHelper +{ + +template +class queue: public CheckpointItem, public std::queue +{ +public: + T ** chkpt; + std::string mmstr; + + queue(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + queue& operator=(const std::queue& pr) + { + std::queue::operator=(pr); + return *this; + } + + virtual ~queue() + { + } + + virtual void checkpoint() + { + chkpt_queue, T>(*this); + } + virtual void restart() + { + restart_queue(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLQUEUE( type, varName ) \ + type* _##varName; \ + CheckpointHelper::queue varName +#else +#define STLQUEUE( type, varName ) \ + type* _##varName +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + varName( &_##varName, #type ) +#endif +#else +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + _##varName() +#endif +#endif + +#define STLQUEUECSTR STL_CSTR1 + +#endif /* STLHELPER_QUEUE_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Set.hh b/trick_source/er7_utils/CheckpointHelper/Set.hh new file mode 100644 index 00000000..634c0d6e --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Set.hh @@ -0,0 +1,117 @@ +/******************************************************************************* + + PURPOSE: + (Set for checkpointable set container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_SET_HH_ +#define CHECKPOINTHELPER_SET_HH_ + +#include "CheckpointItem.hh" +#include + +namespace CheckpointHelper +{ + +template +class set: public CheckpointItem, public std::set +{ +public: + T ** chkpt; + std::string mmstr; + + set(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + set& operator=(const std::set& pr) + { + std::set::operator=(pr); + return *this; + } + + virtual ~set() + { + } + + virtual void checkpoint() + { + chkpt_seq::iterator, T>(*this); + } + virtual void restart() + { + restart_seq::iterator>(*this); + } +}; + +template +class multiset: public CheckpointHelper::CheckpointItem, public std::multiset +{ +public: + T ** chkpt; + std::string mmstr; + + multiset(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + multiset& operator=(const std::multiset& pr) + { + std::multiset::operator=(pr); + return *this; + } + + virtual ~multiset() + { + } + + virtual void checkpoint() + { + chkpt_seq::iterator, T>(*this); + } + virtual void restart() + { + restart_seq::iterator>(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLSET( type, varName ) \ + type* _##varName; \ + CheckpointHelper::set varName +#define STLMULTISET( type, varName ) \ + type* _##varName; \ + CheckpointHelper::multiset varName +#else +#define STLSET( type, varName ) \ + type* _##varName +#define STLMULTISET( type, varName ) \ + type* _##varName; +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + varName( &_##varName, #type ) +#endif +#else +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + _##varName() +#endif +#endif + +#define STLSETCSTR STL_CSTR1 +#define STLMULTISETCSTR STL_CSTR1 + +#endif /* STLHELPER_SET_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Stack.hh b/trick_source/er7_utils/CheckpointHelper/Stack.hh new file mode 100644 index 00000000..37491f60 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Stack.hh @@ -0,0 +1,78 @@ +/******************************************************************************* + + PURPOSE: + (Stack for checkpointable stack container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_STACK_HH_ +#define CHECKPOINTHELPER_STACK_HH_ + +#include "CheckpointItem.hh" +#include + +namespace CheckpointHelper +{ + +template +class stack: public CheckpointItem, public std::stack +{ +public: + T ** chkpt; + std::string mmstr; + + stack(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + stack& operator=(const std::stack& pr) + { + std::stack::operator=(pr); + return *this; + } + + virtual ~stack() + { + } + + virtual void checkpoint() + { + chkpt_stack, T>(*this); + } + virtual void restart() + { + restart_stack(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLSTACK( type, varName ) \ + type* _##varName; \ + CheckpointHelper::stack varName +#else +#define STLSTACK( type, varName ) \ + type* _##varName +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + varName( &_##varName, #type ) +#endif +#else +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + _##varName() +#endif +#endif + +#define STLSTACKCSTR STL_CSTR1 + +#endif /* STLHELPER_STACK_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/UnsafeChkptVector.hh b/trick_source/er7_utils/CheckpointHelper/UnsafeChkptVector.hh new file mode 100644 index 00000000..91dfdde2 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/UnsafeChkptVector.hh @@ -0,0 +1,83 @@ +/******************************************************************************* + + PURPOSE: + (Definition of Unsafevector container class. Minimal protections and + forced-inlining for this container to acheive maximum performance..) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (Apr 2014) (--))) + + ICG:(No.) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_UNSAFECHKPTVECTOR_HH_ +#define CHECKPOINTHELPER_UNSAFECHKPTVECTOR_HH_ +#include "Unsafevector.hh" +#include "CheckpointItem.hh" + +#define stlhelper_inline inline __attribute__((always_inline)) +#define stlhelper_force_optimize __attribute__((optimize("-O3"))) + +//#define stlhelper_inline inline +//#define stlhelper_force_optimize + +namespace CheckpointHelper +{ + +template +class UnsafeChkptVector: public Unsafevector, public CheckpointItem +{ +public: + T ** chkpt; + std::string mmstr; + + stlhelper_inline UnsafeChkptVector(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + stlhelper_inline UnsafeChkptVector(const UnsafeChkptVector & other) : + Unsafevector(other), chkpt(other.chkpt), mmstr(other.mmstrIn) + { + *chkpt = 0x0; + } + + virtual void checkpoint() + { + chkpt_unsafevec(*this); + } + + virtual void restart() + { + restart_unsafevec(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLUNSAFECHKPTVECTOR( type, varName ) \ + type* _##varName; \ + CheckpointHelper::UnsafeChkptVector varName +#else +#define STLUNSAFECHKPTVECTOR( type, varName ) \ + type* _##varName +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + varName( &_##varName, #type ) +#endif +#else +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + _##varName() +#endif +#endif + +#define STLUNSAFECHKPTVECTORCSTR STL_CSTR1 + +#endif /* UNSAFEVECTOR_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Unsafemap.hh b/trick_source/er7_utils/CheckpointHelper/Unsafemap.hh new file mode 100644 index 00000000..f924a886 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Unsafemap.hh @@ -0,0 +1,173 @@ +/******************************************************************************* + + PURPOSE: + (Definition of Unsafemap container class. Minimal protections and + forced-inlining for this container to acheive maximum performance..) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (Apr 2014) (--))) + + ICG:(No.) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_UNSAFEMAP_HH_ +#define CHECKPOINTHELPER_UNSAFEMAP_HH_ +#include +#include "Unsafevector.hh" + +namespace CheckpointHelper +{ + +template +class Unsafemap +{ +public: + stlhelper_inline Unsafemap() + { + } + + stlhelper_inline ~Unsafemap() + { + int vsize = m.size(); + for (int ii = 0; ii < vsize; ++ii) + { + internal * it = m[ii]; + delete it; + } + } + + class internal + { + public: + stlhelper_inline internal() : + first(), second() + { + } + stlhelper_inline internal(const U & firstIn) : + first(firstIn), second() + { + } + + U first; + T second; + }; + + Unsafevector m; + + stlhelper_inline static int comparekeys(const void * a, const void * b) + { + U & key = *((U*) a); + internal * bPtr = *((internal **) b); + if (key < bPtr->first) + return -1; + if (key == bPtr->first) + return 0; + return 1; + } + + stlhelper_inline static int compareelems(const void * a, const void * b) + { + internal * aPtr = *((internal **) a); + internal * bPtr = *((internal **) b); + if (aPtr->first < bPtr->first) + return -1; + if (aPtr->first == bPtr->first) + return 0; + return 1; + } + + stlhelper_inline int size() + { + return m.size(); + } + + stlhelper_inline void clear() + { + for (int ii = 0, end = m.size(); ii != end; ++ii) + { + internal * Elem = m[ii]; + delete Elem; + } + m.clear(); + } + + stlhelper_inline T & getElement(int idx) + { + return m.v[idx]->second; + } + +#define compareKeys (int (*)( const void *, const void * )) Unsafemap::comparekeys +#define compareElems (int (*)( const void *, const void * )) Unsafemap::compareelems + + stlhelper_inline internal * find(const U & keyIn) + { + int res = searchForIndex(&keyIn); + if (res == -1) + { + return 0x0; + } + else + { + return m[res]; + } + } + + stlhelper_inline T & operator[](const U & keyIn) + { + int res = searchForIndex(&keyIn); + if (res == -1) + { + internal * Elem = new internal(keyIn); + m.addElement(Elem); + qsort(m.v, m.size(), sizeof(internal *), compareElems); + return Elem->second; + } + else + { + return m[res]->second; + } + } + + stlhelper_inline void remove(const U & keyIn) + { + int res = searchForIndex(&keyIn); + if (res != -1) + { + m.removeElement(res); + } + } + +protected: + stlhelper_inline int searchForIndex(const U * keyIn) + { + size_t lowerIdx, upperIdx, currIdx; + const void *currAddr; + int comparResult; + + lowerIdx = 0; + upperIdx = m.size(); + while (lowerIdx < upperIdx) + { + currIdx = (lowerIdx + upperIdx) / 2; + currAddr = (void *) (((const char *) m.v) + (currIdx * sizeof(internal *))); + comparResult = (*compareKeys )(keyIn, currAddr); + if (comparResult < 0) + upperIdx = currIdx; + else if (comparResult > 0) + lowerIdx = currIdx + 1; + else + { + return currIdx; + } + } + return -1; + } + +#undef compareKeys +#undef compareElems +}; + +} + +#endif /* UNSAFEMAP_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Unsafevector.hh b/trick_source/er7_utils/CheckpointHelper/Unsafevector.hh new file mode 100644 index 00000000..bd66263b --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Unsafevector.hh @@ -0,0 +1,516 @@ +/******************************************************************************* + + PURPOSE: + (Definition of Unsafevector container class. Minimal protections and + forced-inlining for this container to acheive maximum performance..) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (Apr 2014) (--))) + + ICG:(No.) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_UNSAFEVECTOR_HH_ +#define CHECKPOINTHELPER_UNSAFEVECTOR_HH_ + +#include + +#ifndef DEBUG +#define stlhelper_inline inline __attribute__((always_inline)) +#define stlhelper_force_optimize __attribute__((optimize("-O3"))) +#else +#define stlhelper_inline +#define stlhelper_force_optimize +#endif + +//#define stlhelper_inline inline +//#define stlhelper_force_optimize + +#include +#include + +namespace CheckpointHelper +{ + +static const int minSize = 16; + +template +class Unsafevector +{ + +public: + + stlhelper_inline Unsafevector() : + v(new T[minSize]), numElems(0), capacity(minSize) + { + } + + stlhelper_inline Unsafevector(int newNumElems) : + numElems(0), capacity(minSize) + { + while (capacity <= newNumElems) + { + capacity *= 2; + } + v = new T[capacity]; + } + + stlhelper_inline Unsafevector(const Unsafevector & other) : + numElems(other.numElems), capacity(other.numElems) + { + v = new T[other.numElems]; + for (int ii = 0; ii < other.numElems; ++ii) + { + v[ii] = other.v[ii]; + } + } + + stlhelper_inline Unsafevector & operator=(const Unsafevector & other) + { + reserve_nocopy(other.numElems); + for (int ii = 0; ii < other.numElems; ++ii) + { + v[ii] = other.v[ii]; + } + capacity = other.numElems; + numElems = other.numElems; + return *this; + } + + stlhelper_inline Unsafevector & operator=(const std::vector & other) + { + int vSize = other.size(); + reserve_nocopy(vSize); + for (int ii = 0; ii < vSize; ++ii) + { + v[ii] = other[ii]; + } + numElems = vSize; + return *this; + } + + stlhelper_inline ~Unsafevector() + { + delete[] v; + } + + stlhelper_inline void reserve(int newSize) + { + if (newSize > capacity) + { + while (capacity <= newSize) + { + capacity *= 2; + } + T * newPtr = new T[capacity]; + for (int ii = 0; ii < numElems; ++ii) + { + newPtr[ii] = v[ii]; + } + delete[] v; + v = newPtr; + } + } + + stlhelper_inline void addVectorNoCheck(std::vector & vecIn) + { + int vecInSize = vecIn.size(); + for (int ii = numElems, jj = 0; jj < vecInSize; ++ii, ++jj) + { + v[ii] = vecIn[jj]; + } + numElems += vecInSize; + } + + stlhelper_inline void addVector(std::vector & vecIn) + { + int vecInSize = vecIn.size(); + reserve(numElems + vecInSize); + for (int ii = numElems, jj = 0; jj < vecInSize; ++ii, ++jj) + { + v[ii] = vecIn[jj]; + } + numElems += vecInSize; + } + + stlhelper_inline void addVectorNoCheck(Unsafevector & vecIn) + { + int vecInSize = vecIn.size(); + for (int ii = numElems, jj = 0; jj < vecInSize; ++ii, ++jj) + { + v[ii] = vecIn[jj]; + } + numElems += vecInSize; + } + + stlhelper_inline void addVector(Unsafevector & vecIn) + { + int vecInSize = vecIn.size(); + reserve(numElems + vecInSize); + for (int ii = numElems, jj = 0; jj < vecInSize; ++ii, ++jj) + { + v[ii] = vecIn[jj]; + } + numElems += vecInSize; + } + + stlhelper_inline void addElementNoCheck(const T & elemIn) + { + v[numElems++] = elemIn; + } + + stlhelper_inline void addElement(const T & elemIn) + { + if (numElems >= capacity) + { + reserve(capacity * 2); + } + v[numElems++] = elemIn; + } + + stlhelper_inline void removeElement(int idx) + { + if ((numElems - 1) != idx) + { + for (int ii = idx, end = numElems; ii != end; ++ii) + { + v[ii] = v[ii + 1]; + } + --numElems; + } + else + { + --numElems; + } + } + + stlhelper_inline int find(const T & testElem) + { + for (int ii = 0, end = numElems; ii != end; ++ii) + { + if (v[ii] == testElem) + { + return ii; + } + } + return -1; + } + + stlhelper_inline void clear() + { + numElems = 0; + } + + stlhelper_inline int size() + { + return numElems; + } + + stlhelper_inline bool isEmpty() + { + return (numElems == 0); + } + + stlhelper_inline T & operator[](int idx) + { + return v[idx]; + } + stlhelper_inline T operator[](int idx) const + { + return v[idx]; + } + + stlhelper_inline void swap(Unsafevector & other) + { + std::swap(v, other.v); + std::swap(numElems, other.numElems); + std::swap(capacity, other.capacity); + } + + T * v; + int numElems; + int capacity; + +protected: + + stlhelper_inline void reserve_nocopy(int newSize) + { + if (newSize > capacity) + { + delete[] v; + v = new T[newSize]; + capacity = newSize; + } + } +}; + +template +class Unsafevector +{ +public: + + stlhelper_inline Unsafevector() : + v(new T *[minSize]), numElems(0), capacity(minSize) + { + } + + stlhelper_inline Unsafevector(int newNumElems) : + numElems(0), capacity(minSize) + { + while (capacity <= newNumElems) + { + capacity *= 2; + } + v = new T *[capacity]; + } + + stlhelper_inline Unsafevector(const Unsafevector & other) + { + v = new T *[other.numElems]; + memcpy(v, other.v, sizeof(T *) * other.numElems); + capacity = other.numElems; + numElems = other.numElems; + } + + stlhelper_inline Unsafevector & operator=(const Unsafevector & other) + { + reserve_nocopy(other.numElems); + memcpy(v, other.v, sizeof(T *) * other.numElems); + capacity = other.numElems; + numElems = other.numElems; + return *this; + } + + stlhelper_inline Unsafevector & operator=(const std::vector & other) + { + int vSize = other.size(); + reserve_nocopy(vSize); + memcpy(v, &other[0], sizeof(T *) * vSize); + numElems = vSize; + return *this; + } + + stlhelper_inline ~Unsafevector() + { + delete[] v; + } + + stlhelper_inline void reserve(int newSize) + { + if (newSize > capacity) + { + while (capacity <= newSize) + { + capacity *= 2; + } + T ** newPtr = new T *[capacity]; + memcpy(newPtr, v, sizeof(T *) * numElems); + delete[] v; + v = newPtr; + } + } + + stlhelper_inline void addVectorNoCheck(std::vector & vecIn) + { + int vecInSize = vecIn.size(); + if (vecInSize) + { + memcpy(&v[numElems], &vecIn[0], sizeof(T *) * vecInSize); + numElems += vecInSize; + } + } + + stlhelper_inline void addVector(std::vector & vecIn) + { + int vecInSize = vecIn.size(); + if (vecInSize) + { + reserve(numElems + vecInSize); + memcpy(&v[numElems], &vecIn[0], sizeof(T *) * vecInSize); + numElems += vecInSize; + } + } + + stlhelper_inline void addVectorNoCheck(Unsafevector & vecIn) + { + int vecInSize = vecIn.size(); + if (vecInSize) + { + memcpy(&v[numElems], vecIn.v, sizeof(T *) * vecInSize); + numElems += vecInSize; + } + } + + stlhelper_inline void addVector(Unsafevector & vecIn) + { + int vecInSize = vecIn.size(); + if (vecInSize) + { + reserve(numElems + vecInSize); + memcpy(&v[numElems], vecIn.v, sizeof(T *) * vecInSize); + numElems += vecInSize; + } + } + + stlhelper_inline void addElementNoCheck(T * elemIn) + { + v[numElems++] = elemIn; + } + + stlhelper_inline void addElement(T * elemIn) + { + if (numElems >= capacity) + { + reserve(capacity * 2); + } + v[numElems++] = elemIn; + } + + void addElementSortedUnique(T * elemIn) + { + for (int ii = 0; ii < numElems; ++ii) + { + if (elemIn == v[ii]) + { + return; + } + } + addElement(elemIn); + sortSelf(); + } + + stlhelper_inline void removeElement(int idx) + { + memmove(&v[idx], &v[idx + 1], sizeof(T*) * (numElems - idx - 1)); + --numElems; + } + + stlhelper_inline int find(const T * testElem) + { + for (int ii = 0, end = numElems; ii != end; ++ii) + { + if (v[ii] == testElem) + { + return ii; + } + } + return -1; + } + + stlhelper_inline void clear() + { + numElems = 0; + } + + stlhelper_inline int size() + { + return numElems; + } + + stlhelper_inline bool isEmpty() + { + return (numElems == 0); + } + + stlhelper_inline T * & operator[](int idx) + { + return v[idx]; + } + stlhelper_inline T * operator[](int idx) const + { + return v[idx]; + } + + stlhelper_inline void swap(Unsafevector & other) + { + std::swap(v, other.v); + std::swap(numElems, other.numElems); + std::swap(capacity, other.capacity); + } + + stlhelper_inline static int compareelems(const void * a, const void * b) + { + T * aPtr = *((T **) a); + T * bPtr = *((T **) b); + if (aPtr < bPtr) + return -1; + if (aPtr == bPtr) + return 0; + return 1; + } + + stlhelper_inline static int comparekey(const void * a, const void * b) + { + T * aPtr = (T *) a; + T * bPtr = *((T **) b); + if (aPtr < bPtr) + return -1; + if (aPtr == bPtr) + return 0; + return 1; + } + + stlhelper_inline bool contains(const T & keyIn) + { + return (search(&keyIn) != 0x0); + } + +#define compareElems (int (*)( const void *, const void * )) Unsafevector::compareelems +#define compareKey (int (*)( const void *, const void * )) Unsafevector::comparekey + + stlhelper_inline void sortSelf() + { + std::qsort(v, numElems, sizeof(T *), compareElems); + } + + stlhelper_inline void sortSelf(int (*compareIn)(const void *, const void *)) + { + std::qsort(v, numElems, sizeof(T *), compareIn); + } + + T ** v; + int numElems; + int capacity; + +protected: + stlhelper_inline T ** search(const T * keyIn) + { + size_t lowerIdx, upperIdx, currIdx; + const void *currAddr; + int comparResult; + + lowerIdx = 0; + upperIdx = numElems; + while (lowerIdx < upperIdx) + { + currIdx = (lowerIdx + upperIdx) / 2; + currAddr = (void *) (((const char *) v) + (currIdx * sizeof(T *))); + comparResult = (*compareKey )(keyIn, currAddr); + if (comparResult < 0) + upperIdx = currIdx; + else if (comparResult > 0) + lowerIdx = currIdx + 1; + else + return (T **) currAddr; + } + + return NULL; + } + + stlhelper_inline void reserve_nocopy(int newSize) + { + if (newSize > capacity) + { + delete[] v; + v = new T *[newSize]; + capacity = newSize; + } + } +#undef compareElems +#undef compareKey +}; + +} + +#endif /* UNSAFEVECTOR_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/Vector.hh b/trick_source/er7_utils/CheckpointHelper/Vector.hh new file mode 100644 index 00000000..45dad796 --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/Vector.hh @@ -0,0 +1,79 @@ +/******************************************************************************* + + PURPOSE: + (Vector for checkpointable vector container.) + + PROGRAMMERS: + (((Thomas Brain) (Metecs) (May 2013) (--))) + + *******************************************************************************/ + +#ifndef CHECKPOINTHELPER_VECTOR_HH_ +#define CHECKPOINTHELPER_VECTOR_HH_ + +#include "CheckpointItem.hh" +#include "Unsafevector.hh" +#include + +namespace CheckpointHelper +{ + +template +class vector: public CheckpointItem, public std::vector +{ +public: + T ** chkpt; + std::string mmstr; + + vector(T ** chkptIn, std::string mmstrIn) : + chkpt(chkptIn), mmstr(mmstrIn) + { + *chkpt = 0x0; + } + + vector& operator=(const std::vector& pr) + { + std::vector::operator=(pr); + return *this; + } + + virtual ~vector() + { + } + + virtual void checkpoint() + { + chkpt_seq::iterator, T>(*this); + } + virtual void restart() + { + restart_seq::iterator>(*this); + } +}; + +} + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#define STLVECTOR( type, varName ) \ + type* _##varName; \ + CheckpointHelper::vector varName +#else +#define STLVECTOR( type, varName ) \ + type* _##varName +#endif + +#if (!defined(SWIG) && !defined(TRICK_ICG)) +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + varName( &_##varName, #type ) +#endif +#else +#ifndef STL_CSTR1 +#define STL_CSTR1( varName, type ) \ + _##varName() +#endif +#endif + +#define STLVECTORCSTR STL_CSTR1 + +#endif /* STLHELPER_VECTOR_HH_ */ diff --git a/trick_source/er7_utils/CheckpointHelper/doxygen/Doxyfile b/trick_source/er7_utils/CheckpointHelper/doxygen/Doxyfile new file mode 100644 index 00000000..d0efb71c --- /dev/null +++ b/trick_source/er7_utils/CheckpointHelper/doxygen/Doxyfile @@ -0,0 +1,2374 @@ +# Doxyfile 1.8.8 + +# 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 = CheckpointHelper + +# 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 = 2.0.0 + +# 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 = + +# 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 = + +# 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 = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# 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 = NO + +# 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 = + +# 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 = NO + +# 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 = NO + +# 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 = 8 + +# 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 = NO + +# 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 = NO + +# 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 = NO + +# 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 ... \endif and \cond +# ... \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. 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 = ../ + +# 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 = *.c \ + *.cc \ + *.cxx \ + *.cpp \ + *.c++ \ + *.d \ + *.java \ + *.ii \ + *.ixx \ + *.ipp \ + *.i++ \ + *.inl \ + *.h \ + *.hh \ + *.hxx \ + *.hpp \ + *.h++ \ + *.idl \ + *.odl \ + *.cs \ + *.php \ + *.php3 \ + *.inc \ + *.m \ + *.mm \ + *.dox \ + *.py \ + *.f90 \ + *.f \ + *.vhd \ + *.vhdl + +# 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 = YES + +# 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 = *io_src* \ + *object_* \ + *swig* \ + *SIM_* + +# 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: +# +# +# +# where is the value of the INPUT_FILTER tag, and 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 = + +#--------------------------------------------------------------------------- +# 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 = NO + +# 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 = 5 + +# 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 additional user-defined +# cascading style sheets that are 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 files to the output directory. +# Note: The order of the extra stylesheet files is of importance (e.g. the last +# stylesheet in the list overrules the setting of the previous ones in the +# list). 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 = YES + +# 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://cdn.mathjax.org/mathjax/latest + +# 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 + S +# (what the is depends on the OS and browser, but it is typically +# , /