diff --git a/Doxyfile b/Doxyfile index a796c7fe3c77edf5984f280f2cd3df359430b9e9..1b947de18b2d18cfb32e7e7fac79db90913b630a 100644 --- a/Doxyfile +++ b/Doxyfile @@ -889,7 +889,22 @@ EXCLUDE_SYMLINKS = NO # 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 = +EXCLUDE_PATTERNS = */Communicators/* \ + */Config/* \ + */Debugging/* \ + */Devices/* \ + */DistributedContainers/* \ + */Exceptions/* \ + */Experimental/* \ + */Functions/* \ + */Images/* \ + */Matrices/* \ + */Meshes/* \ + */Operators/* \ + */Pointers/* \ + */Problems/* \ + */Solvers/* + # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the @@ -906,7 +921,7 @@ EXCLUDE_SYMBOLS = # that contain example code fragments that are included (see the \include # command). -EXAMPLE_PATH = +EXAMPLE_PATH = src/Examples # 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 diff --git a/generate-doc b/generate-doc index 6007851f47e071c08ce263d2da8040e261d75cd9..9a2ad0ab92a491a70024ec4182d656346cb9c716 100755 --- a/generate-doc +++ b/generate-doc @@ -15,6 +15,7 @@ done doxygen if [[ "$INSTALL" == "yes" ]]; then - cp -r Documentation/* ${PREFIX}/share/doc + mkdir -p ${PREFIX}/share/doc/tnl + cp -r Documentation/* ${PREFIX}/share/doc/tnl fi diff --git a/src/Benchmarks/BLAS/tnl-benchmark-blas.h b/src/Benchmarks/BLAS/tnl-benchmark-blas.h index 6419087a93b393fe1ee0d4ad56c5bbba6252ce56..8c78205e76df75f7541e9cc3c6098f5199c19b3c 100644 --- a/src/Benchmarks/BLAS/tnl-benchmark-blas.h +++ b/src/Benchmarks/BLAS/tnl-benchmark-blas.h @@ -43,7 +43,7 @@ runBlasBenchmarks( Benchmark & benchmark, metadata ); for( std::size_t size = minSize; size <= maxSize; size *= 2 ) { benchmark.setMetadataColumns( Benchmark::MetadataColumns({ - {"size", String( size ) }, + {"size", convertToString( size ) }, } )); benchmarkArrayOperations< Real >( benchmark, loops, size ); } @@ -53,7 +53,7 @@ runBlasBenchmarks( Benchmark & benchmark, metadata ); for( std::size_t size = minSize; size <= maxSize; size *= sizeStepFactor ) { benchmark.setMetadataColumns( Benchmark::MetadataColumns({ - { "size", String( size ) }, + { "size", convertToString( size ) }, } )); benchmarkVectorOperations< Real >( benchmark, loops, size ); } @@ -63,9 +63,9 @@ runBlasBenchmarks( Benchmark & benchmark, metadata ); for( std::size_t size = minSize; size <= maxSize; size *= 2 ) { benchmark.setMetadataColumns( Benchmark::MetadataColumns({ - {"rows", String( size ) }, - {"columns", String( size ) }, - {"elements per row", String( elementsPerRow ) }, + {"rows", convertToString( size ) }, + {"columns", convertToString( size ) }, + {"elements per row", convertToString( elementsPerRow ) }, } )); benchmarkSpmvSynthetic< Real >( benchmark, loops, size, elementsPerRow ); } diff --git a/src/Benchmarks/Benchmarks.h b/src/Benchmarks/Benchmarks.h index 2b8b28b892b1c8f2332e0d9e702b8b74228578aa..ceb6b9c7eb8656925f8c780ce1272d98ee5178b6 100644 --- a/src/Benchmarks/Benchmarks.h +++ b/src/Benchmarks/Benchmarks.h @@ -504,25 +504,25 @@ Benchmark::MetadataMap getHardwareMetadata() { "system release", Devices::SystemInfo::getSystemRelease() }, { "start time", Devices::SystemInfo::getCurrentTime() }, #ifdef HAVE_MPI - { "number of MPI processes", (Communicators::MpiCommunicator::IsInitialized()) + { "number of MPI processes", String( (Communicators::MpiCommunicator::IsInitialized()) ? Communicators::MpiCommunicator::GetSize( Communicators::MpiCommunicator::AllGroup ) - : 1 }, + : 1 ) }, #endif - { "OpenMP enabled", Devices::Host::isOMPEnabled() }, - { "OpenMP threads", Devices::Host::getMaxThreadsCount() }, + { "OpenMP enabled", String( Devices::Host::isOMPEnabled() ) }, + { "OpenMP threads", String( Devices::Host::getMaxThreadsCount() ) }, { "CPU model name", Devices::SystemInfo::getCPUModelName( cpu_id ) }, - { "CPU cores", Devices::SystemInfo::getNumberOfCores( cpu_id ) }, - { "CPU threads per core", Devices::SystemInfo::getNumberOfThreads( cpu_id ) / Devices::SystemInfo::getNumberOfCores( cpu_id ) }, - { "CPU max frequency (MHz)", Devices::SystemInfo::getCPUMaxFrequency( cpu_id ) / 1e3 }, + { "CPU cores", String( Devices::SystemInfo::getNumberOfCores( cpu_id ) ) }, + { "CPU threads per core", String( Devices::SystemInfo::getNumberOfThreads( cpu_id ) / Devices::SystemInfo::getNumberOfCores( cpu_id ) ) }, + { "CPU max frequency (MHz)", String( Devices::SystemInfo::getCPUMaxFrequency( cpu_id ) / 1e3 ) }, { "CPU cache sizes (L1d, L1i, L2, L3) (kiB)", cacheInfo }, #ifdef HAVE_CUDA { "GPU name", Devices::CudaDeviceInfo::getDeviceName( activeGPU ) }, - { "GPU architecture", deviceArch }, - { "GPU CUDA cores", Devices::CudaDeviceInfo::getCudaCores( activeGPU ) }, - { "GPU clock rate (MHz)", (double) Devices::CudaDeviceInfo::getClockRate( activeGPU ) / 1e3 }, - { "GPU global memory (GB)", (double) Devices::CudaDeviceInfo::getGlobalMemory( activeGPU ) / 1e9 }, - { "GPU memory clock rate (MHz)", (double) Devices::CudaDeviceInfo::getMemoryClockRate( activeGPU ) / 1e3 }, - { "GPU memory ECC enabled", Devices::CudaDeviceInfo::getECCEnabled( activeGPU ) }, + { "GPU architecture", String( deviceArch ) }, + { "GPU CUDA cores", String( Devices::CudaDeviceInfo::getCudaCores( activeGPU ) ) }, + { "GPU clock rate (MHz)", String( (double) Devices::CudaDeviceInfo::getClockRate( activeGPU ) / 1e3 ) }, + { "GPU global memory (GB)", String( (double) Devices::CudaDeviceInfo::getGlobalMemory( activeGPU ) / 1e9 ) }, + { "GPU memory clock rate (MHz)", String( (double) Devices::CudaDeviceInfo::getMemoryClockRate( activeGPU ) / 1e3 ) }, + { "GPU memory ECC enabled", String( Devices::CudaDeviceInfo::getECCEnabled( activeGPU ) ) }, #endif }; diff --git a/src/Benchmarks/DistSpMV/tnl-benchmark-distributed-spmv.h b/src/Benchmarks/DistSpMV/tnl-benchmark-distributed-spmv.h index 11ae35b43604546c740e051870808aaac4c264c4..ecc001d6676c5c8021c3e115ed2af49d49bab614 100644 --- a/src/Benchmarks/DistSpMV/tnl-benchmark-distributed-spmv.h +++ b/src/Benchmarks/DistSpMV/tnl-benchmark-distributed-spmv.h @@ -177,11 +177,11 @@ struct SpmvBenchmark benchmark.setMetadataColumns( Benchmark::MetadataColumns({ // TODO: strip the device // {"matrix type", matrix.getType()}, - {"rows", matrix.getRows()}, - {"columns", matrix.getColumns()}, + {"rows", String( matrix.getRows() ) }, + {"columns", String( matrix.getColumns() ) }, // FIXME: getMaxRowLengths() returns 0 for matrices loaded from file // {"max elements per row", matrix.getMaxRowLength()}, - {"max elements per row", maxRowLength}, + {"max elements per row", String( maxRowLength ) }, } )); const bool reorder = parameters.getParameter< bool >( "reorder-dofs" ); diff --git a/src/Benchmarks/LinearSolvers/tnl-benchmark-linear-solvers.h b/src/Benchmarks/LinearSolvers/tnl-benchmark-linear-solvers.h index a898f156b4e2e25915e20ece50539991b25f47b2..c31f776cd4ff571b4f00e85a6ffcef2959a55e50 100644 --- a/src/Benchmarks/LinearSolvers/tnl-benchmark-linear-solvers.h +++ b/src/Benchmarks/LinearSolvers/tnl-benchmark-linear-solvers.h @@ -347,11 +347,11 @@ struct LinearSolversBenchmark benchmark.setMetadataColumns( Benchmark::MetadataColumns({ // TODO: strip the device // {"matrix type", matrixPointer->getType()}, - {"rows", matrixPointer->getRows()}, - {"columns", matrixPointer->getColumns()}, + {"rows", String( matrixPointer->getRows() ) }, + {"columns", String( matrixPointer->getColumns() ) }, // FIXME: getMaxRowLengths() returns 0 for matrices loaded from file // {"max elements per row", matrixPointer->getMaxRowLength()}, - {"max elements per row", maxRowLength}, + {"max elements per row", String( maxRowLength ) }, } )); const bool reorder = parameters.getParameter< bool >( "reorder-dofs" ); diff --git a/src/Examples/CMakeLists.txt b/src/Examples/CMakeLists.txt index 8fcc4a5de7f5ae768fb9709bddd6d875fd53c257..502f90d8a3bce49bcae7167a8a06360868ba6ac2 100644 --- a/src/Examples/CMakeLists.txt +++ b/src/Examples/CMakeLists.txt @@ -17,3 +17,33 @@ add_subdirectory( flow-vl ) #add_subdirectory( hamilton-jacobi-parallel-map ) #add_subdirectory( fast-sweeping-map ) #add_subdirectory( narrow-band ) + +ADD_EXECUTABLE( ConfigDescriptionExample ConfigDescriptionExample.cpp ) +target_link_libraries( ConfigDescriptionExample tnl ) + +ADD_EXECUTABLE( FileExample FileExample.cpp ) +target_link_libraries( FileExample tnl ) + +ADD_EXECUTABLE( ListExample ListExample.cpp ) +target_link_libraries( ListExample tnl ) + +ADD_EXECUTABLE( LoggerExample LoggerExample.cpp ) +target_link_libraries( LoggerExample tnl ) + +ADD_EXECUTABLE( MathExample MathExample.cpp ) +target_link_libraries( MathExample tnl ) + +ADD_EXECUTABLE( StringExample StringExample.cpp ) +target_link_libraries( StringExample tnl ) + +ADD_EXECUTABLE( StringExampleGetAllocatedSize StringExampleGetAllocatedSize.cpp ) +target_link_libraries( StringExampleGetAllocatedSize tnl ) + +ADD_EXECUTABLE( StringExampleGetSize StringExampleGetSize.cpp ) +target_link_libraries( StringExampleGetSize tnl ) + +ADD_EXECUTABLE( StringExampleSetSize StringExampleSetSize.cpp ) +target_link_libraries( StringExampleSetSize tnl ) + +ADD_EXECUTABLE( TimerExample TimerExample.cpp ) +target_link_libraries( TimerExample tnl ) \ No newline at end of file diff --git a/src/Examples/ConfigDescriptionExample.cpp b/src/Examples/ConfigDescriptionExample.cpp new file mode 100644 index 0000000000000000000000000000000000000000..59958f1d103458f247ec501b0bb08a1142eac8e6 --- /dev/null +++ b/src/Examples/ConfigDescriptionExample.cpp @@ -0,0 +1,14 @@ +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + Config::ConfigDescription confd; + confd.template addEntry< String >("--new-entry","Specific description."); + confd.template addEntryEnum< String >("option1"); + confd.template addEntryEnum< String >("option2"); + confd.addDelimiter("-----------------------------"); +} diff --git a/src/Examples/FileExample.cpp b/src/Examples/FileExample.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4d379f4b18f5ffd107cb5840ee745841486fa547 --- /dev/null +++ b/src/Examples/FileExample.cpp @@ -0,0 +1,24 @@ +#include +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + File file; + + file.open( String("new-file.tnl"), IOMode::write ); + String title("Header"); + file.write( &title ); + file.close(); + + file.open( String("new-file.tnl"), IOMode::read ); + String title2; + file.read( &title2, 4); + file.close(); + + cout << "title2:" << title2 < +#include +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + Containers::List< int > lst; + lst.isEmpty(); + + lst.Append(1); + lst.Append(3); + + lst.isEmpty(); + lst.getSize(); + + lst.Insert(2,1); + + Containers::Array array; + lst.toArray(array); +} \ No newline at end of file diff --git a/src/Examples/LoggerExample.cpp b/src/Examples/LoggerExample.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cb4e3dc4a8548cb05eda84943e297e09b310e5e9 --- /dev/null +++ b/src/Examples/LoggerExample.cpp @@ -0,0 +1,23 @@ +#include +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + Logger logger(50,cout); + + Config::ParameterContainer parameters; + logger.writeSystemInformation(parameters); + + logger.writeHeader("MyTitle"); + parameters.template addParameter< String >( "Device:", "cuda" ); + parameters.template addParameter< String >( "Real type:", "double" ); + parameters.template addParameter< String >( "Index type:", "int" ); + logger.writeSeparator(); + logger.writeSystemInformation(parameters); + logger.writeSeparator(); +} + diff --git a/src/Examples/MathExample.cpp b/src/Examples/MathExample.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bb5e29b5e18b4660ecd2e96db8c617be09fafbb5 --- /dev/null +++ b/src/Examples/MathExample.cpp @@ -0,0 +1,11 @@ +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + isPow2(1024); + roundUpDivision(10,4); +} \ No newline at end of file diff --git a/src/Examples/StringExample.cpp b/src/Examples/StringExample.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f69fe9f1f70a1996892228600c9062855d6d0f40 --- /dev/null +++ b/src/Examples/StringExample.cpp @@ -0,0 +1,146 @@ +#include +#include +#include +#include + +using namespace TNL; +using namespace std; + +int main( int argc, char* argv[] ) +{ + // constructors + String str1; + String str2( "xxstringxxx", 2, 3 ); + String str3( str2 ); // copy constructor + String str4( 28.4 ); // converts to string + + cout << "str1:" << str1 << endl; + cout << "str2:" << str2 << endl; + cout << "str3:" << str3 << endl; + cout << "str4:" << str4 << endl; + + // functions + /*int size = str3.getSize(); + cout << "size of string:" << size << "bytes" << endl; + + int alloc_size = str3.getAllocatedSize(); + cout << "alloc_size:" << alloc_size << endl; + + str1.setSize( 256 ); + size = str3.getSize(); + cout << "size of string:" << size << "bytes" << endl;*/ + + String str; + str.setString( "Something new" ); + String setter = str; + cout << "setter:" << setter << endl; + + const char* getter = str4.getString(); + cout << "getter:" << getter << endl; + + String word( "computer" ) ; + char third_letter = word[2]; + cout << "third_letter:" << third_letter << endl; + + // Operators for C Strings + String a( "hello" ); + a = "bye"; + cout << "a:" << a << endl; + + String b( "see" ); + b += " you"; + cout << "b:" << b << endl; + + String c; + c = b + " soon"; + cout << "c:" << c << endl; + + String name( "Jack" ); + if ( name == "Jack" ) cout << "Names are the same." << endl; + + String surname( "Sparrow" ); + if ( surname != "Jones" ) cout << "Surnames are different." << endl; + + // Operators for Strings + String d1( "Cheese" ); + String d = d1; + cout << "d:" << d << endl; + + String e( "Mac&" ); + e += d; + cout << "e:" << e << endl; + + String f; + String f1("Tim likes "); + f = f1 + e; + cout << "f:" << f << endl; + + String num1( "one" ); + String num2( "Anyone", 3); + if ( num1 == num2 ) cout << "Numbers are the same." << endl; + + String eq1( "a + b" ); + String eq2( "a" ); + if ( eq1 != eq2 ) cout << "Equations are different." << endl; + + // Operators for single characters + String g; + g = 'y'; + cout << "g:" << g << endl; + + String h( "x" ); + h += g; + cout << "h:" << h << endl; + + String i; + i = 'a' + 'b'; + cout << "i:" << i << endl; + + String letter1( "u" ); + if ( letter1 == "u" ) cout << "Letters are the same." << endl; + + String letter2( "v" ); + if ( letter2 != "w" ) cout << "Letters are different." << endl; + + // Cast to bool operators + String full( "string" ); + if ( full ) cout << "String is not empty." << endl; + + String empty; + if ( !empty ) cout << "String is empty." << endl; + + // replace + String phrase( "Hakuna matata" ); + String new_phrase = phrase.replace( "a", "u", 2 ); + cout << "new_phrase:" << new_phrase << endl; + + // strip + String names(" Josh Martin John Marley Charles "); + String better_names = names.strip(); + cout << "better_names:" << better_names << endl; + + // split + String dates("3/4/2005;8/7/2011;11/12/2019"); + Containers::List list; + dates.split( list, ';' ); + cout << "list_dates:" << list << endl; + + // save + File myFile; + String("Header").save(myFile); // saves "Header" into myFile + + // load + String strg; + strg.load(myFile); + cout << "strg:" << strg << endl; + + // get line + std::stringstream text; + text << "Hello!" << std::endl; + text << "What's up?" << std::endl; + + String string; + string.getLine( text ); + cout << "str:" << string << endl; + +} diff --git a/src/Examples/StringExample.out b/src/Examples/StringExample.out new file mode 100644 index 0000000000000000000000000000000000000000..61886792acbdb70945a2d05e0c731620e613d15f --- /dev/null +++ b/src/Examples/StringExample.out @@ -0,0 +1,52 @@ +//constructors +str1: +str2: string +str3: string +str4: 28.4 //string type + +//functions +size of string: 8 bytes +alloc_size: 256 +memory: 512 +setter: Something new +getter: 28.4 +third_letter: m + +// Operators for C Strings +a: bye +b: see you +c: see you soon +Names are the same. +Surnames are different. + +// Operators for Strings +d: Cheese +e: Mac&Cheese +f: Tim likes Mac&Cheese +Numbers are the same. +Equations are different. +// Operators for single characters +g: y +h: xy +i: ab +Letters are the same. +Letters are different. + +// Cast to bool operators +String is not empty. +String is empty. + +// replace +new_phrase: Hukunu matata + +// strip +list_dates: 3/4/2005 8/7/2011 11/12/2019 + +// save +true + +// load +strg: Header + +// get line +str: Hello! \ No newline at end of file diff --git a/src/Examples/StringExampleGetAllocatedSize.cpp b/src/Examples/StringExampleGetAllocatedSize.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ad616de67304d41769fbd4389a0d2d3e03e90546 --- /dev/null +++ b/src/Examples/StringExampleGetAllocatedSize.cpp @@ -0,0 +1,12 @@ +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + String str("my world"); + int alloc_size = str.getAllocatedSize(); + cout << "alloc_size:" << alloc_size << endl; +} \ No newline at end of file diff --git a/src/Examples/StringExampleGetSize.cpp b/src/Examples/StringExampleGetSize.cpp new file mode 100644 index 0000000000000000000000000000000000000000..77fb499a478f45b9da7355355e01c747bdd1e639 --- /dev/null +++ b/src/Examples/StringExampleGetSize.cpp @@ -0,0 +1,13 @@ +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + String str("my world"); + int size = str.getSize(); + cout << "size of string:" << size << "bytes" << endl; +} + diff --git a/src/Examples/StringExampleSetSize.cpp b/src/Examples/StringExampleSetSize.cpp new file mode 100644 index 0000000000000000000000000000000000000000..8451295a75a87f49e46c286cb5ef6ea94c06dcc8 --- /dev/null +++ b/src/Examples/StringExampleSetSize.cpp @@ -0,0 +1,13 @@ +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + String memory; + memory.setSize( 256 ); + int memorysize = memory.getSize(); + cout << "memory:" << memorysize << endl; +} diff --git a/src/Examples/TimerExample.cpp b/src/Examples/TimerExample.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5d5a814540aa7265e023efb571627dffc3c47334 --- /dev/null +++ b/src/Examples/TimerExample.cpp @@ -0,0 +1,23 @@ +#include +#include +#include +#include + +using namespace TNL; +using namespace std; + +int main() +{ + unsigned int microseconds = 0.5; + Timer time; + time.start(); + usleep(microseconds); + time.stop(); + cout << "before reset:" << time.getRealTime() << endl; + time.reset(); + cout << "after reset:" << time.getRealTime() << endl; + // writeLog example + Logger log1(50,cout); + time.writeLog( log1, 0 ); +} + diff --git a/src/TNL/Assert.h b/src/TNL/Assert.h index 6d13e35b11db7e7e304400bb5a3fd772891cbb85..d601f9c1b95dd7e85737304c05a3536ac0d0f8ae 100644 --- a/src/TNL/Assert.h +++ b/src/TNL/Assert.h @@ -33,14 +33,77 @@ #if defined(NDEBUG) || defined(HAVE_MIC) // empty macros for optimized build +/** + * \brief Asserts that the expression \e val evaluates to \e true. + * + * The assertion succeeds if, and only if, \e val evaluates to equal to \e true. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_TRUE( val, msg ) +/** + * \brief Asserts that the expression \e val evaluates to \e false. + * + * The assertion succeeds if, and only if, \e val evaluates to equal to \e false. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_FALSE( val, msg ) +/** + * \brief Asserts that the expression \e val1 is equal to \e val2. + * + * The assertion succeeds if, and only if, \e val1 and \e val2 are equal. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_EQ( val1, val2, msg ) +/** + * \brief Asserts that the expression \e val1 is not equal to \e val2. + * + * The assertion succeeds if, and only if, \e val1 and \e val2 are not equal. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_NE( val1, val2, msg ) +/** + * \brief Asserts that the expression \e val1 is less than or equal to \e val2. + * + * The assertion succeeds if, and only if, \e val1 is less than or equal to \e val2. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_LE( val1, val2, msg ) +/** + * \brief Asserts that the expression \e val1 is less than \e val2. + * + * The assertion succeeds if, and only if, \e val1 is less than \e val2. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_LT( val1, val2, msg ) +/** + * \brief Asserts that the expression \e val1 is greater than or equal to \e val2. + * + * The assertion succeeds if, and only if, \e val1 is greater than or equal to \e val2. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_GE( val1, val2, msg ) +/** + * \brief Asserts that the expression \e val1 is greater than \e val2. + * + * The assertion succeeds if, and only if, \e val1 is greater than \e val2. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e msg. + */ #define TNL_ASSERT_GT( val1, val2, msg ) +/** + * \brief Asserts that the specified \e ___tnl__assert_condition is valid. + * + * The assertion succeeds if, and only if, ___tnl__assert_condition is valid. + * On success the test continues without any side effects. + * On failure the test is terminated with the error message \e ___tnl__assert_command. + */ #define TNL_ASSERT( ___tnl__assert_condition, ___tnl__assert_command ) #else /* #ifdef NDEBUG */ diff --git a/src/TNL/Config/ConfigDescription.h b/src/TNL/Config/ConfigDescription.h index 37325183b7ae2dde99aa6d6e2a573c66e7531410..833e99a47af2a11b19fcdbd3b2ed9c5f5cccf0f4 100644 --- a/src/TNL/Config/ConfigDescription.h +++ b/src/TNL/Config/ConfigDescription.h @@ -27,8 +27,18 @@ class ConfigDescription { public: + /** + * \brief Basic constructor. + */ ConfigDescription(); + /** + * \brief Adds new entry to the configuration description. + * + * \tparam EntryType Type of the entry. + * \param name Name of the entry. + * \param description More specific information about the entry. + */ template< typename EntryType > void addEntry( const String& name, const String& description ) @@ -37,6 +47,13 @@ class ConfigDescription entries.Append( currentEntry ); } + /** + * \brief Adds new entry to the configuration description, that requires set value. + * + * \tparam EntryType Type of the entry. + * \param name Name of the entry. + * \param description More specific information about the entry. + */ template< typename EntryType > void addRequiredEntry( const String& name, const String& description ) @@ -44,7 +61,15 @@ class ConfigDescription currentEntry = new ConfigEntry< EntryType >( name, description, true ); entries.Append( currentEntry ); } - + + /** + * \brief Adds new entry to the configuration description. + * + * \tparam EntryType Type of the entry. + * \param name Name of the entry. + * \param description More specific information about the entry. + * \param defaultValue Default value of the entry. + */ template< typename EntryType > void addEntry( const String& name, const String& description, @@ -57,6 +82,13 @@ class ConfigDescription entries. Append( currentEntry ); } + /** + * \brief Adds new list to the configuration description. + * + * \tparam EntryType Type of the list. + * \param name Name of the list. + * \param description More specific information about the list. + */ template< typename EntryType > void addList( const String& name, const String& description ) @@ -65,6 +97,13 @@ class ConfigDescription entries.Append( currentEntry ); } + /** + * \brief Adds new list to the configuration description, that requires specific value. + * + * \tparam EntryType Type of the list. + * \param name Name of the list. + * \param description More specific information about the list. + */ template< typename EntryType > void addRequiredList( const String& name, const String& description ) @@ -73,6 +112,14 @@ class ConfigDescription entries.Append( currentEntry ); } + /** + * \brief Adds new list to the configuration description. + * + * \tparam EntryType Type of the list. + * \param name Name of the list. + * \param description More specific information about the list. + * \param defaultValue Default value of the list. + */ template< typename EntryType > void addList( const String& name, const String& description, @@ -85,6 +132,13 @@ class ConfigDescription entries. Append( currentEntry ); } + /** + * \brief Adds new entry enumeration of type \e EntryType. + * + * Adds new option of setting an entry value. + * \tparam EntryType Type of the entry enumeration. + * \param entryEnum Value of the entry enumeration. + */ template< typename EntryType > void addEntryEnum( const EntryType& entryEnum ) { @@ -92,18 +146,34 @@ class ConfigDescription ( ( ConfigEntry< EntryType >* ) currentEntry )->getEnumValues().Append( entryEnum ); } + /** + * \brief Adds new entry enumeration of type \e char. + * + * Adds new option of setting an entry value. + * \param entryEnum Value of the entry enumeration. + */ void addEntryEnum( const char* entryEnum ) { TNL_ASSERT( this->currentEntry,); ( ( ConfigEntry< String >* ) currentEntry )->getEnumValues().Append( String( entryEnum ) ); } + /** + * \brief Adds delimeter/section to the configuration description. + * + * \param delimeter String that defines how the delimeter looks like. + */ void addDelimiter( const String& delimiter ) { entries.Append( new ConfigDelimiter( delimiter ) ); currentEntry = 0; } + /** + * \brief Gets entry out of the configuration description. + * + * \param name Name of the entry. + */ const ConfigEntryBase* getEntry( const String& name ) const { for( int i = 0; i < entries.getSize(); i++ ) @@ -148,7 +218,13 @@ class ConfigDescription return NULL; } - //! If there is missing entry with defined default value in the Config::ParameterContainer it is going to be added + /** + * \brief Fills in the parameters from the \e parameter_container. + * + * Parameters which were not defined in the command line by user but have their default value are added to the congiguration description. + * If there is missing entry with defined default value in the Config::ParameterContainer it is going to be added. + * \param parameter_container Name of the ParameterContainer object. + */ void addMissingEntries( Config::ParameterContainer& parameter_container ) const; //! Check for all entries with the flag 'required'. @@ -158,10 +234,18 @@ class ConfigDescription bool printUsage, const char* programName ) const; + /** + * \brief Prints configuration description with the \e program_name at the top. + * + * \param program_name Name of the program + */ void printUsage( const char* program_name ) const; //bool parseConfigDescription( const char* file_name ); + /** + * \brief Basic destructor. + */ ~ConfigDescription(); protected: diff --git a/src/TNL/Config/ParameterContainer.h b/src/TNL/Config/ParameterContainer.h index 2450c380941aa092cbbb9d57a8ee8a2f63a40433..aac0cb6ab707799bac7d7079eb569705ef21933a 100644 --- a/src/TNL/Config/ParameterContainer.h +++ b/src/TNL/Config/ParameterContainer.h @@ -44,22 +44,55 @@ class ParameterContainer { public: + /** + * \brief Basic constructor. + */ ParameterContainer(); + /** + * \brief Adds new parameter to the ParameterContainer. + * + * \tparam T Type of parameter value. + * \param name Name of the new parameter. + * \param value Value assigned to the parameter. + */ template< class T > bool addParameter( const String& name, const T& value ); bool addParameter( const String& name, const String& value ); + /** + * \brief Checks whether the parameter \e name already exists in ParameterContainer. + * + * \param name Name of the parameter. + */ bool checkParameter( const String& name ) const; + /** + * \brief Assigns new \e value to the parameter \e name. + * + * \tparam T Type of the parameter value. + * \param name Name of parameter. + * \param value Value of type T assigned to the parameter. + */ template< class T > bool setParameter( const String& name, const T& value ); bool setParameter( const String& name, const String& value ); + /** + * \brief Checks whether the parameter \e name is given the \e value. + * + * Returns \e true if the parameter \e name is given the \e value. + * If the parameter does not have any value or has different value then the given + * \e value the method returns \e false and shows message when \e verbose is \e true. + * + * \param name Name of parameter. + * \param value Value of type T we want to check whether is assigned to the parameter. + * \param verbose Boolean value defining whether to show error message (when true) or not (when false). + */ template< class T > bool getParameter( const String& name, T& value, bool verbose = true ) const @@ -80,6 +113,11 @@ class ParameterContainer return false; } + /** + * \brief Returns parameter value. + * + * \param name Name of parameter. + */ template< class T > const T& getParameter( const String& name ) const { int i; @@ -95,6 +133,9 @@ class ParameterContainer //! Broadcast to other nodes in MPI cluster // void MPIBcast( int root, MPI_Comm mpi_comm = MPI_COMM_WORLD ); + /** + * \brief Basic destructor. + */ ~ParameterContainer(); protected: diff --git a/src/TNL/Containers/Array.h b/src/TNL/Containers/Array.h index 5605f7a9c27762a347e6c92116a104e5996fb4cd..d188d84f7e020f933bcfd7af43d184e4dc5657a4 100644 --- a/src/TNL/Containers/Array.h +++ b/src/TNL/Containers/Array.h @@ -19,9 +19,12 @@ namespace Containers { template< int, typename > class StaticArray; -/**** +/** * Array handles memory allocation and sharing of the same data between more Arrays. * + * \tparam Value Type of array values. + * \tparam Device Device type. + * \tparam Index Type of index. */ template< typename Value, typename Device = Devices::Host, @@ -36,34 +39,73 @@ class Array : public Object typedef Containers::Array< Value, Devices::Host, Index > HostType; typedef Containers::Array< Value, Devices::Cuda, Index > CudaType; + /** \brief Basic constructor. + * + * Constructs an empty array with the size of zero. + */ Array(); + /** + * \brief Constructor with size. + * + * \param size Number of array elements. / Size of allocated memory. + */ Array( const IndexType& size ); + /** + * \brief Constructor with data and size. + * + * \param data + * \param size Number of array elements. + */ Array( Value* data, const IndexType& size ); + /** + * \brief Copy constructor. + * + * Copies \e size elements from existing \e array into a new array. + * \param array Existing array that is about to be copied. + * \param begin Index from which the array is copied. + * \param size Number of array elements that should be copied. + */ Array( Array& array, const IndexType& begin = 0, const IndexType& size = 0 ); + /** \brief Returns type of array value, device type and the type of index. */ static String getType(); + /** \brief Returns type of array value, device type and the type of index. */ virtual String getTypeVirtual() const; + /** \brief Returns (host) type of array value, device type and the type of index. */ static String getSerializationType(); + /** \brief Returns (host) type of array value, device type and the type of index. */ virtual String getSerializationTypeVirtual() const; - /**** - * This sets size of the array. If the array shares data with other arrays - * these data are released. If the current data are not shared and the current - * size is the same as the new one, nothing happens. + /** + * \brief Method for setting the size of an array. + * + * If the array shares data with other arrays these data are released. + * If the current data are not shared and the current size is the same + * as the new one, nothing happens. + * + * \param size Number of array elements. */ void setSize( Index size ); + /** \brief Method for getting the size of an array. */ __cuda_callable__ Index getSize() const; + /** + * \brief Assigns features of the existing \e array to the given array. + * + * Sets the same size as the size of existing \e array. + * \tparam ArrayT Type of array. + * \param array Existing array. + */ template< typename ArrayT > void setLike( const ArrayT& array ); @@ -78,54 +120,119 @@ class Array : public Object template< int Size > void bind( StaticArray< Size, Value >& array ); + /** + * \brief Swaps all features of given array with existing \e array. + * + * Swaps sizes, all values (data), allocated memory and references of given + * array with existing array. + * \param array Existing array, which features are swaped with given array. + */ void swap( Array& array ); + /** + * \brief Resets the given array. + * + * Releases all data from array. + */ void reset(); + /** + * \brief Method for getting the data from given array with constant poiner. + */ __cuda_callable__ const Value* getData() const; + /** + * \brief Method for getting the data from given array. + */ __cuda_callable__ Value* getData(); + /** + * \brief Assignes the value \e x to the array element at position \e i. + * + * \param i Index position. + * \param x New value of an element. + */ void setElement( const Index& i, const Value& x ); + /** + * \brief Accesses specified element at the position \e i and returns its value. + * + * \param i Index position of an element. + */ Value getElement( const Index& i ) const; + /** + * \brief Accesses specified element at the position \e i and returns a reference to its value. + * + * \param i Index position of an element. + */ __cuda_callable__ inline Value& operator[] ( const Index& i ); + /** + * \brief Accesses specified element at the position \e i and returns a (constant?) reference to its value. + * + * \param i Index position of an element. + */ __cuda_callable__ inline const Value& operator[] ( const Index& i ) const; + /** Assigns \e array to the given array, replacing its current contents. */ Array& operator = ( const Array& array ); + /** Assigns \e array to the given array, replacing its current contents. */ template< typename ArrayT > Array& operator = ( const ArrayT& array ); + /** \brief This function checks whether the given array is equal to \e array. */ template< typename ArrayT > bool operator == ( const ArrayT& array ) const; + /** \brief This function checks whether the given array is not equal to \e array. */ template< typename ArrayT > bool operator != ( const ArrayT& array ) const; + /** + * \brief + * + * \param v Reference to a value. + */ void setValue( const Value& v ); - // Checks if there is an element with value v in this array + /** + * \brief Checks if there is an element with value \e v in given array. + * + * \param v Reference to a value. + */ bool containsValue( const Value& v ) const; - // Checks if all elements in this array have the same value v + /** + * \brief Checks if all elements in given array have the same value \e v. + * + * \param v Reference to a value. + */ bool containsOnlyValue( const Value& v ) const; - /*! - * Returns true if non-zero size is set. + /** + * \brief Returns true if non-zero size is set. */ operator bool() const; - //! Method for saving the object to a file as a binary data. + /** + * \brief Method for saving the object to a \e file as a binary data. + * + * \param file Reference to a file. + */ bool save( File& file ) const; - //! Method for loading the object from a file as a binary data. + /** + * Method for loading the object from a file as a binary data. + * + * \param file Reference to a file. + */ bool load( File& file ); - //! This method loads data without reallocation. - /**** + /** + * \brief This method loads data without reallocation. + * * This is useful for loading data into shared arrays. * If the array was not initialize yet, common load is * performed. Otherwise, the array size must fit with @@ -139,31 +246,36 @@ class Array : public Object using Object::boundLoad; + /** \brief Basic destructor. */ ~Array(); protected: + /** \brief Method for releasing array data. */ void releaseData() const; - //!Number of elements in array + /** \brief Number of elements in array. */ mutable Index size; - //! Pointer to data + /** \brief Pointer to data. */ mutable Value* data; - /**** - * Pointer to the originally allocated data. They might differ if one - * long array is partitioned into more shorter arrays. Each of them - * must know the pointer on allocated data because the last one must - * deallocate the array. If outer data (not allocated by TNL) are bind - * then this pointer is zero since no deallocation is necessary. + /** + * \brief Pointer to the originally allocated data. + * + * They might differ if one long array is partitioned into more shorter + * arrays. Each of them must know the pointer on allocated data because + * the last one must deallocate the array. If outer data (not allocated + * by TNL) are bind then this pointer is zero since no deallocation is + * necessary. */ mutable Value* allocationPointer; - /**** - * Counter of objects sharing this array or some parts of it. The reference counter is - * allocated after first sharing of the data between more arrays. This is to avoid - * unnecessary dynamic memory allocation. + /** + * \brief Counter of objects sharing this array or some parts of it. + * + * The reference counter is allocated after first sharing of the data + * between more arrays. This is to avoid unnecessary dynamic memory allocation. */ mutable int* referenceCounter; }; diff --git a/src/TNL/Containers/List.h b/src/TNL/Containers/List.h index c64a8a957b3d7106a8601a7033c169052f599362..2c175bcce772236d54c8cd0a2f664822e9c97a8c 100644 --- a/src/TNL/Containers/List.h +++ b/src/TNL/Containers/List.h @@ -22,13 +22,13 @@ namespace Containers { template< class T > class ListDataElement; -//! Template for double linked lists +/// \brief Template for double linked lists /*! To acces elements in the list one can use method getSize() and operator[](). To add elements there are methods Append(), Prepend() and Insert() to insert an element at given - position. To erase particular element there is merthod + position. To erase particular element there is method Erase() taking the element position. To erase all elements - there is method EraseAll. There are also alternatives DeepErase() + there is method reset(). There are also alternatives DeepErase() and DeepEraseAll() to free dynamicaly allocated data inside the data elements. The list stores pointer to last accesed element so if one goes @@ -43,27 +43,35 @@ template< class T > class List public: typedef T ValueType; - //! Basic constructor + /// \brief Basic constructor. + /// + /// Constructs an empty list. List(); - //! Copy constructor + /// \brief Copy constructor. + /// + /// Construct a copy of \e list. + /// \param list Name of another list. List( const List& list ); - //! Destructor + /// \brief Destructor. + /// + /// Destroys the list. References to the values in the list become invalid. ~List(); + /// Returns the type of list. static String getType(); - //! If the list is empty return 'true' + /// Returns \e true if the list contains no items, otherwise returns \e false. bool isEmpty() const; - //! Return size of the list + /// Returns number of items in the list. int getSize() const; - //! Indexing operator + /// Indexing operator. T& operator[] ( const int& ind ); - //! Indexing operator for constant instances + /// Indexing operator for constant instances. const T& operator[] ( const int& ind ) const; const List& operator = ( const List& lst ); @@ -72,64 +80,89 @@ template< class T > class List bool operator != ( const List& lst ) const; - //! Append new data element + /// \brief Appends new data element. + /// + /// Inserts \e data at the end of the list. bool Append( const T& data ); - //! Prepend new data element + /// \brief Prepends new data element. + /// + /// Inserts \e data at the beginning of the list. bool Prepend( const T& data ); - //! Insert new data element at given position + /// \brief Inserts new data element at given position. + /// + /// Inserts \e data at index position \e ind in the list. bool Insert( const T& data, const int& ind ); - //! Append copy of another list + /// Appends copy of another list. + /// + /// \param lst Name of another list. bool AppendList( const List< T >& lst ); - //! Prepend copy of another list + /// Prepends copy of another list. + /// + /// \param lst Name of another list. bool PrependList( const List< T >& lst ); + /// Transforms list to an \e array. template< typename Array > void toArray( Array& array ); - //! Erase data element at given position + /// Erases data element at given position. + /// + /// \param ind Index of the data element one chooses to remove. void Erase( const int& ind ); - //! Erase data element with contained data at given position + /// Erases data element with contained data at given position. + /// + /// \param ind Index of the data element one chooses to remove. void DeepErase( const int& ind ); - //! Erase all data elements + /// Erases all data elements. void reset(); - //! Erase all data elements with contained data + /// \brief Erases all data elements with contained data. + /// + /// Frees dynamicaly allocated data inside the data elements void DeepEraseAll(); - //! Save the list in binary format + /// Saves the list in binary format. + /// + /// \param file Name of file. bool Save( File& file ) const; - //! Save the list in binary format using method save of type T + /// Saves the list in binary format using method save of type T. + /// + /// \param file Name of file. bool DeepSave( File& file ) const; - //! Load the list + /// Loads the list from file. + /// + /// \param file Name of file. bool Load( File& file ); - //! Load the list using method Load of the type T + /// Loads the list from file using method Load of the type T. + /// + /// \param file Name of file. bool DeepLoad( File& file ); protected: - //! Pointer to the first element + /// Pointer to the first element. ListDataElement< T >* first; - //! Pointer to the last element + /// Pointer to the last element. /*! We use pointer to last element while adding new element to keep order of elements */ ListDataElement< T >* last; - //! List size + /// List size. int size; - //! Iterator + /// Iterator. mutable ListDataElement< T >* iterator; - //! Iterator index + /// Iterator index. mutable int index; }; diff --git a/src/TNL/Doxyfile b/src/TNL/Doxyfile deleted file mode 100644 index 4fb5d22f99cc6342e6854ebf539caa7325cd03c7..0000000000000000000000000000000000000000 --- a/src/TNL/Doxyfile +++ /dev/null @@ -1,1514 +0,0 @@ -# Doxyfile 1.6.1 - -# This file describes the settings to be used by the documentation system -# doxygen (www.doxygen.org) for a project -# -# All text after a 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. - -DOXYFILE_ENCODING = UTF-8 - -# The PROJECT_NAME tag is a single word (or a sequence of words surrounded -# by quotes) that should identify the project. - -PROJECT_NAME = tnl - -# 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 = - -# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) -# base path where the generated documentation will be put. -# 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 = ../Release/src - -# 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 cause performance problems for the file system. - -CREATE_SUBDIRS = YES - -# 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. -# The default language is English, other supported languages are: -# Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional, -# Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German, -# Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English -# messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian, -# Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrilic, Slovak, -# Slovene, Spanish, Swedish, Ukrainian, and Vietnamese. - -OUTPUT_LANGUAGE = English - -# If the BRIEF_MEMBER_DESC tag is set to YES (the default) 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. - -BRIEF_MEMBER_DESC = YES - -# If the REPEAT_BRIEF tag is set to YES (the default) 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. - -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" "the" - -ABBREVIATE_BRIEF = - -# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then -# Doxygen will generate a detailed section even if there is only a brief -# description. - -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. - -INLINE_INHERITED_MEMB = YES - -# If the FULL_PATH_NAMES tag is set to YES then 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. - -FULL_PATH_NAMES = YES - -# If the FULL_PATH_NAMES tag is set to YES then 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. - -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 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. - -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 -# comments will behave just like regular Qt-style comments -# (thus requiring an explicit @brief command for a brief description.) - -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 comments -# will behave just like regular Qt-style comments (thus requiring -# an explicit \brief command for a brief description.) - -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 behaviour. -# 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 behaviour instead. - -MULTILINE_CPP_IS_BRIEF = NO - -# If the INHERIT_DOCS tag is set to YES (the default) then an undocumented -# member inherits the documentation from any documented member that it -# re-implements. - -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. - -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. - -TAB_SIZE = 3 - -# This tag can be used to specify a number of aliases that acts -# 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 = - -# 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. - -OPTIMIZE_OUTPUT_FOR_C = NO - -# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java -# sources only. Doxygen will then generate output that is more tailored for -# Java. For instance, namespaces will be presented as packages, qualified -# scopes will look different, etc. - -OPTIMIZE_OUTPUT_JAVA = NO - -# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran -# sources only. Doxygen will then generate output that is more tailored for -# Fortran. - -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. - -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, VHDL, C, C++. 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 that for custom extensions you also need to set FILE_PATTERNS otherwise the files are not read by doxygen. - -EXTENSION_MAPPING = - -# 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); v.s. -# func(std::string) {}). This also make the inheritance and collaboration -# diagrams that involve STL classes more complete and accurate. - -BUILTIN_STL_SUPPORT = NO - -# If you use Microsoft's C++/CLI language, you should set this option to YES to -# enable parsing support. - -CPP_CLI_SUPPORT = NO - -# Set the SIP_SUPPORT tag to YES if your project consists of sip 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. - -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 (the default) -# 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. - -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. - -DISTRIBUTE_GROUP_DOC = NO - -# Set the SUBGROUPING tag to YES (the default) 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. - -SUBGROUPING = YES - -# When TYPEDEF_HIDES_STRUCT 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. - -TYPEDEF_HIDES_STRUCT = NO - -# The SYMBOL_CACHE_SIZE determines the size of the internal cache use to -# determine which symbols to keep in memory and which to flush to disk. -# When the cache is full, less often used symbols will be written to disk. -# For small to medium size projects (<1000 input files) the default value is -# probably good enough. For larger projects a too small cache size can cause -# doxygen to be busy swapping symbols to and from disk most of the time -# causing a significant performance penality. -# If the system has enough physical memory increasing the cache will improve the -# performance by keeping more symbols in memory. Note that the value works on -# a logarithmic scale so increasing the size by one will rougly double the -# memory usage. The cache size is given by this formula: -# 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0, -# corresponding to a cache size of 2^16 = 65536 symbols - -SYMBOL_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 and EXTRACT_STATIC tags are set to YES - -EXTRACT_ALL = NO - -# If the EXTRACT_PRIVATE tag is set to YES all private members of a class -# will be included in the documentation. - -EXTRACT_PRIVATE = NO - -# If the EXTRACT_STATIC tag is set to YES all static members of a file -# will be included in the documentation. - -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. - -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 (the default) only methods in the interface are included. - -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. - -EXTRACT_ANON_NSPACES = NO - -# If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all -# undocumented members of documented classes, files or namespaces. -# If set to NO (the default) 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. - -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 (the default) these classes will be included in the various -# overviews. This option has no effect if EXTRACT_ALL is enabled. - -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 (the default) these declarations will be included in the -# documentation. - -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 (the default) these blocks will be appended to the -# function's detailed documentation block. - -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 (the default) then the documentation will be excluded. -# Set it to YES to include the internal documentation. - -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. - -CASE_SENSE_NAMES = YES - -# If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen -# will show members with their full class and namespace scopes in the -# documentation. If set to YES the scope will be hidden. - -HIDE_SCOPE_NAMES = NO - -# If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen -# will put a list of the files that are included by a file in the documentation -# of that file. - -SHOW_INCLUDE_FILES = YES - -# If the INLINE_INFO tag is set to YES (the default) then a tag [inline] -# is inserted in the documentation for inline members. - -INLINE_INFO = YES - -# If the SORT_MEMBER_DOCS tag is set to YES (the default) 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. - -SORT_MEMBER_DOCS = YES - -# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the -# brief documentation of file, namespace and class members alphabetically -# by member name. If set to NO (the default) the members will appear in -# declaration order. - -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 default) the constructors will appear in the respective orders defined by SORT_MEMBER_DOCS and SORT_BRIEF_DOCS. This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO and ignored for detailed docs if SORT_MEMBER_DOCS is set to 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 default) -# the group names will appear in their defined order. - -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 default), 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. - -SORT_BY_SCOPE_NAME = 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. - -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. - -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. - -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. - -GENERATE_DEPRECATEDLIST= YES - -# The ENABLED_SECTIONS tag can be used to enable conditional -# documentation sections, marked by \if sectionname ... \endif. - -ENABLED_SECTIONS = - -# The MAX_INITIALIZER_LINES tag determines the maximum number of lines -# the initial value of a variable or define consists of 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 initializer of individual variables and defines in the -# documentation can be controlled using \showinitializer or \hideinitializer -# command in the documentation regardless of this setting. - -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. - -SHOW_USED_FILES = YES - -# If the sources in your project are distributed over multiple directories -# then setting the SHOW_DIRECTORIES tag to YES will show the directory hierarchy -# in the documentation. The default is NO. - -SHOW_DIRECTORIES = NO - -# 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 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 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 , where is the value of -# the FILE_VERSION_FILTER tag, and is the name of an input file -# provided by doxygen. Whatever the program writes to standard output -# is used as the file version. See the manual for examples. - -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. The 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. - -LAYOUT_FILE = - -#--------------------------------------------------------------------------- -# configuration options related to warning and progress messages -#--------------------------------------------------------------------------- - -# The QUIET tag can be used to turn on/off the messages that are generated -# by doxygen. Possible values are YES and NO. If left blank NO is used. - -QUIET = NO - -# The WARNINGS tag can be used to turn on/off the warning messages that are -# generated by doxygen. Possible values are YES and NO. If left blank -# NO is used. - -WARNINGS = YES - -# If WARN_IF_UNDOCUMENTED 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. - -WARN_IF_UNDOCUMENTED = YES - -# If WARN_IF_DOC_ERROR 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. - -WARN_IF_DOC_ERROR = YES - -# This WARN_NO_PARAMDOC option can be abled to get warnings for -# functions that are documented, but have no documentation for their parameters -# or return value. If set to NO (the default) doxygen will only warn about -# wrong or incomplete parameter documentation, but not about the absence of -# documentation. - -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) - -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 stderr. - -WARN_LOGFILE = - -#--------------------------------------------------------------------------- -# configuration options related to the input files -#--------------------------------------------------------------------------- - -# The INPUT tag can be 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. - -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, which is -# also the default input encoding. 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. - -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 pattern (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 *.h *.hh *.hxx -# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py *.f90 - -FILE_PATTERNS = - -# The RECURSIVE tag can be used to turn specify whether or not subdirectories -# should be searched for input files as well. Possible values are YES and NO. -# If left blank NO is used. - -RECURSIVE = YES - -# The EXCLUDE tag can be used to specify files and/or directories that should -# 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. - -EXCLUDE = - -# The EXCLUDE_SYMLINKS tag can be used select whether or not files or -# directories that are symbolic links (a Unix filesystem feature) are excluded -# from the input. - -EXCLUDE_SYMLINKS = NO - -# If the value of the INPUT tag contains directories, you can use the -# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude -# certain files from those directories. Note that the wildcards are matched -# against the file with absolute path, so to exclude all test directories -# for example use the pattern */test/* - -EXCLUDE_PATTERNS = - -# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names -# (namespaces, classes, functions, etc.) that should be excluded from the -# output. The symbol name can be a fully qualified name, a word, or if the -# wildcard * is used, a substring. Examples: ANamespace, AClass, -# AClass::ANamespace, ANamespace::*Test - -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. -# Possible values are YES and NO. If left blank NO is used. - -EXAMPLE_RECURSIVE = NO - -# The IMAGE_PATH tag can be used to specify one or more files or -# directories that contain image that are 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. - -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 -# info on how filters are used. If FILTER_PATTERNS is empty, INPUT_FILTER -# is applied to all files. - -FILTER_PATTERNS = - -# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using -# INPUT_FILTER) will be used to filter the input files when producing source -# files to browse (i.e. when SOURCE_BROWSER is set to YES). - -FILTER_SOURCE_FILES = NO - -#--------------------------------------------------------------------------- -# 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 also -# VERBATIM_HEADERS is set to NO. - -SOURCE_BROWSER = NO - -# Setting the INLINE_SOURCES tag to YES will include the body -# of functions and classes directly in the documentation. - -INLINE_SOURCES = NO - -# Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct -# doxygen to hide any special comment blocks from generated source code -# fragments. Normal C and C++ comments will always remain visible. - -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. - -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. - -REFERENCES_RELATION = NO - -# If the REFERENCES_LINK_SOURCE tag is set to YES (the default) -# 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. - -REFERENCES_LINK_SOURCE = 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. - -USE_HTAGS = NO - -# If the VERBATIM_HEADERS tag is set to YES (the default) 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. - -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. - -ALPHABETICAL_INDEX = NO - -# If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then -# the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns -# in which this list will be split (can be a number in the range [1..20]) - -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 one or more prefixes that -# should be ignored while generating the index headers. - -IGNORE_PREFIX = - -#--------------------------------------------------------------------------- -# configuration options related to the HTML output -#--------------------------------------------------------------------------- - -# If the GENERATE_HTML tag is set to YES (the default) Doxygen will -# generate HTML output. - -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. If left blank `html' will be used as the default path. - -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). If it is left blank -# doxygen will generate files with .html extension. - -HTML_FILE_EXTENSION = .html - -# The HTML_HEADER tag can be used to specify a personal HTML header for -# each generated HTML page. If it is left blank doxygen will generate a -# standard header. - -HTML_HEADER = - -# The HTML_FOOTER tag can be used to specify a personal HTML footer for -# each generated HTML page. If it is left blank doxygen will generate a -# standard footer. - -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 the tag is left blank doxygen -# will generate a default style sheet. Note that doxygen will try to copy -# the style sheet file to the HTML output directory, so don't put your own -# stylesheet in the HTML output directory as well, or it will be erased! - -HTML_STYLESHEET = - -# If the HTML_ALIGN_MEMBERS tag is set to YES, the members of classes, -# files or namespaces will be aligned in HTML using tables. If set to -# NO a bullet list will be used. - -HTML_ALIGN_MEMBERS = YES - -# 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. For this to work a browser that supports -# JavaScript and DHTML is required (for instance Mozilla 1.0+, Firefox -# Netscape 6.0+, Internet explorer 5.0+, Konqueror, or Safari). - -HTML_DYNAMIC_SECTIONS = NO - -# 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, 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. - -GENERATE_DOCSET = NO - -# When GENERATE_DOCSET tag is set to YES, this tag determines the name of the -# 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. - -DOCSET_FEEDNAME = "Doxygen generated docs" - -# When GENERATE_DOCSET tag is set to YES, 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. - -DOCSET_BUNDLE_ID = org.doxygen.Project - -# If the GENERATE_HTMLHELP tag is set to YES, additional index files -# will be generated that can be used as input for tools like the -# Microsoft HTML help workshop to generate a compiled HTML help file (.chm) -# of the generated HTML documentation. - -GENERATE_HTMLHELP = NO - -# If the GENERATE_HTMLHELP tag is set to YES, 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. - -CHM_FILE = - -# If the GENERATE_HTMLHELP tag is set to YES, 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. - -HHC_LOCATION = - -# If the GENERATE_HTMLHELP tag is set to YES, 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). - -GENERATE_CHI = NO - -# If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING -# is used to encode HtmlHelp index (hhk), content (hhc) and project file -# content. - -CHM_INDEX_ENCODING = - -# If the GENERATE_HTMLHELP tag is set to YES, 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. - -BINARY_TOC = NO - -# The TOC_EXPAND flag can be set to YES to add extra items for group members -# to the contents of the HTML help documentation and to the tree view. - -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. - -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. - -QCH_FILE = - -# The QHP_NAMESPACE tag specifies the namespace to use when generating -# Qt Help Project output. For more information please see -# http://doc.trolltech.com/qthelpproject.html#namespace - -QHP_NAMESPACE = - -# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating -# Qt Help Project output. For more information please see -# http://doc.trolltech.com/qthelpproject.html#virtual-folders - -QHP_VIRTUAL_FOLDER = doc - -# If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to add. -# For more information please see -# http://doc.trolltech.com/qthelpproject.html#custom-filters - -QHP_CUST_FILTER_NAME = - -# The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the custom filter to add.For more information please see -# Qt Help Project / Custom Filters. - -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. - -QHP_SECT_FILTER_ATTRS = - -# If the GENERATE_QHP tag is set to YES, 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. - -QHG_LOCATION = - -# The DISABLE_INDEX tag can be used to turn on/off the condensed index at -# top of each HTML page. The value NO (the default) enables the index and -# the value YES disables it. - -DISABLE_INDEX = NO - -# This tag can be used to set the number of enum values (range [1..20]) -# that doxygen will group on one line in the generated HTML documentation. - -ENUM_VALUES_PER_LINE = 4 - -# 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. - -GENERATE_TREEVIEW = NO - -# By enabling USE_INLINE_TREES, doxygen will generate the Groups, Directories, -# and Class Hierarchy pages using a tree view instead of an ordered list. - -USE_INLINE_TREES = NO - -# 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. - -TREEVIEW_WIDTH = 250 - -# Use this tag to change the font size of Latex formulas included -# as images in the HTML documentation. The default is 10. Note that -# 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. - -FORMULA_FONTSIZE = 10 - -# When the SEARCHENGINE tag is enable 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) or Qt help (GENERATE_QHP) -# there is already a search function so this one should typically -# be disabled. - -SEARCHENGINE = YES - -#--------------------------------------------------------------------------- -# configuration options related to the LaTeX output -#--------------------------------------------------------------------------- - -# If the GENERATE_LATEX tag is set to YES (the default) Doxygen will -# generate Latex output. - -GENERATE_LATEX = YES - -# The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `latex' will be used as the default path. - -LATEX_OUTPUT = latex - -# The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be -# invoked. If left blank `latex' will be used as the default command name. - -LATEX_CMD_NAME = latex - -# The MAKEINDEX_CMD_NAME tag can be used to specify the command name to -# generate index for LaTeX. If left blank `makeindex' will be used as the -# default command name. - -MAKEINDEX_CMD_NAME = makeindex - -# If the COMPACT_LATEX tag is set to YES Doxygen generates more compact -# LaTeX documents. This may be useful for small projects and may help to -# save some trees in general. - -COMPACT_LATEX = NO - -# The PAPER_TYPE tag can be used to set the paper type that is used -# by the printer. Possible values are: a4, a4wide, letter, legal and -# executive. If left blank a4wide will be used. - -PAPER_TYPE = a4wide - -# The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX -# packages that should be included in the LaTeX output. - -EXTRA_PACKAGES = - -# The LATEX_HEADER tag can be used to specify a personal LaTeX header for -# the generated latex document. The header should contain everything until -# the first chapter. If it is left blank doxygen will generate a -# standard header. Notice: only use this tag if you know what you are doing! - -LATEX_HEADER = - -# If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated -# is prepared for conversion to pdf (using ps2pdf). The pdf file will -# contain links (just like the HTML output) instead of page references -# This makes the output suitable for online browsing using a pdf viewer. - -PDF_HYPERLINKS = YES - -# If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of -# plain latex in the generated Makefile. Set this option to YES to get a -# higher quality PDF documentation. - -USE_PDFLATEX = YES - -# If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode. -# command to the generated LaTeX files. This will instruct LaTeX to keep -# running if errors occur, instead of asking the user for help. -# This option is also used when generating formulas in HTML. - -LATEX_BATCHMODE = NO - -# If LATEX_HIDE_INDICES is set to YES then doxygen will not -# include the index chapters (such as File Index, Compound Index, etc.) -# in the output. - -LATEX_HIDE_INDICES = NO - -# If LATEX_SOURCE_CODE is set to YES then doxygen will include source code with syntax highlighting in the LaTeX output. Note that which sources are shown also depends on other settings such as SOURCE_BROWSER. - -LATEX_SOURCE_CODE = NO - -#--------------------------------------------------------------------------- -# configuration options related to the RTF output -#--------------------------------------------------------------------------- - -# If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output -# The RTF output is optimized for Word 97 and may not look very pretty with -# other RTF readers or editors. - -GENERATE_RTF = NO - -# The RTF_OUTPUT tag is used to specify where the RTF docs will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `rtf' will be used as the default path. - -RTF_OUTPUT = rtf - -# If the COMPACT_RTF tag is set to YES Doxygen generates more compact -# RTF documents. This may be useful for small projects and may help to -# save some trees in general. - -COMPACT_RTF = NO - -# If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated -# will contain hyperlink fields. The RTF file will -# contain links (just like the HTML output) instead of page references. -# This makes the output suitable for online browsing using WORD or other -# programs which support those fields. -# Note: wordpad (write) and others do not support links. - -RTF_HYPERLINKS = NO - -# Load stylesheet definitions from file. Syntax is similar to doxygen's -# config file, i.e. a series of assignments. You only have to provide -# replacements, missing definitions are set to their default value. - -RTF_STYLESHEET_FILE = - -# Set optional variables used in the generation of an rtf document. -# Syntax is similar to doxygen's config file. - -RTF_EXTENSIONS_FILE = - -#--------------------------------------------------------------------------- -# configuration options related to the man page output -#--------------------------------------------------------------------------- - -# If the GENERATE_MAN tag is set to YES (the default) Doxygen will -# generate man pages - -GENERATE_MAN = NO - -# The MAN_OUTPUT tag is used to specify where the man pages will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `man' will be used as the default path. - -MAN_OUTPUT = man - -# The MAN_EXTENSION tag determines the extension that is added to -# the generated man pages (default is the subroutine's section .3) - -MAN_EXTENSION = .3 - -# If the MAN_LINKS tag is set to YES and Doxygen generates man output, -# then it will generate one additional man file for each entity -# documented in the real man page(s). These additional files -# only source the real man page, but without them the man command -# would be unable to find the correct page. The default is NO. - -MAN_LINKS = NO - -#--------------------------------------------------------------------------- -# configuration options related to the XML output -#--------------------------------------------------------------------------- - -# If the GENERATE_XML tag is set to YES Doxygen will -# generate an XML file that captures the structure of -# the code including all documentation. - -GENERATE_XML = NO - -# The XML_OUTPUT tag is used to specify where the XML pages will be put. -# If a relative path is entered the value of OUTPUT_DIRECTORY will be -# put in front of it. If left blank `xml' will be used as the default path. - -XML_OUTPUT = xml - -# The XML_SCHEMA tag can be used to specify an XML schema, -# which can be used by a validating XML parser to check the -# syntax of the XML files. - -XML_SCHEMA = - -# The XML_DTD tag can be used to specify an XML DTD, -# which can be used by a validating XML parser to check the -# syntax of the XML files. - -XML_DTD = - -# If the XML_PROGRAMLISTING tag is set to YES Doxygen will -# dump the program listings (including syntax highlighting -# and cross-referencing information) to the XML output. Note that -# enabling this will significantly increase the size of the XML output. - -XML_PROGRAMLISTING = YES - -#--------------------------------------------------------------------------- -# configuration options for the AutoGen Definitions output -#--------------------------------------------------------------------------- - -# If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will -# generate an AutoGen Definitions (see autogen.sf.net) file -# that captures the structure of the code including all -# documentation. Note that this feature is still experimental -# and incomplete at the moment. - -GENERATE_AUTOGEN_DEF = NO - -#--------------------------------------------------------------------------- -# configuration options related to the Perl module output -#--------------------------------------------------------------------------- - -# If the GENERATE_PERLMOD tag is set to YES Doxygen will -# generate a Perl module file that captures the structure of -# the code including all documentation. Note that this -# feature is still experimental and incomplete at the -# moment. - -GENERATE_PERLMOD = NO - -# If the PERLMOD_LATEX tag is set to YES Doxygen will generate -# the necessary Makefile rules, Perl scripts and LaTeX code to be able -# to generate PDF and DVI output from the Perl module output. - -PERLMOD_LATEX = NO - -# If the PERLMOD_PRETTY tag is set to YES the Perl module output will be -# nicely formatted so it can be parsed by a human reader. -# This is useful -# if you want to understand what is going on. -# On the other hand, if this -# tag is set to NO the size of the Perl module output will be much smaller -# and Perl will parse it just the same. - -PERLMOD_PRETTY = YES - -# The names of the make variables in the generated doxyrules.make file -# are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX. -# This is useful so different doxyrules.make files included by the same -# Makefile don't overwrite each other's variables. - -PERLMOD_MAKEVAR_PREFIX = - -#--------------------------------------------------------------------------- -# Configuration options related to the preprocessor -#--------------------------------------------------------------------------- - -# If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will -# evaluate all C-preprocessor directives found in the sources and include -# files. - -ENABLE_PREPROCESSING = YES - -# If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro -# names in the source code. If set to NO (the default) only conditional -# compilation will be performed. Macro expansion can be done in a controlled -# way by setting EXPAND_ONLY_PREDEF to YES. - -MACRO_EXPANSION = NO - -# If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES -# then the macro expansion is limited to the macros specified with the -# PREDEFINED and EXPAND_AS_DEFINED tags. - -EXPAND_ONLY_PREDEF = NO - -# If the SEARCH_INCLUDES tag is set to YES (the default) the includes files -# in the INCLUDE_PATH (see below) will be search if a #include is found. - -SEARCH_INCLUDES = YES - -# The INCLUDE_PATH tag can be used to specify one or more directories that -# contain include files that are not input files but should be processed by -# the preprocessor. - -INCLUDE_PATH = - -# You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard -# patterns (like *.h and *.hpp) to filter out the header-files in the -# directories. If left blank, the patterns specified with FILE_PATTERNS will -# be used. - -INCLUDE_FILE_PATTERNS = - -# The PREDEFINED tag can be used to specify one or more macro names that -# are defined before the preprocessor is started (similar to the -D option of -# gcc). The argument of the tag is a list of macros of the form: name -# or name=definition (no spaces). If the definition and the = are -# omitted =1 is assumed. To prevent a macro definition from being -# undefined via #undef or recursively expanded use the := operator -# instead of the = operator. - -PREDEFINED = - -# If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then -# this tag can be used to specify a list of macro names that should be expanded. -# The macro definition that is found in the sources will be used. -# Use the PREDEFINED tag if you want to use a different macro definition. - -EXPAND_AS_DEFINED = - -# If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then -# doxygen's preprocessor will remove all function-like macros that are alone -# on a line, have an all uppercase name, and do not end with a semicolon. Such -# function macros are typically used for boiler-plate code, and will confuse -# the parser if not removed. - -SKIP_FUNCTION_MACROS = YES - -#--------------------------------------------------------------------------- -# Configuration::additions related to external references -#--------------------------------------------------------------------------- - -# The TAGFILES option can be used to specify one or more tagfiles. -# Optionally an initial location of the external documentation -# can be added for each tagfile. The format of a tag file without -# this location is as follows: -# -# TAGFILES = file1 file2 ... -# Adding location for the tag files is done as follows: -# -# TAGFILES = file1=loc1 "file2 = loc2" ... -# where "loc1" and "loc2" can be relative or absolute paths or -# URLs. If a location is present for each tag, the installdox tool -# does not have to be run to correct the links. -# Note that each tag file must have a unique name -# (where the name does NOT include the path) -# If a tag file is not located in the directory in which doxygen -# is run, you must also specify the path to the tagfile here. - -TAGFILES = - -# When a file name is specified after GENERATE_TAGFILE, doxygen will create -# a tag file that is based on the input files it reads. - -GENERATE_TAGFILE = - -# If the ALLEXTERNALS tag is set to YES all external classes will be listed -# in the class index. If set to NO only the inherited external classes -# will be listed. - -ALLEXTERNALS = NO - -# If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed -# in the modules index. If set to NO, only the current project's groups will -# be listed. - -EXTERNAL_GROUPS = YES - -# The PERL_PATH should be the absolute path and name of the perl script -# interpreter (i.e. the result of `which perl'). - -PERL_PATH = /usr/bin/perl - -#--------------------------------------------------------------------------- -# Configuration options related to the dot tool -#--------------------------------------------------------------------------- - -# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will -# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base -# or super classes. Setting the tag to NO turns the diagrams off. Note that -# this option is superseded by the HAVE_DOT option below. This is only a -# fallback. It is recommended to install and use dot, since it yields more -# powerful graphs. - -CLASS_DIAGRAMS = YES - -# You can define message sequence charts within doxygen comments using the \msc -# command. Doxygen will then run the mscgen tool (see -# http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the -# documentation. The MSCGEN_PATH tag allows you to specify the directory where -# the mscgen tool resides. If left empty the tool is assumed to be found in the -# default search path. - -MSCGEN_PATH = - -# If set to YES, the inheritance and collaboration graphs will hide -# inheritance and usage relations if the target is undocumented -# or is not a class. - -HIDE_UNDOC_RELATIONS = YES - -# If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is -# available from the path. This tool is part of Graphviz, a graph visualization -# toolkit from AT&T and Lucent Bell Labs. The other options in this section -# have no effect if this option is set to NO (the default) - -HAVE_DOT = NO - -# By default doxygen will write a font called FreeSans.ttf to the output -# directory and reference it in all dot files that doxygen generates. This -# font does not include all possible unicode characters however, so when you need -# these (or just want a differently looking font) you can specify the font name -# using DOT_FONTNAME. You need need to make sure dot is able to find the font, -# which can be done by putting it in a standard location or by setting the -# DOTFONTPATH environment variable or by setting DOT_FONTPATH to the directory -# containing the font. - -DOT_FONTNAME = FreeSans - -# The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs. -# The default size is 10pt. - -DOT_FONTSIZE = 10 - -# By default doxygen will tell dot to use the output directory to look for the -# FreeSans.ttf font (which doxygen will put there itself). If you specify a -# different font using DOT_FONTNAME you can set the path where dot -# can find it using this tag. - -DOT_FONTPATH = - -# If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for each documented class showing the direct and -# indirect inheritance relations. Setting this tag to YES will force the -# the CLASS_DIAGRAMS tag to NO. - -CLASS_GRAPH = YES - -# If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for each documented class showing the direct and -# indirect implementation dependencies (inheritance, containment, and -# class references variables) of the class with other documented classes. - -COLLABORATION_GRAPH = YES - -# If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen -# will generate a graph for groups, showing the direct groups dependencies - -GROUP_GRAPHS = YES - -# If the UML_LOOK tag is set to YES doxygen will generate inheritance and -# collaboration diagrams in a style similar to the OMG's Unified Modeling -# Language. - -UML_LOOK = NO - -# If set to YES, the inheritance and collaboration graphs will show the -# relations between templates and their instances. - -TEMPLATE_RELATIONS = NO - -# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT -# tags are set to YES then doxygen will generate a graph for each documented -# file showing the direct and indirect include dependencies of the file with -# other documented files. - -INCLUDE_GRAPH = YES - -# If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and -# HAVE_DOT tags are set to YES then doxygen will generate a graph for each -# documented header file showing the documented files that directly or -# indirectly include this file. - -INCLUDED_BY_GRAPH = YES - -# If the CALL_GRAPH and HAVE_DOT options are set to YES then -# doxygen will generate a call dependency graph for every global function -# or class method. Note that enabling this option will significantly increase -# the time of a run. So in most cases it will be better to enable call graphs -# for selected functions only using the \callgraph command. - -CALL_GRAPH = NO - -# If the CALLER_GRAPH and HAVE_DOT tags are set to YES then -# doxygen will generate a caller dependency graph for every global function -# or class method. Note that enabling this option will significantly increase -# the time of a run. So in most cases it will be better to enable caller -# graphs for selected functions only using the \callergraph command. - -CALLER_GRAPH = NO - -# If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen -# will graphical hierarchy of all classes instead of a textual one. - -GRAPHICAL_HIERARCHY = YES - -# If the DIRECTORY_GRAPH, SHOW_DIRECTORIES and HAVE_DOT tags are set to YES -# then doxygen will show the dependencies a directory has on other directories -# in a graphical way. The dependency relations are determined by the #include -# relations between the files in the directories. - -DIRECTORY_GRAPH = YES - -# The DOT_IMAGE_FORMAT tag can be used to set the image format of the images -# generated by dot. Possible values are png, jpg, or gif -# If left blank png will be used. - -DOT_IMAGE_FORMAT = png - -# The tag DOT_PATH can be used to specify the path where the dot tool can be -# found. If left blank, it is assumed the dot tool can be found in the path. - -DOT_PATH = - -# The DOTFILE_DIRS tag can be used to specify one or more directories that -# contain dot files that are included in the documentation (see the -# \dotfile command). - -DOTFILE_DIRS = - -# The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of -# nodes that will be shown in the graph. If the number of nodes in a graph -# becomes larger than this value, doxygen will truncate the graph, which is -# visualized by representing a node as a red box. Note that doxygen if the -# number of direct children of the root node in a graph is already larger than -# DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note -# that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH. - -DOT_GRAPH_MAX_NODES = 50 - -# The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the -# graphs generated by dot. A depth value of 3 means that only nodes reachable -# from the root by following a path via at most 3 edges will be shown. Nodes -# that lay further from the root node will be omitted. Note that setting this -# option to 1 or 2 may greatly reduce the computation time needed for large -# code bases. Also note that the size of a graph can be further restricted by -# DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction. - -MAX_DOT_GRAPH_DEPTH = 0 - -# Set the DOT_TRANSPARENT tag to YES to generate images with a transparent -# background. This is disabled by default, because dot on Windows does not -# seem to support this out of the box. Warning: Depending on the platform used, -# enabling this option may lead to badly anti-aliased labels on the edges of -# a graph (i.e. they become hard to read). - -DOT_TRANSPARENT = NO - -# Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output -# files in one run (i.e. multiple -o and -T options on the command line). This -# makes dot run faster, but since only newer versions of dot (>1.8.10) -# support this, this feature is disabled by default. - -DOT_MULTI_TARGETS = YES - -# If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will -# generate a legend page explaining the meaning of the various boxes and -# arrows in the dot generated graphs. - -GENERATE_LEGEND = YES - -# If the DOT_CLEANUP tag is set to YES (the default) Doxygen will -# remove the intermediate dot files that are used to generate -# the various graphs. - -DOT_CLEANUP = YES diff --git a/src/TNL/File.h b/src/TNL/File.h index 7a8a024dbf086f556ed28bbf0df8e1d09bbbcb5e..afa5631f642b6c0774bf6bf639f1ec8ade3aafc0 100644 --- a/src/TNL/File.h +++ b/src/TNL/File.h @@ -36,9 +36,13 @@ enum class IOMode */ const size_t FileGPUvsCPUTransferBufferSize = 5 * 2<<20; -/* - * This file is aimed mainly for the binary data. It supports transparent compression. - */ + +///\brief Class file is aimed mainly for saving and loading binary data. +/// +/// \par Example +/// \include FileExample.cpp +// \par Output +// \include FileExample.out class File { IOMode mode; @@ -55,43 +59,77 @@ class File public: + /// \brief Basic constructor. File(); + /// \brief Destructor. ~File(); + ///// + /// \brief Attempts to open given file and returns \e true after the file is + /// successfully opened. Otherwise returns \e false. + /// + /// Opens file with given \e fileName and returns true/false based on the success in opening the file. + /// \param fileName String which indicates name of the file user wants to open. + /// \param mode Indicates what user needs to do with opened file. + /// Modes to choose: IOMode::read, IOMode::write or IOMode::undefined. bool open( const String& fileName, const IOMode mode ); - + /// \brief Returns name of given file. const String& getFileName() const { return this->fileName; } + /// \brief Returns number of read elements. long int getReadElements() const { return this->readElements; } + /// \brief Returns number of written elements. long int getWrittenElements() const { return this->writtenElements; } + /// \brief Method that can write particular data type from given file into GPU. (Function that gets particular elements from given file.) + /// + /// Returns \e true when the elements are successfully read from given file. Otherwise returns \e false. + /// + /// \tparam Type Type of data. + /// \tparam Device Place where data are stored after reading from file. For example Devices::Host or Devices::Cuda. + /// \tparam Index Type of index by which the elements are indexed. + /// \param buffer Pointer in memory where the elements are loaded and stored after reading. + /// \param elements Number of elements the user wants to get (read) from given file. template< typename Type, typename Device = Devices::Host, typename Index = int > bool read( Type* buffer, const Index& elements ); + // Toto je treba?? template< typename Type, typename Device = Devices::Host > bool read( Type* buffer ); + /// \brief Method that can write particular data type from CPU into given file. (Function that writes particular elements into given file.) + /// + /// Returns \e true when the elements are successfully written into given file. Otherwise returns \e false. + /// + /// \tparam Type Type of data. + /// \tparam Device Place from where the data are loaded before writing into file. For example Devices::Host or Devices::Cuda. + /// \tparam Index Type of index by which the elements are indexed. + /// \param buffer Pointer in memory where the elements are loaded from before writing into file. + /// \param elements Number of elements the user wants to write into the given file. template< typename Type, typename Device = Devices::Host, typename Index = int > bool write( const Type* buffer, const Index elements ); + // Toto je treba? template< typename Type, typename Device = Devices::Host > bool write( const Type* buffer ); + /// \brief Attempts to close given file and returns \e true when the file is + /// successfully closed. Otherwise returns \e false. bool close(); protected: @@ -138,6 +176,10 @@ protected: const std::size_t& elements ); }; +/// Returns true if the file exists and false otherwise. +/// +/// Finds out if the file \e fileName exists. +/// \param fileName Name of the file that user wants to find in the PC. bool fileExists( const String& fileName ); } // namespace TNL diff --git a/src/TNL/FileName.h b/src/TNL/FileName.h index ddf7c78d3a9f06a6ead37ab554c25c15418dc94e..3dae01c5407153357d91a45e74b73382cc3559e0 100644 --- a/src/TNL/FileName.h +++ b/src/TNL/FileName.h @@ -18,10 +18,16 @@ String getFileExtension( const String fileName ); void removeFileExtension( String& file_name ); +/// \brief Class for creating the full name of a file. +/// +/// Merges base name, index number and extention to create the full name of a file. class FileName { public: - + + /// \brief Basic constructor. + /// + /// Constructs an empty filename object. FileName(); FileName( const String& fileNameBase ); @@ -29,12 +35,29 @@ class FileName FileName( const String& fileNameBase, const String& extension ); + /// \brief Sets the base name of given file. + /// + /// Sets \e fileNameBase as the base name of given file. + /// @param fileNameBase String that specifies new name of file. void setFileNameBase( const String& fileNameBase ); - + + /// \brief Sets the extension of given file. + /// + /// Sets \e extension as suffix of a file name. + /// @param extension A String that specifies extension of file (without dot). + /// Suffix of a file name. E.g. doc, xls, tnl. void setExtension( const String& extension ); - + + /// \brief Sets index for given file. + /// + /// Sets \e index after the base name of given file. + /// @param index Integer - number of maximum 5(default) digits. + /// (Number of digits can be changed with \c setDigitsCount). void setIndex( const int index ); - + + /// \brief Sets number of digits for index of given file. + /// + /// @param digitsCount Integer - number of digits. void setDigitsCount( const int digitsCount ); void setDistributedSystemNodeId( int nodeId ); @@ -42,6 +65,10 @@ class FileName template< typename Coordinates > void setDistributedSystemNodeId( const Coordinates& nodeId ); + /// \brief Creates appropriate name for given file. + /// + /// Creates particular file name using \e fileNameBase, \e digitsCount, + /// \e index and \e extension. String getFileName(); protected: diff --git a/src/TNL/Logger.h b/src/TNL/Logger.h index 5b7fda238a90468ad4aedd984eb55b40d3dd7077..7a6472bfae4e80e180b3ceabb03e9168a91543cd 100644 --- a/src/TNL/Logger.h +++ b/src/TNL/Logger.h @@ -15,38 +15,73 @@ namespace TNL { +/// Creates calculations log in the form of a table. class Logger { public: + ///// + /// \brief Basic constructor. + /// + /// \param _width Integer that defines the width of the log. + /// \param _stream Defines output stream where the log will be printed out. Logger( int _width, std::ostream& _stream ); + ///// + /// \brief Creates header in given log. + /// + /// The header usually contains title of the program. + /// + /// \param title A String containing the header title. void writeHeader( const String& title ); + /// \brief Creates separator used as a log structure. void writeSeparator(); + /// \brief Inserts information about various system parameters into the log. + /// + /// \param parameters A container with configuration parameters. bool writeSystemInformation( const Config::ParameterContainer& parameters ); - + ///// + /// \brief Inserts a line with current time into the log. + /// + /// \param label Label to be printed to the log together with the current time. void writeCurrentTime( const char* label ); + /// \brief Inserts parameter information into the log. + /// + /// \tparam ParameterType Type of the parameter. + /// \param label Description/label of the line. + /// \param parameterName Name of the parameter. + /// \param parameters A container with configuration parameters. + /// \param parameterLevel Integer defining the indent used in the log. + // TODO: add units - template< typename T > + template< typename ParameterType > void writeParameter( const String& label, const String& parameterName, const Config::ParameterContainer& parameters, int parameterLevel = 0 ); - template< typename T > + /// \brief Inserts parameter information into the log. + /// + /// \tparam ParameterType Type of the parameter. + /// \param label Description/label of the line. + /// \param value Parameter value. + /// \param parameterLevel Integer defining the indent used in the log. + template< typename ParameterType > void writeParameter( const String& label, - const T& value, + const ParameterType& value, int parameterLevel = 0 ); protected: + /// \brief Integer defining the width of the log. int width; + /// \brief Output stream where the log will be printed out. std::ostream& stream; }; diff --git a/src/TNL/Logger_impl.h b/src/TNL/Logger_impl.h index e502332662a02312e97d80778603333243c2432b..08181070f48b33ca691c93f1ae0b9b7b78a17d97 100644 --- a/src/TNL/Logger_impl.h +++ b/src/TNL/Logger_impl.h @@ -15,7 +15,7 @@ namespace TNL { -template< typename T > +template< typename ParameterType > void Logger::writeParameter( const String& label, const String& parameterName, const Config::ParameterContainer& parameters, @@ -26,16 +26,16 @@ void Logger::writeParameter( const String& label, for( i = 0; i < parameterLevel; i ++ ) stream << " "; std::stringstream str; - str << parameters.getParameter< T >( parameterName ); + str << parameters.getParameter< ParameterType >( parameterName ); stream << label << std::setw( width - label.getLength() - parameterLevel - 3 ) << str.str() << " |" << std::endl; } -template< typename T > +template< typename ParameterType > void Logger :: writeParameter( const String& label, - const T& value, - int parameterLevel ) + const ParameterType& value, + int parameterLevel ) { stream << "| "; int i; diff --git a/src/TNL/Math.h b/src/TNL/Math.h index 67e9f5e082af0b238e1d045bc516bf578efe82a0..68eb1f556f246c2a3e0909e0f58ebd2ee57b17dd 100644 --- a/src/TNL/Math.h +++ b/src/TNL/Math.h @@ -18,8 +18,9 @@ namespace TNL { -/*** - * This function returns minimum of two numbers. +/** + * \brief This function returns minimum of two numbers. + * * GPU device code uses the functions defined in the CUDA's math_functions.h, * MIC uses trivial override and host uses the STL functions. */ @@ -42,8 +43,9 @@ ResultType min( const T1& a, const T2& b ) } -/*** - * This function returns maximum of two numbers. +/** + * \brief This function returns maximum of two numbers. + * * GPU device code uses the functions defined in the CUDA's math_functions.h, * MIC uses trivial override and host uses the STL functions. */ @@ -65,8 +67,8 @@ ResultType max( const T1& a, const T2& b ) #endif } -/*** - * This function returns absolute value of given number. +/** + * \brief This function returns absolute value of given number \e n. */ template< class T > __cuda_callable__ inline @@ -87,7 +89,7 @@ T abs( const T& n ) } /*** - * This function returns argument of minimum of two numbers. + * \brief This function returns argument of minimum of two numbers. */ template< typename T1, typename T2, typename ResultType = typename std::common_type< T1, T2 >::type > __cuda_callable__ inline @@ -97,7 +99,7 @@ ResultType argMin( const T1& a, const T2& b ) } /*** - * This function returns argument of maximum of two numbers. + * \brief This function returns argument of maximum of two numbers. */ template< typename T1, typename T2, typename ResultType = typename std::common_type< T1, T2 >::type > __cuda_callable__ @@ -107,7 +109,7 @@ ResultType argMax( const T1& a, const T2& b ) } /*** - * This function returns argument of minimum of absolute values of two numbers. + * \brief This function returns argument of minimum of absolute values of two numbers. */ template< typename T1, typename T2, typename ResultType = typename std::common_type< T1, T2 >::type > __cuda_callable__ inline @@ -117,7 +119,7 @@ ResultType argAbsMin( const T1& a, const T2& b ) } /*** - * This function returns argument of maximum of absolute values of two numbers. + * \brief This function returns argument of maximum of absolute values of two numbers. */ template< typename T1, typename T2, typename ResultType = typename std::common_type< T1, T2 >::type > __cuda_callable__ @@ -126,6 +128,9 @@ ResultType argAbsMax( const T1& a, const T2& b ) return ( TNL::abs( a ) > TNL::abs( b ) ) ? a : b; } +/** + * \brief This function returns the result of \e base to the power of \e exp. + */ template< typename T1, typename T2, typename ResultType = typename std::common_type< T1, T2 >::type > __cuda_callable__ inline ResultType pow( const T1& base, const T2& exp ) @@ -137,7 +142,9 @@ ResultType pow( const T1& base, const T2& exp ) #endif } - +/** + * \brief This function returns square root of the given \e value. + */ template< typename T > __cuda_callable__ inline T sqrt( const T& value ) @@ -149,7 +156,11 @@ T sqrt( const T& value ) #endif } - +/** + * \brief This function swaps values of two parameters. + * + * It assigns the value of \e a to the parameter \e b and vice versa. + */ template< typename Type > __cuda_callable__ void swap( Type& a, Type& b ) @@ -159,6 +170,13 @@ void swap( Type& a, Type& b ) b = tmp; } +/** + * \brief This function represents the signum function. + * + * It extracts the sign of the number \e a. In other words, the signum function projects + * negative numbers to value -1, positive numbers to value 1 and zero to value 0. + * Non-zero complex numbers are projected to the unit circle. + */ template< class T > __cuda_callable__ T sign( const T& a ) @@ -168,6 +186,14 @@ T sign( const T& a ) return ( T ) 1; } +/** + * \brief This function tests whether the given real number is small. + * + * It tests whether the number \e v is in \e tolerance, in other words, whether + * \e v in absolute value is less then or equal to \e tolerance. + * \param v Real number. + * \param tolerance Critical value which is set to 0.00001 by defalt. + */ template< typename Real > __cuda_callable__ bool isSmall( const Real& v, @@ -176,24 +202,48 @@ bool isSmall( const Real& v, return ( -tolerance <= v && v <= tolerance ); } +/** + * \brief This function divides \e num by \e div and rounds up the result. + * + * \param num An integer considered as dividend. + * \param div An integer considered as divisor. + */ __cuda_callable__ inline int roundUpDivision( const int num, const int div ) { return num / div + ( num % div != 0 ); } +/** + * \brief This function rounds up \e number to the nearest multiple of number \e multiple. + * + * \param number Integer we want to round. + * \param multiple Integer. + */ __cuda_callable__ inline int roundToMultiple( int number, int multiple ) { return multiple*( number/ multiple + ( number % multiple != 0 ) ); } +/** + * \brief This function checks if \e x is an integral power of two. + * + * Returns \e true if \e x is a power of two. Otherwise returns \e false. + * \param x Integer. + */ __cuda_callable__ inline bool isPow2( int x ) { return ( ( x & ( x - 1 ) ) == 0 ); } +/** + * \brief This function checks if \e x is an integral power of two. + * + * Returns \e true if \e x is a power of two. Otherwise returns \e false. + * \param x Long integer. + */ __cuda_callable__ inline bool isPow2( long int x ) { diff --git a/src/TNL/Object.h b/src/TNL/Object.h index 4b37d8a77ad36d2aa48a3af9fffbebf83a877af4..405bcd76d05ec1bafcfad6ed71bc04280f3d1659 100644 --- a/src/TNL/Object.h +++ b/src/TNL/Object.h @@ -17,8 +17,9 @@ namespace TNL { -//! This is basic class for all 'large' objects like matrices, meshes, grids, solvers etc. -/*! +/** + * \brief This is the basic class for all 'large' objects like matrices, meshes, grids, solvers, etc.. + * * Objects like numerical grids, meshes, matrices large vectors etc. * are inherited by this class. This class provides name for such objects. Giving * a name to each bigger object is compulsory. The name can help to locate @@ -32,17 +33,19 @@ class Object { public: - /**** - * Type getter. This returns the type in C++ style - for example the returned value + /** + * \brief Type getter. + * + * Returns the type in C++ style - for example the returned value * may look as follows: "Vector< double, Devices::Cuda >". */ - static String getType(); virtual String getTypeVirtual() const; - /**** - * This is used for load and save methods. + /** + * \brief This is used for load and save methods. + * * Each object is saved as if it was stored on Devices::Host. So even Vector< double, Devices::Cuda > * is saved as Vector< double, Devices::Host >. */ @@ -50,22 +53,49 @@ class Object virtual String getSerializationTypeVirtual() const; - //! Method for saving the object to a file as a binary data + /** + * \brief Method for saving the object to a file as a binary data. + * + * \param file Name of file object. + */ virtual bool save( File& file ) const; - //! Method for restoring the object from a file + /** + * \brief Method for restoring the object from a file. + * + * \param file Name of file object. + */ virtual bool load( File& file ); - //! Method for restoring the object from a file + /** + * \brief Method for restoring the object from a file. + * + * \param file Name of file object. + */ virtual bool boundLoad( File& file ); + /** + * \brief Method for saving the object to a file as a binary data. + * + * \param fileName String defining the name of a file. + */ bool save( const String& fileName ) const; + /** + * \brief Method for restoring the object from a file. + * + * \param fileName String defining the name of a file. + */ bool load( const String& fileName ); + /** + * \brief Method for restoring the object from a file. + * + * \param fileName String defining the name of a file. + */ bool boundLoad( const String& fileName ); - //! Destructor + /// Destructor. // FIXME: __cuda_callable__ would have to be added to every overriding destructor, // even if the object's constructor is not __cuda_callable__ // __cuda_callable__ diff --git a/src/TNL/String.cpp b/src/TNL/String.cpp index 292d90c0a5a60c5e15546ba207e3efd271c4a208..92663a4d8aed06405514f4a9e2ca69013832a92a 100644 --- a/src/TNL/String.cpp +++ b/src/TNL/String.cpp @@ -29,12 +29,6 @@ String::String() setString( nullptr ); } -String::String( const char* str ) - : string( nullptr ), length( 0 ) -{ - setString( str ); -} - String::String( const char* c, int prefix_cut_off, int sufix_cut_off ) : string( nullptr ), length( 0 ) { @@ -47,13 +41,6 @@ String::String( const String& str ) setString( str.getString() ); } -String::String( const bool b ) - : string( nullptr ), length( 0 ) -{ - if( b ) this->setString( "true" ); - else this->setString( "false" ); -} - String String::getType() { return String( "String" ); @@ -348,22 +335,24 @@ String::strip( char strip ) const return ""; } -int String::split( Containers::List< String >& list, const char separator ) const +int String::split( Containers::List< String >& list, + const char separator, + bool skipEmpty ) const { list.reset(); - String copy( *this ); - int len = copy.getLength(); - for( int i = 0; i < len; i ++ ) - if( copy[ i ] == separator ) - copy[ i ] = 0; - for( int i = 0; i < len; i ++ ) + String s; + for( int i = 0; i < this->getLength(); i ++ ) { - if( copy[ i ] == 0 ) continue; - String new_string; - new_string.setString( ©.getString()[ i ] ); - i += new_string.getLength(); - list.Append( new_string ); + if( ( *this )[ i ] == separator ) + { + if( ! skipEmpty || s != "" ) + list.Append( s ); + s = ""; + } + else s += ( *this )[ i ]; } + if( ! skipEmpty || s != "" ) + list.Append( s ); return list.getSize(); } diff --git a/src/TNL/String.h b/src/TNL/String.h index f5657a20ff089a5219d931083e3b7b1fd05bfab1..44f42423fe207955dab89e05eddf62344191ea19 100644 --- a/src/TNL/String.h +++ b/src/TNL/String.h @@ -25,146 +25,276 @@ class String; template< typename T > String convertToString( const T& value ); -//! Class for managing strings +///// +/// \brief Class for managing strings. +/// +/// \par Example +/// \include StringExample.cpp +/// \par Output +/// \include StringExample.out class String { - //! Pointer to char ended with zero - char* string; - - //! Length of the allocated piece of memory - int length; - -public: - //! Basic constructor - String(); - - //! Constructor from const char* - String( const char* str ); - - //! Constructor with char pointer - /*! @param prefix_cut_off says length of the prefix that is going to be omitted and - @param sufix_cut_off says the same about sufix. - */ - String( const char* c, - int prefix_cut_off, - int sufix_cut_off = 0 ); - - //! Copy constructor - String( const String& str ); - - ////// - /// Templated constructor - /// - /// It must be explicit otherwise it is called recursively from inside of its - /// definition ( in operator << ). It leads to stack overflow and segmentation fault. - template< typename T > - explicit - String( const T& value ) - : string( nullptr ), length( 0 ) - { - std::stringstream str; - str << value; - setString( str.str().data() ); - } - - String( const bool b ); - - //! Destructor - ~String(); - - static String getType(); - - //! Return length of the string - int getLength() const; - int getSize() const; - - //! Return currently allocated size - int getAllocatedSize() const; - - //! Reserve space for given number of characters - void setSize( int size ); - - //! Set string from given char pointer - /*! @param prefix_cut_off says length of the prefix that is going to be omitted and - @param sufix_cut_off says the same about sufix. - */ - void setString( const char* c, - int prefix_cut_off = 0, - int sufix_cut_off = 0 ); - - //! Return pointer to data - const char* getString() const; - - //! Return pointer to data - char* getString(); - - //! Operator for accesing particular chars of the string - const char& operator[]( int i ) const; - - //! Operator for accesing particular chars of the string - char& operator[]( int i ); - - /**** - * Operators for C strings - */ - String& operator=( const char* str ); - String& operator+=( const char* str ); - String operator+( const char* str ) const; - bool operator==( const char* str ) const; - bool operator!=( const char* str ) const; - - /**** - * Operators for Strings - */ - String& operator=( const String& str ); - String& operator+=( const String& str ); - String operator+( const String& str ) const; - bool operator==( const String& str ) const; - bool operator!=( const String& str ) const; - - /**** - * Operators for single characters - */ - String& operator=( char str ); - String& operator+=( char str ); - String operator+( char str ) const; - bool operator==( char str ) const; - bool operator!=( char str ) const; - - //! Cast to bool operator - operator bool() const; - - //! Cast to bool with negation operator - bool operator!() const; - - String replace( const String& pattern, - const String& replaceWith, - int count = 0 ) const; - - String strip( char strip = ' ' ) const; - - //! Split the string into list of strings w.r.t. given separator. - int split( Containers::List< String >& list, const char separator = ' ' ) const; - - //! Write to a binary file - bool save( File& file ) const; - - //! Read from binary file - bool load( File& file ); - - //! Broadcast to other nodes in MPI cluster -// void MPIBcast( int root, MPI_Comm mpi_comm = MPI_COMM_WORLD ); - - //! Read one line from given stream. - bool getLine( std::istream& stream ); - - friend std::ostream& operator<<( std::ostream& stream, const String& str ); -}; - + public: + + ///// + /// \brief Basic constructor. + /// + /// Constructs an empty string object. + String(); + + ///// + /// \brief Constructor with char pointer. + /// + /// Constructs a string initialized with the 8-bit string \e c, excluding + /// the given number of \e prefix_cut_off and \e sufix_cut_off characters. + /// + /// @param c Pointer to an array of characters. + /// @param prefix_cut_off Determines the length of the prefix that is going + /// to be omitted from the string \e c. + /// @param sufix_cut_off Determines the length of the sufix that is going + /// to be omitted from the string \e c. + String( const char* c, + int prefix_cut_off = 0, + int sufix_cut_off = 0 ); + + /// \brief Returns type of string - String. + static String getType(); + + ///// + /// \brief Copy constructor. + /// + /// Constructs a copy of the string \e str. + /// @param str Another string object, whose value is copied. + String( const String& str ); + + /// \brief Converts anything to a string. + /// + /// This function converts any type of value into type string. + /// @tparam T is a type of a value to be converted + /// @param value Word of any type (e.g. int, bool, double,...). + template< typename T > + explicit + String( T value ) + : string( nullptr ), length( 0 ) + { + setString( convertToString( value ).getString() ); + } + + /// \brief Destructor. + ~String(); + + /// \brief Returns the number of characters in given string. Equivalent to getSize(). + int getLength() const; + + /// \brief Returns the number of characters in given string. + /// + /// \par Example + /// \include StringExampleGetSize.cpp + /// \par Output + /// \include StringExampleGetSize.out + int getSize() const; + + /// \brief Returns size of allocated storage for given string. + /// + /// \par Example + /// \include StringExampleGetAllocatedSize.cpp + /// \par Output + /// \include StringExampleGetAllocatedSize.out + int getAllocatedSize() const; + + ///// + /// \brief Reserves space for given \e size. + /// + /// Requests to allocate storage space of given \e size to avoid memory reallocation. + /// It allocates one more byte for the terminating 0. + /// @param size Number of characters. + /// + /// \par Example + /// \include StringExampleSetSize.cpp + /// \par Output + /// \include StringExampleSetSize.out + void setSize( int size ); + + ///// + /// \brief Sets string from given char pointer \e c. + /// + /// @param prefix_cut_off determines the length of the prefix that is + /// going to be omitted from the string \e c + /// @param sufix_cut_off determines the length of the sufix that is going + /// to be omitted from the string \e c + void setString( const char* c, + int prefix_cut_off = 0, + int sufix_cut_off = 0 ); + + ///// + /// \brief Returns pointer to data. + /// + /// It returns the content of the given string as a constant pointer to char. + const char* getString() const; + + /// \brief Returns pointer to data. + /// + /// It returns the content of the given string as a non-constant pointer to char. + char* getString(); + + ///// + /// \brief Operator for accessing particular chars of the string. + /// + /// This function overloads operator[](). It returns a reference to + /// the character at position \e i in given string. + /// The character can not be changed be user. + const char& operator[]( int i ) const; + + /// \brief Operator for accessing particular chars of the string. + /// + /// It returns the character at the position \e i in given string as + /// a modifiable reference. + char& operator[]( int i ); + + ///// + // Operators for C strings. + + /// \brief This function overloads operator=(). + /// + /// It assigns C string \e str to this string, replacing its current contents. + String& operator=( const char* str ); + /// \brief This function overloads operator+=(). + /// + /// It appends the C string \e str to this string. + String& operator+=( const char* str ); + /// \brief This function concatenates C strings \e str and returns a newly + /// constructed string object. + String operator+( const char* str ) const; + /// \brief This function overloads operator==(). + bool operator==( const char* str ) const; + /// \brief This function overloads operator!=(). + bool operator!=( const char* str ) const; + + ///// + // Operators for Strings. + + /// \brief This function assigns \e str to this string and returns a reference to + /// this string. + String& operator=( const String& str ); + /// \brief This function appends the string \e str onto the end of this string + /// and returns a reference to this string. + String& operator+=( const String& str ); + /// \brief This function concatenates strings \e str and returns a newly + /// constructed string object. + String operator+( const String& str ) const; + /// \brief This function overloads operator==(). + /// + /// Returns \c true if this string is equal to \e str, otherwise returns + /// \c false. + bool operator==( const String& str ) const; + /// \brief This function overloads operator!=(). + /// + /// Returns \c true if this string is not equal to \e str, otherwise + /// returns \c false. + bool operator!=( const String& str ) const; + + ///// + // Operators for single characters. + + /// \brief This function overloads operator=(). + /// + /// Assigns character \e str to this string. + String& operator=( char str ); + /// \brief This function overloads operator+=(). + /// + /// Appends character \e str to this string. + String& operator+=( char str ); + /// \brief This function concatenates strings and returns a newly constructed string object. + String operator+( char str ) const; + /// \brief This function checks whether the given string is equal to \e str. + /// + /// It returns \e true when the given string is equal to \e str. Otherwise returns \e false. + bool operator==( char str ) const; + /// \brief This function overloads operator!=(). + bool operator!=( char str ) const; + + /// \brief Cast to bool operator. + /// + /// This function overloads operator bool(). It converts string to boolean + /// expression (true or false). + operator bool() const; + + /// \brief Cast to bool with negation operator. + /// + /// This function overloads operator!(). It converts string to boolean + /// expression (false or true). + bool operator!() const; + + ///// + /// \brief Replaces portion of string. + /// + /// Replaces section \e pattern from this string with new piece of string \e replaceWith. + /// If parameter \e count is defined, the function makes replacement several times, + /// every time when it finds the same pattern in this string. + /// @param pattern Section of given string that will be replaced. + /// @param replaceWith New piece of string that will be used to replace \e pattern. + /// @param count A whole number that specifies how many replacements should be done. + String replace( const String& pattern, + const String& replaceWith, + int count = 0 ) const; + + ///// + /// \brief Trims/strips given string. + /// + /// Removes all spaces from given string except for single spaces between words. + String strip( char strip = ' ' ) const; + + /// \brief Splits string into list of strings with respect to given \e separator. + /// + /// Splits the string into list of substrings wherever \e separator occurs, + /// and returs list of those strings. When \e separator does not appear + /// anywhere in the given string, this function returns a single-element list + /// containing given sting. + /// @param list Name of list. + /// @param separator Character, which separates substrings in given string. + /// Empty character can not be used. + int split( Containers::List< String >& list, const char separator = ' ', bool skipEmpty = false ) const; + + ///// + /// \brief Function for saving file. + /// + /// Writes the string to a binary file and returns boolean expression based on the + /// success in writing into the file. + bool save( File& file ) const; + + ///// + /// \brief Function for loading from file. + /// + /// Reads a string from binary file and returns boolean expression based on the + /// success in reading the file. + bool load( File& file ); + + ///// + /// \brief Function for getting a line from stream. + /// + /// Reads one line from given stream and returns either the line or boolean + /// expression based on the success in reading the line. + bool getLine( std::istream& stream ); + + friend std::ostream& operator<<( std::ostream& stream, const String& str ); + + protected: + + /// \brief Pointer to char ended with zero byte. + char* string; + + /// \brief Length of allocated piece of memory. + int length; + +}; // class String + +/// \brief Returns concatenation of \e string1 and \e string2. String operator+( char string1, const String& string2 ); +/// \brief Returns concatenation of \e string1 and \e string2. String operator+( const char* string1, const String& string2 ); +/// \brief Performs the string output to a stream std::ostream& operator<<( std::ostream& stream, const String& str ); template< typename T > diff --git a/src/TNL/Timer.h b/src/TNL/Timer.h index f885bdd443bbeeec0af8d496a7daf9c2193daa27..a2e01ea8eea32d53a072fbf9ab866a6ca4f499ab 100644 --- a/src/TNL/Timer.h +++ b/src/TNL/Timer.h @@ -15,32 +15,94 @@ namespace TNL { class Logger; +/// \brief Class for time measuring. +/// +/// Counts the elapsed time in seconds between the start() and stop() methods. +/// \par Example +/// \include TimerExample.cpp +// \par Output +// \include TimerExample.out class Timer { public: - + + ///// + /// \brief Basic constructor. + /// + /// This function creates a new timer and resets it. Timer(); + ///// + /// \brief Resets timer. + /// + /// Resets all time and cycle measurements such as real time, CPU time and CPU cycles. + /// Sets all of them to zero. void reset(); + //// + /// \brief Stops (pauses) the timer. + /// + /// Pauses all time and cycle measurements such as real time, CPU time and + /// CPU cycles, but does not set them to zero. void stop(); + ///// + /// \brief Starts timer. + /// + /// Starts all time and cycle measurements such as real time, CPU time and + /// CPU cycles. Method start() can be used also after using stop() method. + /// The timer then continues measuring the time without reseting. void start(); + ///// + /// \brief Returns the elapsed time on given timer. + /// + /// It returns the elapsed time (in seconds) between calling the start() and stop() methods. + /// Starts counting the real time after the method start() is called and + /// pauses when the method stop() is called. + /// If the timer has been started more then once without resetting, + /// the real time is counted by adding all intervals (between start and stop + /// methods) together. + /// This function can be called while the timer is running, there is no + /// need to use stop() method first. double getRealTime() const; + ///// + /// \brief Returns the elapsed CPU time on given timer. + /// + /// The CPU time is measured in seconds. + /// CPU time is the amount of time for which a central processing unit (CPU) + /// was used for processing instructions of a computer program or operating system. + /// The CPU time is measured by adding the amount of CPU time between start() and stop() + /// methods together. double getCPUTime() const; + /// \brief Returns the number of CPU cycles (machine cycles). + /// + /// CPU cycles are counted by adding the number of CPU cycles between start() and stop() + /// methods together. unsigned long long int getCPUCycles() const; - + + /// \brief Writes a record into the \e logger. + /// + /// \param logger Name of Logger object. + /// \param logLevel A non-negative integer recording the log record indent. bool writeLog( Logger& logger, int logLevel = 0 ) const; protected: - + + /// \brief Function for measuring the real time. + /// + /// Returns number of seconds since Epoch, 1970-01-01 00:00:00 UTC. double readRealTime() const; + /// \brief Function for measuring the CPU time. + /// + /// CPU time is the amount of time for which a central processing unit (CPU) + /// was used for processing instructions of a computer program or operating system. double readCPUTime() const; + /// \brief Function for counting the number of CPU cycles (machine cycles). unsigned long long int readCPUCycles() const; @@ -48,9 +110,15 @@ class Timer initialCPUTime, totalCPUTime; unsigned long long int initialCPUCycles, totalCPUCycles; - + + /// \brief Saves information about the state of given timer. + /// + /// Knows whether the timer is currently stopped or it is running. bool stopState; - + + /// \brief Time Stamp Counter returning number of CPU cycles since reset. + /// + /// Only for x86 compatibile CPUs. inline unsigned long long rdtsc() const { unsigned hi, lo; @@ -59,6 +127,7 @@ class Timer } }; +// !!! Odstranit ???!!! extern Timer defaultTimer; } // namespace TNL diff --git a/src/UnitTests/CMakeLists.txt b/src/UnitTests/CMakeLists.txt index 842ce9f2ccad538d954b3a67783549e5a9190f16..cf0fc8c475192df37da7daa1e673b032de6d4fec 100644 --- a/src/UnitTests/CMakeLists.txt +++ b/src/UnitTests/CMakeLists.txt @@ -31,17 +31,17 @@ else() tnl ) endif() +ADD_EXECUTABLE( FileNameTest FileNameTest.cpp ) +TARGET_COMPILE_OPTIONS( FileNameTest PRIVATE ${CXX_TESTS_FLAGS} ) +TARGET_LINK_LIBRARIES( FileNameTest ${GTEST_BOTH_LIBRARIES} tnl ) + ADD_EXECUTABLE( StringTest StringTest.cpp ) TARGET_COMPILE_OPTIONS( StringTest PRIVATE ${CXX_TESTS_FLAGS} ) -TARGET_LINK_LIBRARIES( StringTest - ${GTEST_BOTH_LIBRARIES} - tnl ) +TARGET_LINK_LIBRARIES( StringTest ${GTEST_BOTH_LIBRARIES} tnl ) ADD_EXECUTABLE( ObjectTest ObjectTest.cpp ) TARGET_COMPILE_OPTIONS( ObjectTest PRIVATE ${CXX_TESTS_FLAGS} ) -TARGET_LINK_LIBRARIES( ObjectTest - ${GTEST_BOTH_LIBRARIES} - tnl ) +TARGET_LINK_LIBRARIES( ObjectTest ${GTEST_BOTH_LIBRARIES} tnl ) ADD_EXECUTABLE( SaveAndLoadMeshfunctionTest SaveAndLoadMeshfunctionTest.cpp ) TARGET_COMPILE_OPTIONS( SaveAndLoadMeshfunctionTest PRIVATE ${CXX_TESTS_FLAGS} ) diff --git a/src/UnitTests/FileNameTest.cpp b/src/UnitTests/FileNameTest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5a69a1f2882d18f7a19928e70bd93c8586ecaefc --- /dev/null +++ b/src/UnitTests/FileNameTest.cpp @@ -0,0 +1,89 @@ +/*************************************************************************** + FileNameTest.cpp - description + ------------------- + begin : Oct 17, 2018 + copyright : (C) 2018 by Tomas Oberhuber + email : tomas.oberhuber@fjfi.cvut.cz + ***************************************************************************/ + +/* See Copyright Notice in tnl/Copyright */ + +// Implemented by Nina Dzugasova + +#ifdef HAVE_GTEST +#include +#endif + +#include +// #include + +using namespace TNL; + +#ifdef HAVE_GTEST +TEST( FileNameTest, Constructor ) +{ + FileName fname; + + EXPECT_EQ( fname.getFileName(), "00000." ); +} + +TEST( FileNameTest, Base ) +{ + FileName fname; + fname.setFileNameBase("name"); + + EXPECT_EQ( fname.getFileName(), "name00000." ); +} + +TEST( FileNameTest, Extension ) +{ + FileName fname; + fname.setExtension("tnl"); + + EXPECT_EQ( fname.getFileName(), "00000.tnl" ); +} + +TEST( FileNameTest, Index ) +{ + FileName fname1; + FileName fname2; + fname1.setIndex(1); + fname2.setIndex(50); + + EXPECT_EQ( fname1.getFileName(), "00001." ); + EXPECT_EQ( fname2.getFileName(), "00050." ); +} + +TEST( FileNameTest, DigitsCount ) +{ + FileName fname; + fname.setDigitsCount(4); + + EXPECT_EQ( fname.getFileName(), "0000." ); +} + +TEST( FileNameTest, AllTogether ) +{ + FileName fname; + fname.setFileNameBase("name"); + fname.setExtension("tnl"); + fname.setIndex(8); + fname.setDigitsCount(3); + + EXPECT_EQ( fname.getFileName(), "name008.tnl" ); + EXPECT_EQ( getFileExtension(fname.getFileName()), "tnl" ); +} +#endif + + +#include "GtestMissingError.h" +int main( int argc, char* argv[] ) +{ +#ifdef HAVE_GTEST + ::testing::InitGoogleTest( &argc, argv ); + return RUN_ALL_TESTS(); +#else + throw GtestMissingError(); +#endif +} + diff --git a/src/UnitTests/StringTest.cpp b/src/UnitTests/StringTest.cpp index 6651455589ceeea3681930e1efb621259381fb46..f6ee1a57225d0287da3418a162363ee39e73925e 100644 --- a/src/UnitTests/StringTest.cpp +++ b/src/UnitTests/StringTest.cpp @@ -8,6 +8,8 @@ /* See Copyright Notice in tnl/Copyright */ +// Implemented by Nina Dzugasova + #ifdef HAVE_GTEST #include #endif @@ -62,6 +64,34 @@ TEST( StringTest, ConstructorWithNumber ) EXPECT_EQ( strcmp( string4.getString(), "false" ), 0 ); } +TEST( StringTest, GetSize ) +{ + String str1( "string" ); + String str2( "12345" ); + String str3( "string3" ); + String str4( "String_4" ); + String str5( "Last String" ); + + EXPECT_EQ( str1.getSize(), 6 ); + EXPECT_EQ( str2.getSize(), 5 ); + EXPECT_EQ( str3.getSize(), 7 ); + EXPECT_EQ( str4.getSize(), 8 ); + EXPECT_EQ( str5.getSize(), 11 ); + + EXPECT_EQ( str1.getLength(), 6 ); + EXPECT_EQ( str2.getLength(), 5 ); + EXPECT_EQ( str3.getLength(), 7 ); + EXPECT_EQ( str4.getLength(), 8 ); + EXPECT_EQ( str5.getLength(), 11 ); +} + +TEST( StringTest, GetAllocatedSize ) +{ + String str( "MeineKleine" ); + + EXPECT_EQ( str.getAllocatedSize(), 256 ); +} + TEST( StringTest, SetSize ) { String str; @@ -85,6 +115,15 @@ TEST( StringTest, SetString ) EXPECT_EQ( strcmp( str2.getString(), "string2" ), 0 ); EXPECT_EQ( strcmp( str3.getString(), "string3" ), 0 ); EXPECT_EQ( strcmp( str4.getString(), "string4" ), 0 ); + + str4.setString( "string4_2", 0, 2 ); + EXPECT_EQ( strcmp( str4.getString(), "string4" ), 0 ); +} + +TEST( StringTest, GetString ) +{ + String str( "MyString" ); + EXPECT_EQ( strcmp( str.getString(), "MyString" ), 0 ); } TEST( StringTest, IndexingOperator ) @@ -229,6 +268,9 @@ TEST( StringTest, replace ) EXPECT_EQ( String( "string" ).replace( "ing", "bc" ), "strbc" ); EXPECT_EQ( String( "abracadabra" ).replace( "ab", "CAT" ), "CATracadCATra" ); EXPECT_EQ( String( "abracadabra" ).replace( "ab", "CAT", 1 ), "CATracadabra" ); + EXPECT_NE( String( "abracadabra" ).replace( "ab", "CAT", 2 ), "abracadCATra" ); + EXPECT_NE( String( "abracadabra" ).replace( "ab", "CAT", 2 ), "abracadabra" ); + EXPECT_EQ( String( "abracadabra" ).replace( "ab", "CAT", 2 ), "CATracadCATra" ); } TEST( StringTest, strip ) @@ -253,6 +295,15 @@ TEST( StringTest, split ) EXPECT_EQ( list[ 2 ], "C" ); String( "abracadabra" ).split( list, 'a' ); + ASSERT_EQ( list.getSize(), 6 ); + EXPECT_EQ( list[ 0 ], "" ); + EXPECT_EQ( list[ 1 ], "br" ); + EXPECT_EQ( list[ 2 ], "c" ); + EXPECT_EQ( list[ 3 ], "d" ); + EXPECT_EQ( list[ 4 ], "br" ); + EXPECT_EQ( list[ 5 ], "" ); + + String( "abracadabra" ).split( list, 'a', true ); ASSERT_EQ( list.getSize(), 4 ); EXPECT_EQ( list[ 0 ], "br" ); EXPECT_EQ( list[ 1 ], "c" ); @@ -268,6 +319,13 @@ TEST( StringTest, split ) String( "abracadabra" ).split( list, 'A' ); ASSERT_EQ( list.getSize(), 1 ); EXPECT_EQ( list[ 0 ], "abracadabra" ); + + String( "a,,b,c" ).split( list, ',' ); + ASSERT_EQ( list.getSize(), 4 ); + EXPECT_EQ( list[ 0 ], "a" ); + EXPECT_EQ( list[ 1 ], "" ); + EXPECT_EQ( list[ 2 ], "b" ); + EXPECT_EQ( list[ 3 ], "c" ); } TEST( StringTest, SaveLoad ) @@ -284,8 +342,24 @@ TEST( StringTest, SaveLoad ) EXPECT_EQ( std::remove( "test-file.tnl" ), 0 ); }; -#endif +TEST( StringTest, getLine ) +{ + std::stringstream str; + str << "Line 1" << std::endl; + str << "Line 2" << std::endl; + str.seekg( 0 ); + + String s; + + s.getLine( str ); + EXPECT_EQ( s, "Line 1" ); + + s.getLine( str ); + EXPECT_EQ( s, "Line 2" ); +}; + +#endif #include "GtestMissingError.h" int main( int argc, char* argv[] ) @@ -297,3 +371,4 @@ int main( int argc, char* argv[] ) throw GtestMissingError(); #endif } + diff --git a/src/UnitTests/TimerTest.cpp b/src/UnitTests/TimerTest.cpp new file mode 100644 index 0000000000000000000000000000000000000000..6c20c4abb2bf6bbd6216db9feeaea7ef06d72d6e --- /dev/null +++ b/src/UnitTests/TimerTest.cpp @@ -0,0 +1,49 @@ +/*************************************************************************** + FileNameTest.cpp - description + ------------------- + begin : Oct 17, 2018 + copyright : (C) 2018 by Tomas Oberhuber + email : tomas.oberhuber@fjfi.cvut.cz + ***************************************************************************/ + +/* See Copyright Notice in tnl/Copyright */ + +// Implemented by Nina Dzugasova + +#ifdef HAVE_GTEST +#include +#endif + +#include + +using namespace TNL; + +#ifdef HAVE_GTEST +TEST( TimerTest, Constructor ) +{ + Timer time; + time.reset(); + EXPECT_EQ(time.getRealTime(),0); + /*time.start(); + EXPECT_FALSE(time.stopState); + + time.stop(); + EXPECT_TRUE(time.stopState); + + EXPECT_NE(time.getRealTime(),0);*/ +} +#endif + + +#include "GtestMissingError.h" +int main( int argc, char* argv[] ) +{ +#ifdef HAVE_GTEST + ::testing::InitGoogleTest( &argc, argv ); + return RUN_ALL_TESTS(); +#else + throw GtestMissingError(); +#endif +} + +