├── README.md ├── dense_flow ├── .gitignore ├── .gitmodules ├── CMakeLists.txt ├── README.md ├── build_of.py ├── cmake │ └── Modules │ │ └── FindLibZip.cmake ├── include │ ├── CLUE │ │ ├── .atom-build.json │ │ ├── .gitignore │ │ ├── .travis.yml │ │ ├── CMakeLists.txt │ │ ├── LICENSE.txt │ │ ├── README.md │ │ ├── appveyor.yml │ │ ├── doc │ │ │ ├── Makefile │ │ │ └── source │ │ │ │ ├── array_view.rst │ │ │ │ ├── concurrent_counter.rst │ │ │ │ ├── concurrent_queue.rst │ │ │ │ ├── conf.py │ │ │ │ ├── index.rst │ │ │ │ ├── meta.rst │ │ │ │ ├── meta_seq.rst │ │ │ │ ├── misc.rst │ │ │ │ ├── optional.rst │ │ │ │ ├── predicates.rst │ │ │ │ ├── reindexed_view.rst │ │ │ │ ├── sformat.rst │ │ │ │ ├── shared_mutex.rst │ │ │ │ ├── stemplate.rst │ │ │ │ ├── string_view.rst │ │ │ │ ├── stringex.rst │ │ │ │ ├── textio.rst │ │ │ │ ├── thread_pool.rst │ │ │ │ ├── timing.rst │ │ │ │ ├── type_name.rst │ │ │ │ ├── type_traits.rst │ │ │ │ └── value_range.rst │ │ ├── examples │ │ │ ├── ex_cccounter.cpp │ │ │ ├── ex_ccqueue.cpp │ │ │ ├── ex_stopwatch.cpp │ │ │ ├── ex_strings.cpp │ │ │ ├── ex_threadpool.cpp │ │ │ └── ex_timing.cpp │ │ ├── include │ │ │ └── clue │ │ │ │ ├── array_view.hpp │ │ │ │ ├── clue.hpp │ │ │ │ ├── common.hpp │ │ │ │ ├── concurrent_counter.hpp │ │ │ │ ├── concurrent_queue.hpp │ │ │ │ ├── config.hpp │ │ │ │ ├── container_common.hpp │ │ │ │ ├── memory.hpp │ │ │ │ ├── meta.hpp │ │ │ │ ├── meta_seq.hpp │ │ │ │ ├── misc.hpp │ │ │ │ ├── optional.hpp │ │ │ │ ├── predicates.hpp │ │ │ │ ├── preproc.hpp │ │ │ │ ├── reindexed_view.hpp │ │ │ │ ├── sformat.hpp │ │ │ │ ├── shared_mutex.hpp │ │ │ │ ├── stemplate.hpp │ │ │ │ ├── string_view.hpp │ │ │ │ ├── stringex.hpp │ │ │ │ ├── textio.hpp │ │ │ │ ├── thread_pool.hpp │ │ │ │ ├── timing.hpp │ │ │ │ ├── type_name.hpp │ │ │ │ ├── type_traits.hpp │ │ │ │ └── value_range.hpp │ │ └── tests │ │ │ ├── test_array_view.cpp │ │ │ ├── test_concurrent_counter.cpp │ │ │ ├── test_concurrent_queue.cpp │ │ │ ├── test_include_all.cpp │ │ │ ├── test_meta.cpp │ │ │ ├── test_meta_seq.cpp │ │ │ ├── test_misc.cpp │ │ │ ├── test_optional.cpp │ │ │ ├── test_predicates.cpp │ │ │ ├── test_reindexed_view.cpp │ │ │ ├── test_sformat.cpp │ │ │ ├── test_shared_mutex.cpp │ │ │ ├── test_stemplate.cpp │ │ │ ├── test_string_view.cpp │ │ │ ├── test_stringex.cpp │ │ │ ├── test_textio.cpp │ │ │ ├── test_thread_pool.cpp │ │ │ ├── test_type_name.cpp │ │ │ └── test_value_range.cpp │ ├── common.h │ ├── dense_flow.h │ ├── easylogging++ │ │ ├── .gitignore │ │ ├── .travis.yml │ │ ├── LICENCE │ │ ├── README.md │ │ ├── doc │ │ │ ├── RELEASE-NOTES-v9.00 │ │ │ ├── RELEASE-NOTES-v9.01 │ │ │ ├── RELEASE-NOTES-v9.02 │ │ │ ├── RELEASE-NOTES-v9.03 │ │ │ ├── RELEASE-NOTES-v9.04 │ │ │ ├── RELEASE-NOTES-v9.05 │ │ │ ├── RELEASE-NOTES-v9.06 │ │ │ ├── RELEASE-NOTES-v9.07 │ │ │ ├── RELEASE-NOTES-v9.08 │ │ │ ├── RELEASE-NOTES-v9.09 │ │ │ ├── RELEASE-NOTES-v9.10 │ │ │ ├── RELEASE-NOTES-v9.11 │ │ │ ├── RELEASE-NOTES-v9.12 │ │ │ ├── RELEASE-NOTES-v9.13 │ │ │ ├── RELEASE-NOTES-v9.14 │ │ │ ├── RELEASE-NOTES-v9.15 │ │ │ ├── RELEASE-NOTES-v9.16 │ │ │ ├── RELEASE-NOTES-v9.17 │ │ │ ├── RELEASE-NOTES-v9.18 │ │ │ ├── RELEASE-NOTES-v9.19 │ │ │ ├── RELEASE-NOTES-v9.20 │ │ │ ├── RELEASE-NOTES-v9.21 │ │ │ ├── RELEASE-NOTES-v9.22 │ │ │ ├── RELEASE-NOTES-v9.23 │ │ │ ├── RELEASE-NOTES-v9.24 │ │ │ ├── RELEASE-NOTES-v9.25 │ │ │ ├── RELEASE-NOTES-v9.26 │ │ │ ├── RELEASE-NOTES-v9.27 │ │ │ ├── RELEASE-NOTES-v9.28 │ │ │ ├── RELEASE-NOTES-v9.29 │ │ │ ├── RELEASE-NOTES-v9.30 │ │ │ ├── RELEASE-NOTES-v9.31 │ │ │ ├── RELEASE-NOTES-v9.32 │ │ │ ├── RELEASE-NOTES-v9.33 │ │ │ ├── RELEASE-NOTES-v9.34 │ │ │ ├── RELEASE-NOTES-v9.35 │ │ │ ├── RELEASE-NOTES-v9.36 │ │ │ ├── RELEASE-NOTES-v9.37 │ │ │ ├── RELEASE-NOTES-v9.38 │ │ │ ├── RELEASE-NOTES-v9.39 │ │ │ ├── RELEASE-NOTES-v9.40 │ │ │ ├── RELEASE-NOTES-v9.41 │ │ │ ├── RELEASE-NOTES-v9.42 │ │ │ ├── RELEASE-NOTES-v9.43 │ │ │ ├── RELEASE-NOTES-v9.44 │ │ │ ├── RELEASE-NOTES-v9.45 │ │ │ ├── RELEASE-NOTES-v9.46 │ │ │ ├── RELEASE-NOTES-v9.47 │ │ │ ├── RELEASE-NOTES-v9.48 │ │ │ ├── RELEASE-NOTES-v9.49 │ │ │ ├── RELEASE-NOTES-v9.50 │ │ │ ├── RELEASE-NOTES-v9.51 │ │ │ ├── RELEASE-NOTES-v9.52 │ │ │ ├── RELEASE-NOTES-v9.53 │ │ │ ├── RELEASE-NOTES-v9.54 │ │ │ ├── RELEASE-NOTES-v9.55 │ │ │ ├── RELEASE-NOTES-v9.56 │ │ │ ├── RELEASE-NOTES-v9.57 │ │ │ ├── RELEASE-NOTES-v9.58 │ │ │ ├── RELEASE-NOTES-v9.59 │ │ │ ├── RELEASE-NOTES-v9.60 │ │ │ ├── RELEASE-NOTES-v9.61 │ │ │ ├── RELEASE-NOTES-v9.62 │ │ │ ├── RELEASE-NOTES-v9.63 │ │ │ ├── RELEASE-NOTES-v9.64 │ │ │ ├── RELEASE-NOTES-v9.65 │ │ │ ├── RELEASE-NOTES-v9.66 │ │ │ ├── RELEASE-NOTES-v9.67 │ │ │ ├── RELEASE-NOTES-v9.68 │ │ │ ├── RELEASE-NOTES-v9.69 │ │ │ ├── RELEASE-NOTES-v9.70 │ │ │ ├── RELEASE-NOTES-v9.71 │ │ │ ├── RELEASE-NOTES-v9.72 │ │ │ ├── RELEASE-NOTES-v9.73 │ │ │ ├── RELEASE-NOTES-v9.74 │ │ │ ├── RELEASE-NOTES-v9.75 │ │ │ ├── RELEASE-NOTES-v9.76 │ │ │ ├── RELEASE-NOTES-v9.77 │ │ │ ├── RELEASE-NOTES-v9.78 │ │ │ ├── RELEASE-NOTES-v9.79 │ │ │ └── RELEASE-NOTES-v9.80 │ │ ├── samples │ │ │ ├── .gitignore │ │ │ ├── API │ │ │ │ ├── .gitignore │ │ │ │ ├── build_all.sh │ │ │ │ ├── compile.sh │ │ │ │ ├── logbuilder.cpp │ │ │ │ ├── run.sh │ │ │ │ └── run_all.sh │ │ │ ├── Dev-C++ │ │ │ │ ├── .gitignore │ │ │ │ ├── HelloDevC++.dev │ │ │ │ ├── HelloDevC++.layout │ │ │ │ └── main.cpp │ │ │ ├── MinGW │ │ │ │ ├── .gitignore │ │ │ │ ├── compile.bat │ │ │ │ ├── easylogging++.h │ │ │ │ └── prog.cpp │ │ │ ├── OpenGL │ │ │ │ ├── .gitignore │ │ │ │ ├── Cube │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── LICENCE │ │ │ │ │ ├── Makefile │ │ │ │ │ ├── imageloader.cpp │ │ │ │ │ ├── imageloader.h │ │ │ │ │ ├── main.cpp │ │ │ │ │ └── vtr.bmp │ │ │ │ ├── basic.cpp │ │ │ │ ├── build_all.sh │ │ │ │ ├── compile.sh │ │ │ │ ├── easylogging++.h │ │ │ │ ├── run.sh │ │ │ │ └── run_all.sh │ │ │ ├── Qt │ │ │ │ ├── .gitignore │ │ │ │ ├── basic │ │ │ │ │ ├── README.md │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ ├── main.cpp │ │ │ │ │ ├── mythread.h │ │ │ │ │ ├── qt-sample.pro │ │ │ │ │ └── test_conf.conf │ │ │ │ ├── fast-dictionary │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ ├── fast-dictionary.pro │ │ │ │ │ ├── listwithsearch.cc │ │ │ │ │ ├── listwithsearch.hh │ │ │ │ │ ├── main.cc │ │ │ │ │ ├── mainwindow.cc │ │ │ │ │ ├── mainwindow.hh │ │ │ │ │ ├── mainwindow.ui │ │ │ │ │ ├── moc_listwithsearch.cpp │ │ │ │ │ ├── moc_mainwindow.cpp │ │ │ │ │ ├── ui_mainwindow.h │ │ │ │ │ └── words.txt │ │ │ │ ├── file-splitter-joiner │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── README.md │ │ │ │ │ ├── about.cpp │ │ │ │ │ ├── about.h │ │ │ │ │ ├── about.ui │ │ │ │ │ ├── addsplittedfiledialog.cpp │ │ │ │ │ ├── addsplittedfiledialog.h │ │ │ │ │ ├── addsplittedfiledialog.ui │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ ├── file-splitter-and-joiner.pro │ │ │ │ │ ├── joinercore.cpp │ │ │ │ │ ├── joinercore.h │ │ │ │ │ ├── joinerwidget.cpp │ │ │ │ │ ├── joinerwidget.h │ │ │ │ │ ├── joinerwidget.ui │ │ │ │ │ ├── main.cpp │ │ │ │ │ ├── mainwindow.cpp │ │ │ │ │ ├── mainwindow.h │ │ │ │ │ ├── partprocessor.cpp │ │ │ │ │ ├── partprocessor.h │ │ │ │ │ ├── splitablefiledelegate.cpp │ │ │ │ │ ├── splitablefiledelegate.h │ │ │ │ │ ├── splittercore.cpp │ │ │ │ │ ├── splittercore.h │ │ │ │ │ ├── splitterwidget.cpp │ │ │ │ │ ├── splitterwidget.h │ │ │ │ │ └── splitterwidget.ui │ │ │ │ └── shared-lib │ │ │ │ │ ├── README.md │ │ │ │ │ ├── myapp │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ ├── main.cc │ │ │ │ │ └── myapp.pro │ │ │ │ │ └── mylib │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ ├── mylib.cc │ │ │ │ │ ├── mylib.hh │ │ │ │ │ ├── mylib.pro │ │ │ │ │ └── mylib_global.hh │ │ │ ├── STL │ │ │ │ ├── .gitignore │ │ │ │ ├── .travis_build.sh │ │ │ │ ├── all-logs.cpp │ │ │ │ ├── autospace.cpp │ │ │ │ ├── build_all.sh │ │ │ │ ├── check-macros.cpp │ │ │ │ ├── compile.sh │ │ │ │ ├── conditional.cpp │ │ │ │ ├── configurator.cpp │ │ │ │ ├── containers.cpp │ │ │ │ ├── crash.cpp │ │ │ │ ├── custom-class.cpp │ │ │ │ ├── custom-crash-handler.cpp │ │ │ │ ├── custom-format-spec.cpp │ │ │ │ ├── custom-performance-output.cpp │ │ │ │ ├── default-configurations.cpp │ │ │ │ ├── default-log-file-from-arg.cpp │ │ │ │ ├── del-logger.cpp │ │ │ │ ├── easylogging++.h │ │ │ │ ├── flags.cpp │ │ │ │ ├── global-configuration.cpp │ │ │ │ ├── helpers.cpp │ │ │ │ ├── locale.cpp │ │ │ │ ├── log-dispatch-callback.cpp │ │ │ │ ├── loggable.cpp │ │ │ │ ├── logger-log-functions.cpp │ │ │ │ ├── make-loggable.cpp │ │ │ │ ├── manipulators.cpp │ │ │ │ ├── multiple-loggers.cpp │ │ │ │ ├── no-default-log-file.cpp │ │ │ │ ├── occasional.cpp │ │ │ │ ├── plog.cpp │ │ │ │ ├── post-performance-tracking-handler.cpp │ │ │ │ ├── pthread.cpp │ │ │ │ ├── roll-out.cpp │ │ │ │ ├── run.sh │ │ │ │ ├── run_all.sh │ │ │ │ ├── shared-static-libs │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── README.md │ │ │ │ │ ├── compile_shared.sh │ │ │ │ │ ├── compile_static.sh │ │ │ │ │ ├── lib │ │ │ │ │ │ ├── include │ │ │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ │ │ └── mylib.hpp │ │ │ │ │ │ └── mylib.cpp │ │ │ │ │ └── myapp.cpp │ │ │ │ ├── shared-storage │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── README.md │ │ │ │ │ ├── compile_shared.sh │ │ │ │ │ ├── lib │ │ │ │ │ │ ├── include │ │ │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ │ │ └── mylib.hpp │ │ │ │ │ │ └── mylib.cpp │ │ │ │ │ └── myapp.cpp │ │ │ │ ├── std-array.cpp │ │ │ │ ├── syslog.cpp │ │ │ │ ├── timed-block.cpp │ │ │ │ ├── timed-scope.cpp │ │ │ │ ├── verbose.cpp │ │ │ │ └── very-basic.cpp │ │ │ ├── VC++ │ │ │ │ ├── DLLSample │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── DLLSample.sln │ │ │ │ │ ├── DLLSample_App │ │ │ │ │ │ ├── DLLSample_App.vcxproj │ │ │ │ │ │ ├── DLLSample_App.vcxproj.filters │ │ │ │ │ │ └── main.cpp │ │ │ │ │ └── DLLSample_Lib │ │ │ │ │ │ ├── DLLSample_Lib.vcxproj │ │ │ │ │ │ ├── DLLSample_Lib.vcxproj.filters │ │ │ │ │ │ ├── DLLSample_Lib.vcxproj.user │ │ │ │ │ │ ├── MyMaths.cpp │ │ │ │ │ │ └── MyMaths.h │ │ │ │ ├── VCPP2012_Win32_Multithreaded │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── VCPP2012_Win32.sln │ │ │ │ │ ├── VCPP2012_Win32.v11.suo │ │ │ │ │ └── VCPP2012_Win32 │ │ │ │ │ │ ├── .gitignore │ │ │ │ │ │ ├── VCPP2012_Win32.vcxproj │ │ │ │ │ │ ├── VCPP2012_Win32.vcxproj.filters │ │ │ │ │ │ ├── VCPP2012_Win32.vcxproj.user │ │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ │ └── main.cpp │ │ │ │ └── VCPP2013_PreviewUltimate │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── Main.cpp │ │ │ │ │ ├── VCPP2013_PreviewUltimate.sln │ │ │ │ │ ├── VCPP2013_PreviewUltimate.vcxproj │ │ │ │ │ ├── VCPP2013_PreviewUltimate.vcxproj.filters │ │ │ │ │ └── easylogging++.h │ │ │ ├── async │ │ │ │ ├── .gitignore │ │ │ │ ├── build.sh │ │ │ │ ├── easylogging++.h │ │ │ │ ├── mymath.h │ │ │ │ └── prog.cpp │ │ │ ├── boost │ │ │ │ ├── .gitignore │ │ │ │ ├── build_all.sh │ │ │ │ ├── compile.sh │ │ │ │ ├── deque.cpp │ │ │ │ ├── easylogging++.h │ │ │ │ ├── list.cpp │ │ │ │ ├── map.cpp │ │ │ │ ├── run.sh │ │ │ │ ├── run_all.sh │ │ │ │ ├── set.cpp │ │ │ │ ├── string.cpp │ │ │ │ └── vector.cpp │ │ │ ├── default-logger.conf │ │ │ ├── global.conf │ │ │ ├── gtkmm │ │ │ │ ├── .gitignore │ │ │ │ ├── build_all.sh │ │ │ │ ├── compile.sh │ │ │ │ ├── easylogging++.h │ │ │ │ ├── hello_gtkmm │ │ │ │ │ ├── .gitignore │ │ │ │ │ ├── compile.sh │ │ │ │ │ ├── easylogging++.h │ │ │ │ │ ├── main.cc │ │ │ │ │ ├── window.cc │ │ │ │ │ └── window.h │ │ │ │ ├── run.sh │ │ │ │ ├── run_all.sh │ │ │ │ ├── sigc++.cpp │ │ │ │ └── ustring.cpp │ │ │ └── wxWidgets │ │ │ │ ├── .gitignore │ │ │ │ ├── build_all.sh │ │ │ │ ├── compile.sh │ │ │ │ ├── easylogging++.h │ │ │ │ ├── run.sh │ │ │ │ ├── run_all.sh │ │ │ │ ├── wxhashmap.cpp │ │ │ │ ├── wxhashset.cpp │ │ │ │ ├── wxlist.cpp │ │ │ │ ├── wxlonglong.cpp │ │ │ │ ├── wxstring.cpp │ │ │ │ └── wxvector.cpp │ │ ├── src │ │ │ └── easylogging++.h │ │ ├── test │ │ │ ├── .gitignore │ │ │ ├── .travis_build.sh │ │ │ ├── build_and_run.sh │ │ │ ├── command-line-args-test.h │ │ │ ├── configurations-test.h │ │ │ ├── custom-format-specifier-test.h │ │ │ ├── easylogging++.h │ │ │ ├── enum-helper-test.h │ │ │ ├── file-utils-test.h │ │ │ ├── format-specifier-test.h │ │ │ ├── global-configurations-test.h │ │ │ ├── helpers-test.h │ │ │ ├── hit-counter-test.h │ │ │ ├── log-format-resolution-test.h │ │ │ ├── loggable-test.h │ │ │ ├── logger-test.h │ │ │ ├── macros-test.h │ │ │ ├── main.cc │ │ │ ├── os-utils-test.h │ │ │ ├── plog-test.h │ │ │ ├── post-log-dispatch-handler-test.h │ │ │ ├── qt-gtest-proj-intel.pro │ │ │ ├── qt-gtest-proj.pro │ │ │ ├── registry-test.h │ │ │ ├── strict-file-size-check-test.h │ │ │ ├── string-utils-test.h │ │ │ ├── syslog-test.h │ │ │ ├── test.h │ │ │ ├── typed-configurations-test.h │ │ │ ├── utilities-test.h │ │ │ ├── verbose-app-arguments-test.h │ │ │ └── write-all-test.h │ │ └── tools │ │ │ ├── .gitignore │ │ │ ├── cpplint.py │ │ │ └── release.sh │ ├── utils.h │ └── warp_flow.h ├── matlab │ ├── extracOpticalFlow.m │ ├── extractOpticalFlow.m │ └── extractOpticalFlow_gpu.m ├── src │ ├── common.cpp │ ├── dense_flow.cpp │ ├── dense_flow_gpu.cpp │ ├── dense_warp_flow_gpu.cpp │ ├── py_denseflow.cpp │ └── zip_utils.cpp └── tools │ ├── extract_flow.cpp │ ├── extract_flow_gpu.cpp │ └── extract_warp_flow_gpu.cpp ├── denseflow.py ├── main.py └── requirements.txt /dense_flow/.gitignore: -------------------------------------------------------------------------------- 1 | *.o 2 | .idea/ 3 | build/ -------------------------------------------------------------------------------- /dense_flow/.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "include/easylogging++"] 2 | path = include/easylogging++ 3 | url = https://github.com/easylogging/easyloggingpp 4 | [submodule "include/CLUE"] 5 | path = include/CLUE 6 | url = https://github.com/lindahua/CLUE 7 | -------------------------------------------------------------------------------- /dense_flow/cmake/Modules/FindLibZip.cmake: -------------------------------------------------------------------------------- 1 | # Finds libzip. 2 | # 3 | # This module defines: 4 | # LIBZIP_INCLUDE_DIR_ZIP 5 | # LIBZIP_INCLUDE_DIR_ZIPCONF 6 | # LIBZIP_LIBRARY 7 | # 8 | 9 | find_package(PkgConfig) 10 | pkg_check_modules(PC_LIBZIP QUIET libzip) 11 | 12 | find_path(LIBZIP_INCLUDE_DIR_ZIP 13 | NAMES zip.h 14 | HINTS ${PC_LIBZIP_INCLUDE_DIRS}) 15 | 16 | find_path(LIBZIP_INCLUDE_DIR_ZIPCONF 17 | NAMES zipconf.h 18 | HINTS ${PC_LIBZIP_INCLUDE_DIRS}) 19 | 20 | find_library(LIBZIP_LIBRARY 21 | NAMES zip) 22 | 23 | include(FindPackageHandleStandardArgs) 24 | FIND_PACKAGE_HANDLE_STANDARD_ARGS( 25 | LIBZIP DEFAULT_MSG 26 | LIBZIP_LIBRARY LIBZIP_INCLUDE_DIR_ZIP LIBZIP_INCLUDE_DIR_ZIPCONF) 27 | 28 | set(LIBZIP_VERSION 0) 29 | 30 | if (LIBZIP_INCLUDE_DIR_ZIPCONF) 31 | FILE(READ "${LIBZIP_INCLUDE_DIR_ZIPCONF}/zipconf.h" _LIBZIP_VERSION_CONTENTS) 32 | if (_LIBZIP_VERSION_CONTENTS) 33 | STRING(REGEX REPLACE ".*#define LIBZIP_VERSION \"([0-9.]+)\".*" "\\1" LIBZIP_VERSION "${_LIBZIP_VERSION_CONTENTS}") 34 | endif () 35 | endif () 36 | 37 | set(LIBZIP_VERSION ${LIBZIP_VERSION} CACHE STRING "Version number of libzip") 38 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/.atom-build.json: -------------------------------------------------------------------------------- 1 | { 2 | "cmd": "make -C ./build", 3 | "errorMatch" : [ 4 | "\n(?[\\/0-9a-zA-Z\\._]+):(?\\d+):(?\\d+)" 5 | ] 6 | } 7 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled Object files 2 | *.slo 3 | *.lo 4 | *.o 5 | *.obj 6 | 7 | # Precompiled Headers 8 | *.gch 9 | *.pch 10 | 11 | # Compiled Dynamic libraries 12 | *.so 13 | *.dylib 14 | *.dll 15 | 16 | # Fortran module files 17 | *.mod 18 | 19 | # Compiled Static libraries 20 | *.lai 21 | *.la 22 | *.a 23 | *.lib 24 | 25 | # Executables 26 | *.exe 27 | *.out 28 | *.app 29 | 30 | # Eclipse files 31 | .cproject 32 | .project 33 | .settings 34 | 35 | # Build outputs 36 | build 37 | build-* 38 | .idea 39 | 40 | # Others 41 | *.swp 42 | .build-tools.cson 43 | .clang_complete 44 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/.travis.yml: -------------------------------------------------------------------------------- 1 | language: cpp 2 | 3 | sudo: false 4 | 5 | os: 6 | - linux 7 | 8 | compiler: 9 | - gcc 10 | - clang 11 | 12 | addons: 13 | apt: 14 | sources: 15 | - ubuntu-toolchain-r-test 16 | packages: 17 | - cmake 18 | - gcc-4.8 19 | - g++-4.8 20 | 21 | before_install: 22 | - "pushd . && mkdir $HOME/deps && cd $HOME/deps" 23 | - "wget https://github.com/google/googletest/archive/release-1.7.0.tar.gz" 24 | - "tar -xvf release-1.7.0.tar.gz" 25 | - "cd googletest-release-1.7.0 && cmake . && cmake --build . && mkdir lib && mv *.a lib/ && cd -" 26 | - "popd" 27 | 28 | install: 29 | - if [ "$CXX" = "g++" ]; then export CXX="g++-4.8" CC="gcc-4.8"; fi 30 | - export GTEST_ROOT="$HOME/deps/googletest-release-1.7.0" 31 | 32 | script: 33 | - "uname -a" 34 | - "$CXX --version" 35 | - "cmake . && make && ctest ." 36 | 37 | notifications: 38 | email: false 39 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/appveyor.yml: -------------------------------------------------------------------------------- 1 | # build format 2 | version: "{build}" 3 | 4 | # scripts that run after cloning repository 5 | install: 6 | # - todo: add code to install google-test 7 | 8 | # configurations to add to build matrix 9 | configuration: 10 | - Debug 11 | - Release 12 | 13 | # scripts to run before build 14 | before_build: 15 | - mkdir build 16 | - cd build 17 | - cmake .. 18 | 19 | # build and run tests 20 | build_script: 21 | - make 22 | - ctest . 23 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/doc/source/stemplate.rst: -------------------------------------------------------------------------------- 1 | String Template 2 | ================== 3 | 4 | *CLUE* provides a light-weight string template engine, by the class ``stemplate``. 5 | 6 | This template engine uses ``{{ name }}`` to indicate the terms to be interpolated, and accepts a dictionary-like object for interpolation. 7 | 8 | .. code-block:: cpp 9 | 10 | clue::stemplate st("{{a}} + {{b}} = {{c}}"); 11 | 12 | std::unordered_map dct; 13 | dct["a"] = 123; 14 | dct["b"] = 456; 15 | dct["c"] = 579; 16 | 17 | std::cout << st.with(dct); // directly write to the output stream 18 | st.with(dct).str(); // return a rendered string 19 | 20 | .. note:: 21 | 22 | Here, ``st.with(dct)`` returns a light-weight wrapper that maintains const references to both the template ``st`` and the value dictionary ``dct``. 23 | When inserted to an output stream, the result is directly written to the output stream. 24 | One may also call the ``str()`` member function of the wrapper, which would return the rendered string, an object of class ``std::string``. 25 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/doc/source/type_name.rst: -------------------------------------------------------------------------------- 1 | (Demangled) Type Names 2 | ======================= 3 | 4 | *CLUE* provides facilities to obtain (demangled) names of C++ types. 5 | All following functions are in the header ````, and they are in the namespace ``clue``. 6 | 7 | .. cpp:function:: bool has_demangle() 8 | 9 | Whether *CLUE* provides demangling support. 10 | 11 | .. note:: 12 | 13 | At this point, demangling is supported with GCC, Clang, and ICC. 14 | 15 | .. cpp:function:: std::string type_name() 16 | 17 | Returns a (demangled) name of type ``T``. 18 | 19 | .. note:: 20 | 21 | It returns the demangled name when ``has_demangle()``, otherwise it returns the name 22 | as given by ``typeid(T).name()``. 23 | 24 | .. cpp:function:: std::string type_name(x) 25 | 26 | Returns the (demangled) name of the type of ``x``. 27 | 28 | .. cpp:function:: std::string demangle(const char* name) 29 | 30 | Demangles the input name (the one returned by ``typeid(T).name()``). 31 | 32 | .. note:: 33 | 34 | When ``has_demangle()`` is true, namely, CLUE has demangling support, this 35 | returns the demangled name, otherwise it returns a string capturing the 36 | intput name. 37 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/examples/ex_stopwatch.cpp: -------------------------------------------------------------------------------- 1 | // An example to illustrate the use of stop_watch class 2 | 3 | #include 4 | #include 5 | #include 6 | #include 7 | 8 | using std::size_t; 9 | using namespace clue; 10 | 11 | inline void sleep_ms(size_t ms) { 12 | std::this_thread::sleep_for(std::chrono::milliseconds(ms)); 13 | } 14 | 15 | int main() { 16 | stop_watch sw; 17 | 18 | const size_t n = 10; 19 | for (size_t i: vrange(n)) { 20 | sw.start(); 21 | sleep_ms(100); 22 | sw.stop(); 23 | 24 | std::printf("sleep %2zu: total elapsed = %.4f secs\n", 25 | (i+1), sw.elapsed().secs()); 26 | } 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/examples/ex_threadpool.cpp: -------------------------------------------------------------------------------- 1 | // An example adapted from CTPL 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | void proc(size_t tidx, size_t id, size_t t) { 8 | std::printf("thread %zu: proc %zu starting ...\n", tidx, id); 9 | std::this_thread::sleep_for(std::chrono::milliseconds(t)); 10 | std::printf("thread %zu: proc %zu stopped\n", tidx, id); 11 | } 12 | 13 | void test(size_t nth, size_t interval, size_t proc_time) { 14 | std::printf("Testing with #th = %zu, interval = %zu ms, proc_time = %zu ms\n", 15 | nth, interval, proc_time); 16 | 17 | clue::thread_pool tpool(nth); 18 | 19 | size_t ntsks = 20; 20 | for (size_t i = 0; i < ntsks; ++i) { 21 | std::this_thread::sleep_for(std::chrono::milliseconds(interval)); 22 | tpool.schedule([i, proc_time](size_t tidx){ proc(tidx, i+1, proc_time); }); 23 | } 24 | 25 | tpool.wait_done(); 26 | std::printf("\n"); 27 | } 28 | 29 | 30 | int main() { 31 | test(4, 50, 20); 32 | test(4, 20, 100); 33 | test(4, 50, 100); 34 | } 35 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/examples/ex_timing.cpp: -------------------------------------------------------------------------------- 1 | // a simple example to illustrate the use of timing facilities 2 | 3 | #include 4 | #include 5 | #include 6 | 7 | using namespace clue; 8 | 9 | static char src[1000000]; 10 | static char dst[1000000]; 11 | 12 | void unused(char c) {} 13 | 14 | // copy 1 million bytes 15 | void copy1M() { 16 | std::memcpy(dst, src, sizeof(src)); 17 | 18 | // ensure the copy actually happens in optimized code 19 | volatile char v = dst[0]; 20 | unused(v); // suppress warning 21 | } 22 | 23 | int main() { 24 | std::memset(src, 0, sizeof(src)); 25 | 26 | auto r = calibrated_time(copy1M); 27 | 28 | std::printf("Result:\n"); 29 | std::printf(" runs = %zu\n", r.count_runs); 30 | std::printf(" elapsed = %.4f secs\n", r.elapsed_secs); 31 | 32 | double gps = r.count_runs * 1.0e-3 / r.elapsed_secs; 33 | std::printf(" speed = %.4f Gbytes/sec\n", gps); 34 | 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/include/clue/clue.hpp: -------------------------------------------------------------------------------- 1 | // inclusion of the entire CLUE++ library 2 | 3 | #ifndef CLUE_CLUE__ 4 | #define CLUE_CLUE__ 5 | 6 | #include 7 | 8 | // type traits & meta-programming 9 | #include 10 | #include 11 | #include 12 | 13 | // string and formatting 14 | #include 15 | #include 16 | #include 17 | 18 | // arrays 19 | #include 20 | #include 21 | #include 22 | 23 | // other facilities 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | 30 | // concurrency 31 | #include 32 | #include 33 | #include 34 | #include 35 | 36 | #endif 37 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/include/clue/common.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CLUE_COMMON__ 2 | #define CLUE_COMMON__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #ifndef CHAR_BIT 11 | #define CHAR_BIT 8 12 | #endif 13 | 14 | // to turn CLUE_ASSERT into no-op, one can pre-define CLUE_NDEBUG 15 | // 16 | #ifndef CLUE_NDEBUG 17 | #define CLUE_ASSERT(cond) assert(cond) 18 | #else 19 | #define CLUE_ASSERT(cond) 20 | #endif 21 | 22 | namespace clue { 23 | 24 | using ::std::size_t; 25 | using ::std::ptrdiff_t; 26 | 27 | } 28 | 29 | #endif 30 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/include/clue/config.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CLUE_CONFIG__ 2 | #define CLUE_CONFIG__ 3 | 4 | #ifdef __GNUC__ 5 | # define CLUE_GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) 6 | #endif 7 | 8 | #ifdef __clang_major__ 9 | # define CLUE_CLANG_VERSION (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) 10 | #endif 11 | 12 | #if defined __GNUC__ 13 | # if defined __clang_major__ 14 | # if CLUE_CLANG_VERSION < 30400 15 | # error CLUE++ requires clang compiler of version 3.4.0 or above. 16 | # endif 17 | # else 18 | # if CLUE_GCC_VERSION < 40801 19 | # error CLUE++ requires gcc of version 4.8.1 or above. 20 | # endif 21 | # endif 22 | #endif 23 | 24 | #endif 25 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/include/clue/container_common.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CLUE_CONTAINER_COMMON__ 2 | #define CLUE_CONTAINER_COMMON__ 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | 12 | #endif 13 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/include/clue/memory.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CLUE_MEMORY__ 2 | #define CLUE_MEMORY__ 3 | 4 | #include 5 | 6 | #if (defined(_WIN32) || defined(_WIN64)) && defined(_MSC_VER) 7 | #include 8 | #else 9 | #include 10 | #endif 11 | 12 | namespace clue { 13 | 14 | #if (defined(_WIN32) || defined(_WIN64)) && defined(_MSC_VER) 15 | 16 | inline void* aligned_alloc(size_t nbytes, unsigned int alignment) 17 | { 18 | void* p = ::_aligned_malloc(nbytes, alignment); 19 | if (!p) 20 | { 21 | throw std::bad_alloc(); 22 | } 23 | return p; 24 | } 25 | 26 | inline void aligned_free(void *p) 27 | { 28 | ::_aligned_free(p); 29 | } 30 | 31 | #else 32 | 33 | inline void* aligned_alloc(size_t nbytes, unsigned int alignment) 34 | { 35 | char* p = 0; 36 | if (::posix_memalign((void**)(&p), alignment, nbytes) != 0) 37 | { 38 | throw std::bad_alloc(); 39 | } 40 | return p; 41 | } 42 | 43 | inline void aligned_free(void *p) 44 | { 45 | ::free(p); 46 | } 47 | 48 | #endif 49 | 50 | } 51 | 52 | #endif 53 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/include/clue/misc.hpp: -------------------------------------------------------------------------------- 1 | #ifndef CLUE_MISC__ 2 | #define CLUE_MISC__ 3 | 4 | // Miscellaneous utilities 5 | 6 | #include 7 | #include 8 | #include 9 | 10 | namespace clue { 11 | 12 | struct place_holder_t {}; 13 | constexpr place_holder_t _{}; 14 | 15 | template 16 | inline void pass(Args&&... args) {} 17 | 18 | template 19 | std::unique_ptr make_unique(Args&&... args) { 20 | return std::unique_ptr(new T(std::forward(args)...)); 21 | } 22 | 23 | 24 | template 25 | class temporary_buffer final { 26 | private: 27 | std::pair ret_; 28 | 29 | public: 30 | temporary_buffer(size_t n) 31 | : ret_(std::get_temporary_buffer(static_cast(n))) {} 32 | 33 | ~temporary_buffer() { 34 | std::return_temporary_buffer(ret_.first); 35 | } 36 | 37 | temporary_buffer(const temporary_buffer&) = delete; 38 | temporary_buffer& operator= (const temporary_buffer&) = delete; 39 | 40 | size_t capacity() const noexcept { 41 | return static_cast(ret_.second); 42 | } 43 | 44 | T* data() noexcept { 45 | return ret_.first; 46 | } 47 | }; 48 | 49 | } 50 | 51 | #endif 52 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/tests/test_concurrent_counter.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | void test_basics() { 5 | clue::concurrent_counter cc_n; 6 | clue::concurrent_counter cc_a; 7 | 8 | assert(0 == cc_n.get()); 9 | assert(0 == cc_a.get()); 10 | 11 | bool stop = false; 12 | std::thread worker([&](){ 13 | long i = 0; 14 | while (!stop) { 15 | std::this_thread::sleep_for(std::chrono::milliseconds(10)); 16 | cc_n.inc(); 17 | cc_a.inc(static_cast(++i)); 18 | } 19 | }); 20 | 21 | long a = 0; 22 | long n = 0; 23 | std::thread listener([&](){ 24 | cc_a.wait( clue::gt(50) ); 25 | stop = true; 26 | n = cc_n.get(); 27 | a = cc_a.get(); 28 | }); 29 | 30 | worker.join(); 31 | listener.join(); 32 | 33 | assert(n == 10); 34 | assert(a == 55); 35 | } 36 | 37 | int main() { 38 | test_basics(); 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/tests/test_misc.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | TEST(Misc, MakeUnique) { 5 | using clue::make_unique; 6 | 7 | auto p = make_unique("abc"); 8 | static_assert(std::is_same>::value, 9 | "clue::make_unique yields wrong type."); 10 | 11 | ASSERT_TRUE((bool)p); 12 | ASSERT_EQ("abc", *p); 13 | } 14 | 15 | 16 | TEST(Misc, TempBuffer) { 17 | using clue::temporary_buffer; 18 | 19 | temporary_buffer buf(12); 20 | ASSERT_TRUE(buf.data() != nullptr); 21 | ASSERT_GE(buf.capacity(), 12); 22 | } 23 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/tests/test_sformat.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | TEST(SFormat, SStr) { 5 | using clue::sstr; 6 | 7 | ASSERT_EQ("", sstr()); 8 | ASSERT_EQ("123", sstr(123)); 9 | ASSERT_EQ("1 + 2 = 3", sstr(1, " + ", 2, " = ", 3)); 10 | } 11 | 12 | TEST(SFormat, Delims) { 13 | using clue::delimits; 14 | 15 | std::vector xs0; 16 | ASSERT_EQ("", sstr(delimits(xs0, ", "))); 17 | 18 | std::vector xs1{1, 2, 3}; 19 | ASSERT_EQ("1, 2, 3", sstr(delimits(xs1, ", "))); 20 | } 21 | 22 | 23 | TEST(SFormat, CFmt) { 24 | using clue::cfmt; 25 | 26 | std::stringstream ss1; 27 | ss1 << cfmt("%04d", 25); 28 | ASSERT_EQ("0025", ss1.str()); 29 | 30 | std::stringstream ss2; 31 | ss2 << cfmt("%.4f", 12.0); 32 | ASSERT_EQ("12.0000", ss2.str()); 33 | } 34 | 35 | 36 | TEST(SFormat, CFmt_s) { 37 | using clue::cfmt_s; 38 | 39 | ASSERT_EQ("0025", cfmt_s("%04d", 25)); 40 | ASSERT_EQ("12.0000", cfmt_s("%.4f", 12.0)); 41 | ASSERT_EQ("1 + 2 = 3", cfmt_s("%d + %d = %d", 1, 2, 3)); 42 | } 43 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/tests/test_stemplate.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | using namespace clue; 6 | 7 | TEST(STemplate, Basics) { 8 | 9 | std::unordered_map dict; 10 | dict["a"] = "Alice"; 11 | dict["b"] = "Bob"; 12 | dict["c"] = "Cavin"; 13 | 14 | stemplate s0(""); 15 | ASSERT_EQ("", s0.with(dict).str()); 16 | 17 | stemplate s1("xyz"); 18 | ASSERT_EQ("xyz", s1.with(dict).str()); 19 | 20 | stemplate s2("{{a}}"); 21 | ASSERT_EQ("Alice", s2.with(dict).str()); 22 | 23 | stemplate s2a("{{ a }}"); 24 | ASSERT_EQ("Alice", s2a.with(dict).str()); 25 | 26 | stemplate s3("call {{ a }}"); 27 | ASSERT_EQ("call Alice", s3.with(dict).str()); 28 | 29 | stemplate s4("{{a}}{{ b }}"); 30 | ASSERT_EQ("AliceBob", s4.with(dict).str()); 31 | 32 | stemplate s5("[{{ a }} -> {{b}}.{{c}}]"); 33 | ASSERT_EQ("[Alice -> Bob.Cavin]", s5.with(dict).str()); 34 | 35 | stemplate s6("{{a}} {} {{b}}"); 36 | ASSERT_EQ("Alice {} Bob", s6.with(dict).str()); 37 | 38 | stemplate s_err("{{a}} + {{d}}."); 39 | ASSERT_THROW(s_err.with(dict).str(), std::out_of_range); 40 | } 41 | -------------------------------------------------------------------------------- /dense_flow/include/CLUE/tests/test_type_name.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | using namespace clue; 5 | 6 | #ifdef CLUE_HAS_DEMANGLE 7 | 8 | struct MyType {}; 9 | 10 | template 11 | struct MyTemplate{}; 12 | 13 | TEST(TypeNames, BasicTypes) { 14 | ASSERT_TRUE(has_demangle()); 15 | 16 | ASSERT_EQ("int", type_name()); 17 | ASSERT_EQ("double", type_name()); 18 | ASSERT_EQ("MyType", type_name(MyType{})); 19 | } 20 | 21 | TEST(TypeNames, TemplateTypes) { 22 | ASSERT_EQ("MyTemplate", type_name>()); 23 | ASSERT_EQ("MyTemplate", (type_name>())); 24 | } 25 | 26 | 27 | #endif // CLUE_HAS_DEMANGLE 28 | -------------------------------------------------------------------------------- /dense_flow/include/common.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by yjxiong on 11/18/15. 3 | // 4 | 5 | #ifndef DENSEFLOW_COMMON_H_H 6 | #define DENSEFLOW_COMMON_H_H 7 | 8 | 9 | 10 | #include "opencv2/video/tracking.hpp" 11 | #include "opencv2/imgproc/imgproc.hpp" 12 | #include "opencv2/highgui/highgui.hpp" 13 | 14 | #include 15 | #include 16 | using namespace cv; 17 | 18 | void convertFlowToImage(const Mat &flow_x, const Mat &flow_y, Mat &img_x, Mat &img_y, 19 | double lowerBound, double higherBound); 20 | void drawOptFlowMap(const Mat& flow, Mat& cflowmap, int step,double, const Scalar& color); 21 | 22 | void encodeFlowMap(const Mat& flow_map_x, const Mat& flow_map_y, 23 | vector& encoded_x, vector& encoded_y, 24 | int bound, bool to_jpg=true); 25 | 26 | inline void initializeMats(const Mat& frame, 27 | Mat& capture_image, Mat& capture_gray, 28 | Mat& prev_image, Mat& prev_gray){ 29 | capture_image.create(frame.size(), CV_8UC3); 30 | capture_gray.create(frame.size(), CV_8UC1); 31 | 32 | prev_image.create(frame.size(), CV_8UC3); 33 | prev_gray.create(frame.size(), CV_8UC1); 34 | } 35 | 36 | void writeImages(vector> images, string name_temp); 37 | 38 | #endif //DENSEFLOW_COMMON_H_H 39 | 40 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/.gitignore: -------------------------------------------------------------------------------- 1 | build-* 2 | *.pro.user 3 | .DS_Store 4 | release.info 5 | bin/* 6 | logs/* 7 | experiments/* 8 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/.travis.yml: -------------------------------------------------------------------------------- 1 | language: cpp 2 | compiler: 3 | - clang 4 | before_install: 5 | - sudo apt-get update 6 | - sudo apt-get install libgtest-dev 7 | - "cd /usr/src/gtest && sudo cmake . && sudo cmake --build . && sudo mv libg* /usr/local/lib/ ; cd -" 8 | before_script: 9 | - pwd 10 | - cd samples/STL/ 11 | - pwd 12 | - which sh 13 | script: "sh ./.travis_build.sh && cd ../../test/ && sh ./.travis_build.sh" 14 | branches: 15 | only: 16 | - develop 17 | notifications: 18 | recipients: 19 | - mkhan3189@gmail.com 20 | email: 21 | on_success: change 22 | on_failure: always 23 | rvm: 24 | - 9.00 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/LICENCE: -------------------------------------------------------------------------------- 1 | The MIT License (MIT) 2 | 3 | Copyright (c) 2015 muflihun.com 4 | 5 | http://github.com/easylogging/ 6 | http://easylogging.muflihun.com 7 | http://muflihun.com 8 | 9 | Permission is hereby granted, free of charge, to any person obtaining a copy of 10 | this software and associated documentation files (the "Software"), to deal in 11 | the Software without restriction, including without limitation the rights to 12 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of 13 | the Software, and to permit persons to whom the Software is furnished to do so, 14 | subject to the following conditions: 15 | 16 | The above copyright notice and this permission notice shall be included in all 17 | copies or substantial portions of the Software. 18 | 19 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 20 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS 21 | FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR 22 | COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 23 | IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 24 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.01: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.01 RELEASE NOTES 3 | --------------------------------- 4 | 5 | =========================== 6 | = NEW FEATURES = 7 | =========================== 8 | 9 | - Failed check should be embedded in square brackets (issue #86) 10 | - Default log file using macro `_ELPP_DEFAULT_LOG_FILE` (if available) 11 | 12 | ============================ 13 | = BUG FIXES = 14 | ============================ 15 | 16 | - Issue with creating shared library that uses easylogging++ (issue #85) 17 | 18 | ========================== 19 | = NOTES = 20 | ========================== 21 | 22 | - Default log location for *nix is in project location logs/ directory 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.02: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.02 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ============================ 6 | = BUG FIXES = 7 | ============================ 8 | 9 | - Minor warning fix with clang++ 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.03: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.03 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ============================ 6 | = BUG FIXES = 7 | ============================ 8 | 9 | - Issue with preloading library that uses easylogging++ (issue #87) 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.04: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.04 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = NOTES = 7 | ========================== 8 | 9 | - Minor refactoring 10 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 11 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.05: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.05 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = BUG FIXES = 7 | ========================== 8 | 9 | - Error while generating stack trace on crash when stacktrace is active (issue #88) 10 | 11 | ========================== 12 | = NEW FEATURES = 13 | ========================== 14 | 15 | - Ability to choose detailed crash reason (issue #90) 16 | 17 | ========================== 18 | = NOTES = 19 | ========================== 20 | 21 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 22 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.06: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.06 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = BUG FIXES = 7 | ========================== 8 | 9 | - std::unordered_set error (issue #91) 10 | 11 | ========================== 12 | = NEW FEATURES = 13 | ========================== 14 | 15 | - Add support for missing boost::container templates (issue #89) 16 | 17 | ========================== 18 | = NOTES = 19 | ========================== 20 | 21 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 22 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.07: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.07 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = BUG FIXES = 7 | ========================== 8 | 9 | ========================== 10 | = NEW FEATURES = 11 | ========================== 12 | 13 | - Added Cygwin Compatibility (issue #93) 14 | 15 | ========================== 16 | = NOTES = 17 | ========================== 18 | 19 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 20 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.08: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.08 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = BUG FIXES = 7 | ========================== 8 | 9 | - Issue with fatal log being disabled (issue #94) 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.09: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.09 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = NEW FEATURES = 7 | ========================== 8 | 9 | - Support for wxWidgets containers (issue #60) 10 | 11 | ========================== 12 | = BUG FIXES = 13 | ========================== 14 | 15 | - NewLineForContainer does not work for Qt containers that dont use writeIterator (isue #96) 16 | 17 | ========================== 18 | = REFACTORING = 19 | ========================== 20 | 21 | - Seperated writer from dispatcher + log class 22 | 23 | ========================== 24 | = NOTES = 25 | ========================== 26 | 27 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 28 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 29 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.10: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.10 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = BUG FIXES = 7 | ========================== 8 | 9 | - Some issues with timeval not declared being struct caused issues with some libs 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.11: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.11 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = BUG FIXES = 7 | ========================== 8 | 9 | - Fix for TDM GCC date/time issue 10 | 11 | ========================== 12 | = NEW FEATURES = 13 | ========================== 14 | 15 | - Logger not registered error now uses 'default' logger 16 | - Android support added 17 | - Support for TDM GCC compilers 18 | - Qt logging does not need QT_CORE_LIB macro anymore for necessities support 19 | 20 | ========================== 21 | = NOTES = 22 | ========================== 23 | 24 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 25 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.12: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.12 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = NEW FEATURES = 7 | ========================== 8 | 9 | - Ability to log third-party classes (issue #97) 10 | - Class to extend to make class loggable (issue #98) 11 | 12 | ========================== 13 | = IMPROVEMENTS = 14 | ========================== 15 | 16 | - CHECK_NOTNULL() to expand to fully qualified function name 17 | - CHECK_EQ and CHECK_NE expands to use CHECK 18 | - Inlined some methods for performance improvements 19 | 20 | ========================== 21 | = NOTES = 22 | ========================== 23 | 24 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 25 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.13: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.13 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ===================== 6 | = NEW FEATURES = 7 | ===================== 8 | 9 | - 'logs' directory is made automatically (issue #99) 10 | 11 | ========================== 12 | = INTERNALS = 13 | ========================== 14 | 15 | - Easylogging++ internal errors are enabled on defining macro `_ELPP_ENABLE_ERRORS` 16 | 17 | ========================== 18 | = NOTES = 19 | ========================== 20 | 21 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 22 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.14: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.14 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = BUG FIXES = 7 | ========================== 8 | 9 | - Fixes issues with valgrind when no default file is used (issue #100) 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.15: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.15 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ============================= 6 | = IMPROVEMENTS = 7 | ============================= 8 | 9 | - Warnings fixes (issue #101) 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.16: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.16 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ============================= 6 | = IMPROVEMENTS = 7 | ============================= 8 | 9 | - Suppressed unused warning for default filename constant (only clang) 10 | - Some serious steps taken for future release to have less warnings - made all samples -pedantic-errors + -Wfatal-errors (note: samples are part of build-tests) 11 | 12 | ========================== 13 | = NOTES = 14 | ========================== 15 | 16 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 17 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 18 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.17: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.17 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ============================= 6 | = NEW FEATURES = 7 | ============================= 8 | 9 | - Add a format specifier to log filename and line number (issue #103) 10 | 11 | ============================= 12 | = IMPROVEMENTS = 13 | ============================= 14 | 15 | - Assertion failure and does not process when configuratoin file does not exist 16 | 17 | ========================== 18 | = NOTES = 19 | ========================== 20 | 21 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 22 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.18: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.18 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = FIXES = 7 | ========================== 8 | 9 | - Completely dithced away QA logging even macros unusable 10 | - Fixed some of verbose logging macro expansions 11 | 12 | ========================== 13 | = NEW FEATURES = 14 | ========================== 15 | 16 | - Only allow aplha-numeric (+ some symbols) for logger names (issue #105) 17 | - Case insensitive app args (issue #106) 18 | - Helper to reconfigure specific level for all loggers (issue #107) 19 | - DCHECK macros for debug mode checks (issue #108) 20 | - Added `bool Loggers::hasLogger(const std::string&)` 21 | 22 | ========================== 23 | = NOTES = 24 | ========================== 25 | 26 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 27 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 28 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.19: -------------------------------------------------------------------------------- 1 | 2 | Easylogging++ v9.19 RELEASE NOTES 3 | --------------------------------- 4 | 5 | ========================== 6 | = FIXES = 7 | ========================== 8 | 9 | - Some internal code refactor 10 | - Issue with clang++ on mac fixes (issue #111) 11 | 12 | ========================== 13 | = NOTES = 14 | ========================== 15 | 16 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 17 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 18 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.20: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.20 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = NEW FEATURES = 6 | ========================== 7 | 8 | - Introduced `el::Helpers::convertTemplateToStdString` for loggable classes (and other classes) to return `std::string` from easylogging++ friendly templates (issue #114) 9 | - Introduced `el::Helpers::commandLineArgs` for reading command line arguments provided 10 | - Quoted values in configurations can have double quotes by escaping them using `\` (issue #113) 11 | - Helper to configure easylogging++ loggers (global conf) from command line argument (issue #115) 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 18 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.21: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.21 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = REFACTORING = 6 | ========================== 7 | 8 | - Removed some unnecessary code 9 | - Removed licence full detail, instead added link to it 10 | - Removed unnecessary methods from VersionInfo static class, just left `version()` and `releaseDate()` 11 | 12 | ========================== 13 | = BUG FIXES = 14 | ========================== 15 | 16 | - Configuring same logger twice loses some information (issue #116) 17 | 18 | ========================== 19 | = NEW FEATRUES = 20 | ========================== 21 | 22 | - Added base configurations pointer to `parseFromText` same as `parseFromFile` 23 | 24 | ========================== 25 | = NOTES = 26 | ========================== 27 | 28 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 29 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 30 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.22: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.22 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = REFACTORING = 6 | ========================== 7 | 8 | - Declared licence as the MIT licence in top comments to avoid confusions for open-source projects 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.23: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.23 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = DEPRECATED = 6 | ========================== 7 | 8 | - `_ELPP_PREVENT_FATAL_ABORT` is replaced with `el::LoggingFlag::DisableApplicationAbortOnFatalLog` (issue #119) 9 | 10 | ========================== 11 | = NEW FEATURES = 12 | ========================== 13 | 14 | - Custom installable format specifiers (issue #118) 15 | - Ability to uninstall pre-rollout handler 16 | - New check macros 17 | - CHECK_LT (less-than) 18 | - CHECK_GT (greater-than) 19 | - CHECK_LE (less-than or equal) 20 | - CHECK_GE (greater-than or equal) 21 | 22 | ========================== 23 | = NOTES = 24 | ========================== 25 | 26 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 27 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 28 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.24: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.24 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = FIXES = 6 | ========================== 7 | 8 | - `strerror` CRT warning fix for VC++ when using PLOG() or any equivalent (issue# 123) 9 | - Fixed `CVERBOSE_EVERY_N` resolution from `VLOG_IF` to custom logger verbose log 10 | 11 | ========================== 12 | = NEW FEATURES = 13 | ========================== 14 | 15 | - New helper `reconfigureLogger(const std::string&, const ConfigurationType&, const std::string&)` 16 | - Support for syslog (issue #120) 17 | 18 | ========================== 19 | = NOTES = 20 | ========================== 21 | 22 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 23 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 24 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.26: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.26 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = NEW FEATURES = 6 | ========================== 7 | 8 | - Debug version of PLOG (issue #133) 9 | - Debug version of SYSLOG 10 | - Introduced `PostLogDispatchHandler` to write your own handler for any action after log is dispatched 11 | - Introduced `LoggingFlag::ColoredTerminalOutput` to support colorful output if supported by terminal 12 | 13 | =========================== 14 | = API CHANGES = 15 | =========================== 16 | 17 | - `el::base::PreRollOutHandler` has moved to `el::PreRollOutHandler` 18 | - `el::base::LogMessage` has moved to `el::LogMessage` 19 | 20 | ========================== 21 | = NOTES = 22 | ========================== 23 | 24 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 25 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.27: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.27 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ======================= 5 | = FIXES = 6 | ======================= 7 | 8 | - Emergency fix for multiple-definition bug caused by v9.26 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.28: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.28 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = IMPROVEMENTS = 6 | ========================== 7 | 8 | - One time resolution for currentUser, currentHost and terminalSupportsColor for performance improvement 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.29: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.29 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = IMPROVEMENTS = 6 | ========================== 7 | 8 | - Better way to deal with PLOG and perror using PErrorWriter 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.30: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.30 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = FIXES = 6 | ========================= 7 | 8 | - Fixes to clang++ 3.4+ 9 | 10 | ========================= 11 | = REFACTORING = 12 | ========================= 13 | 14 | - Removed unused variable m_postStream 15 | 16 | ========================== 17 | = NOTES = 18 | ========================== 19 | 20 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 21 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.31: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.31 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = FIXES = 6 | ========================= 7 | 8 | - Fixes for Intel C++ after updated to g++ 4.8 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.32: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.32 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = NEW FEATURES = 6 | ========================= 7 | 8 | - Unicode support (enabled when `_ELPP_UNICODE` is defined) 9 | 10 | ========================= 11 | = API CHANGES = 12 | ========================= 13 | 14 | - It is recommended to use `el::base::types::ostream_t` in `el::Loggable` to make it happier with unicode 15 | 16 | ========================== 17 | = NOTES = 18 | ========================== 19 | 20 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 21 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.33: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.33 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = REFACTORING = 6 | ========================= 7 | 8 | - Includes only when UNICODE is enabled 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.34: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.34 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = FIXES = 6 | ========================= 7 | 8 | - Fixes to Trackable after Unicode (this also fixes VC++ 2013 compilation) 9 | - Fixes MAKE_CONTAINER_ELPP_FRIENDLY to be generic for UNICODE 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.35: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.35 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = FIXES = 6 | ========================= 7 | 8 | - UNICODE fix for wstring operator 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.36: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.36 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================ 5 | = REFACTOR = 6 | ============================ 7 | 8 | - Happy Google C++ style guide (cpplint.py) - Lambda semi-colon and line length is left as-is 9 | - API changes to use pointers instead of reference e.g, `populateAllLoggerIds(std::vector&)` to `populateAllLoggerIds(std::vector*)` 10 | 11 | ========================== 12 | = FIXES = 13 | ========================== 14 | 15 | - Fixed `TIMED_BLOCK` to reflect `_ELPP_PERFORMANCE_MICROSECONDS` 16 | 17 | ========================== 18 | = NOTES = 19 | ========================== 20 | 21 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 22 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.37: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.37 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = FIXES = 6 | ========================== 7 | 8 | - Fixed issue with EnumType and unicode (issue 137) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.38: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.38 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ================================= 5 | = NEW FEATURES = 6 | ================================= 7 | 8 | - Define `_LOGGER` before include to use specified logger, e.g, `#define _LOGGER "my_logger"` 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.39: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.39 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = BUG FIXES = 6 | ============================== 7 | 8 | - Issue with disabling logs when using manipulators e.g, `std::endl` 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.40: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.40 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = NEW FEATURES = 6 | ============================== 7 | 8 | - Default configuration getter 9 | - Default typed-configuration getter 10 | - Log streams reference (constant) getter for public-use 11 | 12 | ============================== 13 | = BUG FIXES = 14 | ============================== 15 | 16 | - Issue with TIMED_FUNC (issue #139) 17 | 18 | ========================== 19 | = NOTES = 20 | ========================== 21 | 22 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 23 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 24 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.41: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.41 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = BUG FIXES = 6 | ============================== 7 | 8 | - Issue with g++ raised from version 9.4 release 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.42: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.42 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = BUG FIXES = 6 | ============================== 7 | 8 | - Registry<>::get for VC++ does not have exception catch anymore that caused problems with CDB 9 | - Issue with Visual C++ and `_ELPP_NO_DEFAULT_LOG_FILE` macro 10 | 11 | ========================== 12 | = NOTES = 13 | ========================== 14 | 15 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 16 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.43: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.43 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = NEW FEATURES = 6 | ============================== 7 | 8 | - Introduced `LOG_AFTER_N` and `LOG_N_TIMES` that works pretty much same as `LOG_EVERY_N` 9 | 10 | ============================== 11 | = BUG FIXES = 12 | ============================== 13 | 14 | - Issue with Visual C++ and `_ELPP_NO_DEFAULT_LOG_FILE` in reconfiguring logger and flushing 15 | 16 | ========================== 17 | = NOTES = 18 | ========================== 19 | 20 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 21 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.44: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.44 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = BUG FIXES = 6 | ============================== 7 | 8 | - DCCHECK_NULLPTR bug fix (issue #141) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.45: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.45 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = BUG FIXES = 6 | ============================== 7 | 8 | - PCHECK macro bug fixes 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.46: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.46 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = BUG FIXES = 6 | ============================== 7 | 8 | - CHECK_EQ and CHECK_STRCASEEQ macro fixes (issue #142) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.47: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.47 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ============================== 5 | = BUG FIXES = 6 | ============================== 7 | 8 | - July month abbreviation fix 9 | - Default date/time fix for 'PM' times 10 | 11 | ======================== 12 | = CHANGES = 13 | ======================== 14 | 15 | - `Logger not registered` message now uses debug level instead of error 16 | 17 | ========================== 18 | = NOTES = 19 | ========================== 20 | 21 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 22 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.48: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.48 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = NOTES = 6 | ========================== 7 | 8 | - Licence and copyright info update to start from 2012 to 2014 9 | 10 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 11 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 12 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.49: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.49 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = NEW FEATURES = 6 | ========================== 7 | 8 | - Unregisterable loggers using Loggers::unregisterLogger(id) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.50: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.50 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ======================= 5 | = BUG FIXES = 6 | ======================= 7 | 8 | - Issue with datetime format (%y and %Y having same behaviour) (issue #144) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.51: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.51 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================== 5 | = NEW FEATURES = 6 | ========================== 7 | 8 | - Add timestamp to file names in the configuration file (issue #145) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.52: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.52 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ======================= 5 | = BUG FIXES = 6 | ======================= 7 | 8 | - Bug fix from ver. 9.51 with unicode support - introduced `_ELPP_FILENAME_TIMESTAMP` 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.53: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.53 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = NEW FEATURES = 6 | ========================= 7 | 8 | - Removed need of `_ELPP_FILENAME_TIMESTAMP` for filename timestamp 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.54: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.54 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = NEW FEATURES = 6 | ========================= 7 | 8 | - Ability to capture performance tracking data when performance tracking is finished (issue #148) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.55: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.55 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = NEW FEATURES = 6 | ========================= 7 | 8 | - FreeBSD build fix (Thanks to Yawning @ Github) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.56: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.56 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = BUG FIXES = 6 | ========================= 7 | 8 | - Issue with writing unicode characters to file (issue #151) 9 | - Issue with syslog along with unicode support (issue #152) 10 | 11 | ========================= 12 | = NEW FEATURES = 13 | ========================= 14 | 15 | - Ability to export symbols for DLL (issue #150) 16 | - Ability to share logging repository (issue #153) 17 | - Ability to force using standard C++ thread using `_ELPP_FORCE_USE_STD_THREAD` 18 | 19 | ========================== 20 | = NOTES = 21 | ========================== 22 | 23 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 24 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.57: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.57 RELEASE NOTES 2 | --------------------------------- 3 | 4 | ========================= 5 | = BUG FIXES = 6 | ========================= 7 | 8 | - Issue with multithreading and disabled logging levels (issue #155) 9 | 10 | ========================== 11 | = NOTES = 12 | ========================== 13 | 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.58: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.58 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================= 8 | = REFACTORING = 9 | ========================= 10 | 11 | - Use `std::string` instead of `const char*` where it does not affect performance. 12 | 13 | ========================= 14 | = BUG FIXES = 15 | ========================= 16 | 17 | - Thread ID resolution function returns `std::string` instead of `const char*` to prevent invalid pointers return 18 | 19 | ========================== 20 | = NOTES = 21 | ========================== 22 | 23 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 24 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.59: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.59 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Major 5 | API changes: No 6 | 7 | ========================= 8 | = REFACTORING = 9 | ========================= 10 | 11 | - Removing trailing spaces and reorder Trackable members class to avoid warning on gcc (issue 158) 12 | 13 | 14 | ========================== 15 | = NEW FEATURES = 16 | ========================== 17 | 18 | - Ability to use multiple loggers to log single message (needs `_ELPP_MULTI_LOGGER_SUPPORT`) (issue #157) 19 | 20 | 21 | ========================== 22 | = BUG FIXES = 23 | ========================== 24 | 25 | - Segmentation fault when running shared lib apps (issue #160) 26 | 27 | 28 | ========================== 29 | = NOTES = 30 | ========================== 31 | 32 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 33 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 34 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.60: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.60 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Major 5 | API changes: No 6 | 7 | ========================== 8 | = NEW FEATURES = 9 | ========================== 10 | 11 | - Support logging from Logger class for compilers with support for variadic templates (issue #162) 12 | 13 | ========================== 14 | = REFACTORING = 15 | ========================== 16 | 17 | - File size cut down 18 | - Changed `inline static` to `static inline` for better readability 19 | 20 | ========================== 21 | = BUG FIXES = 22 | ========================== 23 | 24 | - Double free corrpution when sharing storage 25 | - Unused variable warning on Windows regarding "nextTok_" (issue #161) 26 | 27 | ========================== 28 | = NOTES = 29 | ========================== 30 | 31 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 32 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 33 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.61: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.61 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================== 8 | = FIXES = 9 | ========================== 10 | 11 | - Log functions now uses `%v` instead of `%` 12 | 13 | ========================== 14 | = NEW FEATURES = 15 | ========================== 16 | 17 | - Type safe internal checks 18 | 19 | ========================== 20 | = NOTES = 21 | ========================== 22 | 23 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 24 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.62: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.62 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================== 8 | = BUG FIXES = 9 | ========================== 10 | 11 | - Fix to `Logger::verbose` checking whether verbosity is on or not 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 18 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.63: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.63 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================== 8 | = BUG FIXES = 9 | ========================== 10 | 11 | - Issue with multi-threading fixed for verbose logging not on (multi-threaded applications only) 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 18 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.65: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.65 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================== 8 | = NEW FEATURES = 9 | ========================== 10 | 11 | - Ability to create loggers on the fly `LoggingFlag::CreateLoggerAutomatically` 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/blob/v9.65/README.md for manual for this release 18 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 19 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.66: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.66 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ======================== 8 | = BUG FIXES = 9 | ======================== 10 | 11 | - Verbose fix when using `Logger::verbose` 12 | 13 | ========================== 14 | = IMPROVEMENTS = 15 | ========================== 16 | 17 | - Changed `func` and `file` to `FUNCTION` and `FILE` respectively 18 | 19 | ========================== 20 | = NOTES = 21 | ========================== 22 | 23 | - See https://github.com/easylogging/easyloggingpp/blob/v9.66/README.md for manual for this release 24 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 25 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.67: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.67 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | =========================== 8 | = IMPROVEMENTS = 9 | =========================== 10 | 11 | - Fix to file stream handling if unable to create file stream 12 | - Fixed android (NDK) build warnings 13 | 14 | ========================== 15 | = NOTES = 16 | ========================== 17 | 18 | - See https://github.com/easylogging/easyloggingpp/blob/v9.67/README.md for manual for this release 19 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 20 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.68: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.68 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | =========================== 8 | = IMPROVEMENTS = 9 | =========================== 10 | 11 | - Ability to change internal debugging macro 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/blob/v9.68/README.md for manual for this release 18 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 19 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.69: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.69 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: Yes 6 | 7 | =========================== 8 | = IMPROVEMENTS = 9 | =========================== 10 | 11 | - Multiple log dispatch call backs by extending `el::LogDispatchCallback` 12 | - Ability to log from `el::LogDispatchCallback` with no problems with recursive calls 13 | 14 | ========================== 15 | = NOTES = 16 | ========================== 17 | 18 | - See https://github.com/easylogging/easyloggingpp/blob/v9.69/README.md for manual for this release 19 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 20 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.70: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.70 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: Yes 6 | 7 | =========================== 8 | = IMPROVEMENTS = 9 | =========================== 10 | 11 | - Improvements to `PerformanceTrackingCallback` - multiple callbacks 12 | - Removed ability to log from log dispatch and performance tracking callbacks since it causes issue in multi-threaded applications 13 | 14 | ============================ 15 | = REMOVED = 16 | ============================ 17 | 18 | - Removed `el::LoggingFlag::EnableLogDispatchCallback` as it is always enabled now since its used internally 19 | - Removed `el::LoggingFlag::DisablePerformanceTrackingDispatch` as you can do it other way (see samples) 20 | - Removed `el::LoggingFlag::PerformanceTrackingCallback` as it is always enabled now since its used internally 21 | 22 | ========================== 23 | = NOTES = 24 | ========================== 25 | 26 | - See https://github.com/easylogging/easyloggingpp/blob/v9.70/README.md for manual for this release 27 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 28 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 29 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.71: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.71 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ======================== 8 | = BUG FIXES = 9 | ======================== 10 | 11 | - Fix to `PERFORMANCE_CHECKPOINT` 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/blob/v9.71/README.md for manual for this release 18 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 19 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.72: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.72 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ======================== 8 | = BUG FIXES = 9 | ======================== 10 | 11 | - Using easylogging++ fails in conjunction with WIN32_LEAN_AND_MEAN (issue #171) 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/blob/v9.72/README.md for manual for this release 18 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 19 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.73: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.73 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | =========================== 8 | = NEW FEATURES = 9 | =========================== 10 | 11 | - Ability to add spaces automatically (issue #179) 12 | 13 | ========================== 14 | = NOTES = 15 | ========================== 16 | 17 | - See https://github.com/easylogging/easyloggingpp/blob/v9.73/README.md for manual for this release 18 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 19 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.74: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.74 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | =========================== 8 | = NEW FEATURES = 9 | =========================== 10 | 11 | - `fbase` format specifier 12 | - VModule clear module function 13 | - `levshort` format specifier 14 | 15 | ========================== 16 | = BUG FIXES = 17 | ========================== 18 | 19 | - Fixes issue with `AutoSpacing` with timing facilities 20 | 21 | ========================== 22 | = NOTES = 23 | ========================== 24 | 25 | - See https://github.com/easylogging/easyloggingpp/blob/v9.74/README.md for manual for this release 26 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 27 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 28 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.75: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.75 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================== 8 | = BUG FIXES = 9 | ========================== 10 | 11 | - Makes Mutex non-copyable (issue #191) 12 | - Fixes issue with `DefaultPerformanceTrackingCallback` (issue #190) 13 | - Fix build for VS2013 under high warnings [warning level 4] (issue #194) 14 | - Fixes a lot of reference to temporary warnings 15 | 16 | ========================== 17 | = NOTES = 18 | ========================== 19 | 20 | - See https://github.com/easylogging/easyloggingpp/blob/v9.75/README.md for manual for this release 21 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 22 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.76: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.76 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Major 5 | API changes: No 6 | 7 | ========================== 8 | = NEW FEATURES = 9 | ========================== 10 | 11 | - Experimental asynchronous logging using `_ELPP_EXPERIMENTAL_ASYNC_LOGGING` (issue #202) 12 | - `CHECK_BOUNDS` macro to check boundaries (issue #204) 13 | 14 | ========================== 15 | = API CHANGES = 16 | ========================== 17 | 18 | - `Logger::flush(Level, base::type::fstream_t)` and `Logger::isFlushNeeded(Level)` made public 19 | 20 | ========================== 21 | = NOTES = 22 | ========================== 23 | 24 | - See https://github.com/easylogging/easyloggingpp/blob/v9.76/README.md for manual for this release 25 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 26 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 27 | - Removed references to `easylogging.org` as site will no longer service. 28 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.77: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.77 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Major 5 | API changes: No 6 | 7 | ========================== 8 | = BUG FIXES = 9 | ========================== 10 | 11 | - Using _ELPP_DISABLE_ASSERT breaks config file parsing (issue #218) 12 | 13 | ========================== 14 | = NEW FEATURES = 15 | ========================== 16 | 17 | - Support for unique unit of measure in performance tracking (issue #208) 18 | - Changing default format from a more localized %d/%M/%Y to ISO 8601 standard (issue #200) 19 | 20 | ========================== 21 | = BUILD FIX = 22 | ========================== 23 | 24 | - Warning fix for `sleep` 25 | 26 | ========================== 27 | = NOTES = 28 | ========================== 29 | 30 | - Changed donation policy 31 | - See https://github.com/easylogging/easyloggingpp/blob/v9.77/README.md for manual for this release 32 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 33 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 34 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.78: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.78 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================== 8 | = NEW FEATURES = 9 | ========================== 10 | 11 | - Ability to add, clear verbose modules on the fly (issue #219) 12 | - Ability to set verbose logging level on the fly (issue #238) 13 | - Solaris support added 14 | 15 | ========================== 16 | = BUILD FIX = 17 | ========================== 18 | 19 | - Warning for `nextTok_` in VS2013 (issue #237) 20 | 21 | ========================== 22 | = BUG FIX = 23 | ========================== 24 | 25 | - `LoggingFlag::AutoSpacing` does not work with some types (issue #220) 26 | 27 | ========================== 28 | = NOTES = 29 | ========================== 30 | 31 | - Experimental async logging only for specific compilers 32 | - Removed `easyloggingpp` as namespace 33 | - Changed support email address 34 | - See https://github.com/easylogging/easyloggingpp/blob/v9.78/README.md for manual for this release 35 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 36 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 37 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/doc/RELEASE-NOTES-v9.80: -------------------------------------------------------------------------------- 1 | Easylogging++ v9.80 RELEASE NOTES 2 | --------------------------------- 3 | 4 | Release type: Minor 5 | API changes: No 6 | 7 | ========================== 8 | = NOTES = 9 | ========================== 10 | 11 | - Licence update 12 | - Email update 13 | - See https://github.com/easylogging/easyloggingpp/blob/v9.80/README.md for manual for this release 14 | - See https://github.com/easylogging/easyloggingpp/tree/master/doc for other release notes 15 | - Closed issues: https://github.com/easylogging/easyloggingpp/issues?page=1&state=closed 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/API/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/API/build_all.sh: -------------------------------------------------------------------------------- 1 | 2 | # Builds all files into bin/ 3 | 4 | [ -d "bin" ] || mkdir "bin" 5 | rm -rf bin/* 6 | 7 | find -maxdepth 1 -type f -name '*.cpp' -exec sh compile.sh {} $1 \; 8 | echo "Completed!" 9 | 10 | files=$(ls -l bin/) 11 | if [ "$files" = "total 0" ];then 12 | exit 1 13 | else 14 | exit 0 15 | fi 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/API/compile.sh: -------------------------------------------------------------------------------- 1 | ## Helper script for build_all.sh 2 | 3 | FILE=$1 4 | 5 | macro="$macro -DELPP_THREAD_SAFE" 6 | macro="$macro -DELPP_STL_LOGGING" 7 | macro="$macro -DELPP_LOG_UNORDERED_SET" 8 | macro="$macro -DELPP_LOG_UNORDERED_MAP" 9 | macro="$macro -DELPP_STACKTRACE_ON_CRASH" 10 | 11 | if [ "$2" = "" ];then 12 | COMPILER=g++ 13 | else 14 | COMPILER=$2 15 | fi 16 | 17 | CXX_STD='-std=c++0x -pthread' 18 | 19 | if [ "$FILE" = "" ]; then 20 | echo "Please provide filename to compile" 21 | exit 22 | fi 23 | 24 | echo "Compiling... [$FILE]" 25 | 26 | COMPILE_LINE="$COMPILER $FILE -o bin/$FILE.bin $macro $CXX_STD -Wall -Wextra -pedantic -pedantic-errors -Werror -Wfatal-errors" 27 | 28 | echo " $COMPILE_LINE" 29 | 30 | $($COMPILE_LINE) 31 | 32 | echo " DONE! [./bin/$FILE.bin]" 33 | echo 34 | echo 35 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/API/logbuilder.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Simple custom log builder 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | /// @brief Not a very fast log builder but good enough for sample 14 | class MyLogBuilder : public el::LogBuilder { 15 | public: 16 | std::string build(const el::LogMessage* logMessage, bool appendNewLine) const { 17 | std::stringstream str; 18 | str << logMessage->message(); 19 | if (appendNewLine) str << "\n"; 20 | return str.str().c_str(); 21 | } 22 | }; 23 | 24 | int main(void) { 25 | el::LogBuilderPtr myLogBuilder = el::LogBuilderPtr(new MyLogBuilder()); 26 | el::Loggers::getLogger("default")->setLogBuilder(myLogBuilder); 27 | LOG(INFO) << "message from default logger"; 28 | 29 | el::Loggers::getLogger("new_logger"); 30 | CLOG(INFO, "new_logger") << "message from new_logger logger"; 31 | 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/API/run.sh: -------------------------------------------------------------------------------- 1 | echo "Running '$1'..." 2 | ./$1 3 | echo "Finished '$1'" 4 | echo 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/API/run_all.sh: -------------------------------------------------------------------------------- 1 | ## Runs all the build binaries from bin/ folder 2 | 3 | find bin/ -name '*.cpp.bin' -exec sh ./run.sh ./{} \; 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Dev-C++/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | *.o 3 | logs/* 4 | *.exe 5 | Makefile.win -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Dev-C++/HelloDevC++.dev: -------------------------------------------------------------------------------- 1 | [Project] 2 | FileName=HelloDevC++.dev 3 | Name=Project2 4 | Type=1 5 | Ver=2 6 | ObjFiles= 7 | Includes= 8 | Libs= 9 | PrivateResource= 10 | ResourceIncludes= 11 | MakeIncludes= 12 | Compiler= 13 | CppCompiler=-std=c++11_@@_ 14 | Linker= 15 | IsCpp=1 16 | Icon= 17 | ExeOutput= 18 | ObjectOutput= 19 | LogOutput= 20 | LogOutputEnabled=0 21 | OverrideOutput=0 22 | OverrideOutputName=HelloDevC++.exe 23 | HostApplication= 24 | UseCustomMakefile=0 25 | CustomMakefile= 26 | CommandLine= 27 | Folders= 28 | IncludeVersionInfo=0 29 | SupportXPThemes=0 30 | CompilerSet=4 31 | CompilerSettings=0000000100000000001000000 32 | UnitCount=1 33 | 34 | [VersionInfo] 35 | Major=1 36 | Minor=0 37 | Release=0 38 | Build=0 39 | LanguageID=1033 40 | CharsetID=1252 41 | CompanyName= 42 | FileVersion=1.0.0.0 43 | FileDescription=Developed using the Dev-C++ IDE 44 | InternalName= 45 | LegalCopyright= 46 | LegalTrademarks= 47 | OriginalFilename= 48 | ProductName= 49 | ProductVersion=1.0.0.0 50 | AutoIncBuildNr=0 51 | SyncProduct=1 52 | 53 | [Unit1] 54 | FileName=main.cpp 55 | CompileCpp=1 56 | Folder= 57 | Compile=1 58 | Link=1 59 | Priority=1000 60 | OverrideBuildCmd=0 61 | BuildCmd= 62 | 63 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Dev-C++/HelloDevC++.layout: -------------------------------------------------------------------------------- 1 | [Editors] 2 | Focused=0 3 | Order=-1,0 4 | [Editor_0] 5 | Open=1 6 | Top=1 7 | CursorCol=2 8 | CursorRow=9 9 | TopLine=1 10 | LeftChar=1 11 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Dev-C++/main.cpp: -------------------------------------------------------------------------------- 1 | #define ELPP_STL_LOGGING 2 | #include "../../src/easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | int main(int argc, char** argv) { 7 | LOG(INFO) << "Hello Dev C++!"; 8 | return 0; 9 | } 10 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/MinGW/.gitignore: -------------------------------------------------------------------------------- 1 | logs/* 2 | *.exe -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/MinGW/compile.bat: -------------------------------------------------------------------------------- 1 | echo Assuming C:\MinGW for MinGW 2 | 3 | set path=%path%;C:\MinGW\bin\ 4 | 5 | "C:\MinGW\bin\g++.exe" prog.cpp -std=c++11 -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/MinGW/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/MinGW/prog.cpp: -------------------------------------------------------------------------------- 1 | #define ELPP_STL_LOGGING 2 | // #define ELPP_STACKTRACE_ON_CRASH -- Stack trace not available for MinGW GCC 3 | #define ELPP_PERFORMANCE_MICROSECONDS 4 | #define ELPP_LOG_STD_ARRAY 5 | #define ELPP_LOG_UNORDERED_MAP 6 | #define ELPP_UNORDERED_SET 7 | #include "easylogging++.h" 8 | 9 | INITIALIZE_EASYLOGGINGPP 10 | 11 | TIMED_SCOPE(appTimer, "myapplication"); 12 | 13 | 14 | int main(int argc, const char* argv[]) { 15 | el::Helpers::removeFlag(el::LoggingFlag::AllowVerboseIfModuleNotSpecified); 16 | 17 | TIMED_BLOCK(itr, "write-simple") { 18 | LOG(INFO) << "Test " << __FILE__; 19 | } 20 | VLOG(3) << "Test"; 21 | } 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/Cube/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/Cube/LICENCE: -------------------------------------------------------------------------------- 1 | Permission is hereby granted, free of charge, to any person obtaining a copy 2 | of this software and associated documentation files (the "Software"), to deal 3 | in the Software without restriction, including without limitation the rights 4 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 5 | copies of the Software, and to permit persons to whom the Software is 6 | furnished to do so, subject to the following conditions: 7 | 8 | The above notice and this permission notice shall be included in all copies 9 | or substantial portions of the Software. 10 | 11 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 12 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 13 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 14 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 15 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 16 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 17 | SOFTWARE. 18 | 19 | File for "Putting It All Together" lesson of the OpenGL tutorial on 20 | www.videotutorialsrock.com 21 | 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/Cube/Makefile: -------------------------------------------------------------------------------- 1 | CC = g++ 2 | CFLAGS = -Wall -std=c++11 3 | PROG = cube 4 | 5 | SRCS = main.cpp imageloader.cpp 6 | 7 | ifeq ($(shell uname),Darwin) 8 | LIBS = -framework OpenGL -framework GLUT 9 | else 10 | LIBS = -lglut -lGLU -lGL 11 | endif 12 | 13 | all: $(PROG) 14 | 15 | $(PROG): $(SRCS) 16 | $(CC) $(CFLAGS) -o bin/$(PROG) $(SRCS) $(LIBS) 17 | 18 | clean: 19 | rm -f $(PROG) 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/Cube/imageloader.h: -------------------------------------------------------------------------------- 1 | #ifndef IMAGE_LOADER_H_INCLUDED 2 | #define IMAGE_LOADER_H_INCLUDED 3 | 4 | //Represents an image 5 | class Image { 6 | public: 7 | Image(char* ps, int w, int h); 8 | ~Image(); 9 | 10 | /* An array of the form (R1, G1, B1, R2, G2, B2, ...) indicating the 11 | * color of each pixel in image. Color components range from 0 to 255. 12 | * The array starts the bottom-left pixel, then moves right to the end 13 | * of the row, then moves up to the next column, and so on. This is the 14 | * format in which OpenGL likes images. 15 | */ 16 | char* pixels; 17 | int width; 18 | int height; 19 | }; 20 | 21 | //Reads a bitmap image from file. 22 | Image* loadBMP(const char* filename); 23 | #endif 24 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/Cube/vtr.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qijiezhao/OpticalFlow-SpeedTest/dee9750cc26c42bc26a1e58e69f7e75425c3f912/dense_flow/include/easylogging++/samples/OpenGL/Cube/vtr.bmp -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/basic.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | int main(void) { 7 | 8 | GLfloat f = 0.1f; 9 | LOG(INFO) << f; 10 | 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/build_all.sh: -------------------------------------------------------------------------------- 1 | 2 | # Builds all files into bin/ 3 | 4 | [ -d "bin" ] || mkdir "bin" 5 | rm -rf bin/* 6 | 7 | find -maxdepth 1 -type f -name '*.cpp' -exec sh compile.sh {} $1 \; 8 | echo "Completed!" 9 | 10 | files=$(ls -l bin/) 11 | if [ "$files" = "total 0" ];then 12 | exit 1 13 | else 14 | exit 0 15 | fi 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/compile.sh: -------------------------------------------------------------------------------- 1 | ## Helper script for build_all.sh 2 | 3 | FILE=$1 4 | 5 | macro="$macro -DELPP_THREAD_SAFE" 6 | macro="$macro -DELPP_STL_LOGGING" 7 | macro="$macro -DELPP_LOG_STD_ARRAY" 8 | macro="$macro -DELPP_LOG_UNORDERED_SET" 9 | macro="$macro -DELPP_LOG_UNORDERED_MAP" 10 | macro="$macro -DELPP_STACKTRACE_ON_CRASH" 11 | 12 | if [ "$2" = "" ];then 13 | COMPILER=g++ 14 | else 15 | COMPILER=$2 16 | fi 17 | 18 | CXX_STD='-std=c++0x -pthread' 19 | 20 | if [ "$FILE" = "" ]; then 21 | echo "Please provide filename to compile" 22 | exit 23 | fi 24 | 25 | echo "Compiling... [$FILE]" 26 | 27 | COMPILE_LINE="$COMPILER $FILE -o bin/$FILE.bin $macro $CXX_STD -Wall -Wextra -lglut -lGLU -lGL -I/usr/include/x86_64-linux-gnu/c++/4.7/" 28 | 29 | echo " $COMPILE_LINE" 30 | 31 | $($COMPILE_LINE) 32 | 33 | echo " DONE! [./bin/$FILE.bin]" 34 | echo 35 | echo 36 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/run.sh: -------------------------------------------------------------------------------- 1 | echo "Running '$1'..." 2 | ./$1 3 | echo "Finished '$1'" 4 | echo 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/OpenGL/run_all.sh: -------------------------------------------------------------------------------- 1 | ## Runs all the build binaries from bin/ folder 2 | 3 | find bin/ -name '*.cpp.bin' -exec sh ./run.sh ./{} \; 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/.gitignore: -------------------------------------------------------------------------------- 1 | Makefile 2 | build-* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/basic/README.md: -------------------------------------------------------------------------------- 1 | ###### Easylogging++ Qt Samples 2 | 3 | This sample contains: 4 | * Qt containers 5 | * QThread based multi-threading 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/basic/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/basic/qt-sample.pro: -------------------------------------------------------------------------------- 1 | QT += core 2 | greaterThan(QT_MAJOR_VERSION, 4) 3 | 4 | CONFIG += static 5 | DEFINES += ELPP_QT_LOGGING \ 6 | ELPP_STL_LOGGING \ 7 | ELPP_STRICT_SIZE_CHECK ELPP_UNICODE \ 8 | ELPP_MULTI_LOGGER_SUPPORT \ 9 | ELPP_THREAD_SAFE 10 | 11 | TARGET = main.cpp.bin 12 | TEMPLATE = app 13 | QMAKE_CXXFLAGS += -std=c++11 14 | SOURCES += main.cpp 15 | HEADERS += \ 16 | mythread.h \ 17 | easylogging++.h 18 | 19 | OTHER_FILES += \ 20 | test_conf.conf 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/basic/test_conf.conf: -------------------------------------------------------------------------------- 1 | // Set configurations for all format 2 | * GLOBAL: 3 | FORMAT = "%level: %log" 4 | FILENAME = "/tmp/logs/qt.log" 5 | ENABLED = true 6 | TO_FILE = true 7 | TO_STANDARD_OUTPUT = true 8 | MILLISECONDS_WIDTH = 6 9 | PERFORMANCE_TRACKING = false 10 | MAX_LOG_FILE_SIZE = 1024 11 | * WARNING: 12 | FILENAME = "/tmp/logs/warnings.log" 13 | MAX_LOG_FILE_SIZE = 100 14 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/fast-dictionary/.gitignore: -------------------------------------------------------------------------------- 1 | logs/* 2 | fast-dictionary 3 | *.o 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/fast-dictionary/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/fast-dictionary/fast-dictionary.pro: -------------------------------------------------------------------------------- 1 | #------------------------------------------------- 2 | # 3 | # Project created by QtCreator 2013-03-19T22:31:41 4 | # 5 | #------------------------------------------------- 6 | 7 | QT += core gui 8 | 9 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets 10 | 11 | TARGET = fast-dictionary 12 | TEMPLATE = app 13 | 14 | COMPILER = g++ 15 | QMAKE_CC = $$COMPILER 16 | QMAKE_CXX = $$COMPILER 17 | QMAKE_LINK = $$COMPILER 18 | 19 | QMAKE_CXXFLAGS += -std=c++0x 20 | DEFINES += ELPP_STACKTRACE_ON_CRASH \ 21 | ELPP_MULTI_LOGGER_SUPPORT 22 | 23 | SOURCES += main.cc\ 24 | mainwindow.cc \ 25 | listwithsearch.cc 26 | 27 | HEADERS += mainwindow.hh \ 28 | listwithsearch.hh \ 29 | easylogging++.h 30 | 31 | FORMS += mainwindow.ui 32 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/fast-dictionary/listwithsearch.hh: -------------------------------------------------------------------------------- 1 | #ifndef LISTWITHSEARCH_HH 2 | #define LISTWITHSEARCH_HH 3 | 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | 11 | class QResizeEvent; 12 | class QListWidgetItem; 13 | template 14 | class QFuture; 15 | 16 | class ListWithSearch : public QWidget 17 | { 18 | Q_OBJECT 19 | 20 | public: 21 | static int kSearchBarHeight; 22 | enum kBehaviour { kCaseInsensative, kCaseSensative }; 23 | 24 | explicit ListWithSearch(int searchBehaviour_ = kCaseSensative, QWidget *parent = 0); 25 | virtual ~ListWithSearch(); 26 | void add(const QString& item); 27 | void resizeEvent(QResizeEvent *); 28 | void setFocus(void); 29 | 30 | private slots: 31 | void on_txtSearchCriteria_textChanged(const QString&); 32 | void selected(void); 33 | 34 | signals: 35 | void selectionMade(const QString& selection); 36 | 37 | private: 38 | QWidget* parent_; 39 | QListWidget* list; 40 | QLineEdit* txtSearchCriteria; 41 | QList items; 42 | QFuture future_; 43 | QFutureWatcher watcher; 44 | int searchBehaviour_; 45 | 46 | void setup(QWidget *parent = 0); 47 | void performSearch(void); 48 | 49 | }; 50 | 51 | #endif // LISTWITHSEARCH_HH 52 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/fast-dictionary/main.cc: -------------------------------------------------------------------------------- 1 | #include "mainwindow.hh" 2 | #include 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | TIMED_SCOPE(app, "app"); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | START_EASYLOGGINGPP(argc, argv); 12 | el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Format, "%datetime{%d/%M/%y} %msg"); 13 | QApplication a(argc, argv); 14 | MainWindow w; 15 | w.show(); 16 | for (int i = 1; i <= 10; ++i) { 17 | CLOG_EVERY_N(2, INFO, "default", "performance") << ELPP_COUNTER_POS; 18 | } 19 | return a.exec(); 20 | } 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/fast-dictionary/mainwindow.hh: -------------------------------------------------------------------------------- 1 | #ifndef MAINWINDOW_HH 2 | #define MAINWINDOW_HH 3 | 4 | #include 5 | 6 | namespace Ui { 7 | class MainWindow; 8 | } 9 | 10 | class ListWithSearch; 11 | class MainWindow : public QMainWindow 12 | { 13 | Q_OBJECT 14 | 15 | public: 16 | explicit MainWindow(QWidget *parent = 0); 17 | ~MainWindow(); 18 | 19 | /** 20 | * Loads memory from list of words provided as param. 21 | * Note, in the source file, this function has performance tracking on. 22 | */ 23 | void initializeDictionary(const QString& wordsFile); 24 | void resizeEvent(QResizeEvent *); 25 | public slots: 26 | void onSelectionMade(const QString& word); 27 | 28 | private slots: 29 | void on_buttonInfo_clicked(); 30 | 31 | private: 32 | Ui::MainWindow* ui; 33 | ListWithSearch* list; 34 | }; 35 | 36 | #endif // MAINWINDOW_HH 37 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/fast-dictionary/words.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qijiezhao/OpticalFlow-SpeedTest/dee9750cc26c42bc26a1e58e69f7e75425c3f912/dense_flow/include/easylogging++/samples/Qt/fast-dictionary/words.txt -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/.gitignore: -------------------------------------------------------------------------------- 1 | # C++ objects and libs 2 | 3 | *.slo 4 | *.lo 5 | *.o 6 | *.a 7 | *.la 8 | *.lai 9 | *.so 10 | *.dll 11 | *.dylib 12 | 13 | # Qt-es 14 | 15 | *.pro.user 16 | *.pro.user.* 17 | moc_*.cpp 18 | qrc_*.cpp 19 | *-build-* 20 | ui_*.h 21 | 22 | # logs 23 | logs/* 24 | # binary 25 | file-splitter-and-joiner 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/README.md: -------------------------------------------------------------------------------- 1 | ###### File splitter/joiner sample 2 | 3 | **About** 4 | 5 | This is multi-threaded application that uses threads in order to split/merge part/s. The idea is not to show how to use threading in Qt, in fact, I might have done it wrong ([this document](http://qt-project.org/wiki/Threads_Events_QObjects) can be helpful to make thread-use better), the idea behind this sample is to show you a possible usage of Easylogging++ is fairly large scale i.e, multiple files project using multi-threading. 6 | 7 | **Usage** 8 | 9 | Once you successfully compile the project using minimum of Qt 4.6.2, you can use this in two ways; 10 | 11 | * Using command-line 12 | 13 | **Split**: `./file-splitter-joiner split [source_file] [total_parts] [destination_dir]` 14 | 15 | **Join**: `./file-splitter-joiner join [destination_file] [parts...]` 16 | 17 | * Using GUI 18 | 19 | When you don't provide enough parameters, a GUI based program will be launched 20 | 21 | **Screen Shots** 22 | 23 | [![Splitter](http://easylogging.org/images/screenshots/splitter.png)](http://easylogging.org/images/screenshots/splitter.png) 24 | 25 | [![Joiner](http://easylogging.org/images/screenshots/joiner.png)](http://easylogging.org/images/screenshots/joiner.png) 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/about.cpp: -------------------------------------------------------------------------------- 1 | #include "about.h" 2 | #include "ui_about.h" 3 | #include 4 | #include "easylogging++.h" 5 | 6 | About::About(QWidget *parent) : 7 | QWidget(parent), 8 | ui(new Ui::About) { 9 | ui->setupUi(this); 10 | ui->el_info->setText(QString("Easylogging++ v") + QString(el::VersionInfo::version().c_str())); 11 | } 12 | 13 | About::~About() { 14 | delete ui; 15 | } 16 | 17 | void About::on_pushButton_clicked() { 18 | QMessageBox aboutQt; 19 | aboutQt.aboutQt(this); 20 | } 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/about.h: -------------------------------------------------------------------------------- 1 | #ifndef ABOUT_H 2 | #define ABOUT_H 3 | 4 | #include 5 | 6 | 7 | namespace Ui { 8 | class About; 9 | } 10 | 11 | class About : public QWidget { 12 | Q_OBJECT 13 | 14 | public: 15 | explicit About(QWidget *parent = 0); 16 | ~About(); 17 | 18 | private slots: 19 | void on_pushButton_clicked(); 20 | 21 | private: 22 | Ui::About *ui; 23 | }; 24 | 25 | #endif // ABOUT_H 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/addsplittedfiledialog.h: -------------------------------------------------------------------------------- 1 | #ifndef ADDSPLITTEDFILEDIALOG_H 2 | #define ADDSPLITTEDFILEDIALOG_H 3 | 4 | #include 5 | 6 | namespace Ui { 7 | class AddSplittedFileDialog; 8 | } 9 | 10 | class QTreeWidget; 11 | class QTreeWidgetItem; 12 | class QDialogButtonBox; 13 | 14 | class AddSplittedFileDialog : public QDialog { 15 | Q_OBJECT 16 | 17 | public: 18 | explicit AddSplittedFileDialog(QTreeWidget* parentView, QWidget *parent = 0); 19 | ~AddSplittedFileDialog(); 20 | 21 | private slots: 22 | void on_buttonAddPart_clicked(); 23 | void on_buttonBox_accepted(); 24 | 25 | void on_pushButton_clicked(); 26 | 27 | void on_buttonRemove_clicked(); 28 | 29 | private: 30 | Ui::AddSplittedFileDialog *ui; 31 | QTreeWidgetItem* filenamePointer; 32 | QTreeWidgetItem* filePartsPointers; 33 | QTreeWidget* parentView; 34 | QDialogButtonBox* buttonOkCancel; 35 | }; 36 | 37 | #endif // ADDSPLITTEDFILEDIALOG_H 38 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/file-splitter-and-joiner.pro: -------------------------------------------------------------------------------- 1 | #------------------------------------------------- 2 | # 3 | # Project created by QtCreator 2012-12-12T18:34:35 4 | # 5 | #------------------------------------------------- 6 | 7 | QT += core gui 8 | 9 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets 10 | 11 | TARGET = file-splitter-and-joiner 12 | TEMPLATE = app 13 | 14 | DEFINES += ELPP_QT_LOGGING \ 15 | ELPP_STL_LOGGING \ 16 | ELPP_STRICT_SIZE_CHECK \ 17 | ELPP_STACKTRACE_ON_CRASH \ 18 | ELPP_THREAD_SAFE 19 | 20 | COMPILER = g++ 21 | QMAKE_CC = $$COMPILER 22 | QMAKE_CXX = $$COMPILER 23 | QMAKE_LINK = $$COMPILER 24 | 25 | QMAKE_CXXFLAGS += -std=c++11 26 | 27 | SOURCES += main.cpp\ 28 | mainwindow.cpp \ 29 | splitterwidget.cpp \ 30 | joinerwidget.cpp \ 31 | splitablefiledelegate.cpp \ 32 | splittercore.cpp \ 33 | partprocessor.cpp \ 34 | addsplittedfiledialog.cpp \ 35 | joinercore.cpp \ 36 | about.cpp 37 | 38 | HEADERS += mainwindow.h \ 39 | easylogging++.h \ 40 | splitterwidget.h \ 41 | joinerwidget.h \ 42 | splitablefiledelegate.h \ 43 | splittercore.h \ 44 | partprocessor.h \ 45 | addsplittedfiledialog.h \ 46 | joinercore.h \ 47 | about.h 48 | 49 | FORMS += \ 50 | joinerwidget.ui \ 51 | splitterwidget.ui \ 52 | addsplittedfiledialog.ui \ 53 | about.ui 54 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/joinercore.cpp: -------------------------------------------------------------------------------- 1 | #include "joinercore.h" 2 | #include 3 | #include 4 | #include "partprocessor.h" 5 | 6 | JoinerCore::JoinerCore(QTreeWidget* widget) { 7 | this->widget = widget; 8 | core = nullptr; 9 | } 10 | 11 | void JoinerCore::startJoining(void) { 12 | QList parts; 13 | QString filename = ""; 14 | for (int i = 0; i < widget->topLevelItemCount(); i++) { 15 | if (core) { 16 | delete core; 17 | core = nullptr; 18 | } 19 | QTreeWidgetItem* currentFile = widget->topLevelItem(i); 20 | parts.clear(); 21 | filename = currentFile->text(0); 22 | for (int p = 0; p < currentFile->childCount(); p++) { 23 | parts.append(currentFile->child(p)->text(0)); 24 | } 25 | core = new PartProcessor(parts, filename, QModelIndex(), PartProcessor::kMerge, this); 26 | connect(core, SIGNAL(updated(PartProcessor*)), this, SIGNAL(updated(PartProcessor*))); 27 | connect(core, SIGNAL(started(PartProcessor*)), this, SIGNAL(started(PartProcessor*))); 28 | connect(core, SIGNAL(finished(PartProcessor*)), this, SIGNAL(finished(PartProcessor*))); 29 | core->start(); 30 | emit started(core); 31 | core->wait(); 32 | emit finished(core); 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/joinercore.h: -------------------------------------------------------------------------------- 1 | #ifndef JOINERCORE_H 2 | #define JOINERCORE_H 3 | 4 | #include 5 | 6 | class QTreeWidget; 7 | class PartProcessor; 8 | 9 | class JoinerCore : public QObject { 10 | Q_OBJECT 11 | public: 12 | explicit JoinerCore(QTreeWidget* widget); 13 | void startJoining(void); 14 | private: 15 | QTreeWidget* widget; 16 | PartProcessor* core; 17 | signals: 18 | void updated(PartProcessor*) const; 19 | void started(PartProcessor*) const; 20 | void finished(PartProcessor*) const; 21 | }; 22 | 23 | #endif // JOINERCORE_H 24 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/joinerwidget.h: -------------------------------------------------------------------------------- 1 | #ifndef JOINERWIDGET_H 2 | #define JOINERWIDGET_H 3 | 4 | #include 5 | namespace Ui { 6 | class JoinerWidget; 7 | } 8 | class PartProcessor; 9 | class JoinerCore; 10 | class JoinerWidget : public QWidget { 11 | Q_OBJECT 12 | 13 | public: 14 | explicit JoinerWidget(QWidget *parent = 0); 15 | ~JoinerWidget(); 16 | 17 | private slots: 18 | void on_buttonAddParts_clicked(); 19 | 20 | void on_buttonUp_clicked(); 21 | 22 | void on_buttonDown_clicked(); 23 | 24 | void on_buttonStart_clicked(); 25 | void updated(PartProcessor*); 26 | void finished(PartProcessor*); 27 | void started(PartProcessor*); 28 | private: 29 | Ui::JoinerWidget *ui; 30 | JoinerCore* core; 31 | 32 | }; 33 | 34 | #endif // JOINERWIDGET_H 35 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/mainwindow.h: -------------------------------------------------------------------------------- 1 | #ifndef MAINWINDOW_H 2 | #define MAINWINDOW_H 3 | 4 | #include 5 | 6 | class QTabWidget; 7 | class SplitterWidget; 8 | class JoinerWidget; 9 | class About; 10 | 11 | class MainWindow : public QMainWindow { 12 | Q_OBJECT 13 | 14 | public: 15 | const static int kWidth = 550; 16 | const static int kHeight = 400; 17 | MainWindow(QWidget *parent = 0); 18 | QTabWidget* tabWidget; 19 | ~MainWindow(); 20 | private: 21 | SplitterWidget* splitterWidget; 22 | JoinerWidget* joinerWidget; 23 | About* about; 24 | 25 | void setupUi(void); 26 | void initWidgets(void); 27 | }; 28 | 29 | #endif // MAINWINDOW_H 30 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/splitablefiledelegate.h: -------------------------------------------------------------------------------- 1 | #ifndef SPLITABLEFILEDELEGATE_H 2 | #define SPLITABLEFILEDELEGATE_H 3 | 4 | #include 5 | class SplitterWidget; 6 | 7 | class SplitableFileDelegate : public QItemDelegate { 8 | Q_OBJECT 9 | public: 10 | SplitableFileDelegate(SplitterWidget *parent = 0); 11 | 12 | virtual QWidget *createEditor(QWidget *parent, const QStyleOptionViewItem &, 13 | const QModelIndex &index) const; 14 | 15 | virtual void setEditorData(QWidget *editor, const QModelIndex &index) const; 16 | virtual void setModelData(QWidget *editor, QAbstractItemModel *model, 17 | const QModelIndex &index) const; 18 | 19 | virtual void updateEditorGeometry(QWidget *editor, 20 | const QStyleOptionViewItem &option, const QModelIndex &index) const; 21 | virtual void paint(QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index) const; 22 | private: 23 | SplitterWidget* parent; 24 | }; 25 | #endif // SPLITABLEFILEDELEGATE_H 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/file-splitter-joiner/splittercore.h: -------------------------------------------------------------------------------- 1 | #ifndef SPLITTER_H 2 | #define SPLITTER_H 3 | 4 | #include 5 | #include 6 | 7 | class QModelIndex; 8 | class QStandardItemModel; 9 | class PartProcessor; 10 | class SplitterWidget; 11 | 12 | class SplitterCore : public QThread { 13 | Q_OBJECT 14 | public: 15 | SplitterCore(QStandardItemModel* fileModel, QObject* parent = 0, SplitterWidget* parentWidget = 0); 16 | void run(void); 17 | 18 | bool paused(void) const; 19 | void cancel(void); 20 | void pause(void); 21 | void resume(void); 22 | private: 23 | QStandardItemModel* fileModel; 24 | QList splitJoinCores; 25 | bool cancelled; 26 | SplitterWidget* parent; 27 | signals: 28 | void updated(PartProcessor*) const; 29 | void started(PartProcessor*) const; 30 | void finished(PartProcessor*) const; 31 | void fileStarted(int index, const QString& filename, const QString& destinationDir, int totalParts) const; 32 | void fileCompleted(int index) const; 33 | }; 34 | 35 | #endif // SPLITTER_H 36 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/README.md: -------------------------------------------------------------------------------- 1 | ``` 2 | A very simple sample demonstrating an app and shared-lib usage that both uses 3 | easylogging++ as their logging library. 4 | 5 | @rev 1.0 6 | @since v9.01 7 | @author mkhan3189 8 | ``` 9 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/myapp/easylogging++.h: -------------------------------------------------------------------------------- 1 | #ifndef EASYLOGGING_H 2 | #define EASYLOGGING_H 3 | #include "../../../../src/easylogging++.h" 4 | #endif // EASYLOGGING_H 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/myapp/main.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include "mylib.hh" 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | int main(int argc, char *argv[]) 8 | { 9 | QApplication a(argc, argv); 10 | 11 | Mylib l; 12 | 13 | LOG(INFO) << "1 + 2 = " << l.add(1, 2); 14 | LOG(INFO) << "1 / 2 = " << l.div(1, 2); 15 | LOG(DEBUG) << "1 * 2 = " << l.mul(1, 2); 16 | 17 | // This will cause FATAL error because of division by zero 18 | // LOG(INFO) << l.div(1, 0); 19 | 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/myapp/myapp.pro: -------------------------------------------------------------------------------- 1 | #------------------------------------------------- 2 | # 3 | # Project created by QtCreator 2013-08-17T01:02:59 4 | # 5 | #------------------------------------------------- 6 | 7 | QT += core gui 8 | 9 | greaterThan(QT_MAJOR_VERSION, 4): QT += widgets 10 | 11 | TARGET = myapp 12 | TEMPLATE = app 13 | 14 | QMAKE_CXXFLAGS += -std=c++11 15 | 16 | DEPENDPATH += . ../mylib 17 | INCLUDEPATH += ../mylib 18 | LIBS+= -L../build-mylib -lmylib # try in lib build dir "sudo cp %{buildDir}/libmylib.so* /usr/lib/" to make this work 19 | 20 | 21 | SOURCES += main.cc 22 | 23 | HEADERS += \ 24 | easylogging++.h 25 | 26 | FORMS += 27 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/mylib/easylogging++.h: -------------------------------------------------------------------------------- 1 | #ifndef EASYLOGGING_H 2 | #define EASYLOGGING_H 3 | #include "../../../../src/easylogging++.h" 4 | #endif // EASYLOGGING_H 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/mylib/mylib.cc: -------------------------------------------------------------------------------- 1 | #include "mylib.hh" 2 | 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | Mylib::Mylib(void) 8 | { 9 | LOG(INFO) << "Mylib has been constructed"; 10 | } 11 | 12 | Mylib::~Mylib() 13 | { 14 | LOG(INFO) << "Destroying Mylib"; 15 | } 16 | 17 | float Mylib::add(float x, float y) const 18 | { 19 | LOG(INFO) << "Adding " << x << " and " << y; 20 | return x + y; 21 | } 22 | 23 | float Mylib::sub(float x, float y) const 24 | { 25 | LOG(INFO) << "Subtracting " << y << " from " << x; 26 | return y - x; 27 | } 28 | 29 | float Mylib::mul(float x, float y) const 30 | { 31 | LOG(INFO) << "Multiplying " << x << " and " << y; 32 | return x * y; 33 | } 34 | 35 | float Mylib::div(float x, float y) const 36 | { 37 | CHECK_NE(y, 0) << "Division by zero!"; 38 | LOG(INFO) << "Dividing " << x << " by " << y; 39 | return x / y; 40 | } 41 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/mylib/mylib.hh: -------------------------------------------------------------------------------- 1 | #ifndef MYLIB_HH 2 | #define MYLIB_HH 3 | 4 | #include "mylib_global.hh" 5 | 6 | class MYLIBSHARED_EXPORT Mylib 7 | { 8 | 9 | public: 10 | Mylib(void); 11 | virtual ~Mylib(void); 12 | float add(float x, float y) const; 13 | float sub(float x, float y) const; 14 | float mul(float x, float y) const; 15 | float div(float x, float y) const; 16 | }; 17 | 18 | #endif // MYLIB_HH 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/mylib/mylib.pro: -------------------------------------------------------------------------------- 1 | #------------------------------------------------- 2 | # 3 | # Project created by QtCreator 2013-08-17T00:52:43 4 | # 5 | #------------------------------------------------- 6 | 7 | QT -= gui 8 | 9 | TARGET = mylib 10 | TEMPLATE = lib 11 | 12 | QMAKE_CXXFLAGS += -std=c++11 13 | 14 | DEFINES += MYLIB_LIBRARY 15 | 16 | SOURCES += mylib.cc 17 | 18 | HEADERS += mylib.hh\ 19 | mylib_global.hh \ 20 | easylogging++.h 21 | 22 | unix:!symbian { 23 | maemo5 { 24 | target.path = /opt/usr/lib 25 | } else { 26 | target.path = /usr/lib 27 | } 28 | INSTALLS += target 29 | } 30 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/Qt/shared-lib/mylib/mylib_global.hh: -------------------------------------------------------------------------------- 1 | #ifndef MYLIB_GLOBAL_HH 2 | #define MYLIB_GLOBAL_HH 3 | 4 | #include 5 | 6 | #if defined(MYLIB_LIBRARY) 7 | # define MYLIBSHARED_EXPORT Q_DECL_EXPORT 8 | #else 9 | # define MYLIBSHARED_EXPORT Q_DECL_IMPORT 10 | #endif 11 | 12 | #endif // MYLIB_GLOBAL_HH 13 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/.travis_build.sh: -------------------------------------------------------------------------------- 1 | sh ./build_all.sh clang++ 2 | if [ "$?" = "0" ];then 3 | echo "Built successfully" 4 | sh ./run_all.sh 5 | echo "Successfully ran all samples" 6 | else 7 | echo "Build failed! (code: $?)" 8 | exit $? 9 | fi 10 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/autospace.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Demonstration of auto spacing functionality 4 | // 5 | // Revision 1.2 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(void) { 14 | 15 | LOG(INFO) << "this" << "is" << "a" << "message"; 16 | std::string str = "-sample-"; 17 | std::wstring wstr = L"-wsample-"; 18 | const char* chr = "-csample-"; 19 | const wchar_t* wchr = L"-wcsample-"; 20 | LOG(INFO) << str << str << str << str; 21 | LOG(INFO) << wstr << wstr << wstr << wstr; 22 | LOG(INFO) << chr << chr << chr << chr; 23 | LOG(INFO) << wchr << wchr << wchr << wchr; 24 | 25 | // ---- THIS IS MAGIC 26 | el::Loggers::addFlag(el::LoggingFlag::AutoSpacing); 27 | 28 | LOG(INFO) << "this" << "is" << "a" << "message"; 29 | LOG(INFO) << str << str << str << str; 30 | LOG(INFO) << wstr << wstr << wstr << wstr; 31 | LOG(INFO) << chr << chr << chr << chr; 32 | LOG(INFO) << wchr << wchr << wchr << wchr; 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/build_all.sh: -------------------------------------------------------------------------------- 1 | 2 | # Builds all files into bin/ 3 | 4 | [ -d "bin" ] || mkdir "bin" 5 | rm -rf bin/* 6 | 7 | find -maxdepth 1 -type f -name '*.cpp' -exec sh compile.sh {} $1 \; 8 | echo "Completed!" 9 | 10 | files=$(ls -l bin/) 11 | if [ "$files" = "total 0" ];then 12 | exit 1 13 | else 14 | exit 0 15 | fi 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/compile.sh: -------------------------------------------------------------------------------- 1 | ## Helper script for build_all.sh 2 | 3 | FILE=$1 4 | 5 | macro="$macro -DELPP_DEBUG_ERRORS" 6 | macro="$macro -DELPP_THREAD_SAFE" 7 | macro="$macro -DELPP_STL_LOGGING" 8 | macro="$macro -DELPP_LOG_UNORDERED_SET" 9 | macro="$macro -DELPP_LOG_UNORDERED_MAP" 10 | macro="$macro -DELPP_STACKTRACE_ON_CRASH" 11 | macro="$macro -DELPP_LOGGING_FLAGS_FROM_ARG" 12 | # macro="$macro -DELPP_DEFAULT_LOG_FILE=\"/a/path/that/does/not/exist/f.log\"" 13 | 14 | if [ "$2" = "" ];then 15 | COMPILER=g++ 16 | else 17 | COMPILER=$2 18 | fi 19 | 20 | CXX_STD='-std=c++0x -pthread' 21 | 22 | if [ "$FILE" = "" ]; then 23 | echo "Please provide filename to compile" 24 | exit 25 | fi 26 | 27 | echo "Compiling... [$FILE]" 28 | 29 | COMPILE_LINE="$COMPILER $FILE -o bin/$FILE.bin $macro $CXX_STD -Wall -Wextra -pedantic -pedantic-errors -Werror -Wfatal-errors" 30 | 31 | echo " $COMPILE_LINE" 32 | 33 | $($COMPILE_LINE) 34 | 35 | echo " DONE! [./bin/$FILE.bin]" 36 | echo 37 | echo 38 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/conditional.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of EasyLogging++ samples 3 | // 4 | // Conditional logging using LOG_IF, you can use CLOG_IF(condition, loggerID) macro to use your own logger if you 5 | // don't want to use default logger 6 | // 7 | // Revision 1.1 8 | // @author mkhan3189 9 | // 10 | 11 | #include "easylogging++.h" 12 | 13 | INITIALIZE_EASYLOGGINGPP 14 | 15 | int main(void) { 16 | 17 | LOG_IF(1 == 1, INFO) << "1 is equal to 1"; 18 | 19 | LOG_IF(1 > 2, INFO) << "1 is greater than 2"; 20 | 21 | LOG_IF(1 == 2, DEBUG) << "1 is equal to 2"; 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/configurator.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Very basic sample to configure using el::Configuration and configuration file 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | int main(int argc, char** argv) { 15 | START_EASYLOGGINGPP(argc, argv); 16 | LOG(INFO) << "Info log using 'default' logger before using configuration"; 17 | 18 | el::Configurations confFromFile("../default-logger.conf"); 19 | 20 | el::Loggers::reconfigureAllLoggers(confFromFile); 21 | 22 | LOG(INFO) << "Info log after manually configuring 'default' logger"; 23 | el::Loggers::getLogger("default")->reconfigure(); 24 | LOG(ERROR) << "Error log"; 25 | LOG(WARNING) << "WARNING! log"; 26 | VLOG(1) << "Verbose log 1"; 27 | VLOG(2) << "Verbose log 2"; 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/crash.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Demonstration on how crashes are handled. You can set second argument of this progam to `y` 5 | // and application will not abort before crash is handled 6 | // 7 | // Revision 1.1 8 | // @author mkhan3189 9 | // 10 | 11 | #include "easylogging++.h" 12 | 13 | INITIALIZE_EASYLOGGINGPP 14 | 15 | class Crasher { 16 | public: 17 | Crasher(void) { 18 | str = nullptr; 19 | call3(); 20 | } 21 | 22 | void call1(void) { 23 | LOG(INFO) << "Bye bye!"; 24 | str->clear(); // Crash! 25 | } 26 | 27 | void call2(void) { 28 | LOG(INFO) << "Calling call1()"; 29 | call1(); 30 | } 31 | 32 | void call3(void) { 33 | LOG(INFO) << "Calling call2()"; 34 | call2(); 35 | } 36 | private: 37 | std::string* str; 38 | }; 39 | 40 | int main(int argc, char** argv) { 41 | // If argv[1] == "y" means PREVENT CRASH ABORTION = YES 42 | if (argc > 1 && argv[1][0] == 'y') { 43 | el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog); 44 | LOG(FATAL) << "Before we crash we try to log using FATAL log and make sure app did not crash because we added flag DisableApplicationAbortOnFatalLog"; 45 | } 46 | Crasher c; 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/custom-crash-handler.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Custom crash handler sample to demonstrate el::Helpers::setCrashHandler 5 | // 6 | // Revision 1.0 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | void myCrashHandler(int sig) { 15 | LOG(ERROR) << "Woops! Crashed!"; 16 | // FOLLOWING LINE IS OPTIONAL 17 | el::Helpers::logCrashReason(sig, true); 18 | // FOLLOWING LINE IS ABSOLUTELY NEEDED AT THE END IN ORDER TO ABORT APPLICATION 19 | el::Helpers::crashAbort(sig); 20 | } 21 | 22 | int main(void) { 23 | 24 | el::Helpers::setCrashHandler(myCrashHandler); 25 | 26 | LOG(INFO) << "My crash handler!"; 27 | 28 | std::string* s = new std::string(); 29 | delete s; 30 | s->clear();; // Crash! 31 | 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/custom-format-spec.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Custom format specifier to demonstrate usage of el::Helpers::installCustomFormatSpecifier 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | class HttpRequest { 15 | public: 16 | const char* getIp(void) { 17 | return "192.168.1.1"; 18 | } 19 | }; 20 | 21 | int main(void) { 22 | HttpRequest request; 23 | // Install format specifier 24 | el::Helpers::installCustomFormatSpecifier(el::CustomFormatSpecifier("%ip_addr", std::bind(&HttpRequest::getIp, request))); 25 | // Either you can do what's done above (for member function) or if you have static function you can simply say 26 | // el::CustomFormatSpecifier("%ip_addr", getIp) 27 | 28 | // Configure loggers 29 | el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Format, "%datetime %level %ip_addr : %msg"); 30 | LOG(INFO) << "This is after installed 'ip_addr' spec"; 31 | // Uninstall custom format specifier 32 | el::Helpers::uninstallCustomFormatSpecifier("%ip_addr"); 33 | LOG(INFO) << "This is after uninstalled"; 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/default-log-file-from-arg.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Default log file using '--default-log-file' arg 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(int argc, char** argv) { 14 | START_EASYLOGGINGPP(argc, argv); 15 | 16 | LOG(INFO) << "My log message - hopefully you have reconfigured log file by using" 17 | << " --default-log-file=blah.log and defined ELPP_NO_DEFAULT_LOG_FILE"; 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/del-logger.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Sample to remove logger 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(void) { 14 | 15 | LOG(INFO) << "My first ultimate log message"; 16 | CLOG(INFO, "test") << "Send me error"; 17 | el::Loggers::getLogger("test"); 18 | CLOG(INFO, "test") << "Write"; 19 | el::Loggers::unregisterLogger("test"); 20 | CLOG(INFO, "test") << "Send me error"; 21 | DLOG(INFO) << "Wow"; 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/flags.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Demonstration of STL flags, e.g, std::boolalpha 4 | // 5 | // Revision 1.1 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(void) { 14 | 15 | bool v = true; 16 | LOG(INFO) << std::boolalpha << v; 17 | LOG(INFO) << std::noboolalpha << v; 18 | 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/global-configuration.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Very basic sample to configure using global configuration (el::Loggers::configureFromGlobal) 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | int main(void) { 15 | 16 | LOG(INFO) << "Info log before using global configuration"; 17 | 18 | el::Loggers::configureFromGlobal("../global.conf"); 19 | 20 | LOG(INFO) << "Info log AFTER using global configuration"; 21 | LOG(ERROR) << "Error log AFTER using global configuration"; 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/helpers.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Helpers sample - this sample contains methods with explanation in comments on how to use them 5 | // 6 | // Revision 1.2 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | void configureFromArg() { 15 | // Configures globally using "--logging" param value 16 | // example: ./prog --logging-conf=/tmp/myglobal.conf 17 | el::Loggers::configureFromArg("--logging-conf"); 18 | } 19 | 20 | void flush() { 21 | // Flush all levels of default logger 22 | el::Loggers::getLogger("default")->flush(); 23 | 24 | // Flush all loggers all levels 25 | el::Loggers::flushAll(); 26 | } 27 | 28 | int main(int argc, char** argv) { 29 | START_EASYLOGGINGPP(argc, argv); 30 | 31 | configureFromArg(); 32 | 33 | flush(); 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/locale.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Demonstration on how locale gives output 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | #ifndef ELPP_UNICODE 10 | # define ELPP_UNICODE 11 | #endif 12 | 13 | #include "easylogging++.h" 14 | 15 | INITIALIZE_EASYLOGGINGPP 16 | 17 | int main(int argc, const char** argv) { 18 | START_EASYLOGGINGPP(argc, argv); 19 | 20 | LOG(INFO) << L"世界，你好"; 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/log-dispatch-callback.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Demonstrates how to use log dispatch callback 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | class MyHandler : public el::LogDispatchCallback { 14 | public: 15 | void handle(const el::LogDispatchData*) { 16 | // NEVER DO LOG FROM HANDLER! 17 | // LOG(INFO) << "Test MyHandler " << msg; 18 | } 19 | }; 20 | 21 | class MyHtmlHandler : public el::LogDispatchCallback { 22 | public: 23 | MyHtmlHandler() { 24 | el::Loggers::getLogger("html"); // register 25 | } 26 | void handle(const el::LogDispatchData*) { 27 | // NEVER DO LOG FROM HANDLER! 28 | // CLOG(INFO, "html") << data->logMessage()->message(); 29 | std::cout << "Test handler" << std::endl; 30 | } 31 | }; 32 | 33 | int main(void) { 34 | 35 | el::Helpers::installLogDispatchCallback("MyHandler"); 36 | el::Helpers::installLogDispatchCallback("MyHtmlHandler"); 37 | 38 | LOG(INFO) << "My first log message"; 39 | LOG(INFO) << "My second log message"; 40 | 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/loggable.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Usage sample of el::Loggable to make class log-friendly 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | class MyClass : public el::Loggable { 15 | public: 16 | MyClass(const std::string& name) : m_name(name) {} 17 | 18 | virtual inline void log(el::base::type::ostream_t& os) const { 19 | os << m_name.c_str(); 20 | } 21 | 22 | 23 | private: 24 | std::string m_name; 25 | }; 26 | 27 | int main(void) { 28 | MyClass c("c"); 29 | MyClass c2("c2"); 30 | LOG(INFO) << "I am " << c << "; and I am " << c2; 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/logger-log-functions.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Very basic sample for Logger::info etc 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(int argc, char** argv) { 14 | 15 | START_EASYLOGGINGPP(argc, argv); 16 | 17 | el::Logger* defaultLogger = el::Loggers::getLogger("default"); 18 | 19 | std::vector i; 20 | i.push_back(1); 21 | i.push_back(2); 22 | defaultLogger->warn("My first ultimate log message %v %v %v", 123, 222, i); 23 | 24 | // Escaping 25 | defaultLogger->info("My first ultimate log message %% %%v %v %v", 123, 222); // My first ultimate log message % %v 123 222 26 | 27 | defaultLogger->verbose(1, "test verbose"); 28 | defaultLogger->verbose(1, "test verbose with args %v", 2); 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/make-loggable.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Usage of MAKE_LOGGABLE to make class log-friendly 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | class Integer { 15 | public: 16 | Integer(int i) : m_underlyingInt(i) {} 17 | Integer& operator=(const Integer& integer) { m_underlyingInt = integer.m_underlyingInt; return *this; } 18 | virtual ~Integer(void) { m_underlyingInt = -1; } 19 | int getInt(void) const { return m_underlyingInt; } 20 | inline operator int() const { return m_underlyingInt; } 21 | private: 22 | int m_underlyingInt; 23 | }; 24 | 25 | // Lets say Integer class is in some third party library 26 | 27 | // We use MAKE_LOGGABLE(class, instance, outputStream) to make it loggable 28 | inline MAKE_LOGGABLE(Integer, integer, os) { 29 | os << integer.getInt(); 30 | return os; 31 | } 32 | 33 | 34 | int main(void) { 35 | 36 | Integer count = 5; 37 | LOG(INFO) << "Integer count = " << count; 38 | int reverse = count; 39 | LOG(INFO) << "int reverse = " << reverse; 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/manipulators.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Demonstration of manipulators usages and how they behave 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | int main(void) { 15 | 16 | LOG(INFO) << "std::endl" << std::endl; 17 | LOG(INFO) << "std::flush" << std::flush; 18 | LOG(INFO) << "std::uppercase "; 19 | 20 | double i = 1.23e100; 21 | LOG(INFO) << i; 22 | LOG(INFO) << std::uppercase << i; 23 | 24 | int j = 10; 25 | LOG(INFO) << std::hex << std::nouppercase << j; 26 | LOG(INFO) << std::hex << std::uppercase << j; 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/multiple-loggers.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Very basic sample - log using multiple loggers 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(void) { 14 | 15 | el::Loggers::addFlag(el::LoggingFlag::MultiLoggerSupport); // Enables support for multiple loggers 16 | 17 | el::Loggers::getLogger("network"); // Register 'network' logger 18 | 19 | CLOG(INFO, "default", "network") << "My first log message that writes with network and default loggers"; 20 | 21 | 22 | // Another way of doing this may be 23 | #define _LOGGER "default", "network" 24 | CLOG(INFO, _LOGGER) << "This is done by _LOGGER"; 25 | 26 | // More practical way of doing this 27 | #define NETWORK_LOG(LEVEL) CLOG(LEVEL, _LOGGER) 28 | NETWORK_LOG(INFO) << "This is achieved by NETWORK_LOG macro"; 29 | 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/no-default-log-file.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Very basic sample to configure using configuration and not default log file 5 | // 6 | // Revision 1.0 7 | // @author mkhan3189 8 | // 9 | 10 | #define ELPP_NO_DEFAULT_LOG_FILE 11 | 12 | #include "easylogging++.h" 13 | 14 | INITIALIZE_EASYLOGGINGPP 15 | 16 | int main(void) { 17 | 18 | // If we log before configuration, we will end up with heaps of internal errors because ELPP_NO_DEFAULT_LOG_FILE is defined before include 19 | el::Configurations confFromFile("../default-logger.conf"); 20 | 21 | el::Loggers::reconfigureAllLoggers(confFromFile); 22 | 23 | LOG(INFO) << "Logging after configured!"; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/occasional.cpp: -------------------------------------------------------------------------------- 1 | // This file is part of Easylogging++ samples 2 | // 3 | // Sample to demonstrate using occasionals and other hit counts based logging 4 | // 5 | // Revision 1.2 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(int argc, char** argv) { 14 | START_EASYLOGGINGPP(argc, argv); 15 | 16 | for (int i = 1;i < 1000; ++i) { 17 | LOG_EVERY_N(20, INFO) << "LOG_EVERY_N i = " << i; 18 | LOG_EVERY_N(100, INFO) << "LOG_EVERY_N Current position is " << ELPP_COUNTER_POS; 19 | } 20 | for (int i = 1;i <= 10; ++i) { 21 | LOG_AFTER_N(6, INFO) << "LOG_AFTER_N i = " << i; 22 | } 23 | for (int i = 1;i < 100; ++i) { 24 | LOG_N_TIMES(50, INFO) << "LOG_N_TIMES i = " << i; 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/plog.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Log using PLOG and family. PLOG is same as perror() with c++-styled stream 5 | // 6 | // Revision 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | int main(void) { 15 | el::Loggers::addFlag(el::LoggingFlag::DisableApplicationAbortOnFatalLog); 16 | std::fstream f("a file that does not exist", std::ifstream::in); 17 | PLOG(INFO) << "A message with plog"; 18 | PLOG_IF(true, INFO) << "A message with plog"; 19 | PLOG_IF(false, INFO) << "A message with plog"; 20 | PCHECK(true) << "This is good"; 21 | LOG(INFO) << "This is normal info log after plog"; 22 | DPCHECK(true) << "Wow"; 23 | DPCHECK(false) << "Wow failed"; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/roll-out.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // 4 | // Demonstration on possible usage of pre-rollout handler 5 | // 6 | // Revision: 1.1 7 | // @author mkhan3189 8 | // 9 | 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | static unsigned int idx; 15 | 16 | void rolloutHandler(const char* filename, std::size_t size) { 17 | // SHOULD NOT LOG ANYTHING HERE BECAUSE LOG FILE IS CLOSED! 18 | std::cout << "************** Rolling out [" << filename << "] because it reached [" << size << " bytes]" << std::endl; 19 | 20 | // BACK IT UP 21 | std::stringstream ss; 22 | ss << "mv " << filename << " bin/log-backup-" << ++idx; 23 | system(ss.str().c_str()); 24 | } 25 | 26 | int main(int, char**) { 27 | idx = 0; 28 | el::Loggers::addFlag(el::LoggingFlag::StrictLogFileSizeCheck); 29 | el::Loggers::reconfigureAllLoggers(el::ConfigurationType::Filename, "/tmp/logs/max-size.log"); 30 | el::Loggers::reconfigureAllLoggers(el::ConfigurationType::MaxLogFileSize, "100"); 31 | el::Helpers::installPreRollOutCallback(rolloutHandler); 32 | 33 | for (int i = 0; i < 100; ++i) 34 | LOG(INFO) << "Test"; 35 | 36 | el::Helpers::uninstallPreRollOutCallback(); 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/run.sh: -------------------------------------------------------------------------------- 1 | echo "Running '$1'..." 2 | ./$1 -v 3 | echo "Finished '$1'" 4 | echo 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/run_all.sh: -------------------------------------------------------------------------------- 1 | ## Runs all the build binaries from bin/ folder 2 | 3 | find bin/ -name '*.cpp.bin' -exec sh ./run.sh ./{} \; 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/.gitignore: -------------------------------------------------------------------------------- 1 | lib/libmyLib.so 2 | lib/mylib.o 3 | lib/myLib.a 4 | myLib.a 5 | libmyLib.so 6 | logs/* 7 | myapp 8 | 9 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/README.md: -------------------------------------------------------------------------------- 1 | ## A Simple example of shared and static compilations 2 | 3 | ``` 4 | . 5 | ├── compile_shared.sh 6 | ├── compile_static.sh 7 | ├── lib 8 | │   ├── include 9 | │   │   ├── easylogging++.h 10 | │   │   └── mylib.hpp 11 | │   └── mylib.cpp 12 | └── myapp.cpp 13 | 14 | 2 directories, 6 files 15 | ``` 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/compile_shared.sh: -------------------------------------------------------------------------------- 1 | rm -rf libmyLib.so lib/libmyLib.so lib/mylib.o lib/myLib.a myLib.a myapp logs ## Clean 2 | 3 | compiler=icpc 4 | standard=c++0x ## If this does not work try c++11 (depends on your compiler) 5 | macros="-DELPP_THREAD_SAFE -DELPP_STACKTRACE_ON_CRASH" ## Macros for library 6 | 7 | cd lib/ 8 | $compiler --std=$standard -pipe -fPIC -g -O0 $macros -Iinclude -c -o mylib.o mylib.cpp 9 | $compiler -fPIC -g -shared -o libmyLib.so mylib.o 10 | cp libmyLib.so .. 11 | cd .. 12 | $compiler -g -std=$standard -fPIC -pipe -Wl,-rpath=lib -L lib myapp.cpp -Ilib/include -lmyLib -o myapp 13 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/compile_static.sh: -------------------------------------------------------------------------------- 1 | rm -rf libmyLib.so lib/libmyLib.so lib/mylib.o lib/myLib.a myLib.a myapp logs ## Clean 2 | 3 | compiler=icpc 4 | standard=c++0x ## If this does not work try c++11 (depends on your compiler) 5 | macros="-DELPP_THREAD_SAFE -DELPP_STACKTRACE_ON_CRASH" ## Macros for library 6 | 7 | cd lib/ 8 | $compiler --std=$standard -pipe -fPIC -g -O0 $macros -Iinclude -c -o mylib.o mylib.cpp 9 | ar rvs myLib.a mylib.o 10 | cp myLib.a .. 11 | cd .. 12 | $compiler -g -std=$standard -o myapp myapp.cpp -Ilib/include myLib.a 13 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/lib/include/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | # include "../../../../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | 7 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/lib/include/mylib.hpp: -------------------------------------------------------------------------------- 1 | //#include "easylogging++.h" 2 | 3 | class MyLib { 4 | public: 5 | MyLib(); 6 | MyLib(int, char**); 7 | ~MyLib(); 8 | void event(int a); 9 | }; 10 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/lib/mylib.cpp: -------------------------------------------------------------------------------- 1 | #include "mylib.hpp" 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | MyLib::MyLib() { 7 | LOG(INFO) << "---MyLib Constructor () ---"; 8 | } 9 | 10 | MyLib::MyLib(int argc, char** argv) { 11 | START_EASYLOGGINGPP(argc, argv); 12 | LOG(INFO) << "---MyLib Constructor(int, char**) ---"; 13 | } 14 | 15 | MyLib::~MyLib() { 16 | LOG(INFO) << "---MyLib Destructor---"; 17 | } 18 | 19 | 20 | void MyLib::event(int a) { 21 | VLOG(1) << "MyLib::event start"; 22 | LOG(INFO) << "Processing event [" << a << "]"; 23 | VLOG(1) << "MyLib::event end"; 24 | } 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-static-libs/myapp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | int main(int argc, char** argv) { 4 | int result = 0; 5 | // 6 | // You can choose MyLib() constructor 7 | // but be aware this will cause vlog to not work because Easylogging++ 8 | // does not know verbose logging level 9 | // 10 | // For your peace of mind, you may pass on const_cast(argv) instead 11 | // 12 | MyLib lib(argc, argv); 13 | lib.event(1); 14 | return result; 15 | } 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-storage/.gitignore: -------------------------------------------------------------------------------- 1 | lib/libmyLib.so 2 | lib/mylib.o 3 | lib/myLib.a 4 | myLib.a 5 | libmyLib.so 6 | logs/* 7 | myapp 8 | 9 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-storage/compile_shared.sh: -------------------------------------------------------------------------------- 1 | rm -rf libmyLib.so lib/libmyLib.so lib/mylib.o lib/myLib.a myLib.a myapp logs ## Clean 2 | 3 | compiler=icpc 4 | standard=c++0x ## If this does not work try c++11 (depends on your compiler) 5 | macros="-DELPP_THREAD_SAFE -DELPP_STACKTRACE_ON_CRASH" ## Macros for library 6 | 7 | cd lib/ 8 | echo "$compiler --std=$standard -pipe -fPIC -g -O0 $macros -Iinclude -c mylib.cpp -o mylib.o" 9 | $compiler --std=$standard -pipe -fPIC -g -O0 $macros -Iinclude -c mylib.cpp -o mylib.o 10 | echo "$compiler -fPIC -g -shared -o libmyLib.so mylib.o" 11 | $compiler -fPIC -g -shared -o libmyLib.so mylib.o 12 | cp libmyLib.so .. 13 | cd .. 14 | echo "$compiler -g -std=$standard $macros -fPIC -pipe -Wl,-rpath=lib -L lib myapp.cpp -Ilib/include -lmyLib -o myapp" 15 | $compiler -g -std=$standard $macros -fPIC -pipe -Wl,-rpath=lib -L lib myapp.cpp -Ilib/include -lmyLib -o myapp 16 | echo "./myapp" 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-storage/lib/include/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | # include "../../../../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | 7 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-storage/lib/include/mylib.hpp: -------------------------------------------------------------------------------- 1 | #include "easylogging++.h" 2 | 3 | class MyLib { 4 | public: 5 | MyLib(); 6 | MyLib(int, char**); 7 | ~MyLib(); 8 | void event(int a); 9 | static el::base::type::StoragePointer getEasyloggingStorage(); 10 | private: 11 | static int runOnceHelper; 12 | static int runOnce(); 13 | }; 14 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-storage/lib/mylib.cpp: -------------------------------------------------------------------------------- 1 | #include "mylib.hpp" 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | int MyLib::runOnceHelper = runOnce(); 7 | 8 | int MyLib::runOnce() { 9 | LOG(INFO) << "Registering logger [mylib]"; 10 | el::Loggers::getLogger("mylib"); 11 | return 0; 12 | } 13 | 14 | MyLib::MyLib() { 15 | LOG(INFO) << "---MyLib Constructor () ---"; 16 | } 17 | 18 | MyLib::MyLib(int argc, char** argv) { 19 | START_EASYLOGGINGPP(argc, argv); 20 | LOG(INFO) << "---MyLib Constructor(int, char**) ---"; 21 | } 22 | 23 | MyLib::~MyLib() { 24 | LOG(INFO) << "---MyLib Destructor---"; 25 | } 26 | 27 | 28 | void MyLib::event(int a) { 29 | VLOG(1) << "MyLib::event start"; 30 | LOG(INFO) << "Processing event [" << a << "]"; 31 | VLOG(1) << "MyLib::event end"; 32 | } 33 | 34 | el::base::type::StoragePointer MyLib::getEasyloggingStorage() { 35 | return el::Helpers::storage(); 36 | } 37 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/shared-storage/myapp.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "easylogging++.h" 3 | 4 | SHARE_EASYLOGGINGPP(MyLib::getEasyloggingStorage()) 5 | 6 | int main(int argc, char** argv) { 7 | LOG(INFO) << "User: " << el::base::utils::s_currentUser; 8 | LOG(INFO) << "Host: " << el::base::utils::s_currentHost; 9 | 10 | { 11 | // Braces only for scoping purpose - remove and compare results 12 | MyLib lib(argc, argv); 13 | lib.event(1); 14 | } 15 | LOG(INFO) << std::boolalpha 16 | << "Has mylib LOGGER: " << MyLib::getEasyloggingStorage()->registeredLoggers()->has("mylib") 17 | << std::endl 18 | << "ARE BOTH STORAGES EQUAL: " << (bool)(MyLib::getEasyloggingStorage() == el::Helpers::storage()); 19 | // See read me 20 | el::Logger* libLogger = CHECK_NOTNULL(el::Loggers::getLogger("mylib", false)); 21 | libLogger->info("This info log is using logger->info(...) with arg %v and %v", 1, 2); 22 | CLOG(INFO, "mylib") << "A logger initialized in shared storage"; 23 | CLOG(INFO, "default") << "Default, configuration from shared storage"; 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/std-array.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Demonstration of STL array (std::array) logging, this requires ELPP_LOG_STD_ARRAY macro (recommended to define it in Makefile) 4 | // 5 | // Revision 1.1 6 | // @author mkhan3189 7 | // 8 | 9 | #define ELPP_LOG_STD_ARRAY 10 | #include "easylogging++.h" 11 | #include 12 | 13 | INITIALIZE_EASYLOGGINGPP 14 | 15 | int main (void) { 16 | 17 | std::array arr; 18 | arr[0] = 1; 19 | arr[1] = 2; 20 | arr[2] = 3; 21 | arr[3] = 4; 22 | arr[4] = 5; 23 | 24 | LOG(INFO) << arr; 25 | 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/syslog.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Syslog sample 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #define ELPP_SYSLOG 10 | #include "easylogging++.h" 11 | 12 | INITIALIZE_EASYLOGGINGPP 13 | 14 | int main(void) { 15 | 16 | ELPP_INITIALIZE_SYSLOG("syslog_sample", LOG_PID | LOG_CONS | LOG_PERROR, LOG_USER); 17 | 18 | SYSLOG(INFO) << "My first easylogging++ syslog message"; 19 | 20 | SYSLOG_IF(true, INFO) << "This is conditional info syslog"; 21 | for (int i = 1; i <= 10; ++i) 22 | SYSLOG_EVERY_N(2, INFO) << "This is [" << i << "] iter of SYSLOG_EVERY_N"; 23 | 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/timed-block.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // TIMED_BLOCK sample 4 | // 5 | // Revision 1.1 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(int argc, char** argv) { 14 | 15 | START_EASYLOGGINGPP(argc, argv); 16 | 17 | TIMED_BLOCK(t, "my-block") { 18 | for (long i = 0; i <= 300; ++i) { 19 | LOG(INFO) << "This is for-block 1"; 20 | } 21 | t.timer.checkpoint("checkpoint-1"); // Note t.timer to access el::base::Trackable 22 | for (int i = 0; i <= 200; ++i) { 23 | LOG(INFO) << "This is for-block 2"; 24 | } 25 | } 26 | LOG(INFO) << "You should get performance result of above scope"; 27 | 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/timed-scope.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // TIMED_SCOPE sample 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(void) { 14 | 15 | { 16 | TIMED_SCOPE(timer, "my-block"); 17 | for (int i = 0; i <= 500; ++i) { 18 | LOG(INFO) << "This is iter " << i; 19 | } 20 | } 21 | LOG(INFO) << "By now, you should get performance result of above scope"; 22 | 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/verbose.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of EasyLogging++ samples 3 | // Demonstration of verbose logging 4 | // 5 | // Revision 1.0 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(int argc, char** argv) { 14 | START_EASYLOGGINGPP(argc, argv); 15 | LOG(INFO) << "This is demo for verbose logs"; 16 | VLOG(1) << "This will be printed when program is started using argument --v=1"; 17 | VLOG(2) << "This will be printed when program is started using argument --v=2"; 18 | VLOG(1) << "This will be printed when program is started using argument --v=1"; 19 | VLOG_IF(true, 1) << "Always verbose for level 1"; 20 | 21 | VLOG_EVERY_N(1, 3) << "Verbose every N"; 22 | 23 | VLOG(4) << "Command line arguments provided " << *el::Helpers::commandLineArgs(); 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/STL/very-basic.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // This file is part of Easylogging++ samples 3 | // Very basic sample 4 | // 5 | // Revision 1.2 6 | // @author mkhan3189 7 | // 8 | 9 | #include "easylogging++.h" 10 | 11 | INITIALIZE_EASYLOGGINGPP 12 | 13 | int main(void) { 14 | 15 | LOG(INFO) << "My first ultimate log message"; 16 | 17 | LOG(INFO) << "This" << "is" << "log" << "without" << "spaces"; 18 | el::Loggers::addFlag(el::LoggingFlag::AutoSpacing); 19 | LOG(INFO) << "This" << "is" << "log" << "with" << "spaces"; 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/DLLSample/.gitignore: -------------------------------------------------------------------------------- 1 | Debug/* 2 | logs/* 3 | *sdf 4 | *.suo -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/DLLSample/DLLSample_App/DLLSample_App.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/DLLSample/DLLSample_App/main.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "../DLLSample_Lib/MyMaths.h" 4 | 5 | // There are two ways to share repository 6 | // one way is: 7 | // SHARE_EASYLOGGINGPP(sharedLoggingRepository()) 8 | 9 | // Other way is 10 | // INITIALIZE_NULL_EASYLOGGINGPP 11 | // and in main function: 12 | // int main(int argc, char** argv) { 13 | // el::Helpers::setStorage(sharedLoggingRepository()); 14 | // ... 15 | // START_EASYLOGGINGPP(argc, argv); 16 | // ... 17 | // } 18 | 19 | INITIALIZE_NULL_EASYLOGGINGPP 20 | 21 | int main() { 22 | el::Helpers::setStorage(sharedLoggingRepository()); 23 | Math::MyMaths::logAdd(1, 2); 24 | LOG(INFO) << "Wow"; 25 | el::Loggers::reconfigureAllLoggers(el::Level::Global, el::ConfigurationType::Format, "%datetime %msg"); 26 | Math::MyMaths::logAdd(1, 2); 27 | LOG(INFO) << "This is after reconfiguration from main"; 28 | system("pause"); 29 | return 0; 30 | } -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/DLLSample/DLLSample_Lib/DLLSample_Lib.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Header Files 20 | 21 | 22 | 23 | 24 | Source Files 25 | 26 | 27 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/DLLSample/DLLSample_Lib/DLLSample_Lib.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/DLLSample/DLLSample_Lib/MyMaths.cpp: -------------------------------------------------------------------------------- 1 | #define ELPP_AS_DLL // Tells Easylogging++ that it's used for DLL 2 | #define ELPP_EXPORT_SYMBOLS // Tells Easylogging++ to export symbols 3 | #define MYMATHS_EXPORTS 4 | 5 | #include "MyMaths.h" 6 | 7 | INITIALIZE_EASYLOGGINGPP 8 | 9 | el::base::type::StoragePointer sharedLoggingRepository() { 10 | return el::Helpers::storage(); 11 | } 12 | 13 | namespace Math 14 | { 15 | int MyMaths::add(int x, int y) 16 | { 17 | return x + y; 18 | } 19 | 20 | void MyMaths::logAdd(int x, int y) { 21 | LOG(INFO) << add(x, y); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/DLLSample/DLLSample_Lib/MyMaths.h: -------------------------------------------------------------------------------- 1 | #ifdef MYMATHS_EXPORTS 2 | #define MYMATHDLL_EXPORT __declspec(dllexport) 3 | #else 4 | #define MYMATHDLL_EXPORT __declspec(dllimport) 5 | #endif 6 | #include "../../../../src/easylogging++.h" 7 | 8 | MYMATHDLL_EXPORT el::base::type::StoragePointer sharedLoggingRepository(); 9 | 10 | namespace Math { 11 | class MyMaths { 12 | public: 13 | static MYMATHDLL_EXPORT int add(int x, int y); 14 | static MYMATHDLL_EXPORT void logAdd(int x, int y); 15 | }; 16 | } -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/.gitignore: -------------------------------------------------------------------------------- 1 | Debug/* 2 | logs/* 3 | *sdf 4 | 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/VCPP2012_Win32.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 2012 4 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VCPP2012_Win32", "VCPP2012_Win32\VCPP2012_Win32.vcxproj", "{CD2ACA76-1033-4E96-A184-7A47B76E55D2}" 5 | EndProject 6 | Global 7 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 8 | Debug|Win32 = Debug|Win32 9 | Release|Win32 = Release|Win32 10 | EndGlobalSection 11 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 12 | {CD2ACA76-1033-4E96-A184-7A47B76E55D2}.Debug|Win32.ActiveCfg = Debug|Win32 13 | {CD2ACA76-1033-4E96-A184-7A47B76E55D2}.Debug|Win32.Build.0 = Debug|Win32 14 | {CD2ACA76-1033-4E96-A184-7A47B76E55D2}.Release|Win32.ActiveCfg = Release|Win32 15 | {CD2ACA76-1033-4E96-A184-7A47B76E55D2}.Release|Win32.Build.0 = Release|Win32 16 | EndGlobalSection 17 | GlobalSection(SolutionProperties) = preSolution 18 | HideSolutionNode = FALSE 19 | EndGlobalSection 20 | EndGlobal 21 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/VCPP2012_Win32.v11.suo: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qijiezhao/OpticalFlow-SpeedTest/dee9750cc26c42bc26a1e58e69f7e75425c3f912/dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/VCPP2012_Win32.v11.suo -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/VCPP2012_Win32/.gitignore: -------------------------------------------------------------------------------- 1 | Debug/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/VCPP2012_Win32/VCPP2012_Win32.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | 23 | 24 | Header Files 25 | 26 | 27 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/VCPP2012_Win32/VCPP2012_Win32.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2012_Win32_Multithreaded/VCPP2012_Win32/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2013_PreviewUltimate/.gitignore: -------------------------------------------------------------------------------- 1 | Debug/* 2 | logs/* 3 | *sdf 4 | *.suo -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2013_PreviewUltimate/Main.cpp: -------------------------------------------------------------------------------- 1 | #include "easylogging++.h" 2 | 3 | INITIALIZE_EASYLOGGINGPP 4 | 5 | TIMED_SCOPE(appTimer, "myapplication"); 6 | 7 | 8 | int main(int argc, const char* argv []) { 9 | el::Helpers::removeFlag(el::LoggingFlag::AllowVerboseIfModuleNotSpecified); 10 | 11 | 12 | TIMED_BLOCK(itr, "write-simple") { 13 | LOG(INFO) << "Test " << __FILE__; 14 | } 15 | 16 | VLOG(3) << "Test"; 17 | system("pause"); 18 | } 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2013_PreviewUltimate/VCPP2013_PreviewUltimate.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio 2013 4 | VisualStudioVersion = 12.0.20617.1 PREVIEW 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VCPP2013_PreviewUltimate", "VCPP2013_PreviewUltimate.vcxproj", "{2436AEA1-93AF-4410-B05F-FA8B5F797975}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|Win32 = Debug|Win32 11 | Release|Win32 = Release|Win32 12 | EndGlobalSection 13 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 14 | {2436AEA1-93AF-4410-B05F-FA8B5F797975}.Debug|Win32.ActiveCfg = Debug|Win32 15 | {2436AEA1-93AF-4410-B05F-FA8B5F797975}.Debug|Win32.Build.0 = Debug|Win32 16 | {2436AEA1-93AF-4410-B05F-FA8B5F797975}.Release|Win32.ActiveCfg = Release|Win32 17 | {2436AEA1-93AF-4410-B05F-FA8B5F797975}.Release|Win32.Build.0 = Release|Win32 18 | EndGlobalSection 19 | GlobalSection(SolutionProperties) = preSolution 20 | HideSolutionNode = FALSE 21 | EndGlobalSection 22 | EndGlobal 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2013_PreviewUltimate/VCPP2013_PreviewUltimate.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;hm;inl;inc;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | 23 | 24 | Header Files 25 | 26 | 27 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/VC++/VCPP2013_PreviewUltimate/easylogging++.h: -------------------------------------------------------------------------------- 1 | #ifndef _EASYLOGGINGPP_H_FOR_SAMPLES 2 | #define _EASYLOGGINGPP_H_FOR_SAMPLES 3 | 4 | #define ELPP_STL_LOGGING 5 | #define ELPP_PERFORMANCE_MICROSECONDS 6 | #define ELPP_LOG_STD_ARRAY 7 | #define ELPP_LOG_UNORDERED_MAP 8 | #define ELPP_UNORDERED_SET 9 | #define ELPP_THREAD_SAFE 10 | 11 | #include "../../../src/easylogging++.h" 12 | 13 | #endif // _EASYLOGGINGPP_H_FOR_SAMPLES -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/async/.gitignore: -------------------------------------------------------------------------------- 1 | prog 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/async/build.sh: -------------------------------------------------------------------------------- 1 | compiler=icpc 2 | echo "$compiler prog.cpp -DELPP_EXPERIMENTAL_ASYNC -std=c++11 -lpthread -o prog && ./prog" 3 | $compiler prog.cpp -DELPP_EXPERIMENTAL_ASYNC -std=c++11 -lpthread -o prog && ./prog 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/async/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/async/mymath.h: -------------------------------------------------------------------------------- 1 | #include "easylogging++.h" 2 | 3 | class MyMath { 4 | public: 5 | static int sum(int a, int b) { 6 | LOG(INFO) << "Adding " << a << " and " << b; 7 | return a + b; 8 | } 9 | }; 10 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/async/prog.cpp: -------------------------------------------------------------------------------- 1 | 2 | #include "easylogging++.h" 3 | #include "mymath.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | TIMED_SCOPE(benchmark, "benchmark-program"); 8 | 9 | int main(int argc, char *argv[]) 10 | { 11 | // ELPP_INITIALIZE_SYSLOG("my_proc", LOG_PID | LOG_CONS | LOG_PERROR, LOG_USER); 12 | el::Loggers::reconfigureAllLoggers(el::ConfigurationType::ToStandardOutput, "false"); 13 | TIMED_BLOCK(loggingPerformance, "benchmark-block") { 14 | el::base::MillisecondsWidth mwidth(3); 15 | std::cout << "Starting program " << el::base::utils::DateTime::getDateTime("%h:%m:%s", &mwidth) << std::endl; 16 | int MAX_LOOP = 1000000; 17 | for (int i = 0; i <= MAX_LOOP; ++i) { 18 | LOG(INFO) << "Log message " << i; 19 | } 20 | int result = MyMath::sum(1, 2); 21 | result = MyMath::sum(1, 3); 22 | 23 | std::cout << "Finished program - cleaning! " << el::base::utils::DateTime::getDateTime("%h:%m:%s", &mwidth) << std::endl; 24 | } 25 | // SYSLOG(INFO) << "This is syslog - read it from /var/log/syslog"; 26 | 27 | return 0; 28 | } 29 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/build_all.sh: -------------------------------------------------------------------------------- 1 | 2 | # Builds all files into bin/ 3 | 4 | [ -d "bin" ] || mkdir "bin" 5 | rm -rf bin/* 6 | 7 | find -maxdepth 1 -type f -name '*.cpp' -exec sh compile.sh {} $1 \; 8 | echo "Completed!" 9 | 10 | files=$(ls -l bin/) 11 | if [ "$files" = "total 0" ];then 12 | exit 1 13 | else 14 | exit 0 15 | fi 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/compile.sh: -------------------------------------------------------------------------------- 1 | ## Helper script for build_all.sh 2 | 3 | FILE=$1 4 | 5 | macro="$macro -DELPP_THREAD_SAFE" 6 | macro="$macro -DELPP_STL_LOGGING" 7 | macro="$macro -DELPP_BOOST_LOGGING" 8 | macro="$macro -DELPP_STACKTRACE_ON_CRASH" 9 | 10 | if [ "$2" = "" ];then 11 | COMPILER=g++ 12 | else 13 | COMPILER=$2 14 | fi 15 | 16 | CXX_STD='-std=c++0x -pthread' 17 | 18 | if [ "$FILE" = "" ]; then 19 | echo "Please provide filename to compile" 20 | exit 21 | fi 22 | 23 | echo "Compiling... [$FILE]" 24 | 25 | COMPILE_LINE="$COMPILER $FILE -o bin/$FILE.bin $macro $CXX_STD -Wall -Wextra" 26 | 27 | echo " $COMPILE_LINE" 28 | 29 | $($COMPILE_LINE) 30 | 31 | echo " DONE! [./bin/$FILE.bin]" 32 | echo 33 | echo 34 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/deque.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | int main(void) { 8 | boost::container::deque d(3, 100); 9 | d.at(1) = 200; 10 | d.at(2) = 20; 11 | LOG(INFO) << d; 12 | } 13 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/list.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | int main(void) { 8 | boost::container::list l; 9 | l.insert(l.cbegin(), 3); 10 | LOG(INFO) << l; 11 | } 12 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/map.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "easylogging++.h" 5 | 6 | INITIALIZE_EASYLOGGINGPP 7 | 8 | int main(void) { 9 | boost::container::map m; 10 | m[0] = 1.0f; 11 | m[5] = 3.3f; 12 | LOG(INFO) << m; 13 | 14 | boost::container::flat_map fm; 15 | fm[1] = 2.5f; 16 | fm[2] = 5.0f; 17 | LOG(INFO) << fm; 18 | } 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/run.sh: -------------------------------------------------------------------------------- 1 | echo "Running '$1'..." 2 | ./$1 3 | echo "Finished '$1'" 4 | echo 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/run_all.sh: -------------------------------------------------------------------------------- 1 | ## Runs all the build binaries from bin/ folder 2 | 3 | find bin/ -name '*.cpp.bin' -exec sh ./run.sh ./{} \; 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/set.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "easylogging++.h" 5 | 6 | INITIALIZE_EASYLOGGINGPP 7 | 8 | int main(void) { 9 | boost::container::set s; 10 | s.insert(4); 11 | s.insert(5); 12 | LOG(INFO) << s; 13 | 14 | boost::container::flat_set fs; 15 | fs.insert(1); 16 | fs.insert(2); 17 | LOG(INFO) << fs; 18 | } 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/string.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | int main(void) { 8 | boost::container::string s = "This is boost::container::string"; 9 | LOG(INFO) << s; 10 | } 11 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/boost/vector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "easylogging++.h" 5 | 6 | INITIALIZE_EASYLOGGINGPP 7 | 8 | int main(void) { 9 | boost::container::vector v; 10 | v.push_back(2); 11 | LOG(INFO) << v; 12 | 13 | boost::container::stable_vector sv; 14 | sv.push_back(3); 15 | LOG(INFO) << sv; 16 | } 17 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/default-logger.conf: -------------------------------------------------------------------------------- 1 | * GLOBAL: 2 | FORMAT = "%datetime | %level | %msg" 3 | FILENAME = "/tmp/logs/myeasylog-configuration.cpp.log" 4 | ENABLED = true 5 | TO_FILE = true 6 | TO_STANDARD_OUTPUT = true 7 | MILLISECONDS_WIDTH = 3 8 | PERFORMANCE_TRACKING = false 9 | MAX_LOG_FILE_SIZE = 2097152 ## Throw log files away after 2MB 10 | * DEBUG: 11 | FILENAME = "/tmp/logs/myeasylog-configuration.cpp-debug.log" 12 | TO_STANDARD_OUTPUT = true 13 | ENABLED = true ## We will set it to false after development completed 14 | * WARNING: 15 | FILENAME = "/tmp/logs/filename-with-time-%datetime{%H:%m}" 16 | * TRACE: 17 | TO_FILE = true ## Unnecessary configuration cuz its already true in GLOBAL but doing it anyway! 18 | * VERBOSE: 19 | FORMAT = "%datetime{%d/%M/%y} | %level-%vlevel | %msg" 20 | ## Error logs 21 | * ERROR: 22 | ENABLED = false 23 | FILENAME = "/tmp/logs/myeasylog-configuration.cpp-error.log" 24 | * FATAL: 25 | ENABLED = false 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/global.conf: -------------------------------------------------------------------------------- 1 | ## Comment line 2 | -- default ## Inline Comment 3 | *INFO: 4 | FORMAT = "%level %msg" 5 | FILENAME = "/tmp/logs/wow.log" 6 | *ERROR: 7 | FORMAT = "%levshort %fbase:%line %msg" 8 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/build_all.sh: -------------------------------------------------------------------------------- 1 | 2 | # Builds all files into bin/ 3 | 4 | [ -d "bin" ] || mkdir "bin" 5 | rm -rf bin/* 6 | 7 | find -maxdepth 1 -type f -name '*.cpp' -exec sh compile.sh {} $1 \; 8 | echo "Completed!" 9 | 10 | files=$(ls -l bin/) 11 | if [ "$files" = "total 0" ];then 12 | exit 1 13 | else 14 | exit 0 15 | fi 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/compile.sh: -------------------------------------------------------------------------------- 1 | ## Helper script for build_all.sh 2 | 3 | FILE=$1 4 | 5 | macro="$macro -DELPP_THREAD_SAFE" 6 | macro="$macro -DELPP_STL_LOGGING" 7 | macro="$macro -DELPP_STACKTRACE_ON_CRASH" 8 | 9 | if [ "$2" = "" ];then 10 | COMPILER=g++ 11 | else 12 | COMPILER=$2 13 | fi 14 | 15 | CXX_STD='-std=c++0x -pthread' 16 | 17 | if [ "$FILE" = "" ]; then 18 | echo "Please provide filename to compile" 19 | exit 20 | fi 21 | 22 | echo "Compiling... [$FILE]" 23 | 24 | COMPILE_LINE="$COMPILER $FILE `pkg-config --libs --cflags gtkmm-2.4 sigc++-2.0` -o bin/$FILE.bin $macro $CXX_STD -Wall -Wextra" 25 | echo " $COMPILE_LINE" 26 | 27 | $($COMPILE_LINE) 28 | 29 | echo " DONE! [./bin/$FILE.bin]" 30 | echo 31 | echo 32 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/hello_gtkmm/.gitignore: -------------------------------------------------------------------------------- 1 | logs/* 2 | *.bin 3 | 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/hello_gtkmm/compile.sh: -------------------------------------------------------------------------------- 1 | ## Helper script for build_all.sh 2 | 3 | macro="$macro -DELPP_THREAD_SAFE" 4 | macro="$macro -DELPP_STL_LOGGING" 5 | macro="$macro -DELPP_STACKTRACE_ON_CRASH" 6 | 7 | if [ "$1" = "" ];then 8 | COMPILER=g++ 9 | else 10 | COMPILER=$1 11 | fi 12 | 13 | CXX_STD='-std=c++0x -pthread' 14 | 15 | COMPILE_LINE="$COMPILER *.cc `pkg-config --libs --cflags gtkmm-2.4 sigc++-2.0` -o hello.bin $macro $CXX_STD -Wall -Wextra" 16 | echo " $COMPILE_LINE" 17 | 18 | $($COMPILE_LINE) 19 | 20 | echo 21 | echo 22 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/hello_gtkmm/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/hello_gtkmm/main.cc: -------------------------------------------------------------------------------- 1 | #include "window.h" 2 | #include 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | int main (int argc, char** argv) { 8 | START_EASYLOGGINGPP(argc, argv); 9 | el::Loggers::reconfigureAllLoggers(el::Level::Trace, el::ConfigurationType::Format, "%datetime %level Entering [%func]"); 10 | 11 | Gtk::Main kit(argc, argv); 12 | 13 | Window win; 14 | Gtk::Main::run(win); 15 | 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/hello_gtkmm/window.cc: -------------------------------------------------------------------------------- 1 | #include "window.h" 2 | #include 3 | #include "easylogging++.h" 4 | 5 | Window::Window() 6 | : m_button("Click Me") { 7 | LOG(TRACE); 8 | 9 | set_border_width(10); 10 | 11 | m_button.signal_clicked().connect(sigc::mem_fun(*this, &Window::on_button_clicked)); 12 | 13 | m_button.show(); 14 | add(m_button); 15 | } 16 | 17 | Window::~Window() { 18 | LOG(TRACE); 19 | } 20 | 21 | void Window::on_button_clicked() { 22 | LOG(TRACE); 23 | LOG(INFO) << "Button has been clicked!"; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/hello_gtkmm/window.h: -------------------------------------------------------------------------------- 1 | #ifndef GTKMM_EXAMPLE_Window_H 2 | #define GTKMM_EXAMPLE_Window_H 3 | 4 | #include 5 | #include 6 | 7 | class Window : public Gtk::Window 8 | { 9 | 10 | public: 11 | Window(); 12 | virtual ~Window(); 13 | 14 | protected: 15 | //Signal handlers: 16 | void on_button_clicked(); 17 | 18 | //Member widgets: 19 | Gtk::Button m_button; 20 | }; 21 | 22 | #endif // GTKMM_EXAMPLE_Window_H 23 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/run.sh: -------------------------------------------------------------------------------- 1 | echo "Running '$1'..." 2 | ./$1 3 | echo "Finished '$1'" 4 | echo 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/run_all.sh: -------------------------------------------------------------------------------- 1 | ## Runs all the build binaries from bin/ folder 2 | 3 | find bin/ -name '*.cpp.bin' -exec sh ./run.sh ./{} \; 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/sigc++.cpp: -------------------------------------------------------------------------------- 1 | // Easylogging++ sample for libsigc++ 2 | // @author mkhan3189 3 | // @rev 1.0 4 | 5 | #include 6 | #include 7 | #include "easylogging++.h" 8 | 9 | INITIALIZE_EASYLOGGINGPP 10 | 11 | class AsyncConnector { 12 | public: 13 | AsyncConnector() {} 14 | void sendNow(void) { LOG(INFO) << "Sending data..."; sleep(2); sent.emit(); } 15 | sigc::signal received; 16 | sigc::signal sent; 17 | }; 18 | 19 | void dataReceived(void) { 20 | LOG(INFO) << "Async data has been received"; 21 | } 22 | 23 | void dataSent(void) { 24 | LOG(INFO) << "Async data has been sent"; 25 | } 26 | 27 | int main(void) { 28 | AsyncConnector asyncConnection; 29 | asyncConnection.received.connect(sigc::ptr_fun(dataReceived)); 30 | asyncConnection.sent.connect(sigc::ptr_fun(dataSent)); 31 | 32 | asyncConnection.sendNow(); 33 | 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/gtkmm/ustring.cpp: -------------------------------------------------------------------------------- 1 | #include "easylogging++.h" 2 | #include 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | int main(int, char**){ 7 | 8 | Glib::ustring s("My GTK"); 9 | LOG(INFO) << s; 10 | 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/build_all.sh: -------------------------------------------------------------------------------- 1 | 2 | # Builds all files into bin/ 3 | 4 | [ -d "bin" ] || mkdir "bin" 5 | rm -rf bin/* 6 | 7 | find -maxdepth 1 -type f -name '*.cpp' -exec sh compile.sh {} $1 \; 8 | echo "Completed!" 9 | 10 | files=$(ls -l bin/) 11 | if [ "$files" = "total 0" ];then 12 | exit 1 13 | else 14 | exit 0 15 | fi 16 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/compile.sh: -------------------------------------------------------------------------------- 1 | ## Helper script for build_all.sh 2 | 3 | FILE=$1 4 | 5 | macro="$macro -DELPP_THREAD_SAFE" 6 | macro="$macro -DELPP_STL_LOGGING" 7 | macro="$macro -DELPP_WXWIDGETS_LOGGING" 8 | macro="$macro -DELPP_STACKTRACE_ON_CRASH" 9 | 10 | if [ "$2" = "" ];then 11 | COMPILER=g++ 12 | else 13 | COMPILER=$2 14 | fi 15 | 16 | CXX_STD='-std=c++0x -pthread' 17 | 18 | if [ "$FILE" = "" ]; then 19 | echo "Please provide filename to compile" 20 | exit 21 | fi 22 | 23 | echo "Compiling... [$FILE]" 24 | 25 | COMPILE_LINE="$COMPILER $FILE -o bin/$FILE.bin $macro $CXX_STD -Wall -Wextra `wx-config --cppflags` `wx-config --libs`" 26 | 27 | echo " $COMPILE_LINE" 28 | 29 | $($COMPILE_LINE) 30 | 31 | echo " DONE! [./bin/$FILE.bin]" 32 | echo 33 | echo 34 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for sample that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_SAMPLES_H 3 | #define EASYLOGGING_FOR_SAMPLES_H 4 | #include "../../src/easylogging++.h" 5 | #endif // EASYLOGGING_FOR_SAMPLES_H 6 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/run.sh: -------------------------------------------------------------------------------- 1 | echo "Running '$1'..." 2 | ./$1 3 | echo "Finished '$1'" 4 | echo 5 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/run_all.sh: -------------------------------------------------------------------------------- 1 | ## Runs all the build binaries from bin/ folder 2 | 3 | find bin/ -name '*.cpp.bin' -exec sh ./run.sh ./{} \; 4 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/wxhashmap.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | WX_DECLARE_STRING_HASH_MAP( wxString, MyHashMap); 7 | 8 | ELPP_WX_HASH_MAP_ENABLED(MyHashMap) 9 | 10 | int main() { 11 | 12 | MyHashMap h1; 13 | h1["Batman"] = "Joker"; 14 | h1["Spiderman"] = "Venom"; 15 | 16 | LOG(INFO) << h1; 17 | } 18 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/wxhashset.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | WX_DECLARE_HASH_SET( int, wxIntegerHash, wxIntegerEqual, IntHashSet ); 7 | WX_DECLARE_HASH_SET( wxString, wxStringHash, wxStringEqual, StringHashSet ); 8 | 9 | ELPP_WX_ENABLED(IntHashSet) 10 | ELPP_WX_ENABLED(StringHashSet) 11 | 12 | int main() { 13 | 14 | IntHashSet h1; 15 | StringHashSet hStr; 16 | 17 | hStr.insert( "foo" ); 18 | hStr.insert( "bar" ); 19 | hStr.insert( "baz" ); 20 | hStr.insert( "bar" ); // Does not add anything! 21 | 22 | LOG(INFO) << hStr; 23 | } 24 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/wxlist.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "easylogging++.h" 4 | 5 | INITIALIZE_EASYLOGGINGPP 6 | 7 | WX_DECLARE_LIST(int, MyList); 8 | 9 | WX_DEFINE_LIST(MyList); 10 | 11 | // Following enables MyList to be log-friendly 12 | ELPP_WX_PTR_ENABLED(MyList) 13 | 14 | int main() { 15 | MyList list; 16 | for (int i = 1; i < 110; ++i) 17 | list.Append(new int (i)); 18 | LOG(INFO) << list; 19 | } 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/wxlonglong.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | int main() { 7 | wxLongLong l = 264375895; 8 | LOG(INFO) << l; 9 | } 10 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/wxstring.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | int main() { 7 | wxString str = "This is a simple wxString"; 8 | LOG(INFO) << str; 9 | } 10 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/samples/wxWidgets/wxvector.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include "easylogging++.h" 3 | 4 | INITIALIZE_EASYLOGGINGPP 5 | 6 | int main() { 7 | wxVector vec; 8 | vec.push_back(1); 9 | vec.push_back(2); 10 | LOG(INFO) << vec; 11 | } 12 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/.gitignore: -------------------------------------------------------------------------------- 1 | bin/* 2 | logs/* 3 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/.travis_build.sh: -------------------------------------------------------------------------------- 1 | echo "Compiling unit tests..." 2 | clang++ main.cc -lgtest -std=c++11 -lpthread -o unit_test -D_ELPP_DEFAULT_LOG_FILE='"logs/el.gtest.log"' 3 | echo "Running unit tests..." 4 | ./unit_test -v 5 | result=$? 6 | rm -r unit_test logs 7 | echo "Unit tests completed : $result" 8 | exit $result 9 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/build_and_run.sh: -------------------------------------------------------------------------------- 1 | 2 | # Builds all tests into bin/ and runs 3 | 4 | [ -d "bin" ] || mkdir "bin" 5 | 6 | cd bin 7 | echo "Building..." 8 | qmake-qt4 ../qt-gtest-proj-intel.pro 9 | make 10 | echo "Running..." 11 | ./qt-gtest-proj-intel 12 | cd .. 13 | echo "Completed!" 14 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/custom-format-specifier-test.h: -------------------------------------------------------------------------------- 1 | #ifndef CUSTOM_FORMAT_SPECIFIER_TEST_H 2 | #define CUSTOM_FORMAT_SPECIFIER_TEST_H 3 | 4 | #include "test.h" 5 | 6 | const char* getIp() { 7 | return "127.0.0.1"; 8 | } 9 | 10 | TEST(CustomFormatSpecifierTest, TestInstall) { 11 | EXPECT_FALSE(el::Helpers::hasCustomFormatSpecifier("%ip")); 12 | el::Helpers::installCustomFormatSpecifier(el::CustomFormatSpecifier("%ip", getIp)); 13 | EXPECT_TRUE(el::Helpers::hasCustomFormatSpecifier("%ip")); 14 | } 15 | 16 | TEST(CustomFormatSpecifierTest, TestResolution) { 17 | Configurations c; 18 | c.setGlobally(el::ConfigurationType::Format, "%datetime{%a %b %d, %H:%m} %ip: %msg"); 19 | el::Loggers::reconfigureLogger(consts::kDefaultLoggerId, c); 20 | LOG(INFO) << "My ip test"; 21 | std::string s = BUILD_STR(getDate() << " 127.0.0.1: My ip test\n"); 22 | EXPECT_EQ(s, tail(1)); 23 | // Reset back 24 | reconfigureLoggersForTest(); 25 | } 26 | 27 | TEST(CustomFormatSpecifierTest, TestUnInstall) { 28 | EXPECT_TRUE(el::Helpers::hasCustomFormatSpecifier("%ip")); 29 | el::Helpers::uninstallCustomFormatSpecifier("%ip"); 30 | EXPECT_FALSE(el::Helpers::hasCustomFormatSpecifier("%ip")); 31 | } 32 | 33 | #endif // CUSTOM_FORMAT_SPECIFIER_TEST_H 34 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/easylogging++.h: -------------------------------------------------------------------------------- 1 | // Header for test that sub-includes original header from src/ folder 2 | #ifndef EASYLOGGING_FOR_TEST_H 3 | #define EASYLOGGING_FOR_TEST_H 4 | 5 | // We define these macros here for travis to pick up 6 | #define ELPP_STOP_ON_FIRST_ASSERTION 7 | #define ELPP_STL_LOGGING 8 | #define ELPP_FORCE_ENV_VAR_FROM_BASH 9 | #define ELPP_ENABLE_THREADING 10 | #define ELPP_STACKTRACE_ON_CRASH 11 | #define ELPP_SYSLOG 12 | #include "../src/easylogging++.h" 13 | #endif // EASYLOGGING_FOR_SAMPLES_H 14 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/helpers-test.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef HELPERS_TEST_H_ 3 | #define HELPERS_TEST_H_ 4 | 5 | #include "test.h" 6 | #include 7 | 8 | TEST(HelpersTest, ConvertTemplateToStdString) { 9 | std::vector vecInt; 10 | vecInt.push_back(1); 11 | vecInt.push_back(2); 12 | vecInt.push_back(3); 13 | vecInt.push_back(4); 14 | std::string strVecInt = el::Helpers::convertTemplateToStdString(vecInt); 15 | EXPECT_EQ("[1, 2, 3, 4]", strVecInt); 16 | } 17 | 18 | #endif // HELPERS_TEST_H_ 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/macros-test.h: -------------------------------------------------------------------------------- 1 | #ifndef MACROS_TEST_H_ 2 | #define MACROS_TEST_H_ 3 | 4 | #include "test.h" 5 | 6 | TEST(MacrosTest, VaLength) { 7 | EXPECT_EQ(10, el_getVALength("a", "b", "c", "d", "e", "f", "g", "h", "i", "j")); 8 | EXPECT_EQ(9, el_getVALength("a", "b", "c", "d", "e", "f", "g", "h", "i")); 9 | EXPECT_EQ(8, el_getVALength("a", "b", "c", "d", "e", "f", "g", "h")); 10 | EXPECT_EQ(7, el_getVALength("a", "b", "c", "d", "e", "f", "g")); 11 | EXPECT_EQ(6, el_getVALength("a", "b", "c", "d", "e", "f")); 12 | EXPECT_EQ(5, el_getVALength("a", "b", "c", "d", "e")); 13 | EXPECT_EQ(4, el_getVALength("a", "b", "c", "d")); 14 | EXPECT_EQ(3, el_getVALength("a", "b", "c")); 15 | EXPECT_EQ(2, el_getVALength("a", "b")); 16 | EXPECT_EQ(1, el_getVALength("a")); 17 | } 18 | 19 | #endif // MACROS_TEST_H_ 20 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/main.cc: -------------------------------------------------------------------------------- 1 | // gtest based unit tests 2 | 3 | #include "test.h" 4 | 5 | // Included in alphabetical order 6 | 7 | #include "command-line-args-test.h" 8 | #include "configurations-test.h" 9 | #include "custom-format-specifier-test.h" 10 | #include "enum-helper-test.h" 11 | #include "file-utils-test.h" 12 | #include "format-specifier-test.h" 13 | #include "global-configurations-test.h" 14 | #include "helpers-test.h" 15 | #include "hit-counter-test.h" 16 | #include "log-format-resolution-test.h" 17 | #include "loggable-test.h" 18 | #include "logger-test.h" 19 | #include "macros-test.h" 20 | #include "os-utils-test.h" 21 | #include "plog-test.h" 22 | #include "post-log-dispatch-handler-test.h" 23 | #include "registry-test.h" 24 | #include "strict-file-size-check-test.h" 25 | #include "string-utils-test.h" 26 | #include "syslog-test.h" 27 | #include "typed-configurations-test.h" 28 | #include "utilities-test.h" 29 | #include "verbose-app-arguments-test.h" 30 | #include "write-all-test.h" 31 | 32 | TIMED_SCOPE(testTimer, "Easylogging++ Unit Tests"); 33 | 34 | int main(int argc, char** argv) { 35 | testing::InitGoogleTest(&argc, argv); 36 | ELPP_INITIALIZE_SYSLOG(kSysLogIdent, 0, 0); 37 | 38 | reconfigureLoggersForTest(); 39 | std::cout << "Logs for test are written in [" << logfile << "]" << std::endl; 40 | 41 | return ::testing::UnitTest::GetInstance()->Run(); 42 | } 43 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/os-utils-test.h: -------------------------------------------------------------------------------- 1 | #ifndef OS_UTILS_TEST_H 2 | #define OS_UTILS_TEST_H 3 | 4 | #include "test.h" 5 | 6 | #if ELPP_OS_UNIX 7 | TEST(OSUtilsTest, GetBashOutput) { 8 | const char* bashCommand = "echo 'test'"; 9 | std::string bashResult = OS::getBashOutput(bashCommand); 10 | EXPECT_EQ("test", bashResult); 11 | } 12 | #endif 13 | 14 | TEST(OSUtilsTest, GetEnvironmentVariable) { 15 | std::string variable = OS::getEnvironmentVariable("PATH", "pathResult"); 16 | EXPECT_FALSE(variable.empty()); 17 | } 18 | #endif // OS_UTILS_TEST_H 19 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/post-log-dispatch-handler-test.h: -------------------------------------------------------------------------------- 1 | #ifndef POST_LOG_DISPATCH_HANDLER_TEST_H 2 | #define POST_LOG_DISPATCH_HANDLER_TEST_H 3 | 4 | #include "test.h" 5 | 6 | static std::vector loggedMessages; 7 | 8 | class LogHandler : public el::LogDispatchCallback { 9 | public: 10 | void handle(const LogDispatchData* data) { 11 | loggedMessages.push_back(data->logMessage()->message()); 12 | } 13 | }; 14 | 15 | TEST(LogDispatchCallbackTest, Installation) { 16 | LOG(INFO) << "Log before handler installed"; 17 | EXPECT_TRUE(loggedMessages.empty()); 18 | 19 | // Install handler 20 | Helpers::installLogDispatchCallback("LogHandler"); 21 | LOG(INFO) << "Should be part of loggedMessages - 1"; 22 | EXPECT_EQ(1, loggedMessages.size()); 23 | type::string_t expectedMessage = ELPP_LITERAL("Should be part of loggedMessages - 1"); 24 | EXPECT_EQ(expectedMessage, loggedMessages.at(0)); 25 | } 26 | 27 | TEST(LogDispatchCallbackTest, Uninstallation) { 28 | 29 | // Uninstall handler 30 | Helpers::uninstallLogDispatchCallback("LogHandler"); 31 | LOG(INFO) << "This is not in list"; 32 | EXPECT_EQ(loggedMessages.end(), 33 | std::find(loggedMessages.begin(), loggedMessages.end(), ELPP_LITERAL("This is not in list"))); 34 | } 35 | 36 | #endif // POST_LOG_DISPATCH_HANDLER_TEST_H 37 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/qt-gtest-proj-intel.pro: -------------------------------------------------------------------------------- 1 | QT += core 2 | 3 | TARGET = qt-gtest-proj-intel 4 | TEMPLATE = app 5 | 6 | QMAKE_CXXFLAGS += -std=c++0x 7 | QMAKE_CXXFLAGS += 8 | 9 | COMPILER = icpc 10 | QMAKE_CC = $$COMPILER 11 | QMAKE_CXX = $$COMPILER 12 | QMAKE_LINK = $$COMPILER 13 | 14 | LIBS += -lgtest 15 | 16 | SOURCES += main.cc 17 | 18 | HEADERS += \ 19 | configurations-test.h \ 20 | enum-helper-test.h \ 21 | hit-counter-test.h \ 22 | registry-test.h \ 23 | test.h \ 24 | typed-configurations-test.h \ 25 | utilities-test.h \ 26 | helpers-test.h \ 27 | write-all-test.h \ 28 | easylogging++.h \ 29 | global-configurations-test.h \ 30 | loggable-test.h \ 31 | logger-test.h \ 32 | verbose-app-arguments-test.h \ 33 | custom-format-specifier-test.h \ 34 | syslog-test.h \ 35 | strict-file-size-check-test.h \ 36 | command-line-args-test.h \ 37 | log-format-resolution-test.h \ 38 | string-utils-test.h \ 39 | os-utils-test.h \ 40 | file-utils-test.h \ 41 | plog-test.h \ 42 | post-log-dispatch-handler-test.h 43 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/qt-gtest-proj.pro: -------------------------------------------------------------------------------- 1 | QT += core 2 | 3 | TARGET = qt-gtest-proj 4 | TEMPLATE = app 5 | 6 | QMAKE_CXXFLAGS += -std=c++0x 7 | QMAKE_CXXFLAGS += -Wall -Wextra -pedantic -pedantic-errors -Werror -Wfatal-errors 8 | 9 | COMPILER = g++ 10 | QMAKE_CC = $$COMPILER 11 | QMAKE_CXX = $$COMPILER 12 | QMAKE_LINK = $$COMPILER 13 | 14 | LIBS += -lgtest 15 | 16 | SOURCES += main.cc 17 | 18 | HEADERS += \ 19 | configurations-test.h \ 20 | enum-helper-test.h \ 21 | hit-counter-test.h \ 22 | registry-test.h \ 23 | test.h \ 24 | typed-configurations-test.h \ 25 | utilities-test.h \ 26 | helpers-test.h \ 27 | write-all-test.h \ 28 | easylogging++.h \ 29 | global-configurations-test.h \ 30 | loggable-test.h \ 31 | logger-test.h \ 32 | verbose-app-arguments-test.h \ 33 | custom-format-specifier-test.h \ 34 | syslog-test.h \ 35 | strict-file-size-check-test.h \ 36 | command-line-args-test.h \ 37 | log-format-resolution-test.h \ 38 | string-utils-test.h \ 39 | os-utils-test.h \ 40 | file-utils-test.h \ 41 | plog-test.h \ 42 | post-log-dispatch-handler-test.h \ 43 | macros-test.h 44 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/strict-file-size-check-test.h: -------------------------------------------------------------------------------- 1 | #ifndef STRICT_FILE_SIZE_CHECK_TEST_H 2 | #define STRICT_FILE_SIZE_CHECK_TEST_H 3 | 4 | #include "test.h" 5 | 6 | static bool handlerCalled; 7 | 8 | void handler(const char*, std::size_t) { 9 | handlerCalled = true; 10 | } 11 | 12 | TEST(StrictFileSizeCheckTest, HandlerCalled) { 13 | EXPECT_FALSE(handlerCalled); 14 | EXPECT_TRUE(ELPP->hasFlag(LoggingFlag::StrictLogFileSizeCheck)); 15 | 16 | el::Loggers::getLogger("handler_check_logger"); 17 | el::Loggers::reconfigureLogger("handler_check_logger", el::ConfigurationType::Filename, "/tmp/logs/max-size.log"); 18 | el::Loggers::reconfigureLogger("handler_check_logger", el::ConfigurationType::MaxLogFileSize, "100"); 19 | el::Helpers::installPreRollOutCallback(handler); 20 | for (int i = 0; i < 100; ++i) { 21 | CLOG(INFO, "handler_check_logger") << "Test " << i; 22 | } 23 | EXPECT_TRUE(handlerCalled); 24 | } 25 | 26 | #endif // STRICTFILESIZECHECKTEST_H 27 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/test/utilities-test.h: -------------------------------------------------------------------------------- 1 | 2 | #ifndef UTILITIES_TEST_H_ 3 | #define UTILITIES_TEST_H_ 4 | 5 | #include "test.h" 6 | 7 | TEST(UtilitiesTest, SafeDelete) { 8 | int* i = new int(12); 9 | ASSERT_TRUE(i != nullptr); 10 | safeDelete(i); 11 | ASSERT_EQ(nullptr, i); 12 | } 13 | 14 | #endif // UTILITIES_TEST_H_ 15 | -------------------------------------------------------------------------------- /dense_flow/include/easylogging++/tools/.gitignore: -------------------------------------------------------------------------------- 1 | releases/* 2 | latest.zip 3 | -------------------------------------------------------------------------------- /dense_flow/include/utils.h: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Yuanjun Xiong on 18/11/2015. 3 | // 4 | 5 | #ifndef DENSEFLOW_UTILS_H 6 | #define DENSEFLOW_UTILS_H 7 | 8 | #include "common.h" 9 | 10 | void writeZipFile(vector >& data, string name_temp, string archive_name); 11 | 12 | #endif //DENSEFLOW_UTILS_H 13 | -------------------------------------------------------------------------------- /dense_flow/matlab/extracOpticalFlow.m: -------------------------------------------------------------------------------- 1 | 2 | function [] = extracOpticalFlow(index) 3 | path1 = '/home/lmwang/data/UCF/ucf101_org/'; 4 | path2 = '/home/lmwang/data/UCF/ucf101_warp_flow_img/'; 5 | 6 | folderlist = dir(path1); 7 | foldername = {folderlist(:).name}; 8 | foldername = setdiff(foldername,{'.','..'}); 9 | 10 | for i = index 11 | if ~exist([path2,foldername{i}],'dir') 12 | mkdir([path2,foldername{i}]); 13 | end 14 | filelist = dir([path1,foldername{i},'/*.avi']); 15 | 16 | for j = 1:length(filelist) 17 | if ~exist([path2,foldername{i},'/',filelist(j).name(1:end-4)],'dir') 18 | mkdir([path2,foldername{i},'/',filelist(j).name(1:end-4)]); 19 | end 20 | file1 = [path1,foldername{i},'/',filelist(j).name]; 21 | file2 = [path2,foldername{i},'/',filelist(j).name(1:end-4),'/','flow_x']; 22 | file3 = [path2,foldername{i},'/',filelist(j).name(1:end-4),'/','flow_y']; 23 | file4 = [path2,foldername{i},'/',filelist(j).name(1:end-4),'/','flow_i']; 24 | cmd = sprintf('./extract_gpu -f %s -x %s -y %s -i %s -b 20',file1,file2,file3,file4); 25 | system(cmd); 26 | end 27 | i 28 | end 29 | end -------------------------------------------------------------------------------- /dense_flow/matlab/extractOpticalFlow.m: -------------------------------------------------------------------------------- 1 | 2 | function [] = extractOpticalFlow(index) 3 | path1 = '/nfs/lmwang/lmwang/Data/UCF101/ucf101_org/'; 4 | path2 = '/media/sdb/lmwang/data/UCF101/ucf101_flow_img_TV/'; 5 | 6 | folderlist = dir(path1); 7 | foldername = {folderlist(:).name}; 8 | foldername = setdiff(foldername,{'.','..'}); 9 | 10 | for i = index 11 | if ~exist([path2,foldername{i}],'dir') 12 | mkdir([path2,foldername{i}]); 13 | end 14 | filelist = dir([path1,foldername{i},'/*.avi']); 15 | 16 | for j = 1:length(filelist) 17 | if ~exist([path2,foldername{i},'/',filelist(j).name(1:end-4)],'dir') 18 | mkdir([path2,foldername{i},'/',filelist(j).name(1:end-4)]); 19 | end 20 | file1 = [path1,foldername{i},'/',filelist(j).name]; 21 | file2 = [path2,foldername{i},'/',filelist(j).name(1:end-4),'/','flow_x']; 22 | file3 = [path2,foldername{i},'/',filelist(j).name(1:end-4),'/','flow_y']; 23 | file4 = [path2,foldername{i},'/',filelist(j).name(1:end-4),'/','flow_i']; 24 | cmd = sprintf('./extract_gpu -f %s -x %s -y %s -i %s -b 20',file1,file2,file3,file4); 25 | system(cmd); 26 | end 27 | i 28 | end 29 | end -------------------------------------------------------------------------------- /dense_flow/src/zip_utils.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Created by Yuanjun Xiong on 18/11/2015. 3 | // 4 | 5 | #include "utils.h" 6 | #include "zip.h" 7 | #include "easylogging++.h" 8 | 9 | void writeZipFile(vector >& data, string name_temp, string archive_name){ 10 | int err=0; 11 | #ifdef USE_OBSEL_LIBZIP 12 | struct zip* archive = zip_open(archive_name.c_str(), ZIP_CREATE, &err); 13 | #else 14 | struct zip* archive = zip_open(archive_name.c_str(), ZIP_CREATE|ZIP_TRUNCATE, &err); 15 | #endif 16 | 17 | CHECK_EQ(err, 0)<<"Failed to open Zip file with error code: "<