pax_global_header00006660000000000000000000000064130575266300014521gustar00rootroot0000000000000052 comment=b86bafefec5fa7754c0a1da45fea329ec8167c06 libosmium-2.11.1/000077500000000000000000000000001305752663000136035ustar00rootroot00000000000000libosmium-2.11.1/.gitignore000066400000000000000000000000611305752663000155700ustar00rootroot00000000000000*.swp .ycm_extra_conf.pyc /build /libosmium-deps libosmium-2.11.1/.travis.yml000066400000000000000000000152611305752663000157210ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # Configuration for continuous integration service at travis-ci.org # #----------------------------------------------------------------------------- language: generic sudo: false cache: directories: - $HOME/.ccache env: global: - CCACHE_TEMPDIR=/tmp/.ccache-temp - CCACHE_COMPRESS=1 - CASHER_TIME_OUT=1000 matrix: include: # 1/ Linux Clang Builds - os: linux compiler: linux-clang35-release addons: apt: sources: ['llvm-toolchain-precise-3.5', 'ubuntu-toolchain-r-test', 'boost-latest'] packages: ['clang-3.5', 'cmake', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='clang++-3.5' BUILD_TYPE='Release' - os: linux compiler: linux-clang35-dev addons: apt: sources: ['llvm-toolchain-precise-3.5', 'ubuntu-toolchain-r-test', 'boost-latest'] packages: ['clang-3.5', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='clang++-3.5' BUILD_TYPE='Dev' - os: linux compiler: linux-clang37-release addons: apt: sources: ['llvm-toolchain-precise-3.7', 'ubuntu-toolchain-r-test', 'boost-latest'] packages: ['clang-3.7', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='clang++-3.7' BUILD_TYPE='Release' - os: linux compiler: linux-clang37-dev addons: apt: sources: ['llvm-toolchain-precise-3.7', 'ubuntu-toolchain-r-test', 'boost-latest'] packages: ['clang-3.7', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='clang++-3.7' BUILD_TYPE='Dev' - os: linux compiler: linux-clang38-release addons: apt: sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test', 'boost-latest'] packages: ['clang-3.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='clang++-3.8' BUILD_TYPE='Release' - os: linux compiler: linux-clang38-dev addons: apt: sources: ['llvm-toolchain-precise-3.8', 'ubuntu-toolchain-r-test', 'boost-latest'] packages: ['clang-3.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='clang++-3.8' BUILD_TYPE='Dev' # 2/ Linux GCC Builds - os: linux compiler: linux-gcc48-release addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-4.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-4.8' COMPILER_FLAGS='-Wno-return-type' BUILD_TYPE='Release' - os: linux compiler: linux-gcc48-dev addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-4.8', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-4.8' COMPILER_FLAGS='-Wno-return-type' BUILD_TYPE='Dev' - os: linux compiler: linux-gcc49-release addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-4.9', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-4.9' BUILD_TYPE='Release' - os: linux compiler: linux-gcc49-dev addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-4.9', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-4.9' BUILD_TYPE='Dev' - os: linux compiler: linux-gcc5-release addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-5', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-5' BUILD_TYPE='Release' - os: linux compiler: linux-gcc5-dev addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-5', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-5' BUILD_TYPE='Dev' - os: linux compiler: linux-gcc6-release addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-6', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-6' BUILD_TYPE='Release' - os: linux compiler: linux-gcc6-dev addons: apt: sources: ['ubuntu-toolchain-r-test', 'boost-latest'] packages: ['g++-6', 'libboost1.55-all-dev', 'libgdal-dev', 'libgeos++-dev', 'libproj-dev', 'libsparsehash-dev', 'spatialite-bin'] env: COMPILER='g++-6' BUILD_TYPE='Dev' # 3/ OSX Clang Builds - os: osx osx_image: xcode6.4 compiler: xcode64-clang-release env: COMPILER='clang++' BUILD_TYPE='Release' - os: osx osx_image: xcode6.4 compiler: xcode64-clang-dev env: COMPILER='clang++' BUILD_TYPE='Dev' - os: osx osx_image: xcode7 compiler: xcode7-clang-release env: COMPILER='clang++' BUILD_TYPE='Release' - os: osx osx_image: xcode7 compiler: xcode7-clang-dev env: COMPILER='clang++' BUILD_TYPE='Dev' - os: osx osx_image: xcode8 compiler: xcode8-clang-release env: COMPILER='clang++' BUILD_TYPE='Release' - os: osx osx_image: xcode8 compiler: xcode8-clang-dev env: COMPILER='clang++' BUILD_TYPE='Dev' install: - DEPS_DIR="${TRAVIS_BUILD_DIR}/deps" - mkdir -p ${DEPS_DIR} && cd ${DEPS_DIR} - git clone --quiet --depth 1 https://github.com/osmcode/osm-testdata.git - | if [[ "${TRAVIS_OS_NAME}" == "osx" ]]; then brew remove gdal brew install cmake boost google-sparsehash gdal || true fi - cmake --version before_script: - cd ${TRAVIS_BUILD_DIR} - mkdir build && cd build - CXX=${COMPILER} CXXFLAGS=${COMPILER_FLAGS} cmake -LA .. -DCMAKE_BUILD_TYPE=${BUILD_TYPE} -DBUILD_WITH_CCACHE=1 -DOSM_TESTDATA="${TRAVIS_BUILD_DIR}/deps/osm-testdata" script: - make VERBOSE=1 && ctest --output-on-failure libosmium-2.11.1/.ycm_extra_conf.py000066400000000000000000000023451305752663000172370ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # Configuration for YouCompleteMe Vim plugin # # http://valloric.github.io/YouCompleteMe/ # #----------------------------------------------------------------------------- from os.path import realpath, dirname basedir = dirname(realpath(__file__)) # some default flags # for more information install clang-3.2-doc package and # check UsersManual.html flags = [ '-Werror', '-Wall', '-Wextra', '-pedantic', '-Wno-return-type', '-Wno-unused-parameter', '-Wno-unused-variable', '-std=c++11', # '-x' and 'c++' also required # use 'c' for C projects '-x', 'c++', # workaround for https://github.com/Valloric/YouCompleteMe/issues/303 # also see https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=800618 '-isystem', '/usr/lib/ycmd/clang_includes/', # libosmium include dirs '-I%s/include' % basedir, '-I%s/test/include' % basedir, '-I%s/test/data-test/include' % basedir, # include third party libraries '-I/usr/include/gdal', ] # youcompleteme is calling this function to get flags # You can also set database for flags. Check: JSONCompilationDatabase.html in # clang-3.2-doc package def FlagsForFile( filename ): return { 'flags': flags, 'do_cache': True } libosmium-2.11.1/CHANGELOG.md000066400000000000000000000474371305752663000154330ustar00rootroot00000000000000 # Change Log All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/). ## [unreleased] - ### Fixed ## [2.11.1] - 2017-03-07 ### 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.) - The `Filter::count()` method didn't compile at all. ## [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.11.1...HEAD [2.11.1]: https://github.com/osmcode/libosmium/compare/v2.11.0...v2.11.1 [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.11.1/CMakeLists.txt000066400000000000000000000410541305752663000163470ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # CMake Config # # Libosmium # #----------------------------------------------------------------------------- cmake_minimum_required(VERSION 2.8 FATAL_ERROR) list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") #----------------------------------------------------------------------------- # # Project version # #----------------------------------------------------------------------------- set(CMAKE_CONFIGURATION_TYPES "Debug;Release;RelWithDebInfo;MinSizeRel;Dev;Coverage" CACHE STRING "List of available configuration types" FORCE) project(libosmium) set(LIBOSMIUM_VERSION_MAJOR 2) set(LIBOSMIUM_VERSION_MINOR 11) set(LIBOSMIUM_VERSION_PATCH 1) 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) else() set(dev_build OFF) 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" ${dev_build}) option(INSTALL_GDALCPP "also install gdalcpp headers" OFF) option(INSTALL_PROTOZERO "also install protozero headers" OFF) option(INSTALL_UTFCPP "also install utfcpp 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 # #----------------------------------------------------------------------------- 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() 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.") if(CMAKE_BUILD_TYPE STREQUAL "Coverage") if(BUILD_EXAMPLES OR BUILD_HEADERS OR BUILD_BENCHMARKS OR BUILD_DATA_TESTS) message(WARNING "Coverage builds don't work for anything but the unit 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 io gdal geos proj sparsehash) # 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}) if(MSVC) find_path(GETOPT_INCLUDE_DIR getopt.h) find_library(GETOPT_LIBRARY NAMES wingetopt) if(GETOPT_INCLUDE_DIR AND GETOPT_LIBRARY) include_directories(SYSTEM ${GETOPT_INCLUDE_DIR}) list(APPEND OSMIUM_LIBRARIES ${GETOPT_LIBRARY}) else() set(GETOPT_MISSING 1) endif() endif() #----------------------------------------------------------------------------- # # Decide which C++ version to use (Minimum/default: C++11). # #----------------------------------------------------------------------------- if(NOT MSVC) if(NOT USE_CPP_VERSION) set(USE_CPP_VERSION c++11) 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(USUAL_COMPILE_OPTIONS "/Ox") set(USUAL_LINK_OPTIONS "/debug") else() set(USUAL_COMPILE_OPTIONS "-O3 -g") set(USUAL_LINK_OPTIONS "") endif() if(WIN32) add_definitions(-DWIN32 -D_WIN32 -DMSWIN32 -DBGDWIN32 -DWINVER=0x0500 -D_WIN32_WINNT=0x0500 -D_WIN32_IE=0x0600) endif() set(CMAKE_CXX_FLAGS_DEV "${USUAL_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 "${USUAL_COMPILE_OPTIONS}" CACHE STRING "Flags used by the compiler during RELWITHDEBINFO builds." FORCE) 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 --enable=warning,style,performance,portability,information,missingInclude --force -Uassert) # cpp doesn't find system includes for some reason, suppress that report set(CPPCHECK_OPTIONS ${CPPCHECK_OPTIONS} --suppress=missingIncludeSystem) 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++11 ${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}) 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} "#include <${hpp}>\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}) endforeach() endif() #----------------------------------------------------------------------------- # # Optional "clang-tidy" target # #----------------------------------------------------------------------------- message(STATUS "Looking for clang-tidy") find_program(CLANG_TIDY NAMES clang-tidy clang-tidy-3.9 clang-tidy-3.8 clang-tidy-3.7 clang-tidy-3.6 clang-tidy-3.5) if(CLANG_TIDY) message(STATUS "Looking for clang-tidy - found") 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}) # For a list of check options, see: # http://clang.llvm.org/extra/clang-tidy/checks/list.html list(APPEND CT_CHECKS "cert-*" "-cert-err60-cpp") # even the std lib doesn't do this # disabled, because it is slow # list(APPEND CT_CHECKS "clang-analyzer-*") list(APPEND CT_CHECKS "google-*" "-google-explicit-constructor" "-google-readability-casting" "-google-readability-function") list(APPEND CT_CHECKS "llvm-*" "-llvm-include-order") list(APPEND CT_CHECKS "misc-*" "-misc-argument-comment") list(APPEND CT_CHECKS "modernize-*") list(APPEND CT_CHECKS "readability-*" "-readability-identifier-naming" "-readability-named-parameter") string(REPLACE ";" "," ALL_CHECKS "${CT_CHECKS}") add_custom_target(clang-tidy ${CLANG_TIDY} -p ${CMAKE_BINARY_DIR} -header-filter='include/osmium/.*' -checks="${ALL_CHECKS}" ${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() if(INSTALL_PROTOZERO) install(DIRECTORY include/protozero DESTINATION include) endif() if(INSTALL_UTFCPP) install(FILES include/utf8.h DESTINATION include) install(DIRECTORY include/utf8 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("You can get it from https://github.com/osmcode/osm-testdata") message("Clone it into the same directory libosmium is in") message("or set the OSM_TESTDATA cmake variable to its path.") message("=============================================================\n") endif() #----------------------------------------------------------------------------- libosmium-2.11.1/CONTRIBUTING.md000066400000000000000000000010501305752663000160300ustar00rootroot00000000000000 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. libosmium-2.11.1/EXTERNAL_LICENSES.txt000066400000000000000000000312001305752663000170470ustar00rootroot00000000000000 ==== For protozero from https://github.com/mapbox/protozero protozero copyright (c) Mapbox. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ==== For protozero from https://github.com/mapbox/protozero Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS ==== For utf8.h Copyright 2006 Nemanja Trifunovic 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.11.1/LICENSE.txt000066400000000000000000000024721305752663000154330ustar00rootroot00000000000000Boost 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.11.1/NOTES_FOR_DEVELOPERS.md000066400000000000000000000133461305752663000172620ustar00rootroot00000000000000 # 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. 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 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, OSX, and Windows. Execptions are allowed for some minor functionality, but please discuss this first. ## 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 a unit tests using the Catch Unit Test Framework in the `test` directory and some data tests in `test/osm-testdata`. They are built by the default cmake config. Run `ctest` to run them. Many more tests are needed. ## 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.11.1/README.md000066400000000000000000000051651305752663000150710ustar00rootroot00000000000000# Libosmium http://osmcode.org/libosmium A fast and flexible C++ library for working with OpenStreetMap data. Libosmium works on Linux, Mac OSX and Windows. [![Build Status](https://secure.travis-ci.org/osmcode/libosmium.svg)](https://travis-ci.org/osmcode/libosmium) [![Build status](https://ci.appveyor.com/api/projects/status/github/osmcode/libosmium?svg=true)](https://ci.appveyor.com/project/Mapbox/libosmium) Please see the [Libosmium manual](http://osmcode.org/libosmium/manual.html) for more details than this README can provide. ## Prerequisites Because Libosmium uses many C++11 features you need a modern compiler and standard C++ library. Osmium needs at least GCC 4.8 or clang (LLVM) 3.4. (Some parts may work with older versions.) 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](http://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) * [protozero](https://github.com/mapbox/protozero) * [utfcpp](http://utfcpp.sourceforge.net/) ## 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 detals see the [Building Libosmium](http://osmcode.org/libosmium/manual.html#building-libosmium) chapter in the manual. ## Testing See the [Libosmium Manual](http://osmcode.org/libosmium/manual.html#running-tests) for instructions. ## Switching from the old Osmium If you have been using the old version of Osmium at https://github.com/joto/osmium you might want to read about the [changes needed](http://osmcode.org/libosmium/manual.html#changes-from-old-versions-of-osmium). ## License Libosmium is available under the Boost Software License. See LICENSE.txt. ## Authors Libosmium was mainly written and is maintained by Jochen Topf (jochen@topf.org). See the git commit log for other authors. libosmium-2.11.1/appveyor.yml000066400000000000000000000010611305752663000161710ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # Configuration for continuous integration service at appveyor.com # #----------------------------------------------------------------------------- environment: matrix: - config: Dev - config: RelWithDebInfo shallow_clone: true # Operating system (build VM template) os: Visual Studio 2015 # scripts that are called at very beginning, before repo cloning init: # clone directory clone_folder: c:\projects\libosmium platform: x64 build_script: - build-appveyor.bat libosmium-2.11.1/benchmarks/000077500000000000000000000000001305752663000157205ustar00rootroot00000000000000libosmium-2.11.1/benchmarks/CMakeLists.txt000066400000000000000000000031311305752663000204560ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # 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}}) 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.11.1/benchmarks/README.md000066400000000000000000000027041305752663000172020ustar00rootroot00000000000000 # 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.11.1/benchmarks/download_data.sh000077500000000000000000000013001305752663000210510ustar00rootroot00000000000000#!/bin/sh # # download_data.sh # cd $DATA_DIR curl --location --output 1_liechtenstein.osm.pbf http://download.geofabrik.de/europe/liechtenstein-latest.osm.pbf # about 2 MB curl --location --output 2_bremen.osm.pbf http://download.geofabrik.de/europe/germany/bremen-latest.osm.pbf # about 16 MB curl --location --output 3_sachsen.osm.pbf http://download.geofabrik.de/europe/germany/sachsen-latest.osm.pbf # about 160 MB curl --location --output 4_germany.osm.pbf http://download.geofabrik.de/europe/germany-latest.osm.pbf # about 3 GB curl --location --output 5_planet.osm.pbf http://planet.osm.org/pbf/planet-latest.osm.pbf # about 35 GB libosmium-2.11.1/benchmarks/osmium_benchmark_count.cpp000066400000000000000000000020601305752663000231550ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #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&) { ++nodes; } void way(const osmium::Way&) { ++ways; } void relation(const osmium::Relation&) { ++relations; } }; int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " OSMFILE\n"; std::exit(1); } 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"; } libosmium-2.11.1/benchmarks/osmium_benchmark_count_tag.cpp000066400000000000000000000021311305752663000240070ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #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&) { ++all; } void relation(const osmium::Relation&) { ++all; } }; int main(int argc, char* argv[]) { if (argc != 2) { std::cerr << "Usage: " << argv[0] << " OSMFILE\n"; std::exit(1); } 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"; } libosmium-2.11.1/benchmarks/osmium_benchmark_index_map.cpp000066400000000000000000000021711305752663000237740ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #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"; std::exit(1); } 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(); } libosmium-2.11.1/benchmarks/osmium_benchmark_mercator.cpp000066400000000000000000000015701305752663000236460ustar00rootroot00000000000000/* 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"; std::exit(1); } const std::string input_filename{argv[1]}; osmium::io::Reader reader{input_filename}; GeomHandler handler; osmium::apply(reader, handler); reader.close(); } libosmium-2.11.1/benchmarks/osmium_benchmark_static_vs_dynamic_index.cpp000066400000000000000000000123441305752663000267250ustar00rootroot00000000000000/* 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 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"; std::exit(1); } const std::string input_filename{argv[1]}; osmium::memory::Buffer buffer{osmium::io::read_file(input_filename)}; const auto& map_factory = osmium::index::MapFactory::instance(); const auto buffer_size = buffer.committed() / (1024*1024); // 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"; } libosmium-2.11.1/benchmarks/osmium_benchmark_write_pbf.cpp000066400000000000000000000014461305752663000240150ustar00rootroot00000000000000/* The code in this file is released into the Public Domain. */ #include #include #include #include #include int main(int argc, char* argv[]) { if (argc != 3) { std::cerr << "Usage: " << argv[0] << " INPUT-FILE OUTPUT-FILE\n"; std::exit(1); } std::string input_filename{argv[1]}; std::string output_filename{argv[2]}; osmium::io::Reader reader{input_filename}; osmium::io::File output_file{output_filename, "pbf"}; osmium::io::Header header; osmium::io::Writer writer{output_file, header, osmium::io::overwrite::allow}; while (osmium::memory::Buffer buffer = reader.read()) { writer(std::move(buffer)); } writer.close(); reader.close(); } libosmium-2.11.1/benchmarks/run_benchmark_count.sh000077500000000000000000000010241305752663000223020ustar00rootroot00000000000000#!/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.11.1/benchmarks/run_benchmark_count_tag.sh000077500000000000000000000010341305752663000231360ustar00rootroot00000000000000#!/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.11.1/benchmarks/run_benchmark_index_map.sh000077500000000000000000000014731305752663000231260ustar00rootroot00000000000000#!/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.11.1/benchmarks/run_benchmark_mercator.sh000077500000000000000000000010321305752663000227650ustar00rootroot00000000000000#!/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.11.1/benchmarks/run_benchmark_static_vs_dynamic_index.sh000077500000000000000000000006111305752663000260450ustar00rootroot00000000000000#!/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.11.1/benchmarks/run_benchmark_write_pbf.sh000077500000000000000000000015421305752663000231400ustar00rootroot00000000000000#!/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.11.1/benchmarks/run_benchmarks.sh000077500000000000000000000003331305752663000212570ustar00rootroot00000000000000#!/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.11.1/benchmarks/setup.sh000077500000000000000000000020161305752663000174160ustar00rootroot00000000000000#!/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.11.1/build-appveyor.bat000066400000000000000000000072101305752663000172350ustar00rootroot00000000000000@ECHO OFF SETLOCAL SET EL=0 ECHO ~~~~~~ %~f0 ~~~~~~ SET CUSTOM_CMAKE=cmake-3.6.2-win64-x64 ::show all available env vars SET ECHO cmake on AppVeyor cmake -version ECHO activating VS cmd prompt && CALL "C:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64 IF %ERRORLEVEL% NEQ 0 GOTO ERROR SET lodir=%CD% SET PATH=%lodir%\%CUSTOM_CMAKE%\bin;%PATH% SET LODEPSDIR=%lodir%\libosmium-deps SET PROJ_LIB=%LODEPSDIR%\proj\share SET GDAL_DATA=%LODEPSDIR%\gdal\data ::gdal.dll SET PATH=%LODEPSDIR%\gdal\lib;%PATH% ::geos.dll SET PATH=%LODEPSDIR%\geos\lib;%PATH% ::libtiff.dll SET PATH=%LODEPSDIR%\libtiff\lib;%PATH% ::jpeg.dll SET PATH=%LODEPSDIR%\jpeg\lib;%PATH% ::libexpat.dll SET PATH=%LODEPSDIR%\expat\lib;%PATH% ::zlibwapi.dll SET PATH=%LODEPSDIR%\zlib\lib;%PATH% ::convert backslashes in bzip2 path to forward slashes ::cmake cannot find it otherwise SET LIBBZIP2=%LODEPSDIR%\bzip2\lib\libbz2.lib SET LIBBZIP2=%LIBBZIP2:\=/% IF NOT EXIST cm.7z ECHO downloading cmake %CUSTOM_CMAKE% ... && powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/%CUSTOM_CMAKE%.7z -OutFile cm.7z IF %ERRORLEVEL% NEQ 0 GOTO ERROR IF NOT EXIST lodeps.7z ECHO downloading binary dependencies... && powershell Invoke-WebRequest https://mapbox.s3.amazonaws.com/windows-builds/windows-build-deps/libosmium-deps-win-14.0-x64.7z -OutFile lodeps.7z IF %ERRORLEVEL% NEQ 0 GOTO ERROR IF NOT EXIST %CUSTOM_CMAKE% ECHO extracting cmake... && 7z x cm.7z | %windir%\system32\find "ing archive" IF %ERRORLEVEL% NEQ 0 GOTO ERROR IF NOT EXIST %LODEPSDIR% ECHO extracting binary dependencies... && 7z x lodeps.7z | %windir%\system32\find "ing archive" IF %ERRORLEVEL% NEQ 0 GOTO ERROR ECHO %LODEPSDIR% DIR %LODEPSDIR% ::TREE %LODEPSDIR% ::powershell (Get-ChildItem $env:LODEPSDIR\boost\lib -Filter *boost*.dll)[0].BaseName.split('_')[-1] FOR /F "tokens=1 usebackq" %%i in (`powershell ^(Get-ChildItem %LODEPSDIR%\boost\lib -Filter *boost*.dll^)[0].BaseName.split^('_'^)[-1]`) DO SET BOOST_VERSION=%%i IF %ERRORLEVEL% NEQ 0 GOTO ERROR ECHO BOOST_VERSION^: %BOOST_VERSION% ECHO our own cmake cmake -version CD %lodir%\.. IF NOT EXIST osm-testdata ECHO cloning osm-testdata && git clone --depth 1 https://github.com/osmcode/osm-testdata.git IF %ERRORLEVEL% NEQ 0 GOTO ERROR CD osm-testdata git fetch IF %ERRORLEVEL% NEQ 0 GOTO ERROR git pull IF %ERRORLEVEL% NEQ 0 GOTO ERROR CD %lodir% IF EXIST build ECHO deleting build dir... && RD /Q /S build IF %ERRORLEVEL% NEQ 0 GOTO ERROR MKDIR build IF %ERRORLEVEL% NEQ 0 GOTO ERROR CD build ECHO config^: %config% ::This will produce lots of LNK4099 warnings which can be ignored. ::Unfortunately they can't be disabled, see ::http://stackoverflow.com/questions/661606/visual-c-how-to-disable-specific-linker-warnings SET CMAKE_CMD=cmake .. ^ -LA -G "Visual Studio 14 Win64" ^ -DOsmium_DEBUG=TRUE ^ -DCMAKE_BUILD_TYPE=%config% ^ -DBUILD_HEADERS=OFF ^ -DBOOST_ROOT=%LODEPSDIR%\boost ^ -DZLIB_LIBRARY=%LODEPSDIR%\zlib\lib\zlibwapi.lib ^ -DBZIP2_LIBRARY_RELEASE=%LIBBZIP2% ^ -DCMAKE_PREFIX_PATH=%LODEPSDIR%\zlib;%LODEPSDIR%\expat;%LODEPSDIR%\bzip2;%LODEPSDIR%\geos;%LODEPSDIR%\gdal;%LODEPSDIR%\proj;%LODEPSDIR%\sparsehash;%LODEPSDIR%\wingetopt ECHO calling^: %CMAKE_CMD% %CMAKE_CMD% IF %ERRORLEVEL% NEQ 0 GOTO ERROR msbuild libosmium.sln ^ /p:Configuration=%config% ^ /toolsversion:14.0 ^ /p:Platform=x64 ^ /p:PlatformToolset=v140 IF %ERRORLEVEL% NEQ 0 GOTO ERROR ctest --output-on-failure ^ -C %config% ^ -E testdata-overview IF %ERRORLEVEL% NEQ 0 GOTO ERROR GOTO DONE :ERROR ECHO ~~~~~~ ERROR %~f0 ~~~~~~ SET EL=%ERRORLEVEL% :DONE IF %EL% NEQ 0 ECHO. && ECHO !!! ERRORLEVEL^: %EL% !!! && ECHO. ECHO ~~~~~~ DONE %~f0 ~~~~~~ EXIT /b %EL% libosmium-2.11.1/build-local.bat000066400000000000000000000012011305752663000164540ustar00rootroot00000000000000@ECHO OFF SETLOCAL SET EL=0 ECHO ~~~~~~ %~f0 ~~~~~~ ECHO. ECHO build-local ["config=Dev"] ECHO default config^: RelWithDebInfo ECHO. SET platform=x64 SET config=RelWithDebInfo :: OVERRIDE PARAMETERS >>>>>>>> :NEXT-ARG IF '%1'=='' GOTO ARGS-DONE ECHO setting %1 SET %1 SHIFT GOTO NEXT-ARG :ARGS-DONE ::<<<<< OVERRIDE PARAMETERS WHERE 7z IF %ERRORLEVEL% NEQ 0 ECHO 7zip not on PATH && GOTO ERROR CALL build-appveyor.bat IF %ERRORLEVEL% NEQ 0 GOTO ERROR GOTO DONE :ERROR ECHO ~~~~~~ ERROR %~f0 ~~~~~~ SET EL=%ERRORLEVEL% :DONE IF %EL% NEQ 0 ECHO. && ECHO !!! ERRORLEVEL^: %EL% !!! && ECHO. ECHO ~~~~~~ DONE %~f0 ~~~~~~ EXIT /b %EL% libosmium-2.11.1/cmake/000077500000000000000000000000001305752663000146635ustar00rootroot00000000000000libosmium-2.11.1/cmake/FindGem.cmake000066400000000000000000000135731305752663000172070ustar00rootroot00000000000000# Author thomas.roehr@dfki.de # # 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${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.11.1/cmake/FindOsmium.cmake000066400000000000000000000307531305752663000177470ustar00rootroot00000000000000#---------------------------------------------------------------------- # # 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 # proj - include if you want to use any of the Proj.4 functions # sparsehash - include if you use the sparsehash index # # 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 and protozero # 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) 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) message(STATUS "Looking for protozero") find_path(PROTOZERO_INCLUDE_DIR protozero/version.hpp PATH_SUFFIXES include PATHS ${_osmium_include_path} ${OSMIUM_INCLUDE_DIR} ) if(PROTOZERO_INCLUDE_DIR) message(STATUS "Looking for protozero - found") else() message(STATUS "Looking for protozero - not found") endif() list(APPEND OSMIUM_EXTRA_FIND_VARS ZLIB_FOUND Threads_FOUND PROTOZERO_INCLUDE_DIR) if(ZLIB_FOUND AND Threads_FOUND AND PROTOZERO_INCLUDE_DIR) list(APPEND OSMIUM_PBF_LIBRARIES ${ZLIB_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ) if(WIN32) # This is needed for the ntohl() function list(APPEND OSMIUM_PBF_LIBRARIES ws2_32) endif() list(APPEND OSMIUM_INCLUDE_DIRS ${ZLIB_INCLUDE_DIR} ${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() #---------------------------------------------------------------------- # Component 'proj' if(Osmium_USE_PROJ) find_path(PROJ_INCLUDE_DIR proj_api.h) find_library(PROJ_LIBRARY NAMES proj) list(APPEND OSMIUM_EXTRA_FIND_VARS PROJ_INCLUDE_DIR PROJ_LIBRARY) if(PROJ_INCLUDE_DIR AND PROJ_LIBRARY) set(PROJ_FOUND 1) list(APPEND OSMIUM_LIBRARIES ${PROJ_LIBRARY}) list(APPEND OSMIUM_INCLUDE_DIRS ${PROJ_INCLUDE_DIR}) else() message(WARNING "Osmium: PROJ.4 library is required but not found, please install it or configure the paths.") endif() endif() #---------------------------------------------------------------------- # Component 'sparsehash' if(Osmium_USE_SPARSEHASH) find_path(SPARSEHASH_INCLUDE_DIR google/sparsetable) list(APPEND OSMIUM_EXTRA_FIND_VARS SPARSEHASH_INCLUDE_DIR) if(SPARSEHASH_INCLUDE_DIR) # Find size of sparsetable::size_type. This does not work on older # CMake versions because they can do this check only in C, not in C++. if(NOT CMAKE_VERSION VERSION_LESS 3.0) include(CheckTypeSize) set(CMAKE_REQUIRED_INCLUDES ${SPARSEHASH_INCLUDE_DIR}) set(CMAKE_EXTRA_INCLUDE_FILES "google/sparsetable") check_type_size("google::sparsetable::size_type" SPARSETABLE_SIZE_TYPE LANGUAGE CXX) set(CMAKE_EXTRA_INCLUDE_FILES) set(CMAKE_REQUIRED_INCLUDES) else() set(SPARSETABLE_SIZE_TYPE ${CMAKE_SIZEOF_VOID_P}) endif() # Sparsetable::size_type must be at least 8 bytes (64bit), otherwise # OSM object IDs will not fit. if(SPARSETABLE_SIZE_TYPE GREATER 7) set(SPARSEHASH_FOUND 1) add_definitions(-DOSMIUM_WITH_SPARSEHASH=${SPARSEHASH_FOUND}) list(APPEND OSMIUM_INCLUDE_DIRS ${SPARSEHASH_INCLUDE_DIR}) else() message(WARNING "Osmium: Disabled Google SparseHash library on 32bit system (size_type=${SPARSETABLE_SIZE_TYPE}).") endif() else() message(WARNING "Osmium: Google SparseHash 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) #---------------------------------------------------------------------- # # 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) add_definitions(-DNOMINMAX -DWIN32_LEAN_AND_MEAN -D_CRT_SECURE_NO_WARNINGS) endif() if(APPLE) # 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.11.1/cmake/README000066400000000000000000000000751305752663000155450ustar00rootroot00000000000000 FindGem.cmake from https://github.com/rock-core/base-cmake libosmium-2.11.1/cmake/build.bat000066400000000000000000000012321305752663000164500ustar00rootroot00000000000000call "%VS120COMNTOOLS%\..\..\VC\vcvarsall.bat" x86_amd64 set CMAKE_PREFIX_PATH=C:\PROJ set VERSION=Debug set TESTS=ON set ALLHPPS=ON set PREFIX=d:\libs18d set BOOST_ROOT=d:\boost cmake .. -G "Visual Studio 12 Win64" -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX=%PREFIX% -DBOOST_ROOT=%BOOST_ROOT% -DBoost_USE_STATIC_LIBS=ON -DBUILD_TESTING=%TESTS% -DBUILD_TRY_HPPS=%ALLHPPS$ -T CTP_Nov2013 msbuild /clp:Verbosity=minimal /nologo libosmium.sln /flp1:logfile=build_errors.txt;errorsonly /flp2:logfile=build_warnings.txt;warningsonly set PATH=%PATH%;%PREFIX%/bin del test\osm-testdata\*.db del test\osm-testdata\*.json if "%TESTS%"=="ON" ctest -VV >build_tests.log libosmium-2.11.1/cmake/iwyu.sh000077500000000000000000000024161305752663000162220ustar00rootroot00000000000000#!/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.11.1/doc/000077500000000000000000000000001305752663000143505ustar00rootroot00000000000000libosmium-2.11.1/doc/CMakeLists.txt000066400000000000000000000021201305752663000171030ustar00rootroot00000000000000#----------------------------------------------------------------------------- # # 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.11.1/doc/Doxyfile.in000066400000000000000000003054731305752663000164770ustar00rootroot00000000000000# 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 # , /