pax_global_header00006660000000000000000000000064147412226160014517gustar00rootroot0000000000000052 comment=2675b6eaecdc677e14751272bca66d2192c8a58a libosmium-2.21.0/000077500000000000000000000000001474122261600136015ustar00rootroot00000000000000libosmium-2.21.0/.clang-tidy000066400000000000000000000153151474122261600156420ustar00rootroot00000000000000--- Checks: '*,-abseil-string-find-str-contains,-altera-*,-android-cloexec-*,-boost-use-ranges,-bugprone-branch-clone,-bugprone-chained-comparison,-bugprone-easily-swappable-parameters,-bugprone-macro-parentheses,-cert-dcl21-cpp,-cert-err58-cpp,-clang-analyzer-optin.cplusplus.VirtualCall,-cppcoreguidelines-avoid-c-arrays,-cppcoreguidelines-avoid-do-while,-cppcoreguidelines-avoid-magic-numbers,-cppcoreguidelines-macro-usage,-cppcoreguidelines-non-private-member-variables-in-classes,-cppcoreguidelines-owning-memory,-cppcoreguidelines-pro-bounds-array-to-pointer-decay,-cppcoreguidelines-pro-bounds-constant-array-index,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-pro-type-const-cast,-cppcoreguidelines-pro-type-reinterpret-cast,-cppcoreguidelines-pro-type-static-cast-downcast,-cppcoreguidelines-pro-type-vararg,-fuchsia-*,-google-runtime-references,-hicpp-avoid-c-arrays,-hicpp-invalid-access-moved,-hicpp-no-array-decay,-hicpp-no-assembler,-hicpp-vararg,-llvmlibc-*,-llvm-qualified-auto,-misc-macro-parentheses,-misc-non-private-member-variables-in-classes,-misc-no-recursion,-misc-unused-parameters,-modernize-avoid-c-arrays,-modernize-raw-string-literal,-modernize-use-trailing-return-type,-portability-template-virtual-member-function,-readability-avoid-const-params-in-decls,-readability-convert-member-functions-to-static,-readability-function-cognitive-complexity,-readability-identifier-length,-readability-implicit-bool-cast,-readability-implicit-bool-conversion,-readability-magic-numbers,-readability-qualified-auto' # # For a list of check options, see: # https://clang.llvm.org/extra/clang-tidy/checks/list.html # # Disabled checks: # # abseil-string-find-str-contains # We don't want the dependency. # # altera-* # Doesn't apply. # # android-cloexec-* # O_CLOEXEC isn't available on Windows making this non-portable. # # boost-use-ranges # Would introduce extra dependency on boost. # # bugprone-branch-clone # Nice idea but collides but with switch statements we'll need to use # fall-throughs to fix this, which is also bad. # # bugprone-chained-comparison # These are generated by our test framework. # # bugprone-easily-swappable-parameters # Interesting test, but not something we can do much about in many places. # # bugprone-macro-parentheses # False positive in the only place where it reports something and # disabling locally doesn't work. # # cert-dcl21-cpp # It is unclear whether this is still a good recommendation in modern C++. # # cert-err58-cpp # Used in several singelton factory functions. I don't know of a better # way to do this and it is rather unlikely that this will be a problem. # # clang-analyzer-optin.cplusplus.VirtualCall # Disable a warning we get from the Catch test framework. # # cppcoreguidelines-avoid-c-arrays # Alias for modernize-avoid-c-arrays. # # cppcoreguidelines-avoid-do-while # Still useful and no better alternative for many cases. # # cppcoreguidelines-avoid-magic-numbers # Generally good advice, but there are too many places where this is # useful, for instance in tests. # # cppcoreguidelines-macro-usage # There are cases where we actually need macros. # # cppcoreguidelines-non-private-member-variables-in-classes # Alias for misc-non-private-member-variables-in-classes # # cppcoreguidelines-owning-memory # Don't want to add dependency on gsl library. # # cppcoreguidelines-pro-bounds-array-to-pointer-decay # Limited use and many false positives including for all asserts. # # cppcoreguidelines-pro-bounds-constant-array-index # Is needed for low-level code. # # cppcoreguidelines-pro-bounds-pointer-arithmetic # This is a low-level library, it needs to do pointer arithmetic. # # cppcoreguidelines-pro-type-const-cast # When you need it, you need it. # # cppcoreguidelines-pro-type-reinterpret-cast # This is a low-level library, it needs to do reinterpret-casts. # # cppcoreguidelines-pro-type-static-cast-downcast # This is needed and totally okay if we are sure about the types. # # cppcoreguidelines-pro-type-vararg # We need some of these functions at least and for some functions it isn't # even clear that those are vararg functions. # # fuchsia-* # Much too strict. # # google-runtime-references # This is just a matter of preference, and we can't change the interfaces # now anyways. # # hicpp-avoid-c-arrays # Alias for modernize-avoid-c-arrays. # # hicpp-invalid-access-moved # Creates false positives. # # hicpp-no-array-decay # Alias for cppcoreguidelines-pro-bounds-array-to-pointer-decay. # # hicpp-no-assembler # Reports are from macros we don't have any control over. # # hicpp-vararg # Too strict, sometimes calling vararg functions is necessary. # # llvm-qualified-auto # readability-qualified-auto # This reports too many cases. Typical case is an iterator that might be # a pointer on one system but some special type on another. # # llvmlibc-* # Doesn't apply to us. # # misc-macro-parentheses # Old name for bugprone-macro-parentheses. # # misc-non-private-member-variables-in-classes # Reports this also for structs, which doesn't make any sense. There is # an option "IgnoreClassesWithAllMemberVariablesBeingPublic" which should # disable this, but it didn't work for me. # # misc-no-recursion # There is nothing wrong with recursion. # # misc-unused-parameters # Can't be fixed, because then Doxygen will complain. (In file # include/osmium/area/problem_reporter.hpp). # # modernize-avoid-c-arrays # Makes sense for some array, but especially for char arrays using # std::array isn't a good solution. # # modernize-raw-string-literal # Readability isn't that much better, arguably worse because of the new # syntax. # # modernize-use-trailing-return-type # I am not quite that modern. # # portability-template-virtual-member-function # There is a bunch of these mostly for functions specified as =0. Totally # unclear what this is supposed to tell me. # # readability-avoid-const-params-in-decls # This is header only library, so the declaration and implementation are # often the same and we want to have the const in implementations. # # readability-convert-member-functions-to-static # Reports too many false positives # # readability-function-cognitive-complexity # Sometimes the large functions are needed. # # readability-identifier-length # Too strict. # # readability-implicit-bool-cast # Old name for readability-implicit-bool-conversion. # # readability-implicit-bool-conversion # I don't think this makes the code more readable. # # readability-magic-numbers # Alias for cppcoreguidelines-avoid-magic-numbers. # #WarningsAsErrors: '*' HeaderFilterRegex: '\/include\/osmium\/.*' ... libosmium-2.21.0/.codecov.yml000066400000000000000000000001641474122261600160250ustar00rootroot00000000000000 ignore: - "include/gdalcpp.hpp" - "include/protozero" - "include/utf8" - "test/include/catch.hpp" libosmium-2.21.0/.github/000077500000000000000000000000001474122261600151415ustar00rootroot00000000000000libosmium-2.21.0/.github/FUNDING.yml000066400000000000000000000000541474122261600167550ustar00rootroot00000000000000custom: "https://osmcode.org/sponsors.html" libosmium-2.21.0/.github/ISSUE_TEMPLATE/000077500000000000000000000000001474122261600173245ustar00rootroot00000000000000libosmium-2.21.0/.github/ISSUE_TEMPLATE/bug-report.md000066400000000000000000000024431474122261600217370ustar00rootroot00000000000000--- name: Report problems with the software about: You found a (possible) bug in libosmium title: '' labels: '' assignees: '' --- ## What version of libosmium are you using? ## What operating system and compiler are you using? ## Tell us something about your system ## What did you do exactly? ## What did you expect to happen? ## What did happen instead? ## What did you do to try analyzing the problem? libosmium-2.21.0/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000002411474122261600213110ustar00rootroot00000000000000contact_links: - name: Official OpenStreetMap forum url: https://community.openstreetmap.org/ about: Ask questions and get support from the community. libosmium-2.21.0/.github/actions/000077500000000000000000000000001474122261600166015ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/build/000077500000000000000000000000001474122261600177005ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/build/action.yml000066400000000000000000000002501474122261600216750ustar00rootroot00000000000000name: Build runs: using: composite steps: - name: Build run: cmake --build . --config Release --verbose shell: bash working-directory: build libosmium-2.21.0/.github/actions/cmake-windows/000077500000000000000000000000001474122261600213515ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/cmake-windows/action.yml000066400000000000000000000007741474122261600233610ustar00rootroot00000000000000name: Windows CMake runs: using: composite steps: - name: Create build directory run: mkdir build shell: bash - name: Configure run: | cmake -LA .. \ -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake \ -DBUILD_HEADERS=OFF \ -DBUILD_BENCHMARKS=ON \ -DOsmium_DEBUG=TRUE \ -DPROTOZERO_INCLUDE_DIR=${GITHUB_WORKSPACE}/../protozero/include shell: bash working-directory: build libosmium-2.21.0/.github/actions/cmake/000077500000000000000000000000001474122261600176615ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/cmake/action.yml000066400000000000000000000006751474122261600216710ustar00rootroot00000000000000name: CMake runs: using: composite steps: - name: Create build directory run: mkdir build shell: bash - name: Configure run: | cmake -LA .. \ -DBUILD_DATA_TESTS=ON \ -DUSE_CPP_VERSION=${CPP_VERSION} \ -DPROTOZERO_INCLUDE_DIR=${GITHUB_WORKSPACE}/../protozero/include \ -DCMAKE_BUILD_TYPE=${BUILD_TYPE} shell: bash working-directory: build libosmium-2.21.0/.github/actions/ctest/000077500000000000000000000000001474122261600177235ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/ctest/action.yml000066400000000000000000000002401474122261600217170ustar00rootroot00000000000000name: Test runs: using: composite steps: - name: Test run: ctest --output-on-failure -C Release shell: bash working-directory: build libosmium-2.21.0/.github/actions/install-macos/000077500000000000000000000000001474122261600213475ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/install-macos/action.yml000066400000000000000000000003111474122261600233420ustar00rootroot00000000000000name: Install homebrew packages on macOS runs: using: composite steps: - name: Install homebrew packages run: | brew install \ boost \ gdal shell: bash libosmium-2.21.0/.github/actions/install-protozero/000077500000000000000000000000001474122261600223105ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/install-protozero/action.yml000066400000000000000000000003171474122261600243110ustar00rootroot00000000000000name: Install Protozero from git runs: using: composite steps: - name: Install from git run: git clone --quiet --depth 1 https://github.com/mapbox/protozero.git ../protozero shell: bash libosmium-2.21.0/.github/actions/install-ubuntu/000077500000000000000000000000001474122261600215675ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/install-ubuntu/action.yml000066400000000000000000000006421474122261600235710ustar00rootroot00000000000000name: Install apt packages on Ubuntu/Debian runs: using: composite steps: - name: Install packages run: | sudo apt-get update -qq sudo apt-get install -yq \ doxygen \ libboost-dev \ libbz2-dev \ libgdal-dev \ libgeos++-dev \ liblz4-dev \ ruby-json \ spatialite-bin shell: bash libosmium-2.21.0/.github/actions/install-windows/000077500000000000000000000000001474122261600217375ustar00rootroot00000000000000libosmium-2.21.0/.github/actions/install-windows/action.yml000066400000000000000000000005321474122261600237370ustar00rootroot00000000000000name: Install vcpkg packages on Windows runs: using: composite steps: - name: Install packages run: | vcpkg install \ boost-crc:x64-windows \ boost-variant:x64-windows \ bzip2:x64-windows \ expat:x64-windows \ lz4:x64-windows \ zlib:x64-windows shell: bash libosmium-2.21.0/.github/workflows/000077500000000000000000000000001474122261600171765ustar00rootroot00000000000000libosmium-2.21.0/.github/workflows/ci.yml000066400000000000000000000166701474122261600203260ustar00rootroot00000000000000name: CI on: [ push, pull_request ] jobs: linux: runs-on: ubuntu-latest timeout-minutes: 40 strategy: fail-fast: false matrix: image: - "ubuntu:20.04" # gcc 9.3.0, clang 10.0.0, cmake 3.16.3 - "ubuntu:22.04" # gcc 12.2.0, clang 15.0.7, cmake 3.24.2 - "ubuntu:24.04" # gcc 14.2.0, clang 18.1.3, cmake 3.28.3 - "debian:bullseye" # gcc 10.2.1, clang 11.0.1, cmake 3.18.4 - "debian:bookworm" # gcc 12.2.0, clang 15.0.6, cmake 3.25.1 - "debian:testing" - "debian:experimental" - "fedora:38" - "fedora:39" - "fedora:40" - "fedora:41" build_type: [Dev] cpp_compiler: [g++] cpp_version: [c++14] include: - image: "ubuntu:22.04" CXXFLAGS: -Wno-stringop-overread - image: "ubuntu:24.04" CXXFLAGS: -Wno-stringop-overread -Wno-dangling-reference - image: "debian:bullseye" cpp_version: c++17 - image: "debian:bullseye" cpp_version: c++20 - image: "debian:bullseye" c_compiler: clang cpp_compiler: clang++ - image: "debian:bullseye" c_compiler: clang cpp_compiler: clang++ cpp_version: c++17 - image: "debian:bullseye" c_compiler: clang cpp_compiler: clang++ cpp_version: c++20 - image: "debian:bullseye" build_type: RelWithDebInfo - image: "debian:bullseye" c_compiler: clang cpp_compiler: clang++ CXXFLAGS: -fsanitize=address,undefined -fno-sanitize-recover=all -fno-omit-frame-pointer LDFLAGS: -fsanitize=address,undefined - image: "debian:bookworm" CXXFLAGS: -Wno-stringop-overread - image: "debian:bookworm" cpp_version: c++17 CXXFLAGS: -Wno-stringop-overread - image: "debian:bookworm" cpp_version: c++20 CXXFLAGS: -Wno-stringop-overread - image: "debian:bookworm" c_compiler: clang cpp_compiler: clang++ - image: "debian:bookworm" c_compiler: clang cpp_compiler: clang++ cpp_version: c++17 - image: "debian:bookworm" c_compiler: clang cpp_compiler: clang++ cpp_version: c++20 - image: "debian:bookworm" build_type: RelWithDebInfo CXXFLAGS: -Wno-stringop-overread - image: "debian:bookworm" c_compiler: clang cpp_compiler: clang++ CXXFLAGS: -fsanitize=address,undefined -fno-sanitize-recover=all -fno-omit-frame-pointer LDFLAGS: -fsanitize=address,undefined - image: "debian:testing" CXXFLAGS: -Wno-stringop-overread -Wno-dangling-reference - image: "debian:testing" c_compiler: clang cpp_compiler: clang++ - image: "debian:experimental" CXXFLAGS: -Wno-stringop-overread -Wno-dangling-reference - image: "debian:experimental" c_compiler: clang cpp_compiler: clang++ - image: "fedora:38" CXXFLAGS: -Wno-stringop-overread -Wno-dangling-reference - image: "fedora:39" CXXFLAGS: -Wno-stringop-overread -Wno-dangling-reference - image: "fedora:40" CXXFLAGS: -Wno-stringop-overread -Wno-dangling-reference - image: "fedora:41" CXXFLAGS: -Wno-stringop-overread -Wno-dangling-reference container: image: ${{ matrix.image }} env: LANG: en_US.UTF-8 BUILD_TYPE: ${{ matrix.build_type }} CC: ${{ matrix.c_compiler }} CXX: ${{ matrix.cpp_compiler }} CXXFLAGS: ${{ matrix.CXXFLAGS }} LDFLAGS: ${{ matrix.LDFLAGS }} CPP_VERSION: ${{ matrix.cpp_version }} APT_LISTCHANGES_FRONTEND: none DEBIAN_FRONTEND: noninteractive steps: - name: Prepare container (apt) shell: bash if: startsWith(matrix.image, 'debian:') || startsWith(matrix.image, 'ubuntu:') run: | apt-get update -qq apt-get install -yq \ clang \ cmake \ doxygen \ g++ \ git \ graphviz \ libboost-dev \ libbz2-dev \ libexpat1-dev \ libgdal-dev \ libgeos++-dev \ liblz4-dev \ make \ ruby \ ruby-json \ spatialite-bin \ zlib1g-dev - name: Prepare container (dnf) shell: bash if: startsWith(matrix.image, 'fedora:') run: | dnf install --quiet --assumeyes \ boost-devel \ bzip2-devel \ cmake \ doxygen \ expat-devel \ gcc-c++ \ gdal-devel \ gdalcpp-static \ geos-devel \ git \ graphviz \ lz4-devel \ make \ ruby \ rubygem-json \ spatialite-tools \ zlib-devel - uses: actions/checkout@v4 with: submodules: true - uses: ./.github/actions/install-protozero - uses: ./.github/actions/cmake - uses: ./.github/actions/build - uses: ./.github/actions/ctest ubuntu-latest: runs-on: ubuntu-24.04 timeout-minutes: 40 env: CC: clang-18 CXX: clang++-18 BUILD_TYPE: Dev steps: - uses: actions/checkout@v4 with: submodules: true - uses: ./.github/actions/install-ubuntu - uses: ./.github/actions/install-protozero - uses: ./.github/actions/cmake - uses: ./.github/actions/build - uses: ./.github/actions/ctest macos: timeout-minutes: 60 strategy: fail-fast: false matrix: os: - macos-14 - macos-15 build_type: [Dev] include: - os: macos-14 build_type: Release runs-on: ${{ matrix.os }} env: CC: clang CXX: clang++ BUILD_TYPE: ${{ matrix.build_type }} steps: - uses: actions/checkout@v4 with: submodules: true - uses: ./.github/actions/install-macos - uses: ./.github/actions/install-protozero - uses: ./.github/actions/cmake - uses: ./.github/actions/build - uses: ./.github/actions/ctest windows-minimal: timeout-minutes: 40 strategy: fail-fast: false matrix: os: - windows-2019 - windows-2022 - windows-2025 runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v4 with: submodules: true - uses: ./.github/actions/install-windows - uses: ./.github/actions/install-protozero - uses: ./.github/actions/cmake-windows - uses: ./.github/actions/build - uses: ./.github/actions/ctest windows-2022-full: runs-on: windows-2022 steps: - uses: actions/checkout@v4 with: submodules: true - uses: ./.github/actions/install-windows - name: Install extra packages run: vcpkg install geos:x64-windows gdal:x64-windows shell: bash - uses: ./.github/actions/install-protozero - uses: ./.github/actions/cmake-windows - uses: ./.github/actions/build - uses: ./.github/actions/ctest libosmium-2.21.0/.github/workflows/clang-tidy.yml000066400000000000000000000033501474122261600217550ustar00rootroot00000000000000name: clang-tidy on: workflow_dispatch jobs: clang-tidy: runs-on: ubuntu-latest strategy: fail-fast: false matrix: image: ["debian:bookworm", "debian:testing", "debian:experimental"] include: - image: "debian:bookworm" clang: 15 - image: "debian:testing" clang: 19 - image: "debian:experimental" clang: 20 container: image: ${{ matrix.image }} env: BUILD_TYPE: Dev CC: clang-${{ matrix.clang }} CXX: clang++-${{ matrix.clang }} CPP_VERSION: c++14 APT_LISTCHANGES_FRONTEND: none DEBIAN_FRONTEND: noninteractive steps: - name: Prepare container (apt) run: | apt-get update -qq apt-get install -yq \ clang-${{ matrix.clang }} \ clang-tidy-${{ matrix.clang }} \ cmake \ git \ libboost-dev \ libbz2-dev \ libexpat1-dev \ libgdal-dev \ libgeos++-dev \ liblz4-dev \ make \ zlib1g-dev shell: bash - uses: actions/checkout@v4 with: submodules: true - uses: ./.github/actions/install-protozero - uses: ./.github/actions/cmake - name: Run clang-tidy run: make clang-tidy | tee libosmium-${{ github.sha }}-clang-tidy-${{ matrix.clang }}.log shell: bash working-directory: build - name: Upload clang-tidy log uses: actions/upload-artifact@v4 if: always() with: name: libosmium-${{ github.sha }}-clang-tidy-${{ matrix.clang }}-log path: build/libosmium-${{ github.sha }}-clang-tidy-${{ matrix.clang }}.log libosmium-2.21.0/.gitignore000066400000000000000000000001001474122261600155600ustar00rootroot00000000000000*.swp .ycm_extra_conf.pyc /_build* /build /libosmium-deps /.vs* libosmium-2.21.0/.gitmodules000066400000000000000000000001771474122261600157630ustar00rootroot00000000000000[submodule "test/data-tests/osm-testdata"] path = test/data-tests/osm-testdata url = https://github.com/osmcode/osm-testdata libosmium-2.21.0/CHANGELOG.md000066400000000000000000001533501474122261600154210ustar00rootroot00000000000000 # Change Log All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](https://semver.org/). ## [unreleased] - ### Added ### Changed ### Fixed ## [2.21.0] - 2025-01-13 ### Changed * Switched to C++14 as minimum requirement * Removed suport for Google Sparsehash * Removed support for projection using the Proj library (which only worked for very old versions of Proj) * Various refactoring and code cleanups ### Fixed * Fix problem where bz2 files were not read completely (#373) * Order deleted objects after visible ones in reverse id order. This fixes a problem when merging diffs for different extracts. * Remove resource leak in temp file creation ## [2.20.0] - 2023-09-20 ### Changed * Optionally allow fractional seconds in timestamps in OSM files. * Enable `posix_fadvise` usage on FreeBSD. * Make parsing PBFs a bit less picky. * Various small code cleanups. ### Fixed * Don't use class template arguments on `GeometryFactory` constructor definition. ## [2.19.0] - 2023-01-19 ### Changed * Mark RapidJSON support as deprecated. * Update included Catch to v2.13.10. * Remove deprecated BoolVector class. * Remove deprecated NWRIdSet class. * Remove deprecated AssemblerConfig constructor. * Print start of offending string in overlong string exception. * Implement `set_thread_name()` on FreeBSD. * Some small code cleanups. ### Fixed * Fix return type in `MembersDatabaseCommon::count_not_removed()`. * Make bzip2 unit tests pass on musl-based systems. * Fix bug in members database test case. ## [2.18.0] - 2022-02-07 ### Changed * Use `system_error` instead of `runtime_error` where it fits better. * Remove `OSMIUM_NORETURN` macro. This hasn't been used in a while. ### Removed deprecated parts of the code Several parts of libosmium have been marked deprecated, many of them for a very long time. These are now removed: * Sparsehash index class `osmium::index::map::SparseMemTable` as well as the complete file `osmium/index/map/sparse_mem_table.hpp`. * Callback functionality of the `osmium::memory::Buffer` class. The `set_full_callback()` will not be available any more. See the source for replacement options. * Various `osmium::builder::build_*` functions in `osmium/builder/builder_helper.hpp`. Use `osmium::builder::add_*` functions instead. Removes `builder_helper.hpp`. * `osmium::builder::Builder::add_item(const osmium::memory::Item* item)`. Use the function of the same name taking a reference instead. * `osmium::builder::OSMObject/ChangesetBuilder::add_user()`. Use `set_user()` instead. * `osmium::builder::ChangesetBuilder::bounds()` returning a modifiable reference. Use `set_bounds()` instead. * Several functions around `osmium::io::OutputIterator`. * `osmium::Area::inner_ring_cbegin/cend()`, use `inner_rings()` instead. * `osmium::RelationMember::ref()`, use `set_ref()` instead. * Implicit conversion from `osmium::Timestamp` to `std::time_t`. Use `seconds_since_epoch()` instead. * `osmium::string_to_user_id()`, use `string_to_uid` instead. * `osmium::static_cast_with_assert()` helper functions as well as the complete include file `osmium/util/cast.hpp`. * Some constructors of `osmium::util::MemoryMapping` and `osmium::util::TypedMemoryMapping`. Use other constructor instead. ## [2.17.3] - 2022-01-19 ### Fixed * Removed possible deadlock when shutting down active Reader. ## [2.17.2] - 2021-12-16 ### Changed * Libosmium now supports being compiled in C++17 and C++20 mode. The minimum version required is still C++11, but if you use libosmium in an C++17 or C++20 application this should work properly. * Switch from catch version 1 to catch2 as test framework. * When `std::variant` is available (C++17 and above), libosmium will use that instead of `boost::variant` reducing the dependencies a little bit. * Removed various workaround that were needed for older MSVC compilers. * Remove use of `boost::filter_iterator` and `boost::indirect_iterator`. The removes the dependency on Boost Iterator. * Examples now mostly use the somewhat cleaner `return` instead of `std::exit()` to return an exit code from `main`. * As always: Various small code cleanups. ### Fixed * When ordering OSM objects (mostly use in the `CheckOrder` handler), the smallest id possible (`INTMIN`) wasn't sorted correctly. * Threading problem when reading files. * Possible dereference of invalid iterator in legacy area assembler. This only affects the legacy area assembler that takes old-style multipolygons into account, so modern code that is not working with history data is not affected. * Fixed read from an empty queue when reading a file which could block libosmium forever when an error was encountered while reading a file. ### Deprecated Several parts of libosmium have been marked deprecated, many of them for a very long time. These will not be part of the next version of libosmium: * Sparsehash index class `osmium::index::map::SparseMemTable` as well as the complete file `osmium/index/map/sparse_mem_table.hpp`. * Callback functionality of the `osmium::memory::Buffer` class. The `set_full_callback()` will not be available any more. See the source for replacement options. * Various `osmium::builder::build_*` functions in `osmium/builder/builder_helper.hpp`. Use `osmium::builder::add_*` functions instead. Removes `builder_helper.hpp`. * `osmium::builder::Builder::add_item(const osmium::memory::Item* item)`. Use the function of the same name taking a reference instead. * `osmium::builder::OSMObject/ChangesetBuilder::add_user()`. Use `set_user()` instead. * `osmium::builder::ChangesetBuilder::bounds()` returning a modifiable reference. Use `set_bounds()` instead. * Several functions around `osmium::io::OutputIterator`. * `osmium::Area::inner_ring_cbegin/cend()`, use `inner_rings()` instead. * `osmium::RelationMember::ref()`, use `set_ref()` instead. * Implicit conversion from `osmium::Timestamp` to `std::time_t`. Use `seconds_since_epoch()` instead. * `osmium::string_to_user_id()`, use `string_to_uid` instead. * `osmium::static_cast_with_assert()` helper functions as well as the complete include file `osmium/util/cast.hpp`. * Some constructors of `osmium::util::MemoryMapping` and `osmium::util::TypedMemoryMapping`. Use other constructor instead. ## [2.17.1] - 2021-10-05 ### Added * Add `osmium_tags_filter` example showing use of tags filter. * Add `Writer::set_header()` function to set header after constructing. ### Changed * Various improvements in PBF file reading make it slightly faster and less CPU intensive. * Since 2.17.0 Osmium will, when reading files, tell the kernel using `fadvise` that it can remove pages from the buffer cache that are not needed any more. This is usually beneficial, because the memory can be used for something else. But if you are reading the same OSM file multiple times at the same time or in short succession, it might be better to keep those buffer pages. In that case you can set the environment variable `OSMIUM_CLEAN_PAGE_CACHE_AFTER_READ` to `no` and Osmium will not call `fadvise`. Set it to `yes` or anything else (or not set it at all) to get the default behaviour. * If the macro `OSMIUM_DEFINE_EXPORT` is defined, all exception classes used by Osmium will get "tagged as exported" using `__declspec(dllexport)` when using MSVC or `__attribute__ ((visibility("default")))` on other compilers. This is needed in PyOsmium. ### Fixed * Fix integer parser. IDs in OPL files can now be anything between -2^63 and 2^63-1. ## [2.17.0] - 2021-04-26 ### Added * Add "ids" output format. New IDS output format that is similar to the OPL format, but only the entity type and id is written out. * Add convenience functions `left()`, `right()`, `top()`, `bottom()` to access `osmium::Box` boundaries. * Add polygon output to WKB factory. * Add functions to access storage from `node_locations_for_ways` handler. * Add flag `osmium::io::buffers_type` for telling the `Reader` class whether you want buffers read to only contain a single type of OSM entity. * Add convenient named `nodes()`, `ways()`, and `relations()` accessor functions to `nwr_array` class. * Add `DeltaDecode::value()` accessor function. * Add variant of the `Buffer::purge_removed()` function which doesn't take a callback parameter. ### Changed * Different varint decoding for faster PBF decoding. This makes PBF decoding about 15% faster. * Several code optimmizations in (PBF) writer code that speed up writing of OSM files considerably while using less CPU and spreading the load on multiple CPUs. * Use memset/memcpy instead of `std::fill_n` and `std::copy` in object builder for some slight speedups. * Ignore metadata setting on reader for history/change files. History and change files must be read with metadata, because otherwise the information is lost whether an object is visible or deleted. So ignore this setting in that case. * On Linux: Use fadvise() to tell kernel about our reading patterns: 1. Tell kernel that we are reading OSM files sequentially. This should improve pre-fetching of data blocks. 2. Tell kernel that we are done with block so they can be released. This means we don't hog the buffer cache for something that will, in all likelyhood, not be needed any more. * Use assert() instead of exception in "can not happen" situation in the relations manager code. * Various code cleanups. ### Fixed * Test failure with `add_tag_list` on some systems. * Test framework fix for aarch64 architecture. * Remove undefined behaviour in bzip2 compression code. * Rename some local variables to not shadow member functions. * Wrap `osmium::util::MemoryMapping::unmap()` in try/catch on Windows also because we call this from a noexcept function. * Removed superfluous `std::forward`s and fixed code that called `std::forward` multiple times on the same object. * Fix in OPL parser which could lead to invalid data being generated. * Fixed three bugs in O5M parser which could lead to an infinit loop or segmentation faults. ## [2.16.0] - 2021-01-08 ### Added * The PBF reader and writer now understand PBF blobs compressed with the LZ4 compression algorithm in addition to the usual ZLIB compression (or no compression at all). LZ4 is much faster to compress and uncompress. Use by setting the `pbf_compression` output file format option to `lz4`. You have to define `OSMIUM_WITH_LZ4` to enable this before including any libosmium includes. * The function `osmium::io::supported_pbf_compression_types` can now be used to get a list of all PBF compression types supported. * The output file option `pbf_compression_level` can now be set to an integer. The range depends on the compression type used, 0-9 for zlib compression and 1-65537 for lz4 compression. * Adds `ptr_begin()`/`ptr_end()` functions to `ObjectPointerCollection` for accessing the pointers instead of the underlying objects. ### Changed * The `osmium::io::Writer::close()` function now returns the number of bytes written to an OSM file if it is available (and 0 otherwise). * Use stable sort when sorting `ObjectPointerCollection`. ### Fixed * Various small fixes and cleanups. ## [2.15.6] - 2020-06-27 ### Added * Add `IdSetSmall::merge_sorted` function. ### Changed * Little optimization for IdSetSmall: Don't add the same id twice in a row. ### Fixed * Do not build areas with "recursion depth > 20". This happens when there are complex multipolygon with many rings touching in single points. This is a quick fix that hopefully keeps us going until we find a better solution. ## [2.15.5] - 2020-04-21 ### Added * Additional constructor for `builder::attr::member_type(_string)` taking char type making it even easier to generate test data. * Allow single C string or `std::string` as argument for `builder::attr::_tag`. Must contain key and value separated by the equal sign. * New `builder::attr::_t()` function to set tags from comma-separated string. * New `nwr_array` iterator. * Support for the PROJ library has now been declared deprecated. The old PROJ API (up to version PROJ 6) is currently still available, but will be removed in a future version. Support for the new PROJ API will not be in libosmium. See https://github.com/osmcode/osmium-proj for some code that might help you if you need this. ### Changed * Check how much space is available in file system before resizing memory mapped file (not on Windows). This means we can, at least in some cases, show an error message instead of crashing the program. ### Fixed * Parsing coordinates in PBF files did not work correctly if an lat/lon offset was specified (which almost never happens). * Make OPL parser more strict: Attributes can only be specified once. * Do not close stdout after writing OSM file to it. ## [2.15.4] - 2019-11-28 ### Added * Add osmium::Options::empty() for consistency with STL containers. ### Fixed * Massive reduction of memory consumption in area assembly code. For some very complex polygons memory usage can drop from multiple gigabytes to just megabytes. ## [2.15.3] - 2019-09-16 ### Added * New header option "sorting" when reading and writing PBFs. If the header option "sorting" is set to `Type_then_ID`, the optional header property `Sort.Type_then_ID` is set on writing to PBF files. When reading PBF files with this header property, the "sorting" header option is set accordingly. ### Fixed * Do not propagate C++ exception through C code. We are using the Expat XML parser, a C library. It calls callbacks in our code. When those callbacks throw, the exception was propagated through the C code. This did work in the tests, but that behaviour isn't guaranteed (C++ standard says it is implementation defined). This fixes it by catching the exception and rethrowing it later. ## [2.15.2] - 2019-08-16 ### Added * Instead of handler classes, the `apply` function can now also take lambdas (or objects from classes implementing `operator()`). * Add swap, copy constructor and assignment operator to IdSetDense. ### Changed * Enable use of the old proj API in proj version 6. This is a stopgap solution until we find a better one. * Better error messages when there is an error parsing a timestamp. * Cleaned up a lot of code based on clang-tidy warnings. * Ignore or subelement of or . elements are created by Overpass API as subelements of ways or relations when the "out bb" format is used. subelements turn up in files downloaded from http://download.openstreetmap.fr/replication . Libosmium used to throw an error like "Unknown element in : bbox". With this commit, these subelements are ignored, ie. there is no error any more, but the data is not read. * Add swap, copy constructor and assignment operator to IdSetDense. * Update included catch.hpp to 1.12.2. * Retire use of `OSMIUM_NORETURN` macro. Use `[[noreturn]]` instead. ### Fixed * Do not build areas with more than 100 locations where rings touch. Places where rings touch are unusual for normal multipolygons and the algorithm in libosmium that assembles multipolygons does not handle them well. If there are too many touching points it becomes very slow. This is not a problem for almost all multipolygons. As I am writing this there are only three relations in the OSM database with more than 100 touching points, all of them rather weird boundaries in the US. With this commit libosmium will simply ignore those areas to keep the processing speed within reasonable bounds. ## [2.15.1] - 2019-02-26 ### Added * More tests. * CMake config: also find clang-tidy-7. ### Changed * Example and benchmark programs now don't crash with exceptions any more but report them properly. ### Fixed * Compile with NDEBUG in RelWithDebInfo mode. * Correctly throw exception in `multimap::dump_as_list()`. * Integer truncation on 32 bit systems in `MemoryUsage`. * Exception specification on some functions. * Forwarding references that might have hidden copy/move constructors. ## [2.15.0] - 2018-12-07 ### Added * Function `dump_as_array()` to dump sparse array indexes. * Set the `xml_josm_upload` header option when reading XML files. * New function `OSMObject::remove_tags()` marks tags on OSM objects as removed. * More tests. ### Changed * When reading OSM files Libosmium now has less memory overhead, especially when reading PBF files. This works by using more, but smaller buffers. * The `TagsFilter` class is now based on the `TagsFilterBase` template class which allows setting the result type. This allows the filter to return more data depending on the rule that matched. * Use enums for many constants instead of (static) const(expr) variables. * Make `chunk_bits` in `IdSetDense` configurable. * Hardcode `%lld` format instead of using `` PRI macro. * Update included gdalcpp to version 1.2.0. ### Fixed * The gzip/bzip2 compression code was overhauled and is better tested now. This fixes some bugs on Windows. ## [2.14.2] - 2018-07-23 ### Fixed * PBF reader and writer depended on byte order of system architecture. * Removed an unreliable test that didn't work on some architectures. ## [2.14.1] - 2018-07-23 ### Changed * Libosmium now needs the newest Protozero version 1.6.3. * Removes dependency on the utfcpp library for conversions between Unicode code points and UTF-8. We have our own functions for this now. This also gives us more control on where errors are thrown in this code. * Add support for using the CRC32 implementation from the zlib library in addition to the one from Boost. It is significantly faster and means we have one less dependency, because zlib is needed anyway in almost all programs using Osmium due to its use in the PBF format. Set macro `OSMIUM_TEST_CRC_USE_BOOST` before compiling the tests, if you want to run the tests with the boost library code, otherwise it will use the zlib code. Note that to use this you have to change your software slightly, see the documentation of the `CRC_zlib` class for details. * Add a `clear_user()` function to OSMObject and Changeset which allows removing the user name of an entity without re-creating it in a new buffer. * In Osmium the 0 value of the Timestamp is used to denote the "invalid" Timestamp, and its output using the `to_iso()` function is the empty string. But this is the wrong output for OSM XML files, where a timestamp that's not set should still be output as 1970-01-01T00:00:00Z. This version introduces a new `to_is_all()` function which will do this and uses that function in the XML writer. * Use `protozero::byteswap_inplace` instead of `htonl`/`ntohl`. Makes the code simpler and also works on Windows. * Marked `MultipolygonCollector` class as deprecated. Use the `MultipolygonManager` class introduced in 2.13.0 instead. * Lots of code cleanups especially around `assert`s. Libosmium checks out clean with `clang-tidy` now. Some documentation updates. ### Fixed * Fix compilation error when `fileno()` is a macro (as in OpenBSD 6.3). * Make `Box` output consistent with the output of a single `Location` and avoids problems with some locales. ## [2.14.0] - 2018-03-31 ### Added * Add `ReaderWithProgressBar` class. This wraps an `osmium::io::Reader` and an `osmium::ProgressBar` into a nice little package allowing easier use in the common case. * Add polygon implementation for WKT and GeoJSON geometry factories. (Thanks to Horace Williams.) * Various tests. ### Changed * Add git submodule with `osm-testdata` repository. Before this the repository had to be installed externally. Now a submodule update can be used to get the correct version of the osm-testdata repository. * The XML file reader was rewritten to be more strict. Cases where it could be tricked into failing badly were removed. There are now more tests for the XML parser. * Replaced `strftime` by our own implementation. Uses a specialized implementation for our use case instead the more general `strftime`. Benchmarked this to be faster. * Changed the way IDs are parsed from strings. No asserts are used any more but checks are done and an exception is thrown when IDs are out of range. This also changes the way negative values are handled. The value `-1` is now always accepted for all IDs and returned as `0`. This deprecates the `string_to_user_id()` function, use `string_to_uid()` instead which returns a different type. * It was always a bit confusing that some of the util classes and functions are directly in the `osmium` namespace and some are in `osmium::util`. The `osmium::util` namespace is now declared `inline`. which allows all util classes and functions to be addressed directly in the `osmium` namespace while keeping backwards compatibility. * An error is now thrown when the deprecated `pbf_add_metadata` file format option is used. Use `add_metadata` instead. * Extended the `add_metadata` file format option. In addition to allowing the values `true`, `yes`, `false`, and `no`, the new values `all` and `none` are now recognized. The option can also be set to a list of attributes separated by the `+` sign. Attributes are `version`, `timestamp`, `changeset`, `uid`, and `user`. All output formats have been updated to only output the specified attributes. This is based on the new `osmium::metadata_options` class which stores information about what metadata an `OSMObject` has or should have. (Thanks to Michael Reichert.) * The `<` (less than) operator on `OSMObject`s now ignores the case when one or both of the timestamps on the objects are not set at all. This allows better handling of OSM data files with reduced metadata. * Allow `version = -1` and `changeset = -1` in PBF input. This value is sometimes used by other programs to denote "no value". Osmium uses the `0` for this. * The example programs using the `getopt_long` function have been rewritten to work without it. This makes using libosmium on Windows easier, where this function is not available. * Removed the embedded protozero from repository. Like other dependencies you have to install protozero first. If you check out the protozero repository in the same directory where you checked out libosmium, libosmium's CMake will find it. * Various code cleanups, fixing of include order, etc. * Remove need for `winsock2` library in Windows by using code from Protozero. (Thanks alex85k.) * Add MSYS2 build to Appveyor and fixed some Windows compile issues. (Thanks to alex85k.) * Use array instead of map to store input/output format creators. * Update included `catch.hpp` to version 1.12.1. ### Fixed * Remove check for lost ways in multipolygon assembler. This rules out too many valid multipolygons, more specifically more complex ones with touching inner rings. * Use different macro magic for registering index maps. This allows the maps to be used for several types at the same time. * Lots of code was rewritten to fix warnings reported by `clang-tidy` making libosmium more robust. * Make ADL work for `begin()`/`end()` of `InputIterator`. * Various fixes to make the code more robust, including an undefined behaviour in the debug output format and a buffer overflow in the o5m parser. * Range checks in o5m parser throw exceptions now instead of triggering assertions. * Better checking that PBF data is in range. * Check `read` and `write` system calls for `EINTR`. * Use tag and type from protozero to make PBF parser more robust. * Test `testdata-multipolygon` on Windows was using the wrong executable name. ## [2.13.1] - 2017-08-25 ### Added - New "blackhole" file format which throws away all data written into it. Used for benchmarking. ### Changed - When reading OPL files, CRLF file endings are now handled correctly. - Reduce the max number of threads allowed for the `Pool` to 32. This should still be plenty and might help with test failures on some architectures. ### Fixed - Tests now run correctly independent of git `core.autocrlf` setting. - Set binary mode for all files on Windows in example code. - Low-level file functions now set an invalid parameter handler on Windows to properly handle errors. - Restore earlier behaviour allowing zero-length mmap. It is important to allow zero-length memory mapping, because it is possible that such an index is empty, for instance when one type of object is missing from an input file as in https://github.com/osmcode/osmium-tool/issues/65. Drawback is that files must be opened read-write for this to work, even if we only want to read from them. - Use Approx() to compare floating point values in tests. - Fix broken `Item` test on 32 bit platforms. ## [2.13.0] - 2017-08-15 ### Added - New `RelationsManager` class superseeds the `relations::Collector` class. The new class is much more modular and easier to extend. If you are using the Collector class, you are encouraged to switch. - New `MultipolygonManager` based on the `RelationsManager` class superseeds the `MultipolygonCollector` class. The examples have been changed to use the new class and all users are encouraged to switch. There is also a `MultipolygonManagerLegacy` class if you still need old-style multipolygon support (see below). - New `FlexMem` index class that works with input files of any size and stores the index in memory. This should now be used as the default index for node location stores. Several example programs now use this index. - New `CallbackBuffer` class, basically a convenient wrapper around the `Buffer` class with an additional callback function that is called whenever the buffer is full. - Introduce new `ItemStash` class for storing OSM objects in memory. - New `osmium::geom::overlaps()` function to check if two `Box` objects overlap. - Add function `IdSet::used_memory()` to get estimate of memory used in the set. - New `is_defined()` and `is_undefined()` methods on `Location` class. - Tests for all provided example programs. (Some tests currently fail on Windows for the `osmium_index_lookup` program.) ### Changed - The area `Assembler` now doesn't work with old-style multipolygons (those are multipolygon relations with the tags on the outer ways(s) instead of on the relation) any more. Because old-style multipolygons are now (mostly) gone from the OSM database this is usually what you want. The new `AssemblerLegacy` class can be used if you actually need support for old-style multipolygons, for instance if you are working with historical data. (In that case you also need to use the `MultipolygonManagerLegacy` class instead of the `MultipolygonManager` class.) - Changes for consistent ordering of OSM data: OSM data can come in any order, but usual OSM files are ordered by type, ID, and version. These changes extend this ordering to negative IDs which are sometimes used for objects that have not been uploaded to the OSM server yet. The negative IDs are ordered now before the positive ones, both in order of their absolute value. This is the same ordering as JOSM uses. - Multipolygon assembler now checks for three or more overlapping segments which are always an error and can report them. - Enable use of user-provided `thread::Pool` instances in `Reader` and `Writer` for special use cases. - Growing a `Buffer` will now work with any capacity parameter, it is always rounded up for proper alignment. Buffer constructor with three arguments will now check that commmitted is not larger than capacity. - Updated embedded protozero to 1.5.2. - Update version of Catch unit test framework to 1.9.7. - And, as always, lots of small code cleanups and more tests. ### Fixed - Buffers larger than 2^32 bytes do now work. - Output coordinate with value of -2^31 correctly. - Changeset comments with more than 2^16 characters are now allowed. The new maximum size is 2^32. - `ChangesetDiscussionBuilder::add_comment_text()` could fail silently instead of throwing an exception. - Changeset bounding boxes are now always output to OSM files (any format) if at least one of the corners is defined. This is needed to handle broken data from the main OSM database which contains such cases. The OPL reader has also been fixed to handle this case. - In the example `osmium_location_cache_create`, the index file written is always truncated first. ## [2.12.2] - 2017-05-03 ### Added - Add two argument (key, value) overload of `TagMatcher::operator()`. ### Changed - Detect, report, and remove duplicate ways in multipolygon relations. - Change EOF behaviour of Reader: The `Reader::read()` function will now always return an invalid buffer exactly once to signal EOF. - Update QGIS multipolygon project that is part of the test suite to show more problem types. - Copy multipolygon QGIS file for tests to build dir in cmake step. - Some code cleanups and improved debug output in multipolygon code. - Refactor I/O code to simplify code. - Disable some warnings on MSVC. - Various small code and build script changes. ### Fixed - Two bugs in area assembler affecting very complex multipolygons and multipolygons with overlapping or nearly overlapping lines. - Invalid use of iterators leading to undefined behaviour in area assembler code. - Area assembler stats were not correctly counting inner rings that are areas in their own right. - Fix a thread problem valgrind found that might or might not be real. - Read OPL file correctly even if trailing newline in file is missing. - Include order for `osmium/index/map` headers and `osmium/index/node_locations_map.hpp` (or `osmium/handler/node_locations_for_ways.hpp`) doesn't matter any more. ## [2.12.1] - 2017-04-10 ### Added - New `TagsFilter::set_default_result()` function. ### Changed - Use larger capacity for `Buffer` if necessary for alignment instead of throwing an exception. Minimum buffer size is now 64 bytes. - Check order of input data in relations collector. The relations collector can not deal with history data or a changes file. This was documented as a requirement, but often lead to problems, because this was ignored by users. So it now checks that the input data it gets is ordered and throws an exception otherwise. - When writing an OSM file, set generator to libosmium if not set by app. ### Fixed - Infinite loop in `Buffer::reserve_space()`. (Issue #202.) - `ObjectPointerCollection::unique()` now removes elements at end. - Tests comparing double using `==` operator. - Build on Cygwin. ## [2.12.0] - 2017-03-07 ### Added - `TagMatcher` and `TagsFilter` classes for more flexibly matching tags and selecting objects based on tags. This obsoletes the less flexible classes based on `osmium::tags::Filter` classes. - Extended `index::RelationsMap(Stash|Index)` classes to also allow parent-to-member lookups. - New `nrw_array` helper class. - `ObjectPointerCollection::unique()` function. ### Changed - Area assembler can now detect invalid locations and report them in the stats and through the problem reporter. If the new config option `ignore_invalid_locations` is set, the Assembler will pretend they weren't even referenced in the ways. (Issue #195.) - `osmium::area::Assembler::operator()` will now return a boolean reporting whether building of the area(s) was successful. - Split up area `Assembler` class into three classes: The `detail::BasicAssembler` is now the parent class. `Assembler` is the child class for usual use. The new `GeomAssembler` also derives from `BasicAssembler` and builds areas without taking tags into account at all. This is to support osm2pgsql which does tag handling itself. (Issue #194.) - The `Projection` class can do any projection supported by the Proj.4 library. As a special case it now uses our own Mercator projection functions when the web mercator projection (EPSG 3857) is used. This is much faster than going through Proj.4. - Better error messages for low-level file utility functions. - Mark `build_tag_list*` functions in `builder_helper.hpp` as deprecated. You should use the functions from `osmium/builder/attr.hpp` instead. - Improved performance of the `osmium::tags::match_(any|all|none)_of` functions. - Improved performance of string comparison in `tags::Filter`. - Update version of Catch unit test framework to 1.8.1. This meant some tests had to be updated. - Use `get_noexcept()` in `NodeLocationsForWays` handler. - And lots of code and test cleanups... ### Fixed - Terminate called on full non-auto-growing buffer. (Issue #189.) - When file formats were used that were not compiled into the binary, it terminated instead of throwing. (Issue #197.) - Windows build problem related to including two different winsock versions. - Windows build problem related to forced build for old Windows versions. (Issue #196.) - Clear stream contents in ProblemReporterException correctly. - Add `-pthread` compiler and linker options on Linux/OSX. This should fix a problem where some linker versions will not link binaries correctly when the `--as-needed` option is used. - The `Filter::count()` method didn't compile at all. - XML reader doesn't fail on relation member ref=0 any more. ## [2.11.0] - 2017-01-14 ### Added - New index::RelationsMap(Stash|Index) classes implementing an index for looking up parent relation IDs given a member relation ID. - Add `get_noexcept()` method to all index maps. For cases where ids are often not in the index using this can speed up a program considerably. - New non-const WayNodeList::operator[]. - Default constructed "invalid" Coordinates. - Tile constructor from web mercator coordinates and some helper functions for tile arithmetic. - Tag matcher matching keys using a regex. - New `envelope()` functions on `NodeRefList`, `Way`, and `Area` returning a `Box` object with the geometric envelope of the object. - Add `amenity_list` example. ### Changed - Replaced the implementation for the web mercator projection using the usual tan-formula with a polynomial approximation which is much faster and good enough for OSM data which only has ~1cm resolution anyway. See https://github.com/osmcode/mercator-projection for all the details and benchmarks. You can disable this by defining the macro `OSMIUM_USE_SLOW_MERCATOR_PROJECTION` before including any of the Osmium headers. - Removed the outdated `Makefile`. Always use CMake directly to build. - Refactoring of `osmium::apply()` removing the resursive templates for faster compile times and allowing rvalue handlers. - Lots of code and test cleanups and more documentation. ### Fixed - Handle endianess on FreeBSD properly. - Fixed doxygen config for reproducible builds. ## [2.10.3] - 2016-11-20 ### Changed - Round out ObjectPointerCollection implementation and test it. - Updated embedded protozero to 1.4.5. ## [2.10.2] - 2016-11-16 ### Changed - Updated embedded protozero to 1.4.4. ### Fixed - Buffer overflow in osmium::Buffer. ## [2.10.1] - 2016-11-15 ### Changed - Updated embedded protozero to 1.4.3. ### Fixed - Made IdSet work on 32bit systems. - Fixed endianness check for WKB tests. ## [2.10.0] - 2016-11-11 ### Added - The `Reader` can take an additional optional `read_meta` flag. If this is set to false the PBF input will ignore metadata on OSM objects (like version, timestamp, uid, ...) which speeds up file reading by 10 to 20%. - New `IdSet` virtual class with two implementations: `IdSetDense` and `IdSetSmall`. Used to efficiently store a set of Ids. This is often needed to track, for instance, which nodes are needed for ways, etc. - Added more examples and better documented existing examples. - Add a benchmark "mercator" converting all node locations in a file to WebMercator and creating geometries in WKB format. ### Changed - Better queue handling makes I/O faster in some circumstances. - The `FindOsmium.cmake` CMake script can now check a current enough libosmium version is found. - Builders can now be constructed with a reference to parent builder. - Made builders more robust by adding asserts that will catch common usage problems. - Calling `OSMObjectBuilder::add_user()` is now optional, and the method was renamed to `set_user()`. (`add_user()` is marked as deprecated.) - Benchmarks now show compiler and compiler options used. - `Builder::add_item()` now takes a reference instead of pointer (old version of the function marked as deprecated). - GEOS support is deprecated. It does not work any more for GEOS 3.6 or newer. Reason is the changed interface in GEOS 3.6. If there is interest for the GEOS support, we can add support back in later (but probably using the GEOS C API which is more stable than the C++ API). Some tests using GEOS were rewritten to work without it. - The `BoolVector` has been deprecated in favour of the new `IdSet` classes. - Lots of code cleanups and improved API documentation in many places. - The relations collector can now tell you whether a relation member was in the input data. See the new `is_available()` and `get_availability_and_offset()` methods. - Updated embedded Catch unit test header to version 1.5.8. ### Fixed - Parsing of coordinates starting with decimal dot and coordinates in scientific notation. - `~` operator for `entity_bits` doesn't set unused bits any more. - Progress bar can now be (temporarily) removed, to allow other output. ## [2.9.0] - 2016-09-15 ### Added - Support for reading OPL files. - For diff output OSM objects in buffers can be marked as only in one or the other file. The OPL and debug output formats support diff output based on this. - Add documentation and range checks to `Tile` struct. - More documentation. - More examples and more extensive comments on examples. - Support for a progress report in `osmium::io::Reader()` and a `ProgressBar` utility class to use it. - New `OSMObject::set_timestamp(const char*)` function. ### Changed - Parse coordinates in scientific notations ourselves. - Updated included protozero version to 1.4.2. - Lots of one-argument constructors are now explicit. - Timestamp parser now uses our own implementation instead of strptime. This is faster and independant of locale settings. - More cases of invalid areas with duplicate segments are reported as errors. ### Fixed - Fixed a problem limiting cache file sizes on Windows to 32 bit. - Fixed includes. - Exception messages for invalid areas do not report "area contains no rings" any more, but "invalid area". ## [2.8.0] - 2016-08-04 ### Added - EWKT support. - Track `pop` type calls and queue underruns when `OSMIUM_DEBUG_QUEUE_SIZE` environment variable is set. ### Changed - Switched to newest protozero v1.4.0. This should deliver some speedups when parsing PBF files. This also removes the DeltaEncodeIterator class, which isn't needed any more. - Uses `std::unordered_map` instead of `std::map` in PBF string table code speeding up writing of PBF files considerably. - Uses less memory when writing PBF files (smaller string table by default). - Removes dependency on sparsehash and boost program options libraries for examples. - Cleaned up threaded queue code. ### Fixed - A potentially very bad bug was fixed: When there are many and/or long strings in tag keys and values and/or user names and/or relation roles, the string table inside a PBF block would overflow. I have never seen this happen for normal OSM data, but that doesn't mean it can't happen. The result is that the strings will all be mixed up, keys for values, values for user names or whatever. - Automatically set correct SRID when creating WKB and GEOS geometries. Note that this changes the behaviour of libosmium when creating GEOS geometries. Before we created them with -1 as SRID unless set otherwise. Manual setting of the SRID on the GEOSGeometryFactory is now deprecated. - Allow coordinates of nodes in scientific notation when reading XML files. This shouldn't be used really, but sometimes you can find them. ## [2.7.2] - 2016-06-08 ### Changed - Much faster output of OSM files in XML, OPL, or debug formats. ### Fixed - Parsing and output of coordinates now faster and always uses decimal dot independant of locale setting. - Do not output empty discussion elements in changeset XML output. - Data corruption regression in mmap based indexes. ## [2.7.1] - 2016-06-01 ### Fixes - Update version number in version.hpp. ## [2.7.0] - 2016-06-01 ### Added - New functions for iterating over specific item types in buffers (`osmium::memory::Buffer::select()`), over specific subitems (`osmium::OSMObject::subitems()`), and for iterating over all rings of an area (`osmium::Areas::outer_rings()`, `inner_rings()`). - Debug output optionally prints CRC32 when `add_crc32` file option is set. ### Changed - XML parser will not allow any XML entities which are usually not used in OSM files anyway. This can help avoiding DOS attacks. - Removed SortedQueue implementation which was never used. - Also incorporate Locations in NodeRefs into CRC32 checksums. This means all checksums will be different compared to earlier versions of libosmium. - The completely new algorithm for assembling multipolygons is much faster, has better error reporting, generates statistics and can build more complex multipolygons correctly. The ProblemReporter classes have changed to make this happen, if you have written your own, you have to fix it. - Sparse node location stores are now only sorted if needed, ie. when nodes come in unordered. ### Fixed - Output operator for Location shows full precision. - Undefined behaviour in WKB writer and `types_from_string()` function. - Fix unsigned overflow in pool.hpp. - OSM objects are now ordered by type (nodes, then ways, then relations), then ID, then version, then timestamp. Ordering by timestamp is normally not necessary, because there can't be two objects with same type, ID, and version but different timestamp. But this can happen when diffs are created from OSM extracts, so we check for this here. This change also makes sure IDs are always ordered by absolute IDs, positives first, so order is 0, 1, -1, 2, -2, ... - Data corruption bug fixed in disk based indexes (used for the node location store for instance). This only affected you, if you created and index, closed it, and re-opened it (possibly in a different process) and if there were missing nodes. If you looked up those nodes, you got location (0,0) back instead of an error. - Memory corruption bug showing up with GDAL 2. ## [2.6.1] - 2016-02-22 ### Added - Add `WITH_PROFILING` option to CMake config. When enabled, this sets the `-fno-omit-frame-pointer` compiler option. ### Changed - Massive speed improvements when building multipolygons. - Uses (and includes) new version 1.3.0 of protozero library. - Removed dependency on Boost Iterator for PBF writer. - Example program `osmium_area_test` now uses `cerr` instead of `cout` for debug output. ## [2.6.0] - 2016-02-04 ### Added - The new handler osmium::handler::CheckOrder can be used to check that a file is properly ordered. - Add new method to build OSM nodes, ways, relations, changesets, and areas in buffers that wraps the older Builder classes. The new code is much easier to use and very flexible. There is no documentation yet, but the tests in `test/t/builder/test_attr.cpp` can give you an idea how it works. - Add util class to get memory usage of current process on Linux. ### Changed - New Buffer memory management speeds up Buffer use, because it doesn't clear the memory unnecessarily. ### Fixed - osmium::Box::extend() function now ignores invalid locations. - Install of external library headers. - Check way has at least one node before calling `is_closed()` in area assembler. - Declaration/definition of some friend functions was in the wrong namespace. ## [2.5.4] - 2015-12-03 ### Changed - Included gdalcpp.hpp header was updated to version 1.1.1. - Included protozero library was updated to version 1.2.3. - Workarounds for missing constexpr support in Visual Studio removed. All constexpr features we need are supported now. - Some code cleanup after running clang-tidy on the code. - Re-added `Buffer::value_type` typedef. Turns out it is needed when using `std::back_inserter` on the Buffer. ### Fixed - Bugs with Timestamp code on 32 bit platforms. This necessitated some changes in Timestamp which might lead to changes in user code. - Bug in segment intersection code (which appeared on i686 platform). ## [2.5.3] - 2015-11-17 ### Added - `osmium::make_diff_iterator()` helper function. ### Changed - Deprecated `osmium::Buffer::set_full_callback()`. - Removed DataFile class which was never used anywhere. - Removed unused and obscure `Buffer::value_type` typedef. ### Fixed - Possible overrun in Buffer when using the full-callback. - Incorrect swapping of Buffer. ## [2.5.2] - 2015-11-06 # Fixed - Writing data through an OutputIterator was extremly slow due to lock contention. ## [2.5.1] - 2015-11-05 ### Added - Header `osmium/fwd.hpp` with forward declarations of the most commonly used Osmium classes. ### Changed - Moved `osmium/io/overwrite.hpp` to `osmium/io/writer_options.hpp` If you still include the old file, you'll get a warning. ## [2.5.0] - 2015-11-04 ### Added - Helper functions to make input iterator ranges and output iterators. - Add support for reading o5m and o5c files. - Option for osmium::io::Writer to fsync file after writing. - Lots of internal asserts() and other robustness checks. ### Changed - Updated included protozero library to version 1.2.0. - Complete overhaul of the I/O system making it much more robust against wrong data and failures during I/O operations. - Speed up PBF writing by running parts of it in parallel. - OutputIterator doesn't hold an internal buffer any more, but it uses one in Writer. Calling flush() on the OutputIterator isn't needed any more. - Reader now throws when trying to read after eof or an error. - I/O functions that used to throw `std::runtime_error` now throw `osmium::io_error` or derived. - Optional parameters on `osmium::io::Writer` now work in any order. ### Fixed - PBF reader now decodes locations of invisible nodes properly. - Invalid Delta encode iterator dereference. - Lots of includes fixed to include (only) what's used. - Dangling reference in area assembly code. ## [2.4.1] - 2015-08-29 ### Fixed - CRC calculation of tags and changesets. ## [2.4.0] - 2015-08-29 ### Added - Checks that user names, member roles and tag keys and values are not longer than 256 * 4 bytes. That is the maximum length 256 Unicode characters can have in UTF-8 encoding. - Support for GDAL 2. GDAL 1 still works. ### Changed - Improved CMake build scripts. - Updated internal version of Protozero to 1.1.0. - Removed `toogr*` examples. They are in their own repository now. See https://github.com/osmcode/osm-gis-export. - Files about to be memory-mapped (for instance index files) are now set to binary mode on Windows so the application doesn't have to do this. ### Fixed - Hanging program when trying to open file with an unknown file format. - Building problems with old boost versions. - Initialization errors in PBF writer. - Bug in byte swap code. - Output on Windows now always uses binary mode, even when writing to stdout, so OSM xml and opl files always use LF line endings. ## [2.3.0] - 2015-08-18 ### Added - Allow instantiating osmium::geom::GEOSFactory with existing GEOS factory. - Low-level functions to support generating a architecture- and endian- independant CRC from OSM data. This is intended to be uses with boost::crc. - Add new debug output format. This format is not intended to be read automatically, but for human consumption. It formats the data nicely. - Make writing of metadata configurable for XML and OPL output (use `add_metadata=false` as file option). ### Changed - Changed `add_user()` and `add_role()` in builders to use string length without the 0-termination. - Improved code setting file format from suffix/format argument. - Memory mapping utility class now supports readonly, private writable or shared writable operation. - Allow empty version (0) in PBF files. - Use utf8cpp header-only lib instead of boost for utf8 decoding. The library is included in the libosmium distribution. - New PBF reader and writer based on the protozero. A complete rewrite of the code for reading and writing OSM PBF files. It doesn't use the Google protobuf library and it doesn't use the OSMPBF/OSM-Binary library any more. Instead is uses the protozero lightweight protobuf header library which is included in the code. Not only does the new code have less dependencies, it is faster and more robust. https://github.com/mapbox/protozero ### Fixed - Various smaller bug fixes. - Add encoding for relation member roles in OPL format. - Change character encoding to new format in OPL: variable length hex code between % characters instead of a % followed by 4-digit hex code. This is necessary because unicode characters can be longer than the 4-digit hex code. - XML writer: The linefeed, carriage return, and tab characters are now escaped properly. - Reading large XML files could block. ## [2.2.0] - 2015-07-04 ### Added - Conversion functions for some low-level types. - BoolVector index class. - `min_op`/`max_op` utility functions. - More tests here and there. - Helper methods `is_between()` and `is_visible_at()` to DiffObject. - GeoJSON factory using the RapidJSON library. - Support for tile calculations. - Create simple polygons from ways in geom factories. - `MemoryMapping` and `TypedMemoryMapping` helper classes. - `close()` function to `mmap_vector_base` class. - Function on `Buffer` class to get iterator to specific offset. - Explicit cast operator from `osmium::Timestamp` to `uint32_t`. ### Changed - Throw exception on illegal values in functions parsing strings to get ids, versions, etc. - Improved error message for geometry exceptions. ### Fixed - Throw exception from `dump_as_array()` and `dump_as_list()` functions if not implemented in an index. - After writing OSM files, program could stall up to a second. - Dense location store was written out only partially. - Use `uint64_t` as counter in benchmarks, so there can be no overflows. - Example programs now read packed XML files, too. - Refactoring of memory mapping code. Removes leak on Windows. - Better check for invalid locations. - Mark `cbegin()` and `cend()` of `mmap_vector_base` as const functions. ## [2.1.0] - 2015-03-31 ### Added - When writing PBF files, sorting the PBF stringtables is now optional. - More tests and documentation. ### Changed - Some functions are now declared `noexcept`. - XML parser fails now if the top-level element is not `osm` or `osmChange`. ### Fixed - Race condition in PBF reader. - Multipolygon collector was accessing non-existent NodeRef. - Doxygen documentation wan't showing all classes/functions due to a bug in Doxygen (up to version 1.8.8). This version contains a workaround to fix this. [unreleased]: https://github.com/osmcode/libosmium/compare/v2.21.0...HEAD [2.21.0]: https://github.com/osmcode/libosmium/compare/v2.20.0...v2.21.0 [2.20.0]: https://github.com/osmcode/libosmium/compare/v2.19.0...v2.20.0 [2.19.0]: https://github.com/osmcode/libosmium/compare/v2.18.9...v2.19.0 [2.18.0]: https://github.com/osmcode/libosmium/compare/v2.17.3...v2.18.0 [2.17.3]: https://github.com/osmcode/libosmium/compare/v2.17.2...v2.17.3 [2.17.2]: https://github.com/osmcode/libosmium/compare/v2.17.1...v2.17.2 [2.17.1]: https://github.com/osmcode/libosmium/compare/v2.17.0...v2.17.1 [2.17.0]: https://github.com/osmcode/libosmium/compare/v2.16.0...v2.17.0 [2.16.0]: https://github.com/osmcode/libosmium/compare/v2.15.6...v2.16.0 [2.15.6]: https://github.com/osmcode/libosmium/compare/v2.15.5...v2.15.6 [2.15.5]: https://github.com/osmcode/libosmium/compare/v2.15.4...v2.15.5 [2.15.4]: https://github.com/osmcode/libosmium/compare/v2.15.3...v2.15.4 [2.15.3]: https://github.com/osmcode/libosmium/compare/v2.15.2...v2.15.3 [2.15.2]: https://github.com/osmcode/libosmium/compare/v2.15.1...v2.15.2 [2.15.1]: https://github.com/osmcode/libosmium/compare/v2.15.0...v2.15.1 [2.15.0]: https://github.com/osmcode/libosmium/compare/v2.14.2...v2.15.0 [2.14.2]: https://github.com/osmcode/libosmium/compare/v2.14.1...v2.14.2 [2.14.1]: https://github.com/osmcode/libosmium/compare/v2.14.0...v2.14.1 [2.14.0]: https://github.com/osmcode/libosmium/compare/v2.13.1...v2.14.0 [2.13.1]: https://github.com/osmcode/libosmium/compare/v2.13.0...v2.13.1 [2.13.0]: https://github.com/osmcode/libosmium/compare/v2.12.2...v2.13.0 [2.12.2]: https://github.com/osmcode/libosmium/compare/v2.12.1...v2.12.2 [2.12.1]: https://github.com/osmcode/libosmium/compare/v2.12.0...v2.12.1 [2.12.0]: https://github.com/osmcode/libosmium/compare/v2.11.0...v2.12.0 [2.11.0]: https://github.com/osmcode/libosmium/compare/v2.10.3...v2.11.0 [2.10.3]: https://github.com/osmcode/libosmium/compare/v2.10.2...v2.10.3 [2.10.2]: https://github.com/osmcode/libosmium/compare/v2.10.1...v2.10.2 [2.10.1]: https://github.com/osmcode/libosmium/compare/v2.10.0...v2.10.1 [2.10.0]: https://github.com/osmcode/libosmium/compare/v2.9.0...v2.10.0 [2.9.0]: https://github.com/osmcode/libosmium/compare/v2.8.0...v2.9.0 [2.8.0]: https://github.com/osmcode/libosmium/compare/v2.7.2...v2.8.0 [2.7.2]: https://github.com/osmcode/libosmium/compare/v2.7.1...v2.7.2 [2.7.1]: https://github.com/osmcode/libosmium/compare/v2.7.0...v2.7.1 [2.7.0]: https://github.com/osmcode/libosmium/compare/v2.6.1...v2.7.0 [2.6.1]: https://github.com/osmcode/libosmium/compare/v2.6.0...v2.6.1 [2.6.0]: https://github.com/osmcode/libosmium/compare/v2.5.4...v2.6.0 [2.5.4]: https://github.com/osmcode/libosmium/compare/v2.5.3...v2.5.4 [2.5.3]: https://github.com/osmcode/libosmium/compare/v2.5.2...v2.5.3 [2.5.2]: https://github.com/osmcode/libosmium/compare/v2.5.1...v2.5.2 [2.5.1]: https://github.com/osmcode/libosmium/compare/v2.5.0...v2.5.1 [2.5.0]: https://github.com/osmcode/libosmium/compare/v2.4.1...v2.5.0 [2.4.1]: https://github.com/osmcode/libosmium/compare/v2.4.0...v2.4.1 [2.4.0]: https://github.com/osmcode/libosmium/compare/v2.3.0...v2.4.0 [2.3.0]: https://github.com/osmcode/libosmium/compare/v2.2.0...v2.3.0 [2.2.0]: https://github.com/osmcode/libosmium/compare/v2.1.0...v2.2.0 [2.1.0]: https://github.com/osmcode/libosmium/compare/v2.0.0...v2.1.0 libosmium-2.21.0/CMakeLists.txt000066400000000000000000000377261474122261600163600ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # CMake Config # # Libosmium # #----------------------------------------------------------------------------- cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR) list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") #----------------------------------------------------------------------------- # # Configurations # #----------------------------------------------------------------------------- set(CMAKE_CXX_FLAGS_COVERAGE "-g -O0 -fno-inline-functions -fno-inline --coverage ${extra_coverage_flags_}" CACHE STRING "Flags used by the compiler during coverage builds.") set(CMAKE_EXE_LINKER_FLAGS_COVERAGE "--coverage" CACHE STRING "Flags used by the linker during coverage builds.") set(CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo;MinSizeRel;Dev;Coverage" CACHE STRING "List of available configuration types" FORCE) #----------------------------------------------------------------------------- # # Project version # #----------------------------------------------------------------------------- project(libosmium) set(LIBOSMIUM_VERSION_MAJOR 2) set(LIBOSMIUM_VERSION_MINOR 21) set(LIBOSMIUM_VERSION_PATCH 0) set(LIBOSMIUM_VERSION "${LIBOSMIUM_VERSION_MAJOR}.${LIBOSMIUM_VERSION_MINOR}.${LIBOSMIUM_VERSION_PATCH}") set(CMAKE_EXPORT_COMPILE_COMMANDS ON) #----------------------------------------------------------------------------- # # Build options # # (Change with -DOPTION=VALUE on cmake command line.) # #----------------------------------------------------------------------------- if(CMAKE_BUILD_TYPE STREQUAL "Dev") set(dev_build ON) set(data_test_build ON) else() set(dev_build OFF) set(data_test_build OFF) endif() if(CMAKE_BUILD_TYPE STREQUAL "Coverage") set(data_test_build ON) endif() option(BUILD_EXAMPLES "compile example programs" ON) option(BUILD_TESTING "compile unit tests, please run them with ctest" ON) option(BUILD_HEADERS "compile every header file on its own" ${dev_build}) option(BUILD_BENCHMARKS "compile benchmark programs" ${dev_build}) option(BUILD_DATA_TESTS "compile data tests, please run them with ctest" ${data_test_build}) option(INSTALL_GDALCPP "also install gdalcpp headers" OFF) option(WITH_PROFILING "add flags needed for profiling" OFF) #----------------------------------------------------------------------------- # # CCache support # #----------------------------------------------------------------------------- option(BUILD_WITH_CCACHE "build using ccache" OFF) if(BUILD_WITH_CCACHE) find_program(CCACHE_PROGRAM ccache) if(CCACHE_PROGRAM) set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "CCACHE_CPP2=1 ${CCACHE_PROGRAM}") # workaround for some clang versions if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") add_definitions(-Qunused-arguments) endif() endif() endif() #----------------------------------------------------------------------------- # # Coverage support # #----------------------------------------------------------------------------- ## This leads to all sorts of compile problems, so disable for now #include(CheckCXXCompilerFlag) #check_cxx_compiler_flag("-fkeep-inline-functions" HAS_KEEP_INLINE_FUNCTIONS) #if(HAS_KEEP_INLINE_FUNCTIONS) # set(extra_coverage_flags_ "-fkeep-inline-functions") #endif() if(CMAKE_BUILD_TYPE STREQUAL "Coverage") if(BUILD_EXAMPLES OR BUILD_HEADERS OR BUILD_BENCHMARKS) message(WARNING "Coverage builds don't work for anything but the tests") endif() if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang") string(REGEX REPLACE "^([0-9]+)\\.([0-9]+).*$" "llvm-cov-\\1.\\2" gcov_ ${CMAKE_CXX_COMPILER_VERSION}) else() set(gcov_ "gcov") endif() find_program(GCOV ${gcov_} DOC "Coverage tool") find_program(GCOVR "gcovr" DOC "Coverage report tool") set(coverage_report_dir "${CMAKE_BINARY_DIR}/coverage") file(MAKE_DIRECTORY ${coverage_report_dir}) add_custom_target(coverage ${GCOVR} ${CMAKE_BINARY_DIR} --root=${CMAKE_SOURCE_DIR} --html --html-details #--verbose #--keep '--filter=.*include/osmium.*' --sort-percentage --gcov-executable=${GCOV} --output=${coverage_report_dir}/index.html) endif() #----------------------------------------------------------------------------- # # Find external dependencies # #----------------------------------------------------------------------------- find_package(Boost 1.38) mark_as_advanced(CLEAR BOOST_ROOT) if(Boost_FOUND) include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) else() set(BOOST_ROOT "NOT FOUND: please choose" CACHE PATH "") message(FATAL_ERROR "PLEASE, specify the directory where the Boost library is installed in BOOST_ROOT") endif() # set OSMIUM_INCLUDE_DIR so FindOsmium will not set anything different set(OSMIUM_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/include") include_directories(${OSMIUM_INCLUDE_DIR}) find_package(Osmium COMPONENTS lz4 io gdal geos) # The find_package put the directory where it found the libosmium includes # into OSMIUM_INCLUDE_DIRS. We remove it again, because we want to make # sure to use our own include directory already set up above. list(FIND OSMIUM_INCLUDE_DIRS "${OSMIUM_INCLUDE_DIR}" _own_index) list(REMOVE_AT OSMIUM_INCLUDE_DIRS ${_own_index}) set(_own_index) include_directories(SYSTEM ${OSMIUM_INCLUDE_DIRS}) #----------------------------------------------------------------------------- # # Decide which C++ version to use (Minimum/default: C++14). # #----------------------------------------------------------------------------- if(NOT MSVC) if(NOT USE_CPP_VERSION) if(CYGWIN) set(USE_CPP_VERSION gnu++14) else() set(USE_CPP_VERSION c++14) endif() endif() message(STATUS "Use C++ version: ${USE_CPP_VERSION}") # following only available from cmake 2.8.12: # add_compile_options(-std=${USE_CPP_VERSION}) # so using this instead: add_definitions(-std=${USE_CPP_VERSION}) endif() #----------------------------------------------------------------------------- # # Compiler and Linker flags # #----------------------------------------------------------------------------- if(MSVC) set(DEV_COMPILE_OPTIONS "/Ox") set(RWD_COMPILE_OPTIONS "/Ox /DNDEBUG") # do not show warnings caused by missing .pdb files for libraries set(USUAL_LINK_OPTIONS "/debug /ignore:4099") else() set(DEV_COMPILE_OPTIONS "-O3 -g") set(RWD_COMPILE_OPTIONS "-O3 -g -DNDEBUG") set(USUAL_LINK_OPTIONS "") endif() if(WIN32) add_definitions(-DWIN32 -D_WIN32 -DMSWIN32 -DBGDWIN32) endif() set(CMAKE_CXX_FLAGS_DEV "${DEV_COMPILE_OPTIONS}" CACHE STRING "Flags used by the compiler during developer builds." FORCE) set(CMAKE_EXE_LINKER_FLAGS_DEV "${USUAL_LINK_OPTIONS}" CACHE STRING "Flags used by the linker during developer builds." FORCE) mark_as_advanced( CMAKE_CXX_FLAGS_DEV CMAKE_EXE_LINKER_FLAGS_DEV ) set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${RWD_COMPILE_OPTIONS}" CACHE STRING "Flags used by the compiler during RELWITHDEBINFO builds." FORCE) set(CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO "${USUAL_LINK_OPTIONS}" CACHE STRING "Flags used by the linker during RELWITHDEBINFO builds." FORCE) mark_as_advanced( CMAKE_CXX_FLAGS_RELWITHDEBINFO CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO ) if(WITH_PROFILING) add_definitions(-fno-omit-frame-pointer) endif() #----------------------------------------------------------------------------- # # Build Type # #----------------------------------------------------------------------------- # In 'Dev' mode: compile with very strict warnings and turn them into errors. if(CMAKE_BUILD_TYPE STREQUAL "Dev") if(NOT MSVC) add_definitions(-Werror) endif() add_definitions(${OSMIUM_WARNING_OPTIONS}) # add_definitions(${OSMIUM_WARNING_OPTIONS} ${OSMIUM_DRACONIC_CLANG_OPTIONS} -Wno-documentation -Wno-format-nonliteral -Wno-deprecated -Wno-covered-switch-default -Wno-shadow) endif() # Force RelWithDebInfo build type if none was given if(CMAKE_BUILD_TYPE) set(build_type ${CMAKE_BUILD_TYPE}) else() set(build_type "RelWithDebInfo") endif() set(CMAKE_BUILD_TYPE ${build_type} CACHE STRING "Choose the type of build, options are: ${CMAKE_CONFIGURATION_TYPES}." FORCE) #----------------------------------------------------------------------------- # # Unit and data tests # #----------------------------------------------------------------------------- enable_testing() if(BUILD_TESTING OR BUILD_DATA_TESTS) find_program(MEMORYCHECK_COMMAND valgrind) set(MEMORYCHECK_COMMAND_OPTIONS "--trace-children=yes --leak-check=full --show-reachable=yes --error-exitcode=1") set(MEMORYCHECK_SUPPRESSIONS_FILE "${PROJECT_SOURCE_DIR}/test/valgrind.supp") endif() if(BUILD_TESTING) add_subdirectory(test) endif() if(BUILD_DATA_TESTS) add_subdirectory(test/data-tests) endif() if(BUILD_EXAMPLES) add_subdirectory(test/examples) endif() #----------------------------------------------------------------------------- # # Optional "cppcheck" target that checks C++ code # #----------------------------------------------------------------------------- message(STATUS "Looking for cppcheck") find_program(CPPCHECK cppcheck) if(CPPCHECK) message(STATUS "Looking for cppcheck - found") set(CPPCHECK_OPTIONS --language=c++ --quiet -j4 --inline-suppr --enable=warning,style,performance,portability,information,missingInclude --force -Uassert -DPROTOZERO_STRICT_API -DPROTOZERO_USE_BUILTIN_BSWAP -UPROTOZERO_USE_VIEW) file(GLOB_RECURSE ALL_INCLUDES include/osmium/*.hpp) file(GLOB ALL_EXAMPLES examples/*.cpp) file(GLOB ALL_BENCHMARKS benchmarks/*.cpp) file(GLOB ALL_UNIT_TESTS test/t/*/test_*.cpp) file(GLOB ALL_DATA_TESTS test/data-tests/*.cpp) if(Osmium_DEBUG) message(STATUS "Checking includes : ${ALL_INCLUDES}") message(STATUS "Checking example code : ${ALL_EXAMPLES}") message(STATUS "Checking benchmarks : ${ALL_BENCHMARKS}") message(STATUS "Checking unit test code: ${ALL_UNIT_TESTS}") message(STATUS "Checking data test code: ${ALL_DATA_TESTS}") endif() set(CPPCHECK_FILES ${ALL_INCLUDES} ${ALL_EXAMPLES} ${ALL_BENCHMARKS} ${ALL_UNIT_TESTS} ${ALL_DATA_TESTS}) add_custom_target(cppcheck ${CPPCHECK} --std=c++14 ${CPPCHECK_OPTIONS} -I ${CMAKE_SOURCE_DIR}/include ${CPPCHECK_FILES} ) else() message(STATUS "Looking for cppcheck - not found") message(STATUS " Build target 'cppcheck' will not be available.") endif() #----------------------------------------------------------------------------- # # Examples, benchmarks and documentation # #----------------------------------------------------------------------------- if(BUILD_EXAMPLES) add_subdirectory(examples) endif() if(BUILD_BENCHMARKS) add_subdirectory(benchmarks) endif() add_subdirectory(doc) #----------------------------------------------------------------------------- # # Headers # # This will try to compile include files on their own to detect missing # include directives and other dependency-related problems. Note that if this # work, it is not enough to be sure it will compile in production code. # But if it reports an error we know we are missing something. # #----------------------------------------------------------------------------- if(BUILD_HEADERS) file(GLOB_RECURSE ALL_HPPS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/include" include/osmium/*.hpp) file(MAKE_DIRECTORY header_check) foreach(hpp ${ALL_HPPS}) if((GDAL_FOUND) OR NOT ((hpp STREQUAL "osmium/area/problem_reporter_ogr.hpp") OR (hpp STREQUAL "osmium/geom/ogr.hpp"))) string(REPLACE ".hpp" "" tmp ${hpp}) string(REPLACE "/" "__" libname ${tmp}) # Create a dummy .cpp file that includes the header file we want to # check. set(DUMMYCPP ${CMAKE_BINARY_DIR}/header_check/${libname}.cpp) file(WRITE ${DUMMYCPP} "#define OSMIUM_UTIL_COMPATIBILITY_HPP\n#define OSMIUM_EXPORT\n#include <${hpp}> // IWYU pragma: keep\n") # There is no way in CMake to just compile but not link a C++ file, # so we pretend to build a library here. add_library(${libname} STATIC ${DUMMYCPP} include/${hpp}) #### this is better but only supported from cmake 3.0: ###add_library(${libname} OBJECT ${DUMMYCPP} include/${hpp}) endif() endforeach() endif() #----------------------------------------------------------------------------- # # Optional "clang-tidy" target # #----------------------------------------------------------------------------- message(STATUS "Looking for clang-tidy") find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-20 clang-tidy-19 clang-tidy-18 clang-tidy-17 clang-tidy-16 clang-tidy-15 clang-tidy-14) if(CLANG_TIDY) message(STATUS "Looking for clang-tidy - found ${CLANG_TIDY}") if(BUILD_EXAMPLES) file(GLOB CT_ALL_EXAMPLES examples/*.cpp) endif() if(BUILD_TESTING) file(GLOB CT_ALL_UNIT_TESTS test/t/*/test_*.cpp) endif() if(BUILD_HEADERS) file(GLOB_RECURSE CT_ALL_INCLUDES ${CMAKE_BINARY_DIR}/header_check/osmium__*.cpp) endif() if(BUILD_BENCHMARKS) file(GLOB CT_ALL_BENCHMARKS benchmarks/*.cpp) endif() if(BUILD_DATA_TESTS) file(GLOB CT_ALL_DATA_TESTS test/data-tests/*.cpp) endif() if(Osmium_DEBUG) message(STATUS "Checking example code : ${CT_ALL_EXAMPLES}") message(STATUS "Checking unit test code: ${CT_ALL_UNIT_TESTS}") message(STATUS "Checking includes : ${CT_ALL_INCLUDES}") message(STATUS "Checking benchmarks : ${CT_ALL_BENCHMARKS}") message(STATUS "Checking data test code: ${CT_ALL_DATA_TESTS}") endif() set(CT_CHECK_FILES ${CT_ALL_EXAMPLES} ${CT_ALL_UNIT_TESTS} ${CT_ALL_INCLUDES} ${CT_ALL_BENCHMARKS} ${CT_ALL_DATA_TESTS}) add_custom_target(clang-tidy ${CLANG_TIDY} -p ${CMAKE_BINARY_DIR} "-extra-arg=-Wno-#pragma-messages" ${CT_CHECK_FILES} ) else() message(STATUS "Looking for clang-tidy - not found") message(STATUS " Build target 'clang-tidy' will not be available.") endif() #----------------------------------------------------------------------------- # # Installation # # External libraries are only installed if the options are set in case they # are installed from somewhere else. # #----------------------------------------------------------------------------- install(DIRECTORY include/osmium DESTINATION include) if(INSTALL_GDALCPP) install(FILES include/gdalcpp.hpp DESTINATION include) endif() #----------------------------------------------------------------------------- # # Packaging # #----------------------------------------------------------------------------- set(CPACK_PACKAGE_VERSION_MAJOR ${LIBOSMIUM_VERSION_MAJOR}) set(CPACK_PACKAGE_VERSION_MINOR ${LIBOSMIUM_VERSION_MINOR}) set(CPACK_PACKAGE_VERSION_PATCH ${LIBOSMIUM_VERSION_PATCH}) if(WIN32) set(CPACK_GENERATOR ZIP) else() set(CPACK_GENERATOR TGZ) endif() include(CPack) #----------------------------------------------------------------------------- # # Print warnings at the end # #----------------------------------------------------------------------------- if(BUILD_DATA_TESTS AND OSM_TESTDATA STREQUAL "OSM_TESTDATA-NOTFOUND") message("\n========================== WARNING ==========================") message("osm-testdata directory not found, data tests were disabled!\n") message("Call 'git submodule update --init' to install test data") message("or set the OSM_TESTDATA cmake variable to its path.") message("=============================================================\n") endif() #----------------------------------------------------------------------------- libosmium-2.21.0/CONTRIBUTING.md000066400000000000000000000015401474122261600160320ustar00rootroot00000000000000 Some rules for contributing to this project: * Please open a separate issue for each problem, question, or comment you have. Do not re-use existing issues for other topics, even if they are similar. This keeps issues small and manageable and makes it much easier to follow through and make sure each problem is taken care of. * We'd love for you to send pull requests for fixes you have made or new features you have added. Please read the [notes for developers](NOTES_FOR_DEVELOPERS.md) beforehand which contains some coding guidelines. If you are reporting a problem: * Describe exactly what you were trying to achieve, what you did, what you expected to happen and what did happen instead. Include relevant information about the platform, OS version etc. you are using. Include shell commands you typed in, log files, errors messages etc. libosmium-2.21.0/LICENSE000066400000000000000000000024721474122261600146130ustar00rootroot00000000000000Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. libosmium-2.21.0/NOTES_FOR_DEVELOPERS.md000066400000000000000000000146721474122261600172630ustar00rootroot00000000000000 # Notes for Developers Read this if you want to contribute to Libosmium. ## Namespace All Osmium code MUST be in the `osmium` namespace or one of its sub-namespaces. ## Include-Only Osmium is a include-only library. You can't compile the library itself. There is no `libosmium.so` or `libosmium.dll`. One drawback ist that you can't have static data in classes, because there is no place to put this data. All free functions must be declared `inline`. ## Coding Conventions These coding conventions have been changing over time and some code is still different. * All include files have `#ifdef` guards around them, macros are the path name in all uppercase where the slashes (`/`) have been changed to underscore (`_`). * Class names begin with uppercase chars and use CamelCase. Smaller helper classes are usually defined as struct and have lowercase names. * Macros (and only macros) are all uppercase. Use macros sparingly, usually a simple (maybe constexpr) inline function is better. Undef macros after use if possible. * Macros should only be used for controlling which parts of the code should be included when compiling or to avoid major code repetitions. * Variables, attributes, and function names are lowercase with `underscores_between_words`. * Class attribute names start with `m_` (member). * Use `descriptive_variable_names`, exceptions are well-established conventions like `i` for a loop variable. Iterators are usually called `it`. * Declare variables where they are first used (C++ style), not at the beginning of a function (old C style). * Names from external namespaces (even `std`) are always mentioned explicitly. Do not use `using` (except for `std::swap`). This way we can't even by accident pollute the namespace of the code using Osmium. * Always use the standard swap idiom: `using std::swap; swap(foo, bar);`. * `#include` directives appear in three "blocks" after the copyright notice. The blocks are separated by blank lines. First block contains `#include`s for standard C/C++ includes, second block for any external libs used, third block for osmium internal includes. Within each block `#include`s are usually sorted by path name. All `#include`s use `<>` syntax not `""`. * Names not to be used from outside the library should be in a namespace called `detail` under the namespace where they would otherwise appear. If whole include files are never meant to be included from outside they should be in a subdirectory called `detail`. * All files have suffix `.hpp`. * Closing } of all classes and namespaces should have a trailing comment with the name of the class/namespace. * All constructors with one (or more arguments if they have a default) should be declared "explicit" unless there is a reason for them not to be. Document that reason. * If a class has any of the special methods (copy/move constructor/assigment, destructor) it should have all of them, possibly marking them as default or deleted. * Typedefs have `names_like_this_type` which end in `_type`. Typedefs should use the new `using foo_type = bar` syntax instead of the old `typedef bar foo_type`. * Template parameters are single uppercase letters or start with uppercase `T` and use CamelCase. * Always use `typename` in templates, not `class`: `template `. * The ellipsis in a variadic template never has a space to the left of it and always has a space to the right: `template ` etc. Keep to the indentation and other styles used in the code. ## C++11 Osmium uses C++11 and you can use its features such as auto, lambdas, threading, etc. There are a few features we do not use, because even modern compilers don't support them yet. This list might change as we get more data about which compilers support which feature and what operating system versions or distributions have which versions of these compilers installed. Use `include/osmium/util/compatibility.hpp` if there are compatibility problems between compilers due to different C++11 support. ## Operating systems Usually all code must work on Linux, macOS, and Windows. Execptions are allowed for some minor functionality, but please discuss this first. When writing code and tests, care must be taken that everything works with the CR line ending convention used on Linux and macOS and the CRLF line ending used on Windows. Note that `git` can be run with different settings regarding line ending rewritings on different machines making things more difficult. Some files have been "forced" to LF line endings using `.gitattributes` files. ## 32bit systems Libosmium tries to work on 32bit systems whereever possible. But there are some parts which will not work on 32bit systems, mainly because the amount of main memory available is not enough for it to work anyway. ## Checking your code The Osmium makefiles use pretty draconian warning options for the compiler. This is good. Code MUST never produce any warnings, even with those settings. If absolutely necessary pragmas can be used to disable certain warnings in specific areas of the code. If the static code checker `cppcheck` is installed, the CMake configuration will add a new build target `cppcheck` that will check all `.cpp` and `.hpp` files. Cppcheck finds some bugs that gcc/clang doesn't. But take the result with a grain of salt, it also sometimes produces wrong warnings. Set `BUILD_HEADERS=ON` in the CMake config to enable compiling all include files on their own to check whether dependencies are all okay. All include files MUST include all other include files they depend on. Call `cmake/iwyu.sh` to check for proper includes and forward declarations. This uses the clang-based `include-what-you-use` program. Note that it does produce some false reports and crashes often. The `osmium.imp` file can be used to define mappings for iwyu. See the IWYU tool at . ## Testing There are unit tests using the Catch Unit Test Framework in the `test` directory, some data tests in `test/osm-testdata` and tests of the examples in `test/examples`. They are built by the default cmake config. Run `ctest` to run them. We can always use more tests. Tests are run automatically using Github Actions. ## Documenting the code All namespaces, classes, functions, attributes, etc. should be documented. Osmium uses the [Doxygen](http://www.doxygen.org) source code documentation system. If it is installed, the CMake configuration will add a new build target, so you can build it with `make doc`. libosmium-2.21.0/README.md000066400000000000000000000046131474122261600150640ustar00rootroot00000000000000# Libosmium https://osmcode.org/libosmium A fast and flexible C++ library for working with OpenStreetMap data. Libosmium works on Linux, macOS and Windows. [![Build Status](https://github.com/osmcode/libosmium/actions/workflows/ci.yml/badge.svg)](https://github.com/osmcode/libosmium/actions) [![Packaging status](https://repology.org/badge/tiny-repos/libosmium.svg)](https://repology.org/metapackage/libosmium) Please see the [Libosmium manual](https://osmcode.org/libosmium/manual.html) for more details than this README can provide. ## Prerequisites You need a C++14 compiler and standard C++ library. Different parts of Libosmium (and the applications built on top of it) need different libraries. You DO NOT NEED to install all of them, just install those you need for your programs. For details see the [list of dependencies](https://osmcode.org/libosmium/manual.html#dependencies) in the manual. The following external (header-only) libraries are included in the libosmium repository: * [gdalcpp](https://github.com/joto/gdalcpp) Note that [protozero](https://github.com/mapbox/protozero) was included in earlier versions of libosmium, but isn't any more. ## Directories * benchmarks: Some benchmarks checking different parts of Libosmium. * cmake: CMake configuration scripts. * doc: Config for API reference documentation. * examples: Osmium example applications. * include: C/C++ include files. All of Libosmium is in those header files which are needed for building Osmium applications. * test: Tests (see below). ## Building Osmium is a header-only library, so there is nothing to build for the library itself. But there are some tests and examples that can be build. Libosmium uses cmake: mkdir build cd build cmake .. make This will build the examples and tests. Call `ctest` to run the tests. For more details see the [Building Libosmium](https://osmcode.org/libosmium/manual.html#building-libosmium) chapter in the manual. ## Testing To download the `osm-testdata` submodule call: ``` git submodule update --init ``` This will enable additional tests. See the [Libosmium Manual](https://osmcode.org/libosmium/manual.html#running-tests) for instructions. ## License Libosmium is available under the Boost Software License. See LICENSE. ## Authors Libosmium was mainly written and is maintained by Jochen Topf (jochen@topf.org). See the git commit log for other authors. libosmium-2.21.0/benchmarks/000077500000000000000000000000001474122261600157165ustar00rootroot00000000000000libosmium-2.21.0/benchmarks/CMakeLists.txt000066400000000000000000000032221474122261600204550ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # CMake Config # # Libosmium benchmarks # #----------------------------------------------------------------------------- message(STATUS "Configuring benchmarks") set(BENCHMARKS count count_tag index_map mercator static_vs_dynamic_index write_pbf CACHE STRING "Benchmark programs" ) #----------------------------------------------------------------------------- # # Configure benchmarks # #----------------------------------------------------------------------------- message(STATUS "Configuring benchmarks - Building these benchmarks:") foreach(benchmark ${BENCHMARKS}) message(STATUS " - osmium_benchmark_${benchmark}") add_executable(osmium_benchmark_${benchmark} "osmium_benchmark_${benchmark}.cpp") target_link_libraries(osmium_benchmark_${benchmark} ${OSMIUM_IO_LIBRARIES} ${BENCHMARK_LIBS_${benchmark}}) set_pthread_on_target(osmium_benchmark_${benchmark}) configure_file(run_benchmark_${benchmark}.sh ${CMAKE_CURRENT_BINARY_DIR}/run_benchmark_${benchmark}.sh @ONLY) endforeach() string(TOUPPER "${CMAKE_BUILD_TYPE}" _cmake_build_type) set(_cxx_flags "${CMAKE_CXX_FLAGS_${_cmake_build_type}}") foreach(file setup run_benchmarks) configure_file(${file}.sh ${CMAKE_CURRENT_BINARY_DIR}/${file}.sh @ONLY) endforeach() #----------------------------------------------------------------------------- message(STATUS "Configuring benchmarks - done") #----------------------------------------------------------------------------- libosmium-2.21.0/benchmarks/README.md000066400000000000000000000027041474122261600172000ustar00rootroot00000000000000 # Benchmarks Benchmarks check the performance of different parts of Libosmium. ## Preparations To run the benchmarks first make a directory for the data files somewhere (outside the repository) and set the `DATA_DIR` environment variable: export DATA_DIR=benchmark_data mkdir $DATA_DIR Then copy the OSM files you want to do the benchmarks with into this directory. You can use the `download_data.sh` script to download a selection of OSM files in different sizes, but you can use a different selection, too. The benchmarks will use whatever files you have in the `DATA_DIR` directory. The download script will start the data files names with a number in order of the size of the file from smallest to largest. You can use the same convention or use a different one. Benchmarks will be run on the files in alphabetical order. The files don't have to be in that directory, you can add soft links from that directory to the real file locations if that suits you. ## Compiling the benchmarks To build the benchmarks set the `BUILD_BENCHMARKS` option when configuring with CMake and run the compilation by calling `make` (or whatever build tool you are using). ## Running the benchmarks Go to the build directory and run `benchmarks/run_benchmarks.sh`. You can also run each benchmark on its own by calling the respective script in the `benchmarks` directory. Results of the benchmarks will be printed to stdout, you might want to redirect them into a file. libosmium-2.21.0/benchmarks/download_data.sh000077500000000000000000000013051474122261600210540ustar00rootroot00000000000000#!/bin/sh # # download_data.sh # cd $DATA_DIR curl --location --output 1_liechtenstein.osm.pbf https://download.geofabrik.de/europe/liechtenstein-latest.osm.pbf # about 2 MB curl --location --output 2_bremen.osm.pbf https://download.geofabrik.de/europe/germany/bremen-latest.osm.pbf # about 16 MB curl --location --output 3_sachsen.osm.pbf https://download.geofabrik.de/europe/germany/sachsen-latest.osm.pbf # about 160 MB curl --location --output 4_germany.osm.pbf https://download.geofabrik.de/europe/germany-latest.osm.pbf # about 3 GB curl --location --output 5_planet.osm.pbf https://planet.osm.org/pbf/planet-latest.osm.pbf # about 35 GB libosmium-2.21.0/benchmarks/osmium_benchmark_count.cpp000066400000000000000000000024071474122261600231600ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #include #include #include #include #include #include #include #include struct CountHandler : public osmium::handler::Handler { uint64_t nodes = 0; uint64_t ways = 0; uint64_t relations = 0; void node(const osmium::Node& /*node*/) { ++nodes; } void way(const osmium::Way& /*way*/) { ++ways; } void relation(const osmium::Relation& /*relation*/) { ++relations; } }; int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " OSMFILE\n"; return 1; } try { const std::string input_filename{argv[1]}; osmium::io::Reader reader{input_filename}; CountHandler handler; osmium::apply(reader, handler); reader.close(); std::cout << "Nodes: " << handler.nodes << '\n'; std::cout << "Ways: " << handler.ways << '\n'; std::cout << "Relations: " << handler.relations << '\n'; } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } return 0; } libosmium-2.21.0/benchmarks/osmium_benchmark_count_tag.cpp000066400000000000000000000024251474122261600240130ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #include #include #include #include #include #include #include #include struct CountHandler : public osmium::handler::Handler { uint64_t counter = 0; uint64_t all = 0; void node(const osmium::Node& node) { ++all; const char* amenity = node.tags().get_value_by_key("amenity"); if (amenity && !strcmp(amenity, "post_box")) { ++counter; } } void way(const osmium::Way& /*way*/) { ++all; } void relation(const osmium::Relation& /*relation*/) { ++all; } }; int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " OSMFILE\n"; return 1; } try { const std::string input_filename{argv[1]}; osmium::io::Reader reader{input_filename}; CountHandler handler; osmium::apply(reader, handler); reader.close(); std::cout << "r_all=" << handler.all << " r_counter=" << handler.counter << '\n'; } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } return 0; } libosmium-2.21.0/benchmarks/osmium_benchmark_index_map.cpp000066400000000000000000000024411474122261600237720ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #include #include #include #include #include #include #include #include #include using index_type = osmium::index::map::Map; using location_handler_type = osmium::handler::NodeLocationsForWays; int main(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " OSMFILE FORMAT\n"; return 1; } try { const std::string input_filename{argv[1]}; const std::string location_store{argv[2]}; osmium::io::Reader reader{input_filename}; const auto& map_factory = osmium::index::MapFactory::instance(); std::unique_ptr index = map_factory.create_map(location_store); location_handler_type location_handler{*index}; location_handler.ignore_errors(); osmium::apply(reader, location_handler); reader.close(); } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } return 0; } libosmium-2.21.0/benchmarks/osmium_benchmark_mercator.cpp000066400000000000000000000020111474122261600236330ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #include #include #include #include #include #include #include #include #include struct GeomHandler : public osmium::handler::Handler { osmium::geom::WKBFactory factory; void node(const osmium::Node& node) { const std::string geom = factory.create_point(node); } }; int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " OSMFILE\n"; return 1; } try { const std::string input_filename{argv[1]}; osmium::io::Reader reader{input_filename}; GeomHandler handler; osmium::apply(reader, handler); reader.close(); } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } return 0; } libosmium-2.21.0/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp000066400000000000000000000134651474122261600267300ustar00rootroot00000000000000/* This benchmarks compares the run time for statically vs. dynamically configured index maps. You can configure index maps at compile-time using typedefs or at run-time using polymorphism. This will read the input file into a buffer and then run the NodeLocationForWays handler multiple times over the complete data. The number of runs depends on the size of the input, but is never smaller than 10. Do not run this with very large input files! It will need about 10 times as much RAM as the file size of the input file. The code in this file is released into the Public Domain. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include using static_index_type = osmium::index::map::SparseMemArray; const std::string location_store{"sparse_mem_array"}; using dynamic_index_type = osmium::index::map::Map; using static_location_handler_type = osmium::handler::NodeLocationsForWays; using dynamic_location_handler_type = osmium::handler::NodeLocationsForWays; int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " OSMFILE\n"; return 1; } try { const std::string input_filename{argv[1]}; const osmium::memory::Buffer buffer{osmium::io::read_file(input_filename)}; const auto& map_factory = osmium::index::MapFactory::instance(); const auto buffer_size = buffer.committed() / (1024UL * 1024UL); // buffer size in MBytes const int runs = std::max(10, static_cast(5000ULL / buffer_size)); std::cout << "input: filename=" << input_filename << " buffer_size=" << buffer_size << "MBytes\n"; std::cout << "runs: " << runs << "\n"; double static_min = std::numeric_limits::max(); double static_sum = 0; double static_max = 0; double dynamic_min = std::numeric_limits::max(); double dynamic_sum = 0; double dynamic_max = 0; for (int i = 0; i < runs; ++i) { { // static index osmium::memory::Buffer tmp_buffer{buffer.committed()}; for (const auto& item : buffer) { tmp_buffer.add_item(item); tmp_buffer.commit(); } static_index_type static_index; static_location_handler_type static_location_handler{static_index}; const auto start = std::chrono::steady_clock::now(); osmium::apply(tmp_buffer, static_location_handler); const auto end = std::chrono::steady_clock::now(); const double duration = std::chrono::duration(end - start).count(); if (duration < static_min) { static_min = duration; } if (duration > static_max) { static_max = duration; } static_sum += duration; } { // dynamic index osmium::memory::Buffer tmp_buffer{buffer.committed()}; for (const auto& item : buffer) { tmp_buffer.add_item(item); tmp_buffer.commit(); } std::unique_ptr index = map_factory.create_map(location_store); dynamic_location_handler_type dynamic_location_handler{*index}; dynamic_location_handler.ignore_errors(); const auto start = std::chrono::steady_clock::now(); osmium::apply(tmp_buffer, dynamic_location_handler); const auto end = std::chrono::steady_clock::now(); const double duration = std::chrono::duration(end - start).count(); if (duration < dynamic_min) { dynamic_min = duration; } if (duration > dynamic_max) { dynamic_max = duration; } dynamic_sum += duration; } } const double static_avg = static_sum / runs; const double dynamic_avg = dynamic_sum / runs; std::cout << "static min=" << static_min << "ms avg=" << static_avg << "ms max=" << static_max << "ms\n"; std::cout << "dynamic min=" << dynamic_min << "ms avg=" << dynamic_avg << "ms max=" << dynamic_max << "ms\n"; const double rfactor = 100.0; const double diff_min = std::round((dynamic_min - static_min) * rfactor) / rfactor; const double diff_avg = std::round((dynamic_avg - static_avg) * rfactor) / rfactor; const double diff_max = std::round((dynamic_max - static_max) * rfactor) / rfactor; const double prfactor = 10.0; const double percent_min = std::round((100.0 * diff_min / static_min) * prfactor) / prfactor; const double percent_avg = std::round((100.0 * diff_avg / static_avg) * prfactor) / prfactor; const double percent_max = std::round((100.0 * diff_max / static_max) * prfactor) / prfactor; std::cout << "difference:"; std::cout << " min=" << diff_min << "ms (" << percent_min << "%)"; std::cout << " avg=" << diff_avg << "ms (" << percent_avg << "%)"; std::cout << " max=" << diff_max << "ms (" << percent_max << "%)\n"; } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } return 0; } libosmium-2.21.0/benchmarks/osmium_benchmark_write_pbf.cpp000066400000000000000000000021571474122261600240130ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #include #include #include #include #include #include #include int main(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " INPUT-FILE OUTPUT-FILE\n"; return 1; } try { const std::string input_filename{argv[1]}; const std::string output_filename{argv[2]}; osmium::io::Reader reader{input_filename}; const osmium::io::File output_file{output_filename, "pbf"}; const osmium::io::Header header; osmium::io::Writer writer{output_file, header, osmium::io::overwrite::allow}; while (osmium::memory::Buffer buffer = reader.read()) { // NOLINT(bugprone-use-after-move) Bug in clang-tidy https://bugs.llvm.org/show_bug.cgi?id=36516 writer(std::move(buffer)); } writer.close(); reader.close(); } catch (const std::exception& e) { std::cerr << e.what() << '\n'; return 1; } return 0; } libosmium-2.21.0/benchmarks/run_benchmark_count.sh000077500000000000000000000010241474122261600223000ustar00rootroot00000000000000#!/bin/sh # # run_benchmark_count.sh # set -e BENCHMARK_NAME=count . @CMAKE_BINARY_DIR@/benchmarks/setup.sh CMD=$OB_DIR/osmium_benchmark_$BENCHMARK_NAME echo "# file size num mem time cpu_kernel cpu_user cpu_percent cmd options" for data in $OB_DATA_FILES; do filename=`basename $data` filesize=`stat --format="%s" --dereference $data` for n in $OB_SEQ; do $OB_TIME_CMD -f "$filename $filesize $n $OB_TIME_FORMAT" $CMD $data 2>&1 >/dev/null | sed -e "s%$DATA_DIR/%%" | sed -e "s%$OB_DIR/%%" done done libosmium-2.21.0/benchmarks/run_benchmark_count_tag.sh000077500000000000000000000010341474122261600231340ustar00rootroot00000000000000#!/bin/sh # # run_benchmark_count_tag.sh # set -e BENCHMARK_NAME=count_tag . @CMAKE_BINARY_DIR@/benchmarks/setup.sh CMD=$OB_DIR/osmium_benchmark_$BENCHMARK_NAME echo "# file size num mem time cpu_kernel cpu_user cpu_percent cmd options" for data in $OB_DATA_FILES; do filename=`basename $data` filesize=`stat --format="%s" --dereference $data` for n in $OB_SEQ; do $OB_TIME_CMD -f "$filename $filesize $n $OB_TIME_FORMAT" $CMD $data 2>&1 >/dev/null | sed -e "s%$DATA_DIR/%%" | sed -e "s%$OB_DIR/%%" done done libosmium-2.21.0/benchmarks/run_benchmark_index_map.sh000077500000000000000000000014731474122261600231240ustar00rootroot00000000000000#!/bin/sh # # run_benchmark_index_map.sh # set -e BENCHMARK_NAME=index_map . @CMAKE_BINARY_DIR@/benchmarks/setup.sh CMD=$OB_DIR/osmium_benchmark_$BENCHMARK_NAME #MAPS="sparse_mem_map sparse_mem_table sparse_mem_array sparse_mmap_array sparse_file_array dense_mem_array dense_mmap_array dense_file_array" MAPS="sparse_mem_map sparse_mem_table sparse_mem_array sparse_mmap_array sparse_file_array" echo "# file size num mem time cpu_kernel cpu_user cpu_percent cmd options" for data in $OB_DATA_FILES; do filename=`basename $data` filesize=`stat --format="%s" --dereference $data` for map in $MAPS; do for n in $OB_SEQ; do $OB_TIME_CMD -f "$filename $filesize $n $OB_TIME_FORMAT" $CMD $data $map 2>&1 >/dev/null | sed -e "s%$DATA_DIR/%%" | sed -e "s%$OB_DIR/%%" done done done libosmium-2.21.0/benchmarks/run_benchmark_mercator.sh000077500000000000000000000010321474122261600227630ustar00rootroot00000000000000#!/bin/sh # # run_benchmark_mercator.sh # set -e BENCHMARK_NAME=mercator . @CMAKE_BINARY_DIR@/benchmarks/setup.sh CMD=$OB_DIR/osmium_benchmark_$BENCHMARK_NAME echo "# file size num mem time cpu_kernel cpu_user cpu_percent cmd options" for data in $OB_DATA_FILES; do filename=`basename $data` filesize=`stat --format="%s" --dereference $data` for n in $OB_SEQ; do $OB_TIME_CMD -f "$filename $filesize $n $OB_TIME_FORMAT" $CMD $data 2>&1 >/dev/null | sed -e "s%$DATA_DIR/%%" | sed -e "s%$OB_DIR/%%" done done libosmium-2.21.0/benchmarks/run_benchmark_static_vs_dynamic_index.sh000077500000000000000000000006111474122261600260430ustar00rootroot00000000000000#!/bin/sh # # run_benchmark_static_vs_dynamic_index.sh # set -e BENCHMARK_NAME=static_vs_dynamic_index . @CMAKE_BINARY_DIR@/benchmarks/setup.sh CMD=$OB_DIR/osmium_benchmark_$BENCHMARK_NAME for data in $OB_DATA_FILES; do filesize=`stat --format="%s" --dereference $data` if [ $filesize -lt 500000000 ]; then echo "========================" $CMD $data fi done libosmium-2.21.0/benchmarks/run_benchmark_write_pbf.sh000077500000000000000000000015421474122261600231360ustar00rootroot00000000000000#!/bin/sh # # run_benchmark_write_pbf.sh # # Will read the input file and after reading it into memory completely, # write it to /dev/null. Because this will need the time to read *and* write # the file, it will report the times for reading and writing. You can # subtract the times needed for the "count" benchmark to (roughly) get the # write times. # set -e BENCHMARK_NAME=write_pbf . @CMAKE_BINARY_DIR@/benchmarks/setup.sh CMD=$OB_DIR/osmium_benchmark_$BENCHMARK_NAME echo "# file size num mem time cpu_kernel cpu_user cpu_percent cmd options" for data in $OB_DATA_FILES; do filename=`basename $data` filesize=`stat --format="%s" --dereference $data` for n in $OB_SEQ; do $OB_TIME_CMD -f "$filename $filesize $n $OB_TIME_FORMAT" $CMD $data /dev/null 2>&1 >/dev/null | sed -e "s%$DATA_DIR/%%" | sed -e "s%$OB_DIR/%%" done done libosmium-2.21.0/benchmarks/run_benchmarks.sh000077500000000000000000000003331474122261600212550ustar00rootroot00000000000000#!/bin/sh # # run_benchmarks.sh # # Run all benchmarks. # set -e for benchmark in @CMAKE_BINARY_DIR@/benchmarks/run_benchmark_*.sh; do name=`basename $benchmark` echo "Running $name..." $benchmark done libosmium-2.21.0/benchmarks/setup.sh000077500000000000000000000020161474122261600174140ustar00rootroot00000000000000#!/bin/sh # # setup.sh # if [ -z $DATA_DIR ]; then echo "Please set DATA_DIR environment variable before running benchmark" exit 1 fi OB_DIR=@CMAKE_BINARY_DIR@/benchmarks OB_BUILD_TYPE=@CMAKE_BUILD_TYPE@ OB_COMPILER=@CMAKE_CXX_COMPILER@ OB_COMPILER_VERSION=`$OB_COMPILER --version | head -1` OB_CXXFLAGS="@_cxx_flags@" OB_RUNS=3 OB_SEQ=`seq -s' ' 1 $OB_RUNS` OB_TIME_CMD=/usr/bin/time OB_TIME_FORMAT="%M %e %S %U %P %C" OB_DATA_FILES=`find -L $DATA_DIR -mindepth 1 -maxdepth 1 -type f | sort` echo "BENCHMARK: $BENCHMARK_NAME" echo "---------------------" echo "BUILD:" echo "build type\t: $OB_BUILD_TYPE" echo "compiler\t: $OB_COMPILER" echo "CXX version\t: $OB_COMPILER_VERSION" echo "CXX flags\t: $OB_CXXFLAGS" echo "---------------------" echo "CPU:" grep '^model name' /proc/cpuinfo | tail -1 grep '^cpu MHz' /proc/cpuinfo | tail -1 grep '^cpu cores' /proc/cpuinfo | tail -1 grep '^siblings' /proc/cpuinfo | tail -1 echo "---------------------" echo "MEMORY:" free echo "---------------------" echo "RESULTS:" libosmium-2.21.0/cmake/000077500000000000000000000000001474122261600146615ustar00rootroot00000000000000libosmium-2.21.0/cmake/FindGem.cmake000066400000000000000000000137201474122261600171770ustar00rootroot00000000000000# Author thomas.roehr@dfki.de # # Version 0.31 2017-09-15 # - find gem executable gem.cmd on Windows # Version 0.3 2013-07-02 # - rely on `gem content` to find library and header # - introduce GEM_OS_PKG to allow search via pkgconfig # Version 0.2 2010-01-14 # - add support for searching for multiple gems # Version 0.1 2010-12-15 # - support basic search functionality # - tested to find rice # # OUTPUT: # # GEM_INCLUDE_DIRS After successful search contains the include directores # # GEM_LIBRARIES After successful search contains the full path of each found library # # # Usage: # set(GEM_DEBUG TRUE) # find_package(Gem COMPONENTS rice hoe) # include_directories(${GEM_INCLUDE_DIRS}) # target_link_libraries(${GEM_LIBRARIES} # # in case pkg-config should be used to search for the os pkg, set GEM_OS_PKG, i.e. # set(GEM_OS_PKG TRUE) # # Check for how 'gem' should be called include(FindPackageHandleStandardArgs) find_program(GEM_EXECUTABLE NAMES "gem.cmd" "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}" "gem${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}" "gem-${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}" "gem-${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}" "gem${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}" "gem${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}" "gem-${RUBY_VERSION_MAJOR}${RUBY_VERSION_MINOR}${RUBY_VERSION_PATCH}" "gem-${RUBY_VERSION_MAJOR}.${RUBY_VERSION_MINOR}.${RUBY_VERSION_PATCH}" "gem") # Making backward compatible if(Gem_DEBUG) set(GEM_DEBUG TRUE) endif() if(NOT GEM_EXECUTABLE) MESSAGE(FATAL_ERROR "Could not find the gem executable - install 'gem' first") endif() if(NOT Gem_FIND_COMPONENTS) MESSAGE(FATAL_ERROR "If searching for a Gem you have to provide COMPONENTS with the name of the gem") endif() foreach(Gem_NAME ${Gem_FIND_COMPONENTS}) set(GEM_${Gem_NAME}_FOUND TRUE) list(APPEND components_found_vars GEM_${Gem_NAME}_FOUND) # If the gem is installed as a gem if(NOT GEM_OS_PKG) set(GEM_HOME ENV{GEM_HOME}) # Use `gem content ` to extract current information about installed gems # Store the information into ${GEM_LOCAL_INFO} EXECUTE_PROCESS(COMMAND ${GEM_EXECUTABLE} content ${Gem_NAME} RESULT_VARIABLE GEM_RUN_RESULT OUTPUT_VARIABLE GEM_LOCAL_INFO) if(GEM_RUN_RESULT STREQUAL "0") list(APPEND FOUND_GEMS ${Gem_NAME}) set(_library_NAME_PATTERN lib${Gem_NAME}.a lib${Gem_NAME}.so lib${Gem_NAME}.dylib ${Gem_NAME}.a ${Gem_NAME}.so ${Gem_NAME}.dylib .*.a .*.so .*.dylib ) set(_header_SUFFIX_PATTERN .h .hh .hpp ) # Create a list from the output results of the gem command string(REPLACE "\n" ";" GEM_CONTENT_LIST "${GEM_LOCAL_INFO}") foreach(_gem_CONTENT_PATH ${GEM_CONTENT_LIST}) # Convert so that only '/' Unix path separator are being using # needed to do proper regex matching FILE(TO_CMAKE_PATH ${_gem_CONTENT_PATH} gem_CONTENT_PATH) # Identify library -- checking for a library in the gems 'lib' (sub)directory # Search for an existing library, but only within the gems folder foreach(_library_NAME ${_library_NAME_PATTERN}) STRING(REGEX MATCH ".*${Gem_NAME}.*/lib/.*${_library_NAME}$" GEM_PATH_INFO "${gem_CONTENT_PATH}") if(NOT "${GEM_PATH_INFO}" STREQUAL "") list(APPEND GEM_LIBRARIES ${GEM_PATH_INFO}) break() endif() endforeach() # Identify headers # Checking for available headers in an include directory foreach(_header_PATTERN ${_header_SUFFIX_PATTERN}) STRING(REGEX MATCH ".*${Gem_NAME}.*/include/.*${_header_PATTERN}$" GEM_PATH_INFO "${gem_CONTENT_PATH}") if(NOT "${GEM_PATH_INFO}" STREQUAL "") STRING(REGEX REPLACE "(.*${Gem_NAME}.*/include/).*${_header_PATTERN}$" "\\1" GEM_PATH_INFO "${gem_CONTENT_PATH}") list(APPEND GEM_INCLUDE_DIRS ${GEM_PATH_INFO}) break() endif() endforeach() endforeach() else() set(GEM_${Gem_NAME}_FOUND FALSE) endif() else(NOT GEM_OS_PKG) pkg_check_modules(GEM_PKG ${Gem_NAME}) set(GEM_${GEM_NAME}_FOUND GEM_PKG_FOUND) set(GEM_INCLUDE_DIRS ${GEM_PKG_INCLUDE_DIRS}) set(GEM_LIBRARIES ${GEM_PKG_LIBRARIES} ${GEM_PKG_STATIC_LIBRARIES}) list(APPEND GEM_LIBRARIES ${GEM_PKG_LDFLAGS} ${GEM_PKG_STATIC_LDFLAGS}) list(APPEND GEM_LIBRARIES ${GEM_PKG_LDFLAGS_OTHER} ${GEM_PKG_STATIC_LDFLAGS_OTHER}) if(GEM_DEBUG) message(STATUS "GEM_OS_PKG is defined") message(STATUS "GEM_INCLUDE_DIRS ${GEM_INCLUDE_DIRS}") message(STATUS "GEM_STATIC_LIBRARY_DIRS ${GEM_PKG_STATIC_LIBRARY_DIRS}") message(STATUS "GEM_LIBRARY_DIRS ${GEM_PKG_STATIC_LIBRARY_DIRS}") message(STATUS "GEM_STATIC_LIBRARIES ${GEM_PKG_STATIC_LIBRARIES}") message(STATUS "GEM_LIBRARIES ${GEM_LIBRARIES}") endif() endif() if(GEM_DEBUG) message(STATUS "${Gem_NAME} library dir: ${GEM_LIBRARIES}") message(STATUS "${Gem_NAME} include dir: ${GEM_INCLUDE_DIRS}") endif() endforeach() # Compact the lists if(DEFINED GEM_LIBRARIES) LIST(REMOVE_DUPLICATES GEM_LIBRARIES) endif() if(DEFINED GEM_INCLUDE_DIRS) LIST(REMOVE_DUPLICATES GEM_INCLUDE_DIRS) endif() find_package_handle_standard_args(Gem REQUIRED_VARS ${components_found_vars} FAIL_MESSAGE "Could not find all required gems") libosmium-2.21.0/cmake/FindLZ4.cmake000066400000000000000000000025321474122261600170770ustar00rootroot00000000000000find_path(LZ4_INCLUDE_DIR NAMES lz4.h DOC "lz4 include directory") mark_as_advanced(LZ4_INCLUDE_DIR) find_library(LZ4_LIBRARY NAMES lz4 liblz4 DOC "lz4 library") mark_as_advanced(LZ4_LIBRARY) if (LZ4_INCLUDE_DIR) file(STRINGS "${LZ4_INCLUDE_DIR}/lz4.h" _lz4_version_lines REGEX "#define[ \t]+LZ4_VERSION_(MAJOR|MINOR|RELEASE)") string(REGEX REPLACE ".*LZ4_VERSION_MAJOR *\([0-9]*\).*" "\\1" _lz4_version_major "${_lz4_version_lines}") string(REGEX REPLACE ".*LZ4_VERSION_MINOR *\([0-9]*\).*" "\\1" _lz4_version_minor "${_lz4_version_lines}") string(REGEX REPLACE ".*LZ4_VERSION_RELEASE *\([0-9]*\).*" "\\1" _lz4_version_release "${_lz4_version_lines}") set(LZ4_VERSION "${_lz4_version_major}.${_lz4_version_minor}.${_lz4_version_release}") unset(_lz4_version_major) unset(_lz4_version_minor) unset(_lz4_version_release) unset(_lz4_version_lines) endif () include(FindPackageHandleStandardArgs) find_package_handle_standard_args(LZ4 REQUIRED_VARS LZ4_LIBRARY LZ4_INCLUDE_DIR VERSION_VAR LZ4_VERSION) if (LZ4_FOUND) set(LZ4_INCLUDE_DIRS "${LZ4_INCLUDE_DIR}") set(LZ4_LIBRARIES "${LZ4_LIBRARY}") if (NOT TARGET LZ4::LZ4) add_library(LZ4::LZ4 UNKNOWN IMPORTED) set_target_properties(LZ4::LZ4 PROPERTIES IMPORTED_LOCATION "${LZ4_LIBRARY}" INTERFACE_INCLUDE_DIRECTORIES "${LZ4_INCLUDE_DIR}") endif () endif () libosmium-2.21.0/cmake/FindOsmium.cmake000066400000000000000000000256771474122261600177560ustar00rootroot00000000000000#---------------------------------------------------------------------- # # FindOsmium.cmake # # Find the Libosmium headers and, optionally, several components needed # for different Libosmium functions. # #---------------------------------------------------------------------- # # Usage: # # Copy this file somewhere into your project directory, where cmake can # find it. Usually this will be a directory called "cmake" which you can # add to the CMake module search path with the following line in your # CMakeLists.txt: # # list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") # # Then add the following in your CMakeLists.txt: # # find_package(Osmium [version] REQUIRED COMPONENTS ) # include_directories(SYSTEM ${OSMIUM_INCLUDE_DIRS}) # # The version number is optional. If it is not set, any version of # libosmium will do. # # For the substitute a space separated list of one or more of the # following components: # # pbf - include libraries needed for PBF input and output # xml - include libraries needed for XML input and output # io - include libraries needed for any type of input/output # geos - include if you want to use any of the GEOS functions # gdal - include if you want to use any of the OGR functions # lz4 - include support for LZ4 compression of PBF files # # You can check for success with something like this: # # if(NOT OSMIUM_FOUND) # message(WARNING "Libosmium not found!\n") # endif() # #---------------------------------------------------------------------- # # Variables: # # OSMIUM_FOUND - True if Osmium found. # OSMIUM_INCLUDE_DIRS - Where to find include files. # OSMIUM_XML_LIBRARIES - Libraries needed for XML I/O. # OSMIUM_PBF_LIBRARIES - Libraries needed for PBF I/O. # OSMIUM_IO_LIBRARIES - Libraries needed for XML or PBF I/O. # OSMIUM_LIBRARIES - All libraries Osmium uses somewhere. # #---------------------------------------------------------------------- # This is the list of directories where we look for osmium includes. set(_osmium_include_path ../libosmium ~/Library/Frameworks /Library/Frameworks /opt/local # DarwinPorts /opt ) # Look for the header file. find_path(OSMIUM_INCLUDE_DIR osmium/version.hpp PATH_SUFFIXES include PATHS ${_osmium_include_path} ) # Check libosmium version number if(Osmium_FIND_VERSION) if(NOT EXISTS "${OSMIUM_INCLUDE_DIR}/osmium/version.hpp") message(FATAL_ERROR "Missing ${OSMIUM_INCLUDE_DIR}/osmium/version.hpp. Either your libosmium version is too old, or libosmium wasn't found in the place you said.") endif() file(STRINGS "${OSMIUM_INCLUDE_DIR}/osmium/version.hpp" _libosmium_version_define REGEX "#define LIBOSMIUM_VERSION_STRING") if("${_libosmium_version_define}" MATCHES "#define LIBOSMIUM_VERSION_STRING \"([0-9.]+)\"") set(_libosmium_version "${CMAKE_MATCH_1}") else() set(_libosmium_version "unknown") endif() endif() set(OSMIUM_INCLUDE_DIRS "${OSMIUM_INCLUDE_DIR}") #---------------------------------------------------------------------- # # Check for optional components # #---------------------------------------------------------------------- if(Osmium_FIND_COMPONENTS) foreach(_component ${Osmium_FIND_COMPONENTS}) string(TOUPPER ${_component} _component_uppercase) set(Osmium_USE_${_component_uppercase} TRUE) endforeach() endif() #---------------------------------------------------------------------- # Component 'io' is an alias for 'pbf' and 'xml' if(Osmium_USE_IO) set(Osmium_USE_PBF TRUE) set(Osmium_USE_XML TRUE) endif() #---------------------------------------------------------------------- # Component 'ogr' is an alias for 'gdal' if(Osmium_USE_OGR) set(Osmium_USE_GDAL TRUE) endif() #---------------------------------------------------------------------- # Component 'pbf' if(Osmium_USE_PBF) find_package(ZLIB) find_package(Threads) find_package(Protozero 1.6.3) if(Osmium_USE_LZ4) find_package(LZ4 REQUIRED) add_definitions(-DOSMIUM_WITH_LZ4) endif() list(APPEND OSMIUM_EXTRA_FIND_VARS ZLIB_FOUND Threads_FOUND PROTOZERO_INCLUDE_DIR) if(ZLIB_FOUND AND Threads_FOUND AND PROTOZERO_FOUND) list(APPEND OSMIUM_PBF_LIBRARIES ${ZLIB_LIBRARIES} ${LZ4_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) list(APPEND OSMIUM_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR} ${LZ4_INCLUDE_DIRS} ${PROTOZERO_INCLUDE_DIR} ) else() message(WARNING "Osmium: Can not find some libraries for PBF input/output, please install them or configure the paths.") endif() endif() #---------------------------------------------------------------------- # Component 'xml' if(Osmium_USE_XML) find_package(EXPAT) find_package(BZip2) find_package(ZLIB) find_package(Threads) list(APPEND OSMIUM_EXTRA_FIND_VARS EXPAT_FOUND BZIP2_FOUND ZLIB_FOUND Threads_FOUND) if(EXPAT_FOUND AND BZIP2_FOUND AND ZLIB_FOUND AND Threads_FOUND) list(APPEND OSMIUM_XML_LIBRARIES ${EXPAT_LIBRARIES} ${BZIP2_LIBRARIES} ${ZLIB_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) list(APPEND OSMIUM_INCLUDE_DIRS ${EXPAT_INCLUDE_DIR} ${BZIP2_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR} ) else() message(WARNING "Osmium: Can not find some libraries for XML input/output, please install them or configure the paths.") endif() endif() #---------------------------------------------------------------------- list(APPEND OSMIUM_IO_LIBRARIES ${OSMIUM_PBF_LIBRARIES} ${OSMIUM_XML_LIBRARIES} ) list(APPEND OSMIUM_LIBRARIES ${OSMIUM_IO_LIBRARIES} ) #---------------------------------------------------------------------- # Component 'geos' if(Osmium_USE_GEOS) find_path(GEOS_INCLUDE_DIR geos/geom.h) find_library(GEOS_LIBRARY NAMES geos) list(APPEND OSMIUM_EXTRA_FIND_VARS GEOS_INCLUDE_DIR GEOS_LIBRARY) if(GEOS_INCLUDE_DIR AND GEOS_LIBRARY) SET(GEOS_FOUND 1) list(APPEND OSMIUM_LIBRARIES ${GEOS_LIBRARY}) list(APPEND OSMIUM_INCLUDE_DIRS ${GEOS_INCLUDE_DIR}) else() message(WARNING "Osmium: GEOS library is required but not found, please install it or configure the paths.") endif() endif() #---------------------------------------------------------------------- # Component 'gdal' (alias 'ogr') if(Osmium_USE_GDAL) find_package(GDAL) list(APPEND OSMIUM_EXTRA_FIND_VARS GDAL_FOUND) if(GDAL_FOUND) list(APPEND OSMIUM_LIBRARIES ${GDAL_LIBRARIES}) list(APPEND OSMIUM_INCLUDE_DIRS ${GDAL_INCLUDE_DIRS}) else() message(WARNING "Osmium: GDAL library is required but not found, please install it or configure the paths.") endif() endif() #---------------------------------------------------------------------- list(REMOVE_DUPLICATES OSMIUM_INCLUDE_DIRS) if(OSMIUM_XML_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_XML_LIBRARIES) endif() if(OSMIUM_PBF_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_PBF_LIBRARIES) endif() if(OSMIUM_IO_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_IO_LIBRARIES) endif() if(OSMIUM_LIBRARIES) list(REMOVE_DUPLICATES OSMIUM_LIBRARIES) endif() #---------------------------------------------------------------------- # # Check that all required libraries are available # #---------------------------------------------------------------------- if(OSMIUM_EXTRA_FIND_VARS) list(REMOVE_DUPLICATES OSMIUM_EXTRA_FIND_VARS) endif() # Handle the QUIETLY and REQUIRED arguments and the optional version check # and set OSMIUM_FOUND to TRUE if all listed variables are TRUE. include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Osmium REQUIRED_VARS OSMIUM_INCLUDE_DIR ${OSMIUM_EXTRA_FIND_VARS} VERSION_VAR _libosmium_version) unset(OSMIUM_EXTRA_FIND_VARS) #---------------------------------------------------------------------- # # A function for setting the -pthread option in compilers/linkers # #---------------------------------------------------------------------- function(set_pthread_on_target _target) if(NOT MSVC) set_target_properties(${_target} PROPERTIES COMPILE_FLAGS "-pthread") if(NOT APPLE) set_target_properties(${_target} PROPERTIES LINK_FLAGS "-pthread") endif() endif() endfunction() #---------------------------------------------------------------------- # # Add compiler flags # #---------------------------------------------------------------------- add_definitions(-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64) if(MSVC) add_definitions(-wd4996) # Disable warning C4068: "unknown pragma" because we want it to ignore # pragmas for other compilers. add_definitions(-wd4068) # Disable warning C4715: "not all control paths return a value" because # it generates too many false positives. add_definitions(-wd4715) # Disable warning C4351: new behavior: elements of array '...' will be # default initialized. The new behaviour is correct and we don't support # old compilers anyway. add_definitions(-wd4351) # Disable warning C4503: "decorated name length exceeded, name was truncated" # there are more than 150 of generated names in libosmium longer than 4096 symbols supported in MSVC add_definitions(-wd4503) add_definitions(-DNOMINMAX -DWIN32_LEAN_AND_MEAN -D_CRT_SECURE_NO_WARNINGS) endif() if(APPLE AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") # following only available from cmake 2.8.12: # add_compile_options(-stdlib=libc++) # so using this instead: add_definitions(-stdlib=libc++) set(LDFLAGS ${LDFLAGS} -stdlib=libc++) endif() #---------------------------------------------------------------------- # This is a set of recommended warning options that can be added when compiling # libosmium code. if(MSVC) set(OSMIUM_WARNING_OPTIONS "/W3 /wd4514" CACHE STRING "Recommended warning options for libosmium") else() set(OSMIUM_WARNING_OPTIONS "-Wall -Wextra -pedantic -Wredundant-decls -Wdisabled-optimization -Wctor-dtor-privacy -Wnon-virtual-dtor -Woverloaded-virtual -Wsign-promo -Wold-style-cast" CACHE STRING "Recommended warning options for libosmium") endif() set(OSMIUM_DRACONIC_CLANG_OPTIONS "-Wdocumentation -Wunused-exception-parameter -Wmissing-declarations -Weverything -Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-unused-macros -Wno-exit-time-destructors -Wno-global-constructors -Wno-padded -Wno-switch-enum -Wno-missing-prototypes -Wno-weak-vtables -Wno-cast-align -Wno-float-equal") if(Osmium_DEBUG) message(STATUS "OSMIUM_XML_LIBRARIES=${OSMIUM_XML_LIBRARIES}") message(STATUS "OSMIUM_PBF_LIBRARIES=${OSMIUM_PBF_LIBRARIES}") message(STATUS "OSMIUM_IO_LIBRARIES=${OSMIUM_IO_LIBRARIES}") message(STATUS "OSMIUM_LIBRARIES=${OSMIUM_LIBRARIES}") message(STATUS "OSMIUM_INCLUDE_DIRS=${OSMIUM_INCLUDE_DIRS}") endif() libosmium-2.21.0/cmake/FindProtozero.cmake000066400000000000000000000037601474122261600204750ustar00rootroot00000000000000#---------------------------------------------------------------------- # # FindProtozero.cmake # # Find the protozero headers. # #---------------------------------------------------------------------- # # Usage: # # Copy this file somewhere into your project directory, where cmake can # find it. Usually this will be a directory called "cmake" which you can # add to the CMake module search path with the following line in your # CMakeLists.txt: # # list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") # # Then add the following in your CMakeLists.txt: # # find_package(Protozero [version] [REQUIRED]) # include_directories(SYSTEM ${PROTOZERO_INCLUDE_DIR}) # # The version number is optional. If it is not set, any version of # protozero will do. # # if(NOT PROTOZERO_FOUND) # message(WARNING "Protozero not found!\n") # endif() # #---------------------------------------------------------------------- # # Variables: # # PROTOZERO_FOUND - True if Protozero was found. # PROTOZERO_INCLUDE_DIR - Where to find include files. # #---------------------------------------------------------------------- # find include path find_path(PROTOZERO_INCLUDE_DIR protozero/version.hpp PATH_SUFFIXES include PATHS ${CMAKE_SOURCE_DIR}/../protozero ) # Check version number if(Protozero_FIND_VERSION) file(STRINGS "${PROTOZERO_INCLUDE_DIR}/protozero/version.hpp" _version_define REGEX "#define PROTOZERO_VERSION_STRING") if("${_version_define}" MATCHES "#define PROTOZERO_VERSION_STRING \"([0-9.]+)\"") set(_version "${CMAKE_MATCH_1}") else() set(_version "unknown") endif() endif() #set(PROTOZERO_INCLUDE_DIRS "${PROTOZERO_INCLUDE_DIR}") include(FindPackageHandleStandardArgs) find_package_handle_standard_args(Protozero REQUIRED_VARS PROTOZERO_INCLUDE_DIR VERSION_VAR _version) #---------------------------------------------------------------------- libosmium-2.21.0/cmake/README000066400000000000000000000000751474122261600155430ustar00rootroot00000000000000 FindGem.cmake from https://github.com/rock-core/base-cmake libosmium-2.21.0/cmake/iwyu.sh000077500000000000000000000024161474122261600162200ustar00rootroot00000000000000#!/bin/sh # # This will run IWYU (Include What You Use) on includes files. The iwyu # program isn't very reliable and crashes often, but is still useful. # # TODO: This script should be integrated with cmake in some way... # # If these are set, the wrong compiler is used by iwyu and there will be # errors about missing includes. unset CC unset CXX cmdline="iwyu -Xiwyu --mapping_file=osmium.imp -std=c++11 -I include" log=build/iwyu.log mkdir -p build/check_reports echo "INCLUDE WHAT YOU USE REPORT:" >$log allok=yes for file in `find include/osmium -name \*.hpp | sort`; do mkdir -p `dirname build/check_reports/$file` ifile="build/check_reports/${file%.hpp}.iwyu" $cmdline $file >$ifile 2>&1 if grep -q 'has correct #includes/fwd-decls' ${ifile}; then echo "\n\033[1m\033[32m========\033[0m \033[1m${file}\033[0m" >>$log echo "[OK] ${file}" elif grep -q 'Assertion failed' ${ifile}; then echo "\n\033[1m======== ${file}\033[0m" >>$log echo "[--] ${file}" allok=no else echo "\n\033[1m\033[31m========\033[0m \033[1m${file}\033[0m" >>$log echo "[ ] ${file}" allok=no fi cat $ifile >>$log done if [ "$allok" = "yes" ]; then echo "All files OK" else echo "There were errors" fi libosmium-2.21.0/doc/000077500000000000000000000000001474122261600143465ustar00rootroot00000000000000libosmium-2.21.0/doc/CMakeLists.txt000066400000000000000000000021201474122261600171010ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # CMake Config # # Libosmium documentation # #----------------------------------------------------------------------------- message(STATUS "Configuring documentation") message(STATUS "Looking for doxygen") find_package(Doxygen) if(DOXYGEN_FOUND) message(STATUS "Looking for doxygen - found") configure_file(header.html ${CMAKE_CURRENT_BINARY_DIR}/header.html @ONLY) configure_file(Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY) add_custom_target(doc ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} COMMENT "Generating API documentation with Doxygen" VERBATIM ) else() message(STATUS "Looking for doxygen - not found") message(STATUS " Disabled making of documentation.") endif() #----------------------------------------------------------------------------- message(STATUS "Configuring documentation - done") #----------------------------------------------------------------------------- libosmium-2.21.0/doc/Doxyfile.in000066400000000000000000003054731474122261600164750ustar00rootroot00000000000000# Doxyfile 1.8.7 # This file describes the settings to be used by the documentation system # doxygen (www.doxygen.org) for a project. # # All text after a double hash (##) is considered a comment and is placed in # front of the TAG it is preceding. # # All text after a single hash (#) is considered a comment and will be ignored. # The format is: # TAG = value [value, ...] # For lists, items can also be appended using: # TAG += value [value, ...] # Values that contain spaces should be placed between quotes (\" \"). #--------------------------------------------------------------------------- # Project related configuration options #--------------------------------------------------------------------------- # This tag specifies the encoding used for all characters in the config file # that follow. The default is UTF-8 which is also the encoding used for all text # before the first occurrence of this tag. Doxygen uses libiconv (or the iconv # built into libc) for the transcoding. See http://www.gnu.org/software/libiconv # for the list of possible encodings. # The default value is: UTF-8. DOXYFILE_ENCODING = UTF-8 # The PROJECT_NAME tag is a single word (or a sequence of words surrounded by # double-quotes, unless you are using Doxywizard) that should identify the # project for which the documentation is generated. This name is used in the # title of most generated pages and in a few other places. # The default value is: My Project. PROJECT_NAME = "Libosmium" # The PROJECT_NUMBER tag can be used to enter a project or revision number. This # could be handy for archiving the generated documentation or if some version # control system is used. PROJECT_NUMBER = @LIBOSMIUM_VERSION@ # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a # quick idea about the purpose of the project. Keep the description short. PROJECT_BRIEF = "Fast and flexible C++ library for working with OpenStreetMap data" # With the PROJECT_LOGO tag one can specify an logo or icon that is included in # the documentation. The maximum height of the logo should not exceed 55 pixels # and the maximum width should not exceed 200 pixels. Doxygen will copy the logo # to the output directory. PROJECT_LOGO = # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path # into which the generated documentation will be written. If a relative path is # entered, it will be relative to the location where doxygen was started. If # left blank the current directory will be used. OUTPUT_DIRECTORY = "@PROJECT_BINARY_DIR@/doc" # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create 4096 sub- # directories (in 2 levels) under the output directory of each output format and # will distribute the generated files over these directories. Enabling this # option can be useful when feeding doxygen a huge amount of source files, where # putting all generated files in the same directory would otherwise causes # performance problems for the file system. # The default value is: NO. CREATE_SUBDIRS = NO # If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII # characters to appear in the names of generated files. If set to NO, non-ASCII # characters will be escaped, for example _xE3_x81_x84 will be used for Unicode # U+3044. # The default value is: NO. ALLOW_UNICODE_NAMES = NO # The OUTPUT_LANGUAGE tag is used to specify the language in which all # documentation generated by doxygen is written. Doxygen will use this # information to generate all constant output in the proper language. # Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, # Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), # Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, # Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), # Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, # Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, # Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, # Ukrainian and Vietnamese. # The default value is: English. OUTPUT_LANGUAGE = English # If the BRIEF_MEMBER_DESC tag is set to YES doxygen will include brief member # descriptions after the members that are listed in the file and class # documentation (similar to Javadoc). Set to NO to disable this. # The default value is: YES. BRIEF_MEMBER_DESC = YES # If the REPEAT_BRIEF tag is set to YES doxygen will prepend the brief # description of a member or function before the detailed description # # Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the # brief descriptions will be completely suppressed. # The default value is: YES. REPEAT_BRIEF = YES # This tag implements a quasi-intelligent brief description abbreviator that is # used to form the text in various listings. Each string in this list, if found # as the leading text of the brief description, will be stripped from the text # and the result, after processing the whole list, is used as the annotated # text. Otherwise, the brief description is used as-is. If left blank, the # following values are used ($name is automatically replaced with the name of # the entity):The $name class, The $name widget, The $name file, is, provides, # specifies, contains, represents, a, an and the. ABBREVIATE_BRIEF = # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then # doxygen will generate a detailed section even if there is only a brief # description. # The default value is: NO. ALWAYS_DETAILED_SEC = NO # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all # inherited members of a class in the documentation of that class as if those # members were ordinary class members. Constructors, destructors and assignment # operators of the base classes will not be shown. # The default value is: NO. INLINE_INHERITED_MEMB = NO # If the FULL_PATH_NAMES tag is set to YES doxygen will prepend the full path # before files name in the file list and in the header files. If set to NO the # shortest path that makes the file name unique will be used # The default value is: YES. FULL_PATH_NAMES = YES # The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. # Stripping is only done if one of the specified strings matches the left-hand # part of the path. The tag can be used to show relative paths in the file list. # If left blank the directory from which doxygen is run is used as the path to # strip. # # Note that you can specify absolute paths here, but also relative paths, which # will be relative from the directory where doxygen is started. # This tag requires that the tag FULL_PATH_NAMES is set to YES. STRIP_FROM_PATH = @PROJECT_SOURCE_DIR@ # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the # path mentioned in the documentation of a class, which tells the reader which # header file to include in order to use a class. If left blank only the name of # the header file containing the class definition is used. Otherwise one should # specify the list of include paths that are normally passed to the compiler # using the -I flag. STRIP_FROM_INC_PATH = # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but # less readable) file names. This can be useful is your file systems doesn't # support long names like on DOS, Mac, or CD-ROM. # The default value is: NO. SHORT_NAMES = NO # If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the # first line (until the first dot) of a Javadoc-style comment as the brief # description. If set to NO, the Javadoc-style will behave just like regular Qt- # style comments (thus requiring an explicit @brief command for a brief # description.) # The default value is: NO. JAVADOC_AUTOBRIEF = NO # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first # line (until the first dot) of a Qt-style comment as the brief description. If # set to NO, the Qt-style will behave just like regular Qt-style comments (thus # requiring an explicit \brief command for a brief description.) # The default value is: NO. QT_AUTOBRIEF = NO # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a # multi-line C++ special comment block (i.e. a block of //! or /// comments) as # a brief description. This used to be the default behavior. The new default is # to treat a multi-line C++ comment block as a detailed description. Set this # tag to YES if you prefer the old behavior instead. # # Note that setting this tag to YES also means that rational rose comments are # not recognized any more. # The default value is: NO. MULTILINE_CPP_IS_BRIEF = NO # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the # documentation from any documented member that it re-implements. # The default value is: YES. INHERIT_DOCS = YES # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce a # new page for each member. If set to NO, the documentation of a member will be # part of the file/class/namespace that contains it. # The default value is: NO. SEPARATE_MEMBER_PAGES = NO # The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen # uses this value to replace tabs by spaces in code fragments. # Minimum value: 1, maximum value: 16, default value: 4. TAB_SIZE = 8 # This tag can be used to specify a number of aliases that act as commands in # the documentation. An alias has the form: # name=value # For example adding # "sideeffect=@par Side Effects:\n" # will allow you to put the command \sideeffect (or @sideeffect) in the # documentation, which will result in a user-defined paragraph with heading # "Side Effects:". You can put \n's in the value part of an alias to insert # newlines. ALIASES = # This tag can be used to specify a number of word-keyword mappings (TCL only). # A mapping has the form "name=value". For example adding "class=itcl::class" # will allow you to use the command class in the itcl::class meaning. TCL_SUBST = # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources # only. Doxygen will then generate output that is more tailored for C. For # instance, some of the names that are used will be different. The list of all # members will be omitted, etc. # The default value is: NO. OPTIMIZE_OUTPUT_FOR_C = NO # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or # Python sources only. Doxygen will then generate output that is more tailored # for that language. For instance, namespaces will be presented as packages, # qualified scopes will look different, etc. # The default value is: NO. OPTIMIZE_OUTPUT_JAVA = NO # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran # sources. Doxygen will then generate output that is tailored for Fortran. # The default value is: NO. OPTIMIZE_FOR_FORTRAN = NO # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL # sources. Doxygen will then generate output that is tailored for VHDL. # The default value is: NO. OPTIMIZE_OUTPUT_VHDL = NO # Doxygen selects the parser to use depending on the extension of the files it # parses. With this tag you can assign which parser to use for a given # extension. Doxygen has a built-in mapping, but you can override or extend it # using this tag. The format is ext=language, where ext is a file extension, and # language is one of the parsers supported by doxygen: IDL, Java, Javascript, # C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran: # FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran: # Fortran. In the later case the parser tries to guess whether the code is fixed # or free formatted code, this is the default for Fortran type files), VHDL. For # instance to make doxygen treat .inc files as Fortran files (default is PHP), # and .f files as C (default is Fortran), use: inc=Fortran f=C. # # Note For files without extension you can use no_extension as a placeholder. # # Note that for custom extensions you also need to set FILE_PATTERNS otherwise # the files are not read by doxygen. EXTENSION_MAPPING = # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments # according to the Markdown format, which allows for more readable # documentation. See http://daringfireball.net/projects/markdown/ for details. # The output of markdown processing is further processed by doxygen, so you can # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in # case of backward compatibilities issues. # The default value is: YES. MARKDOWN_SUPPORT = YES # When enabled doxygen tries to link words that correspond to documented # classes, or namespaces to their corresponding documentation. Such a link can # be prevented in individual cases by by putting a % sign in front of the word # or globally by setting AUTOLINK_SUPPORT to NO. # The default value is: YES. AUTOLINK_SUPPORT = YES # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want # to include (a tag file for) the STL sources as input, then you should set this # tag to YES in order to let doxygen match functions declarations and # definitions whose arguments contain STL classes (e.g. func(std::string); # versus func(std::string) {}). This also make the inheritance and collaboration # diagrams that involve STL classes more complete and accurate. # The default value is: NO. BUILTIN_STL_SUPPORT = NO # If you use Microsoft's C++/CLI language, you should set this option to YES to # enable parsing support. # The default value is: NO. CPP_CLI_SUPPORT = NO # Set the SIP_SUPPORT tag to YES if your project consists of sip (see: # http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen # will parse them like normal C++ but will assume all classes use public instead # of private inheritance when no explicit protection keyword is present. # The default value is: NO. SIP_SUPPORT = NO # For Microsoft's IDL there are propget and propput attributes to indicate # getter and setter methods for a property. Setting this option to YES will make # doxygen to replace the get and set methods by a property in the documentation. # This will only work if the methods are indeed getting or setting a simple # type. If this is not the case, or you want to show the methods anyway, you # should set this option to NO. # The default value is: YES. IDL_PROPERTY_SUPPORT = YES # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC # tag is set to YES, then doxygen will reuse the documentation of the first # member in the group (if any) for the other members of the group. By default # all members of a group must be documented explicitly. # The default value is: NO. DISTRIBUTE_GROUP_DOC = NO # Set the SUBGROUPING tag to YES to allow class member groups of the same type # (for instance a group of public functions) to be put as a subgroup of that # type (e.g. under the Public Functions section). Set it to NO to prevent # subgrouping. Alternatively, this can be done per class using the # \nosubgrouping command. # The default value is: YES. SUBGROUPING = YES # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions # are shown inside the group in which they are included (e.g. using \ingroup) # instead of on a separate page (for HTML and Man pages) or section (for LaTeX # and RTF). # # Note that this feature does not work in combination with # SEPARATE_MEMBER_PAGES. # The default value is: NO. INLINE_GROUPED_CLASSES = NO # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions # with only public data fields or simple typedef fields will be shown inline in # the documentation of the scope in which they are defined (i.e. file, # namespace, or group documentation), provided this scope is documented. If set # to NO, structs, classes, and unions are shown on a separate page (for HTML and # Man pages) or section (for LaTeX and RTF). # The default value is: NO. INLINE_SIMPLE_STRUCTS = NO # When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or # enum is documented as struct, union, or enum with the name of the typedef. So # typedef struct TypeS {} TypeT, will appear in the documentation as a struct # with name TypeT. When disabled the typedef will appear as a member of a file, # namespace, or class. And the struct will be named TypeS. This can typically be # useful for C code in case the coding convention dictates that all compound # types are typedef'ed and only the typedef is referenced, never the tag name. # The default value is: NO. TYPEDEF_HIDES_STRUCT = NO # The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This # cache is used to resolve symbols given their name and scope. Since this can be # an expensive process and often the same symbol appears multiple times in the # code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small # doxygen will become slower. If the cache is too large, memory is wasted. The # cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range # is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 # symbols. At the end of a run doxygen will report the cache usage and suggest # the optimal cache size from a speed point of view. # Minimum value: 0, maximum value: 9, default value: 0. LOOKUP_CACHE_SIZE = 0 #--------------------------------------------------------------------------- # Build related configuration options #--------------------------------------------------------------------------- # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in # documentation are documented, even if no documentation was available. Private # class members and static file members will be hidden unless the # EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. # Note: This will also disable the warnings about undocumented members that are # normally produced when WARNINGS is set to YES. # The default value is: NO. EXTRACT_ALL = YES # If the EXTRACT_PRIVATE tag is set to YES all private members of a class will # be included in the documentation. # The default value is: NO. EXTRACT_PRIVATE = YES # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal # scope will be included in the documentation. # The default value is: NO. EXTRACT_PACKAGE = NO # If the EXTRACT_STATIC tag is set to YES all static members of a file will be # included in the documentation. # The default value is: NO. EXTRACT_STATIC = YES # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs) defined # locally in source files will be included in the documentation. If set to NO # only classes defined in header files are included. Does not have any effect # for Java sources. # The default value is: YES. EXTRACT_LOCAL_CLASSES = YES # This flag is only useful for Objective-C code. When set to YES local methods, # which are defined in the implementation section but not in the interface are # included in the documentation. If set to NO only methods in the interface are # included. # The default value is: NO. EXTRACT_LOCAL_METHODS = NO # If this flag is set to YES, the members of anonymous namespaces will be # extracted and appear in the documentation as a namespace called # 'anonymous_namespace{file}', where file will be replaced with the base name of # the file that contains the anonymous namespace. By default anonymous namespace # are hidden. # The default value is: NO. EXTRACT_ANON_NSPACES = NO # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all # undocumented members inside documented classes or files. If set to NO these # members will be included in the various overviews, but no documentation # section is generated. This option has no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_MEMBERS = NO # If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all # undocumented classes that are normally visible in the class hierarchy. If set # to NO these classes will be included in the various overviews. This option has # no effect if EXTRACT_ALL is enabled. # The default value is: NO. HIDE_UNDOC_CLASSES = NO # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend # (class|struct|union) declarations. If set to NO these declarations will be # included in the documentation. # The default value is: NO. HIDE_FRIEND_COMPOUNDS = NO # If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any # documentation blocks found inside the body of a function. If set to NO these # blocks will be appended to the function's detailed documentation block. # The default value is: NO. HIDE_IN_BODY_DOCS = NO # The INTERNAL_DOCS tag determines if documentation that is typed after a # \internal command is included. If the tag is set to NO then the documentation # will be excluded. Set it to YES to include the internal documentation. # The default value is: NO. INTERNAL_DOCS = NO # If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file # names in lower-case letters. If set to YES upper-case letters are also # allowed. This is useful if you have classes or files whose names only differ # in case and if your file system supports case sensitive file names. Windows # and Mac users are advised to set this option to NO. # The default value is: system dependent. CASE_SENSE_NAMES = YES # If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with # their full class and namespace scopes in the documentation. If set to YES the # scope will be hidden. # The default value is: NO. HIDE_SCOPE_NAMES = NO # If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of # the files that are included by a file in the documentation of that file. # The default value is: YES. SHOW_INCLUDE_FILES = YES # If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each # grouped member an include statement to the documentation, telling the reader # which file to include in order to use the member. # The default value is: NO. SHOW_GROUPED_MEMB_INC = NO # If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include # files with double quotes in the documentation rather than with sharp brackets. # The default value is: NO. FORCE_LOCAL_INCLUDES = NO # If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the # documentation for inline members. # The default value is: YES. INLINE_INFO = YES # If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the # (detailed) documentation of file and class members alphabetically by member # name. If set to NO the members will appear in declaration order. # The default value is: YES. SORT_MEMBER_DOCS = YES # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief # descriptions of file, namespace and class members alphabetically by member # name. If set to NO the members will appear in declaration order. Note that # this will also influence the order of the classes in the class list. # The default value is: NO. SORT_BRIEF_DOCS = NO # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the # (brief and detailed) documentation of class members so that constructors and # destructors are listed first. If set to NO the constructors will appear in the # respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. # Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief # member documentation. # Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting # detailed member documentation. # The default value is: NO. SORT_MEMBERS_CTORS_1ST = NO # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy # of group names into alphabetical order. If set to NO the group names will # appear in their defined order. # The default value is: NO. SORT_GROUP_NAMES = NO # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by # fully-qualified names, including namespaces. If set to NO, the class list will # be sorted only by class name, not including the namespace part. # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. # Note: This option applies only to the class list, not to the alphabetical # list. # The default value is: NO. SORT_BY_SCOPE_NAME = NO # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper # type resolution of all parameters of a function it will reject a match between # the prototype and the implementation of a member function even if there is # only one candidate or it is obvious which candidate to choose by doing a # simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still # accept a match between prototype and implementation in such cases. # The default value is: NO. STRICT_PROTO_MATCHING = NO # The GENERATE_TODOLIST tag can be used to enable ( YES) or disable ( NO) the # todo list. This list is created by putting \todo commands in the # documentation. # The default value is: YES. GENERATE_TODOLIST = YES # The GENERATE_TESTLIST tag can be used to enable ( YES) or disable ( NO) the # test list. This list is created by putting \test commands in the # documentation. # The default value is: YES. GENERATE_TESTLIST = YES # The GENERATE_BUGLIST tag can be used to enable ( YES) or disable ( NO) the bug # list. This list is created by putting \bug commands in the documentation. # The default value is: YES. GENERATE_BUGLIST = YES # The GENERATE_DEPRECATEDLIST tag can be used to enable ( YES) or disable ( NO) # the deprecated list. This list is created by putting \deprecated commands in # the documentation. # The default value is: YES. GENERATE_DEPRECATEDLIST= YES # The ENABLED_SECTIONS tag can be used to enable conditional documentation # sections, marked by \if ... \endif and \cond # ... \endcond blocks. ENABLED_SECTIONS = # The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the # initial value of a variable or macro / define can have for it to appear in the # documentation. If the initializer consists of more lines than specified here # it will be hidden. Use a value of 0 to hide initializers completely. The # appearance of the value of individual variables and macros / defines can be # controlled using \showinitializer or \hideinitializer command in the # documentation regardless of this setting. # Minimum value: 0, maximum value: 10000, default value: 30. MAX_INITIALIZER_LINES = 30 # Set the SHOW_USED_FILES tag to NO to disable the list of files generated at # the bottom of the documentation of classes and structs. If set to YES the list # will mention the files that were used to generate the documentation. # The default value is: YES. SHOW_USED_FILES = YES # Set the SHOW_FILES tag to NO to disable the generation of the Files page. This # will remove the Files entry from the Quick Index and from the Folder Tree View # (if specified). # The default value is: YES. SHOW_FILES = YES # Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces # page. This will remove the Namespaces entry from the Quick Index and from the # Folder Tree View (if specified). # The default value is: YES. SHOW_NAMESPACES = YES # The FILE_VERSION_FILTER tag can be used to specify a program or script that # doxygen should invoke to get the current version for each file (typically from # the version control system). Doxygen will invoke the program by executing (via # popen()) the command command input-file, where command is the value of the # FILE_VERSION_FILTER tag, and input-file is the name of an input file provided # by doxygen. Whatever the program writes to standard output is used as the file # version. For an example see the documentation. FILE_VERSION_FILTER = # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed # by doxygen. The layout file controls the global structure of the generated # output files in an output format independent way. To create the layout file # that represents doxygen's defaults, run doxygen with the -l option. You can # optionally specify a file name after the option, if omitted DoxygenLayout.xml # will be used as the name of the layout file. # # Note that if you run doxygen from a directory containing a file called # DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE # tag is left empty. LAYOUT_FILE = # The CITE_BIB_FILES tag can be used to specify one or more bib files containing # the reference definitions. This must be a list of .bib files. The .bib # extension is automatically appended if omitted. This requires the bibtex tool # to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info. # For LaTeX the style of the bibliography can be controlled using # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the # search path. Do not use file names with spaces, bibtex cannot handle them. See # also \cite for info how to create references. CITE_BIB_FILES = #--------------------------------------------------------------------------- # Configuration options related to warning and progress messages #--------------------------------------------------------------------------- # The QUIET tag can be used to turn on/off the messages that are generated to # standard output by doxygen. If QUIET is set to YES this implies that the # messages are off. # The default value is: NO. QUIET = YES # The WARNINGS tag can be used to turn on/off the warning messages that are # generated to standard error ( stderr) by doxygen. If WARNINGS is set to YES # this implies that the warnings are on. # # Tip: Turn warnings on while writing the documentation. # The default value is: YES. WARNINGS = YES # If the WARN_IF_UNDOCUMENTED tag is set to YES, then doxygen will generate # warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag # will automatically be disabled. # The default value is: YES. WARN_IF_UNDOCUMENTED = YES # If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for # potential errors in the documentation, such as not documenting some parameters # in a documented function, or documenting parameters that don't exist or using # markup commands wrongly. # The default value is: YES. WARN_IF_DOC_ERROR = YES # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that # are documented, but have no documentation for their parameters or return # value. If set to NO doxygen will only warn about wrong or incomplete parameter # documentation, but not about the absence of documentation. # The default value is: NO. WARN_NO_PARAMDOC = NO # The WARN_FORMAT tag determines the format of the warning messages that doxygen # can produce. The string should contain the $file, $line, and $text tags, which # will be replaced by the file and line number from which the warning originated # and the warning text. Optionally the format may contain $version, which will # be replaced by the version of the file (if it could be obtained via # FILE_VERSION_FILTER) # The default value is: $file:$line: $text. WARN_FORMAT = "$file:$line: $text" # The WARN_LOGFILE tag can be used to specify a file to which warning and error # messages should be written. If left blank the output is written to standard # error (stderr). WARN_LOGFILE = #--------------------------------------------------------------------------- # Configuration options related to the input files #--------------------------------------------------------------------------- # The INPUT tag is used to specify the files and/or directories that contain # documented source files. You may enter file names like myfile.cpp or # directories like /usr/src/myproject. Separate the files or directories with # spaces. # Note: If this tag is empty the current directory is searched. INPUT = @PROJECT_SOURCE_DIR@/include/osmium \ @PROJECT_SOURCE_DIR@/doc/doc.md # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses # libiconv (or the iconv built into libc) for the transcoding. See the libiconv # documentation (see: http://www.gnu.org/software/libiconv) for the list of # possible encodings. # The default value is: UTF-8. INPUT_ENCODING = UTF-8 # If the value of the INPUT tag contains directories, you can use the # FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank the # following patterns are tested:*.c, *.cc, *.cxx, *.cpp, *.c++, *.java, *.ii, # *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, *.hh, *.hxx, *.hpp, # *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, *.m, *.markdown, # *.md, *.mm, *.dox, *.py, *.f90, *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, # *.qsf, *.as and *.js. FILE_PATTERNS = *.hpp # The RECURSIVE tag can be used to specify whether or not subdirectories should # be searched for input files as well. # The default value is: NO. RECURSIVE = YES # The EXCLUDE tag can be used to specify files and/or directories that should be # excluded from the INPUT source files. This way you can easily exclude a # subdirectory from a directory tree whose root is specified with the INPUT tag. # # Note that relative paths are relative to the directory from which doxygen is # run. EXCLUDE = # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or # directories that are symbolic links (a Unix file system feature) are excluded # from the input. # The default value is: NO. EXCLUDE_SYMLINKS = NO # If the value of the INPUT tag contains directories, you can use the # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude # certain files from those directories. # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories for example use the pattern */test/* EXCLUDE_PATTERNS = detail # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names # (namespaces, classes, functions, etc.) that should be excluded from the # output. The symbol name can be a fully qualified name, a word, or if the # wildcard * is used, a substring. Examples: ANamespace, AClass, # AClass::ANamespace, ANamespace::*Test # # Note that the wildcards are matched against the file with absolute path, so to # exclude all test directories use the pattern */test/* EXCLUDE_SYMBOLS = *::detail # The EXAMPLE_PATH tag can be used to specify one or more files or directories # that contain example code fragments that are included (see the \include # command). EXAMPLE_PATH = # If the value of the EXAMPLE_PATH tag contains directories, you can use the # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and # *.h) to filter out the source-files in the directories. If left blank all # files are included. EXAMPLE_PATTERNS = # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be # searched for input files to be used with the \include or \dontinclude commands # irrespective of the value of the RECURSIVE tag. # The default value is: NO. EXAMPLE_RECURSIVE = NO # The IMAGE_PATH tag can be used to specify one or more files or directories # that contain images that are to be included in the documentation (see the # \image command). IMAGE_PATH = # The INPUT_FILTER tag can be used to specify a program that doxygen should # invoke to filter for each input file. Doxygen will invoke the filter program # by executing (via popen()) the command: # # # # where is the value of the INPUT_FILTER tag, and is the # name of an input file. Doxygen will then use the output that the filter # program writes to standard output. If FILTER_PATTERNS is specified, this tag # will be ignored. # # Note that the filter must not add or remove lines; it is applied before the # code is scanned, but not when the output code is generated. If lines are added # or removed, the anchors will not be placed correctly. INPUT_FILTER = "grep -v static_assert" # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern # basis. Doxygen will compare the file name with each pattern and apply the # filter if there is a match. The filters are a list of the form: pattern=filter # (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how # filters are used. If the FILTER_PATTERNS tag is empty or if none of the # patterns match the file name, INPUT_FILTER is applied. FILTER_PATTERNS = # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using # INPUT_FILTER ) will also be used to filter the input files that are used for # producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). # The default value is: NO. FILTER_SOURCE_FILES = YES # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file # pattern. A pattern will override the setting for FILTER_PATTERN (if any) and # it is also possible to disable source filtering for a specific pattern using # *.ext= (so without naming a filter). # This tag requires that the tag FILTER_SOURCE_FILES is set to YES. FILTER_SOURCE_PATTERNS = # If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that # is part of the input, its contents will be placed on the main page # (index.html). This can be useful if you have a project on for instance GitHub # and want to reuse the introduction page also for the doxygen output. USE_MDFILE_AS_MAINPAGE = @PROJECT_SOURCE_DIR@/doc/doc.md #--------------------------------------------------------------------------- # Configuration options related to source browsing #--------------------------------------------------------------------------- # If the SOURCE_BROWSER tag is set to YES then a list of source files will be # generated. Documented entities will be cross-referenced with these sources. # # Note: To get rid of all source code in the generated output, make sure that # also VERBATIM_HEADERS is set to NO. # The default value is: NO. SOURCE_BROWSER = NO # Setting the INLINE_SOURCES tag to YES will include the body of functions, # classes and enums directly into the documentation. # The default value is: NO. INLINE_SOURCES = NO # Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any # special comment blocks from generated source code fragments. Normal C, C++ and # Fortran comments will always remain visible. # The default value is: YES. STRIP_CODE_COMMENTS = YES # If the REFERENCED_BY_RELATION tag is set to YES then for each documented # function all documented functions referencing it will be listed. # The default value is: NO. REFERENCED_BY_RELATION = NO # If the REFERENCES_RELATION tag is set to YES then for each documented function # all documented entities called/used by that function will be listed. # The default value is: NO. REFERENCES_RELATION = NO # If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set # to YES, then the hyperlinks from functions in REFERENCES_RELATION and # REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will # link to the documentation. # The default value is: YES. REFERENCES_LINK_SOURCE = YES # If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the # source code will show a tooltip with additional information such as prototype, # brief description and links to the definition and documentation. Since this # will make the HTML file larger and loading of large files a bit slower, you # can opt to disable this feature. # The default value is: YES. # This tag requires that the tag SOURCE_BROWSER is set to YES. SOURCE_TOOLTIPS = YES # If the USE_HTAGS tag is set to YES then the references to source code will # point to the HTML generated by the htags(1) tool instead of doxygen built-in # source browser. The htags tool is part of GNU's global source tagging system # (see http://www.gnu.org/software/global/global.html). You will need version # 4.8.6 or higher. # # To use it do the following: # - Install the latest version of global # - Enable SOURCE_BROWSER and USE_HTAGS in the config file # - Make sure the INPUT points to the root of the source tree # - Run doxygen as normal # # Doxygen will invoke htags (and that will in turn invoke gtags), so these # tools must be available from the command line (i.e. in the search path). # # The result: instead of the source browser generated by doxygen, the links to # source code will now point to the output of htags. # The default value is: NO. # This tag requires that the tag SOURCE_BROWSER is set to YES. USE_HTAGS = NO # If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a # verbatim copy of the header file for each class for which an include is # specified. Set to NO to disable this. # See also: Section \class. # The default value is: YES. VERBATIM_HEADERS = YES #--------------------------------------------------------------------------- # Configuration options related to the alphabetical class index #--------------------------------------------------------------------------- # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all # compounds will be generated. Enable this if the project contains a lot of # classes, structs, unions or interfaces. # The default value is: YES. ALPHABETICAL_INDEX = NO # The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in # which the alphabetical index list will be split. # Minimum value: 1, maximum value: 20, default value: 5. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. COLS_IN_ALPHA_INDEX = 5 # In case all classes in a project start with a common prefix, all classes will # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag # can be used to specify a prefix (or a list of prefixes) that should be ignored # while generating the index headers. # This tag requires that the tag ALPHABETICAL_INDEX is set to YES. IGNORE_PREFIX = #--------------------------------------------------------------------------- # Configuration options related to the HTML output #--------------------------------------------------------------------------- # If the GENERATE_HTML tag is set to YES doxygen will generate HTML output # The default value is: YES. GENERATE_HTML = YES # The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a # relative path is entered the value of OUTPUT_DIRECTORY will be put in front of # it. # The default directory is: html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_OUTPUT = html # The HTML_FILE_EXTENSION tag can be used to specify the file extension for each # generated HTML page (for example: .htm, .php, .asp). # The default value is: .html. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FILE_EXTENSION = .html # The HTML_HEADER tag can be used to specify a user-defined HTML header file for # each generated HTML page. If the tag is left blank doxygen will generate a # standard header. # # To get valid HTML the header file that includes any scripts and style sheets # that doxygen needs, which is dependent on the configuration options used (e.g. # the setting GENERATE_TREEVIEW). It is highly recommended to start with a # default header using # doxygen -w html new_header.html new_footer.html new_stylesheet.css # YourConfigFile # and then modify the file new_header.html. See also section "Doxygen usage" # for information on how to generate the default header that doxygen normally # uses. # Note: The header is subject to change so you typically have to regenerate the # default header when upgrading to a newer version of doxygen. For a description # of the possible markers and block names see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_HEADER = header.html # The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each # generated HTML page. If the tag is left blank doxygen will generate a standard # footer. See HTML_HEADER for more information on how to generate a default # footer and what special commands can be used inside the footer. See also # section "Doxygen usage" for information on how to generate the default footer # that doxygen normally uses. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_FOOTER = # The HTML_STYLESHEET tag can be used to specify a user-defined cascading style # sheet that is used by each HTML page. It can be used to fine-tune the look of # the HTML output. If left blank doxygen will generate a default style sheet. # See also section "Doxygen usage" for information on how to generate the style # sheet that doxygen normally uses. # Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as # it is more robust and this tag (HTML_STYLESHEET) will in the future become # obsolete. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_STYLESHEET = # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional user- # defined cascading style sheet that is included after the standard style sheets # created by doxygen. Using this option one can overrule certain style aspects. # This is preferred over using HTML_STYLESHEET since it does not replace the # standard style sheet and is therefor more robust against future updates. # Doxygen will copy the style sheet file to the output directory. For an example # see the documentation. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_STYLESHEET = "@PROJECT_SOURCE_DIR@/doc/osmium.css" # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or # other source files which should be copied to the HTML output directory. Note # that these files will be copied to the base HTML output directory. Use the # $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these # files. In the HTML_STYLESHEET file, use the file name only. Also note that the # files will be copied as-is; there are no commands or markers available. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_EXTRA_FILES = # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen # will adjust the colors in the stylesheet and background images according to # this color. Hue is specified as an angle on a colorwheel, see # http://en.wikipedia.org/wiki/Hue for more information. For instance the value # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 # purple, and 360 is red again. # Minimum value: 0, maximum value: 359, default value: 220. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_HUE = 220 # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors # in the HTML output. For a value of 0 the output will use grayscales only. A # value of 255 will produce the most vivid colors. # Minimum value: 0, maximum value: 255, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_SAT = 100 # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the # luminance component of the colors in the HTML output. Values below 100 # gradually make the output lighter, whereas values above 100 make the output # darker. The value divided by 100 is the actual gamma applied, so 80 represents # a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not # change the gamma. # Minimum value: 40, maximum value: 240, default value: 80. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_COLORSTYLE_GAMMA = 80 # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML # page will contain the date and time when the page was generated. Setting this # to NO can help when comparing the output of multiple runs. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_TIMESTAMP = NO # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML # documentation will contain sections that can be hidden and shown after the # page has loaded. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_DYNAMIC_SECTIONS = NO # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries # shown in the various tree structured indices initially; the user can expand # and collapse entries dynamically later on. Doxygen will expand the tree to # such a level that at most the specified number of entries are visible (unless # a fully collapsed tree already exceeds this amount). So setting the number of # entries 1 will produce a full collapsed tree by default. 0 is a special value # representing an infinite number of entries and will result in a full expanded # tree by default. # Minimum value: 0, maximum value: 9999, default value: 100. # This tag requires that the tag GENERATE_HTML is set to YES. HTML_INDEX_NUM_ENTRIES = 100 # If the GENERATE_DOCSET tag is set to YES, additional index files will be # generated that can be used as input for Apple's Xcode 3 integrated development # environment (see: http://developer.apple.com/tools/xcode/), introduced with # OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a # Makefile in the HTML output directory. Running make will produce the docset in # that directory and running make install will install the docset in # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at # startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html # for more information. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_DOCSET = NO # This tag determines the name of the docset feed. A documentation feed provides # an umbrella under which multiple documentation sets from a single provider # (such as a company or product suite) can be grouped. # The default value is: Doxygen generated docs. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_FEEDNAME = "Doxygen generated docs" # This tag specifies a string that should uniquely identify the documentation # set bundle. This should be a reverse domain-name style string, e.g. # com.mycompany.MyDocSet. Doxygen will append .docset to the name. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_BUNDLE_ID = org.doxygen.Project # The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify # the documentation publisher. This should be a reverse domain-name style # string, e.g. com.mycompany.MyDocSet.documentation. # The default value is: org.doxygen.Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_ID = org.doxygen.Publisher # The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. # The default value is: Publisher. # This tag requires that the tag GENERATE_DOCSET is set to YES. DOCSET_PUBLISHER_NAME = Publisher # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three # additional HTML index files: index.hhp, index.hhc, and index.hhk. The # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop # (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on # Windows. # # The HTML Help Workshop contains a compiler that can convert all HTML output # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML # files are now used as the Windows 98 help format, and will replace the old # Windows help format (.hlp) on all Windows platforms in the future. Compressed # HTML files also contain an index, a table of contents, and you can search for # words in the documentation. The HTML workshop also contains a viewer for # compressed HTML files. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_HTMLHELP = NO # The CHM_FILE tag can be used to specify the file name of the resulting .chm # file. You can add a path in front of the file if the result should not be # written to the html output directory. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_FILE = # The HHC_LOCATION tag can be used to specify the location (absolute path # including file name) of the HTML help compiler ( hhc.exe). If non-empty # doxygen will try to run the HTML help compiler on the generated index.hhp. # The file has to be specified with full path. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. HHC_LOCATION = # The GENERATE_CHI flag controls if a separate .chi index file is generated ( # YES) or that it should be included in the master .chm file ( NO). # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. GENERATE_CHI = NO # The CHM_INDEX_ENCODING is used to encode HtmlHelp index ( hhk), content ( hhc) # and project file content. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. CHM_INDEX_ENCODING = # The BINARY_TOC flag controls whether a binary table of contents is generated ( # YES) or a normal table of contents ( NO) in the .chm file. Furthermore it # enables the Previous and Next buttons. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. BINARY_TOC = NO # The TOC_EXPAND flag can be set to YES to add extra items for group members to # the table of contents of the HTML help documentation and to the tree view. # The default value is: NO. # This tag requires that the tag GENERATE_HTMLHELP is set to YES. TOC_EXPAND = NO # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that # can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help # (.qch) of the generated HTML documentation. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_QHP = NO # If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify # the file name of the resulting .qch file. The path specified is relative to # the HTML output folder. # This tag requires that the tag GENERATE_QHP is set to YES. QCH_FILE = # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help # Project output. For more information please see Qt Help Project / Namespace # (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace). # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_NAMESPACE = # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt # Help Project output. For more information please see Qt Help Project / Virtual # Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual- # folders). # The default value is: doc. # This tag requires that the tag GENERATE_QHP is set to YES. QHP_VIRTUAL_FOLDER = doc # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom # filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_NAME = # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the # custom filter to add. For more information please see Qt Help Project / Custom # Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom- # filters). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_CUST_FILTER_ATTRS = # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this # project's filter section matches. Qt Help Project / Filter Attributes (see: # http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes). # This tag requires that the tag GENERATE_QHP is set to YES. QHP_SECT_FILTER_ATTRS = # The QHG_LOCATION tag can be used to specify the location of Qt's # qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the # generated .qhp file. # This tag requires that the tag GENERATE_QHP is set to YES. QHG_LOCATION = # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be # generated, together with the HTML files, they form an Eclipse help plugin. To # install this plugin and make it available under the help contents menu in # Eclipse, the contents of the directory containing the HTML and XML files needs # to be copied into the plugins directory of eclipse. The name of the directory # within the plugins directory should be the same as the ECLIPSE_DOC_ID value. # After copying Eclipse needs to be restarted before the help appears. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_ECLIPSEHELP = NO # A unique identifier for the Eclipse help plugin. When installing the plugin # the directory name containing the HTML and XML files should also have this # name. Each documentation set should have its own identifier. # The default value is: org.doxygen.Project. # This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. ECLIPSE_DOC_ID = org.doxygen.Project # If you want full control over the layout of the generated HTML pages it might # be necessary to disable the index and replace it with your own. The # DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top # of each HTML page. A value of NO enables the index and the value YES disables # it. Since the tabs in the index contain the same information as the navigation # tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. DISABLE_INDEX = NO # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index # structure should be generated to display hierarchical information. If the tag # value is set to YES, a side panel will be generated containing a tree-like # index structure (just like the one that is generated for HTML Help). For this # to work a browser that supports JavaScript, DHTML, CSS and frames is required # (i.e. any modern browser). Windows users are probably better off using the # HTML help feature. Via custom stylesheets (see HTML_EXTRA_STYLESHEET) one can # further fine-tune the look of the index. As an example, the default style # sheet generated by doxygen has an example that shows how to put an image at # the root of the tree instead of the PROJECT_NAME. Since the tree basically has # the same information as the tab index, you could consider setting # DISABLE_INDEX to YES when enabling this option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. GENERATE_TREEVIEW = NONE # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that # doxygen will group on one line in the generated HTML documentation. # # Note that a value of 0 will completely suppress the enum values from appearing # in the overview section. # Minimum value: 0, maximum value: 20, default value: 4. # This tag requires that the tag GENERATE_HTML is set to YES. ENUM_VALUES_PER_LINE = 4 # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used # to set the initial width (in pixels) of the frame in which the tree is shown. # Minimum value: 0, maximum value: 1500, default value: 250. # This tag requires that the tag GENERATE_HTML is set to YES. TREEVIEW_WIDTH = 250 # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open links to # external symbols imported via tag files in a separate window. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. EXT_LINKS_IN_WINDOW = NO # Use this tag to change the font size of LaTeX formulas included as images in # the HTML documentation. When you change the font size after a successful # doxygen run you need to manually remove any form_*.png images from the HTML # output directory to force them to be regenerated. # Minimum value: 8, maximum value: 50, default value: 10. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_FONTSIZE = 10 # Use the FORMULA_TRANPARENT tag to determine whether or not the images # generated for formulas are transparent PNGs. Transparent PNGs are not # supported properly for IE 6.0, but are supported on all modern browsers. # # Note that when changing this option you need to delete any form_*.png files in # the HTML output directory before the changes have effect. # The default value is: YES. # This tag requires that the tag GENERATE_HTML is set to YES. FORMULA_TRANSPARENT = YES # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see # http://www.mathjax.org) which uses client side Javascript for the rendering # instead of using prerendered bitmaps. Use this if you do not have LaTeX # installed or if you want to formulas look prettier in the HTML output. When # enabled you may also need to install MathJax separately and configure the path # to it using the MATHJAX_RELPATH option. # The default value is: NO. # This tag requires that the tag GENERATE_HTML is set to YES. USE_MATHJAX = NO # When MathJax is enabled you can set the default output format to be used for # the MathJax output. See the MathJax site (see: # http://docs.mathjax.org/en/latest/output.html) for more details. # Possible values are: HTML-CSS (which is slower, but has the best # compatibility), NativeMML (i.e. MathML) and SVG. # The default value is: HTML-CSS. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_FORMAT = HTML-CSS # When MathJax is enabled you need to specify the location relative to the HTML # output directory using the MATHJAX_RELPATH option. The destination directory # should contain the MathJax.js script. For instance, if the mathjax directory # is located at the same level as the HTML output directory, then # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax # Content Delivery Network so you can quickly see the result without installing # MathJax. However, it is strongly recommended to install a local copy of # MathJax from http://www.mathjax.org before deployment. # The default value is: http://cdn.mathjax.org/mathjax/latest. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_RELPATH = http://cdn.mathjax.org/mathjax/latest # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax # extension names that should be enabled during MathJax rendering. For example # MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_EXTENSIONS = # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces # of code that will be used on startup of the MathJax code. See the MathJax site # (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an # example see the documentation. # This tag requires that the tag USE_MATHJAX is set to YES. MATHJAX_CODEFILE = # When the SEARCHENGINE tag is enabled doxygen will generate a search box for # the HTML output. The underlying search engine uses javascript and DHTML and # should work on any modern browser. Note that when using HTML help # (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) # there is already a search function so this one should typically be disabled. # For large projects the javascript based search engine can be slow, then # enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to # search using the keyboard; to jump to the search box use + S # (what the is depends on the OS and browser, but it is typically # , /