sij/mapnik
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' into svg-group-render

Browse source
This commit is contained in:
Artem Pavlenko 2023-01-18 09:48:29 +00:00
commit edddd08d73
185 changed files with 1906 additions and 1752 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
.github/actions/run_tests/action.yml vendored
View file

@ -27,14 +27,14 @@ runs:
- name: Test visuals (windows)
continue-on-error: true
working-directory: build/${{ inputs.cmake-preset }}/out
working-directory: build/out
shell: "pwsh"
if: runner.os == 'Windows'
run: OpenCppCoverage --modules *libmapnik* --modules mapnik*.exe --modules *.input --sources ${{ github.workspace }} --export_type binary --input_coverage=${{ github.workspace }}/ctest.cov --cover_children -- .\mapnik-test-visual.exe -j (Get-CimInstance -ClassName Win32_ComputerSystem).NumberOfLogicalProcessors --output-dir ./visual-test-result
- name: Test visuals (linux & mac)
continue-on-error: true
working-directory: build/${{ inputs.cmake-preset }}/out
working-directory: build/out
shell: "bash"
if: runner.os != 'Windows'
run: |
@ -45,7 +45,7 @@ runs:
fi
- name: Pack visual test results
working-directory: build/${{ inputs.cmake-preset }}/out
working-directory: build/out
shell: "pwsh"
run: tar cfvz visual-test-results.tar.gz ./visual-test-result
@ -60,16 +60,16 @@ runs:
uses: actions/upload-artifact@v3
with:
name: ${{ inputs.cmake-preset }}-visual-tests-${{ steps.run-guid.outputs.GUID }}
path: build/${{ inputs.cmake-preset }}/out/visual-test-results.tar.gz
path: build/out/visual-test-results.tar.gz
- name: Run Benchmarks
working-directory: build/${{ inputs.cmake-preset }}/out
working-directory: build/out
if: runner.os != 'Windows'
shell: "pwsh"
run: ./run_benchmarks
- name: Collect coverage (linux & macos)
working-directory: build/${{ inputs.cmake-preset }}
working-directory: build
if: runner.os != 'Windows'
shell: "bash"
run: |
@ -81,10 +81,10 @@ runs:
if: runner.os != 'Windows'
uses: codecov/codecov-action@v3
with:
files: build/${{ inputs.cmake-preset }}/coverage.info
files: build/coverage.info
- name: Upload coverage to Codecov (windows)
if: runner.os == 'Windows'
uses: codecov/codecov-action@v3
with:
files: build/${{ inputs.cmake-preset }}/out/mapnik-test-visual.cov
files: build/out/mapnik-test-visual.cov

3
.github/workflows/build_and_test.yml vendored
View file

@ -32,6 +32,7 @@ jobs:
matrix:
os: [macos-latest, windows-latest, ubuntu-latest]
memory-mapped: ["OFF", "ON"]
static-build: ["OFF", "ON"]
include:
- os: ubuntu-latest
mono: mono
@ -82,7 +83,7 @@ jobs:
echo "PRESET=${{ steps.lc_platform.outputs.lowercase }}-ci" >>${GITHUB_ENV}
- name: Configure CMake
run: cmake -DUSE_MEMORY_MAPPED_FILE=${{ matrix.memory-mapped }} --preset ${{ env.PRESET }}
run: cmake -DUSE_MEMORY_MAPPED_FILE=${{ matrix.memory-mapped }} -DBUILD_SHARED_LIBS=${{ matrix.static-build }} --preset ${{ env.PRESET }}
- name: Build
run: cmake --build --preset ${{ env.PRESET }}

8
CHANGELOG.md
View file

@ -12,6 +12,12 @@ For a complete change history, see the git log.
#### Notice
- Mapnik now requires C++14 compliant compiler (`-std=c++14`)
- Mapnik now supports CMake as a build system. See [#4191](https://github.com/mapnik/mapnik/pull/4191) and the [docs](https://github.com/mapnik/mapnik/blob/master/docs/cmake-usage.md) for more info.
#### Breaking Changes
- Reworked datasource plugin system. Plugins now need to implement a class with the macros in `datasource_plugin.hpp` ([#4291](https://github.com/mapnik/mapnik/pull/4291))
- mapnik now has a global `mapnik::setup()` method which have to be called before any other functions of mapnik. Defined in `mapnik.hpp`. Currently there is a auto setup functionality. It can be disabled using the cmake option `DISABLE_MAPNIK_AUTOSETUP=ON`. Note: In order not to insert this change into every code base, it is currently still called during the dynamic initialisation time. However, if mapnik is compiled statically, this function must be called. ([#4291](https://github.com/mapnik/mapnik/pull/4291))
#### Core
@ -27,6 +33,8 @@ For a complete change history, see the git log.
- Slightly improved `sql_utils::table_from_sql` ([2587bb3](https://github.com/mapnik/mapnik/commit/2587bb3a1d8db397acfa8dcc2d332da3a8a9399f))
- Added wrappers for proper quoting in SQL query construction: `sql_utils::identifier`, `sql_utils::literal` ([7b21713](https://github.com/mapnik/mapnik/commit/7b217133e2749b82c2638551045c4edbece15086))
- Added two-argument `sql_utils::unquote`, `sql_utils::unquote_copy` that also collapse inner quotes ([a4e8ea2](https://github.com/mapnik/mapnik/commit/a4e8ea21be297d89bbf36ba594d6c661a7a9ac81))
- Fixed mapnik static build with static plugins ([#4291](https://github.com/mapnik/mapnik/pull/4291))
- Reworked mapnik::enumeration<...> ([#4372](https://github.com/mapnik/mapnik/pull/4372))
#### Plugins

108
CMakeLists.txt
View file

@ -16,6 +16,7 @@ message(STATUS "mapnik version: ${PROJECT_VERSION}")
# https://cliutils.gitlab.io/modern-cmake/chapters/features/ides.html
set_property(GLOBAL PROPERTY USE_FOLDERS ON)
set(CMAKE_FIND_PACKAGE_TARGETS_GLOBAL ON) # with newer cmake versions put all find_package in global scope
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
include(FeatureSummary)
include(MapnikOption)
@ -27,8 +28,13 @@ include(CTest)
add_feature_info(BUILD_TESTING BUILD_TESTING "Adds tests")
mapnik_option(INSTALL_DEPENDENCIES "if ON, all dependencies (eg. required dlls) will be copied into CMAKE_INSTALL_PREFIX/MAPNIK_BIN_DIR." ON)
mapnik_option(BUILD_SHARED_LIBS "build mapnik dynamic(ON) or static(OFF)" ON)
mapnik_option(BUILD_SHARED_PLUGINS "build dynamic plugins" ${BUILD_SHARED_LIBS}) # use BUILD_SHARED_LIBS as default option
mapnik_option(BUILD_SHARED_CRT "(only windows with msvc) use msvc shared crt" ON)
if(WIN32 AND BUILD_SHARED_PLUGINS AND NOT BUILD_SHARED_LIBS)
message(FATAL_ERROR "static libmapnik and dynamic plugins won't work correctly")
endif()
mapnik_option(USE_EXTERNAL_MAPBOX_GEOMETRY "Use a external mapnik/geometry.hpp. If off, use the submodule" OFF)
mapnik_option(USE_EXTERNAL_MAPBOX_POLYLABEL "Use a external mapnik/polylabel. If off, use the submodule" OFF)
mapnik_option(USE_EXTERNAL_MAPBOX_PROTOZERO "Use a external mapnik/protozero. If off, use the submodule" OFF)
@ -56,6 +62,8 @@ mapnik_option(USE_LOG "enables logging output. See log severity level." OFF)
set(USE_LOG_SEVERITY "1" CACHE STRING "sets the logging severity (only applies when USE_LOG is ON")
mapnik_option(USE_STATS "Enable statistics reporting" OFF)
mapnik_option(DISABLE_MAPNIK_AUTOSETUP "disables the autosetup. Need to call mapnik::setup() then" OFF)
mapnik_option(USE_PLUGIN_INPUT_CSV "adds plugin input csv" ON)
mapnik_option(USE_PLUGIN_INPUT_GDAL "adds plugin input gdal" ON)
mapnik_option(USE_PLUGIN_INPUT_GEOBUF "adds plugin input geobuf" ON)
@ -87,18 +95,6 @@ mapnik_option(USE_GLIBC_WORKAROUND "see https://github.com/mapnik/mapnik/pull/37
feature_summary(WHAT ENABLED_FEATURES DISABLED_FEATURES)
feature_summary(FILENAME "${CMAKE_CURRENT_BINARY_DIR}/features.log" WHAT ENABLED_FEATURES DISABLED_FEATURES)
set(CMAKE_CXX_STANDARD 14 CACHE STRING "Sets the c++ standard. c++14 is minimum.")
message(STATUS "Using c++${CMAKE_CXX_STANDARD}")
# https://cmake.org/cmake/help/latest/prop_tgt/CXX_EXTENSIONS.html
set(CXX_EXTENSIONS OFF CACHE STRING "Enables the compiler specific extensions.") # Fallsback to -std=c++<ver> if off
message(STATUS "Using c++ extensions: ${CXX_EXTENSIONS}")
# https://cmake.org/cmake/help/latest/prop_tgt/CXX_STANDARD_REQUIRED.html#prop_tgt:CXX_STANDARD_REQUIRED
set(CXX_STANDARD_REQUIRED ON) # require the specified CMAKE_CXX_STANDARD
# add debug postfix to the libraries
set(MAPNIK_DEBUG_POSTFIX "d" CACHE STRING "sets the debug library postfix on mapnik, wkt and json")
message(STATUS "postfix for debug libraries: ${MAPNIK_DEBUG_POSTFIX}")
include(GNUInstallDirs)
# See for more details: https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html
set(MAPNIK_BIN_DIR ${CMAKE_INSTALL_BINDIR} CACHE STRING "Install directory for binaries")
@ -123,9 +119,29 @@ set(MAPNIK_COMPILE_DEFS "")
set(MAPNIK_OPTIONAL_LIBS "")
set(MAPNIK_OPTIONAL_LIBS_INCLUDE "")
#############################
#############################
# Begin project configuration
#############################
#############################
set(CMAKE_CXX_STANDARD 14 CACHE STRING "Sets the c++ standard. c++14 is minimum.")
set(CMAKE_CXX_STANDARD_REQUIRED ON) # require the specified CMAKE_CXX_STANDARD
set(CMAKE_CXX_EXTENSIONS OFF CACHE STRING "Enables the compiler specific extensions.") # Fallsback to -std=c++<ver> if off
message(STATUS "Using c++${CMAKE_CXX_STANDARD}")
message(STATUS "Using c++ extensions: ${CXX_EXTENSIONS}")
# add debug postfix to the libraries
set(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "sets the debug library postfix on mapnik, wkt and json")
message(STATUS "postfix for debug libraries: ${CMAKE_DEBUG_POSTFIX}")
set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>$<$<BOOL:${BUILD_SHARED_CRT}>:DLL>")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}")
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib")
# needs to be before the first call of find_boost.
list(APPEND MAPNIK_COMPILE_DEFS BOOST_SPIRIT_X3_HIDE_CXX17_WARNING)
if(USE_MULTITHREADED)
set(Boost_USE_MULTITHREADED ON)
list(APPEND MAPNIK_COMPILE_DEFS MAPNIK_THREADSAFE)
@ -134,7 +150,7 @@ else()
endif()
find_package(PkgConfig)
mapnik_find_package(PkgConfig REQUIRED)
mapnik_find_threads()
mapnik_find_package(ICU REQUIRED COMPONENTS uc i18n data)
@ -163,7 +179,7 @@ else()
# It might be possible that in future version harfbuzz could only be found via pkg-config.
# harfbuzz related discussion: https://github.com/harfbuzz/harfbuzz/issues/2653
message(STATUS "harfbuzz not found via cmake. Searching via pkg-config...")
pkg_check_modules(harfbuzz REQUIRED IMPORTED_TARGET harfbuzz>=${HARFBUZZ_MIN_VERSION})
mapnik_pkg_check_modules(harfbuzz REQUIRED IMPORTED_TARGET harfbuzz>=${HARFBUZZ_MIN_VERSION})
list(APPEND MAPNIK_OPTIONAL_LIBS PkgConfig::harfbuzz)
endif()
@ -290,20 +306,15 @@ if(USE_TIFF)
endif()
if(USE_WEBP)
mapnik_find_package(WebP REQUIRED)
mapnik_pkg_check_modules(WebP REQUIRED IMPORTED_TARGET libwebp)
list(APPEND MAPNIK_COMPILE_DEFS HAVE_WEBP)
list(APPEND MAPNIK_OPTIONAL_LIBS WebP::WebP)
list(APPEND MAPNIK_OPTIONAL_LIBS PkgConfig::WebP)
endif()
if(USE_CAIRO)
if(WIN32)
mapnik_find_package(Cairo REQUIRED)
list(APPEND MAPNIK_OPTIONAL_LIBS Cairo::Cairo)
else()
pkg_check_modules(Cairo REQUIRED IMPORTED_TARGET cairo)
list(APPEND MAPNIK_OPTIONAL_LIBS PkgConfig::Cairo)
endif()
mapnik_pkg_check_modules(Cairo REQUIRED IMPORTED_TARGET cairo)
list(APPEND MAPNIK_COMPILE_DEFS HAVE_CAIRO)
list(APPEND MAPNIK_OPTIONAL_LIBS PkgConfig::Cairo)
endif()
if(USE_PROJ)
@ -312,7 +323,7 @@ if(USE_PROJ)
# currently the cmake files are not installed, when installing proj via apt-get. So search via pkg-config
if(NOT PROJ_FOUND)
message(STATUS "PROJ not found via FindPROJ. Searching via pkg-config...")
pkg_check_modules(PROJ REQUIRED IMPORTED_TARGET proj>=${PROJ_MIN_VERSION})
mapnik_pkg_check_modules(PROJ REQUIRED IMPORTED_TARGET proj>=${PROJ_MIN_VERSION})
string(REGEX MATCH "([0-9]+)\.([0-9]+)\.([0-9]+)" _dummy "${PROJ_VERSION}")
set(PROJ_VERSION_MAJOR "${CMAKE_MATCH_1}")
set(PROJ_VERSION_MINOR "${CMAKE_MATCH_2}")
@ -344,10 +355,24 @@ if(NOT WIN32)
list(APPEND MAPNIK_OPTIONAL_LIBS ${CMAKE_DL_LIBS})
endif()
if(NOT BUILD_SHARED_PLUGINS)
list(APPEND MAPNIK_COMPILE_DEFS MAPNIK_STATIC_PLUGINS)
endif()
# when building static, this have to be public so that all depending libs know about
if(NOT BUILD_SHARED_LIBS)
list(APPEND MAPNIK_COMPILE_DEFS MAPNIK_STATIC_DEFINE)
endif()
if(DISABLE_MAPNIK_AUTOSETUP)
list(APPEND MAPNIK_COMPILE_DEFS MAPNIK_DISABLE_AUTOSETUP)
endif()
# force utf-8 source code processing
# see https://docs.microsoft.com/de-de/cpp/build/reference/utf-8-set-source-and-executable-character-sets-to-utf-8?view=msvc-170
add_compile_options("$<$<C_COMPILER_ID:MSVC>:/utf-8>")
add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/utf-8>")
add_compile_options(
"$<$<CXX_COMPILER_ID:MSVC>:/utf-8>"
"$<$<CXX_COMPILER_ID:MSVC>:/EHsc>"
)
add_library(core INTERFACE)
add_library(mapnik::core ALIAS core)
@ -377,9 +402,20 @@ target_compile_definitions(core INTERFACE ${MAPNIK_COMPILE_DEFS})
mapnik_install(core)
###
# forward declaring libraries to consume them when building static plugins (circle deps between mapnik <-> plugin_target)
add_library(mapnik "")
add_library(mapnik::mapnik ALIAS mapnik)
add_library(wkt STATIC "")
add_library(mapnik::wkt ALIAS wkt)
add_library(json STATIC "")
add_library(mapnik::json ALIAS json)
# end forward declaration
###
add_subdirectory(deps)
add_subdirectory(src)
add_subdirectory(plugins)
add_subdirectory(src)
add_subdirectory(utils)
add_subdirectory(demo)
if(BUILD_BENCHMARK)
@ -396,23 +432,23 @@ feature_summary(FILENAME "${CMAKE_CURRENT_BINARY_DIR}/packages.log" WHAT PACKAGE
include(MapnikExport)
include(MapnikExportPkgConfig)
install(DIRECTORY include/ DESTINATION ${MAPNIK_INCLUDE_DIR})
install(DIRECTORY deps/agg/include/ DESTINATION ${MAPNIK_INCLUDE_DIR})
install(DIRECTORY deps/mapnik DESTINATION ${MAPNIK_INCLUDE_DIR})
install(DIRECTORY include/ DESTINATION "${MAPNIK_INCLUDE_DIR}")
install(DIRECTORY deps/agg/include/ DESTINATION "${MAPNIK_INCLUDE_DIR}")
install(DIRECTORY deps/mapnik DESTINATION "${MAPNIK_INCLUDE_DIR}")
file(GLOB TTF_FONT_FILES "fonts/*/*/*.ttf")
install(FILES ${TTF_FONT_FILES} DESTINATION ${FONTS_INSTALL_DIR})
install(FILES ${TTF_FONT_FILES} DESTINATION "${FONTS_INSTALL_DIR}")
if(NOT USE_EXTERNAL_MAPBOX_GEOMETRY)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/geometry/include/ DESTINATION ${MAPNIK_INCLUDE_DIR})
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/geometry/include/" DESTINATION "${MAPNIK_INCLUDE_DIR}")
endif()
if(NOT USE_EXTERNAL_MAPBOX_POLYLABEL)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/polylabel/include/ DESTINATION ${MAPNIK_INCLUDE_DIR})
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/polylabel/include/" DESTINATION "${MAPNIK_INCLUDE_DIR}")
endif()
if(NOT USE_EXTERNAL_MAPBOX_PROTOZERO)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/protozero/include/ DESTINATION ${MAPNIK_INCLUDE_DIR})
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/protozero/include/" DESTINATION "${MAPNIK_INCLUDE_DIR}")
endif()
if(NOT USE_EXTERNAL_MAPBOX_VARIANT)
install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/variant/include/ DESTINATION ${MAPNIK_INCLUDE_DIR})
install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/deps/mapbox/variant/include/" DESTINATION "${MAPNIK_INCLUDE_DIR}")
endif()
mapnik_install_targets()

15
CMakePresets.json
View file

@ -17,7 +17,7 @@
{
"name": "default-build-dir",
"hidden": true,
"binaryDir": "${sourceDir}/build/${presetName}"
"binaryDir": "${sourceDir}/build"
},
{
"name": "debug-build",
@ -180,8 +180,9 @@
"cacheVariables": {
"BUILD_TESTING": "ON",
"BUILD_DEMO_VIEWER": "OFF",
"CMAKE_TOOLCHAIN_FILE": "vcpkg/scripts/buildsystems/vcpkg.cmake"
}
"DISABLE_MAPNIK_AUTOSETUP": "ON"
},
"toolchainFile": "vcpkg/scripts/buildsystems/vcpkg.cmake"
},
{
"name": "windows-ci",
@ -192,10 +193,10 @@
],
"cacheVariables": {
"INSTALL_DEPENDENCIES": "ON",
"ADDITIONAL_LIBARIES_PATHS": "${sourceDir}/build/${presetName}/vcpkg_installed/x64-windows/bin"
"ADDITIONAL_LIBARIES_PATHS": "${sourceDir}/build/vcpkg_installed/x64-windows/bin"
},
"environment": {
"PROJ_LIB": "${sourceDir}/build/${presetName}/vcpkg_installed/x64-windows/share/proj"
"PROJ_LIB": "${sourceDir}/build/vcpkg_installed/x64-windows/share/proj"
}
},
{
@ -210,7 +211,7 @@
"CMAKE_CXX_FLAGS": "--coverage"
},
"environment": {
"PROJ_LIB": "${sourceDir}/build/${presetName}/vcpkg_installed/x64-linux/share/proj"
"PROJ_LIB": "${sourceDir}/build/vcpkg_installed/x64-linux/share/proj"
}
},
{
@ -239,7 +240,7 @@
"CMAKE_CXX_FLAGS": "-fprofile-arcs -ftest-coverage"
},
"environment": {
"PROJ_LIB": "${sourceDir}/build/${presetName}/vcpkg_installed/x64-osx/share/proj"
"PROJ_LIB": "${sourceDir}/build/vcpkg_installed/x64-osx/share/proj"
}
}
],

1
SConstruct
View file

@ -1879,6 +1879,7 @@ if not preconfigured:
env.Prepend(CPPPATH = '#deps/mapbox/geometry/include')
env.Prepend(CPPPATH = '#deps/mapbox/protozero/include')
env.Prepend(CPPPATH = '#deps/mapbox/polylabel/include')
env.Prepend(CPPPATH = '#plugins/input/base/include')
# prepend deps dir for auxillary headers
env.Prepend(CPPPATH = '#deps')

9
benchmark/CMakeLists.txt
View file

@ -31,11 +31,12 @@ function(mapnik_create_benchmark)
set(TARGET_NAME "mapnik-benchmark-${BENCHNAME}")
add_executable(${TARGET_NAME} ${ARGV0})
target_include_directories(${TARGET_NAME} PRIVATE include)
target_link_libraries(${TARGET_NAME} PRIVATE mapnik::agg mapnik::mapnik)
target_link_libraries(${TARGET_NAME} PRIVATE
mapnik::agg
mapnik::mapnik
ICU::data ICU::i18n ICU::uc # needed for the static build (TODO: why isn't this correctly propagated from mapnik::mapnik?)
)
set_target_properties(${TARGET_NAME} PROPERTIES
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
OUTPUT_NAME "${BENCHNAME}"
)
endfunction()

2
benchmark/include/bench_framework.hpp
View file

@ -2,6 +2,7 @@
#define MAPNIK_BENCH_FRAMEWORK_HPP
// mapnik
#include <mapnik/mapnik.hpp>
#include <mapnik/debug.hpp>
#include <mapnik/params.hpp>
#include <mapnik/value/types.hpp>
@ -124,6 +125,7 @@ inline int handle_args(int argc, char** argv, mapnik::parameters& params)
#define BENCHMARK(test_class, name) \
int main(int argc, char** argv) \
{ \
mapnik::setup(); \
try \
{ \
mapnik::parameters params; \

1
benchmark/src/normalize_angle.cpp
View file

@ -30,6 +30,7 @@ struct bench_func : benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
return benchmark::sequencer(argc, argv)
.BENCH_FUNC1(mapnik::util::normalize_angle, +3)
.BENCH_FUNC1(mapnik::util::normalize_angle, +6)

1
benchmark/src/test_array_allocation.cpp
View file

@ -349,6 +349,7 @@ class test7 : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
return benchmark::sequencer(argc, argv)
.run<test4>("calloc")
.run<test1>("malloc/memcpy")

1
benchmark/src/test_expression_parse.cpp
View file

@ -36,6 +36,7 @@ class test : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
mapnik::parameters params;
benchmark::handle_args(argc, argv, params);
test test_runner(params);

1
benchmark/src/test_face_ptr_creation.cpp
View file

@ -59,6 +59,7 @@ class test : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
mapnik::parameters params;
benchmark::handle_args(argc, argv, params);
bool success = mapnik::freetype_engine::register_fonts("./fonts", true);

1
benchmark/src/test_getline.cpp
View file

@ -101,6 +101,7 @@ class test2 : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
int return_value = 0;
try
{

1
benchmark/src/test_numeric_cast_vs_static_cast.cpp
View file

@ -76,5 +76,6 @@ class test_numeric : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
return benchmark::sequencer(argc, argv).run<test_static>("static_cast").run<test_numeric>("numeric_cast").done();
}

1
benchmark/src/test_offset_converter.cpp
View file

@ -92,6 +92,7 @@ class test_offset : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
mapnik::parameters params;
benchmark::handle_args(argc, argv, params);
int return_value = 0;

1
benchmark/src/test_polygon_clipping.cpp
View file

@ -510,6 +510,7 @@ expected_count << "\n"; valid = false;
int main(int argc, char** argv)
{
mapnik::setup();
mapnik::parameters params;
benchmark::handle_args(argc, argv, params);

1
benchmark/src/test_polygon_clipping_rendering.cpp
View file

@ -43,6 +43,7 @@ class test : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
mapnik::parameters params;
benchmark::handle_args(argc, argv, params);
mapnik::datasource_cache::instance().register_datasources("./plugins/input/");

1
benchmark/src/test_proj_transform1.cpp
View file

@ -60,6 +60,7 @@ class test : public benchmark::test_case
// echo -180 -60 | cs2cs -f "%.10f" epsg:4326 +to epsg:3857
int main(int argc, char** argv)
{
mapnik::setup();
mapnik::box2d<double> from(-180, -80, 180, 80);
mapnik::box2d<double> to(-20037508.3427892476, -15538711.0963092316, 20037508.3427892476, 15538711.0963092316);
std::string from_str("epsg:4326");

1
benchmark/src/test_rendering.cpp
View file

@ -95,6 +95,7 @@ class test : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
int return_value = 0;
try
{

1
benchmark/src/test_rendering_shared_map.cpp
View file

@ -150,6 +150,7 @@ class test : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
int return_value = 0;
try
{

1
benchmark/src/test_utf_encoding.cpp
View file

@ -106,6 +106,7 @@ class test3 : public benchmark::test_case
int main(int argc, char** argv)
{
mapnik::setup();
mapnik::parameters params;
benchmark::handle_args(argc, argv, params);
int return_value = 0;

98
cmake/FindCairo.cmake
View file

@ -1,98 +0,0 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
FindCairo
-----------
Find Cairo 2D graphics library.
Imported Targets
^^^^^^^^^^^^^^^^
This module defines :prop_tgt:`IMPORTED` target ``Cairo::Cairo``, if
cairo has been found.
Result variables
^^^^^^^^^^^^^^^^
This module will set the following variables in your project:
``CAIRO_FOUND``
True if cairo headers and library were found.
``CAIRO_INCLUDE_DIRS``
Directory where cairo headers are located.
``CAIRO_LIBRARIES``
cairo libraries to link against.
``CAIRO_VERSION_MAJOR``
The major version of cairo
``CAIRO_VERSION_MINOR``
The minor version of cairo
``CAIRO_VERSION_PATCH``
The patch version of cairo
``CAIRO_VERSION_STRING``
version number as a string (ex: "1.16.0")
#]=======================================================================]
if(NOT CAIRO_LIBRARY)
find_path(CAIRO_INCLUDE_DIR NAMES cairo.h HINTS ${PC_CAIRO_INCLUDEDIR} ${PC_CAIRO_INCLUDE_DIR} PATH_SUFFIXES cairo)
find_library(CAIRO_LIBRARY_RELEASE NAMES ${Cairo_NAMES} cairo HINTS ${PC_CAIRO_LIBDIR} ${PC_CAIRO_LIBRARY_DIRS})
find_library(CAIRO_LIBRARY_DEBUG NAMES ${Cairo_NAMES} cairod HINTS ${PC_CAIRO_LIBDIR} ${PC_CAIRO_LIBRARY_DIRS})
include(SelectLibraryConfigurations)
select_library_configurations(CAIRO)
else()
file(TO_CMAKE_PATH "${CAIRO_LIBRARY}" CAIRO_LIBRARY)
endif()
if(CAIRO_INCLUDE_DIR AND NOT CAIRO_VERSION)
if(EXISTS "${CAIRO_INCLUDE_DIR}/cairo-version.h")
file(READ "${CAIRO_INCLUDE_DIR}/cairo-version.h" CAIRO_VERSION_CONTENT)
string(REGEX MATCH "#define +CAIRO_VERSION_MAJOR +([0-9]+)" _dummy "${CAIRO_VERSION_CONTENT}")
set(CAIRO_VERSION_MAJOR "${CMAKE_MATCH_1}")
string(REGEX MATCH "#define +CAIRO_VERSION_MINOR +([0-9]+)" _dummy "${CAIRO_VERSION_CONTENT}")
set(CAIRO_VERSION_MINOR "${CMAKE_MATCH_1}")
string(REGEX MATCH "#define +CAIRO_VERSION_MICRO +([0-9]+)" _dummy "${CAIRO_VERSION_CONTENT}")
set(CAIRO_VERSION_PATCH "${CMAKE_MATCH_1}")
set(CAIRO_VERSION "${CAIRO_VERSION_MAJOR}.${CAIRO_VERSION_MINOR}.${CAIRO_VERSION_PATCH}")
set(CAIRO_VERSION_STRING ${CAIRO_VERSION})
endif()
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Cairo
REQUIRED_VARS
CAIRO_LIBRARY
CAIRO_INCLUDE_DIR
VERSION_VAR
CAIRO_VERSION_STRING
)
mark_as_advanced(CAIRO_INCLUDE_DIR CAIRO_LIBRARY)
if (CAIRO_FOUND)
set(CAIRO_LIBRARIES ${CAIRO_LIBRARY})
set(CAIRO_INCLUDE_DIRS ${CAIRO_INCLUDE_DIR})
if(NOT TARGET Cairo::Cairo)
add_library(Cairo::Cairo UNKNOWN IMPORTED)
set_target_properties(Cairo::Cairo PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${CAIRO_INCLUDE_DIR}
IMPORTED_LINK_INTERFACE_LANGUAGES C)
if(CAIRO_LIBRARY_RELEASE)
set_property(TARGET Cairo::Cairo APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(Cairo::Cairo PROPERTIES IMPORTED_LOCATION_RELEASE "${CAIRO_LIBRARY_RELEASE}")
endif()
if(CAIRO_LIBRARY_DEBUG)
set_property(TARGET Cairo::Cairo APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
set_target_properties(Cairo::Cairo PROPERTIES IMPORTED_LOCATION_DEBUG "${CAIRO_LIBRARY_DEBUG}")
endif()
if(NOT CAIRO_LIBRARY_RELEASE AND NOT CAIRO_LIBRARY_DEBUG)
set_target_properties(Cairo::Cairo PROPERTIES IMPORTED_LOCATION "${CAIRO_LIBRARY}")
endif()
endif()
endif ()

97
cmake/FindWebP.cmake
View file

@ -1,97 +0,0 @@
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
#[=======================================================================[.rst:
FindWebP
-------
Finds the WebP library.
Imported Targets
^^^^^^^^^^^^^^^^
This module provides the following imported targets, if found:
``WebP::WebP``
The WebP library
Result Variables
^^^^^^^^^^^^^^^^
This will define the following variables:
``WebP_FOUND``
True if the system has the WebP library.
``WebP_VERSION``
The version of the WebP library which was found.
``WebP_INCLUDE_DIRS``
Include directories needed to use WebP.
``WebP_LIBRARIES``
Libraries needed to link to WebP.
Cache Variables
^^^^^^^^^^^^^^^
The following cache variables may also be set:
``WebP_INCLUDE_DIR``
The directory containing ``decode.h``.
``WebP_LIBRARY``
The path to the Foo library.
#]=======================================================================]
if(NOT WebP_LIBRARY)
find_package(PkgConfig QUIET)
pkg_check_modules(PC_WebP QUIET libwebp)
set(WebP_VERSION ${PC_WebP_VERSION})
find_path(WebP_INCLUDE_DIR NAMES decode.h HINTS ${PC_WebP_INCLUDEDIR} ${PC_WebP_INCLUDE_DIR} PATH_SUFFIXES webp)
find_library(WebP_LIBRARY_RELEASE NAMES ${WebP_NAMES} webp HINTS ${PC_WebP_LIBDIR} ${PC_WebP_LIBRARY_DIRS})
find_library(WebP_LIBRARY_DEBUG NAMES ${WebP_NAMES} webpd HINTS ${PC_WebP_LIBDIR} ${PC_WebP_LIBRARY_DIRS})
include(SelectLibraryConfigurations)
select_library_configurations(WebP)
else()
file(TO_CMAKE_PATH "${WebP_LIBRARY}" WebP_LIBRARY)
endif()
if ("${WebP_FIND_VERSION}" VERSION_GREATER "${WebP_VERSION}")
if (WebP_VERSION)
message(FATAL_ERROR "Required version (" ${WebP_FIND_VERSION} ") is higher than found version (" ${PC_WebP_VERSION} ")")
else ()
message(WARNING "Cannot determine WebP version without pkg-config")
endif ()
endif ()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(WebP
REQUIRED_VARS
WebP_LIBRARY
WebP_INCLUDE_DIR
VERSION_VAR WebP_VERSION
)
mark_as_advanced(WebP_INCLUDE_DIR WebP_LIBRARY)
if (WebP_FOUND)
set(WebP_LIBRARIES ${WebP_LIBRARY})
set(WebP_INCLUDE_DIRS ${WebP_INCLUDE_DIR})
if(NOT TARGET WebP::WebP)
add_library(WebP::WebP UNKNOWN IMPORTED)
set_target_properties(WebP::WebP PROPERTIES
INTERFACE_INCLUDE_DIRECTORIES ${WebP_INCLUDE_DIR}
IMPORTED_LINK_INTERFACE_LANGUAGES C)
if(WebP_LIBRARY_RELEASE)
set_property(TARGET WebP::WebP APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
set_target_properties(WebP::WebP PROPERTIES IMPORTED_LOCATION_RELEASE "${WebP_LIBRARY_RELEASE}")
endif()
if(WebP_LIBRARY_DEBUG)
set_property(TARGET WebP::WebP APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
set_target_properties(WebP::WebP PROPERTIES IMPORTED_LOCATION_DEBUG "${WebP_LIBRARY_DEBUG}")
endif()
if(NOT WebP_LIBRARY_RELEASE AND NOT WebP_LIBRARY_DEBUG)
set_target_properties(WebP::WebP PROPERTIES IMPORTED_LOCATION "${WebP_LIBRARY}")
endif()
endif()
endif ()

46
cmake/MapnikExport.cmake
View file

@ -1,5 +1,7 @@
include(CMakePackageConfigHelpers)
### exports mapnik cmake config files (mapnikConfigVersion and mapnikConfig)
function(mapnik_export_cmake_config)
# export mapnik configuration
write_basic_package_version_file(
"${CMAKE_CURRENT_BINARY_DIR}/mapnikConfigVersion.cmake"
@ -7,28 +9,38 @@ write_basic_package_version_file(
COMPATIBILITY ExactVersion
)
get_property(MAPNIK_UTILITIES GLOBAL PROPERTY MAPNIK_UTILITIES)
list(JOIN MAPNIK_DEPENDENCIES "\n" MAPNIK_DEPENDENCIES)
configure_package_config_file(${CMAKE_CURRENT_SOURCE_DIR}/cmake/mapnikConfig.cmake.in
# generate all find_dependency and pkg_config calls
set(mapnik_find_deps)
foreach(dep IN LISTS mapnik_deps)
set(ver_comment "# ${dep} used with version ${mapnik_${dep}_version}")
set(mapnik_find_deps "${mapnik_find_deps}\n${ver_comment}\n")
if(mapnik_${dep}_find_args)
list(REMOVE_DUPLICATES mapnik_${dep}_find_args)
list(JOIN mapnik_${dep}_find_args " " m_args_joined)
set(mapnik_find_deps "${mapnik_find_deps}find_dependency(${dep} ${m_args_joined})")
else()
list(JOIN mapnik_${dep}_pkg_args " " m_args_joined)
set(mapnik_find_deps "${mapnik_find_deps}pkg_check_modules(${dep} ${m_args_joined})")
endif()
endforeach()
configure_package_config_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/mapnikConfig.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/mapnikConfig.cmake"
INSTALL_DESTINATION ${MAPNIK_CMAKE_DIR}
PATH_VARS MAPNIK_INCLUDE_DIR PLUGINS_INSTALL_DIR FONTS_INSTALL_DIR MAPNIK_DEPENDENCIES MAPNIK_UTILITIES
PATH_VARS MAPNIK_INCLUDE_DIR PLUGINS_INSTALL_DIR FONTS_INSTALL_DIR mapnik_find_deps MAPNIK_UTILITIES
NO_CHECK_REQUIRED_COMPONENTS_MACRO
)
install(
FILES
"${CMAKE_CURRENT_BINARY_DIR}/mapnikConfig.cmake"
"${CMAKE_CURRENT_BINARY_DIR}/mapnikConfigVersion.cmake"
DESTINATION ${MAPNIK_CMAKE_DIR}
)
endfunction()
# install our modules, so that the expected target names are found.
install(
FILES
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindCairo.cmake"
"${CMAKE_CURRENT_SOURCE_DIR}/cmake/FindWebP.cmake"
DESTINATION ${MAPNIK_CMAKE_DIR}/Modules
)
mapnik_export_cmake_config()
install(EXPORT MapnikTargets
DESTINATION ${MAPNIK_CMAKE_DIR}
@ -36,21 +48,21 @@ install(EXPORT MapnikTargets
NAMESPACE mapnik::
)
### install plugin cmake config files ###
# Create configuration dependend files for the plugin install dirs.
# some package managers are using different paths per configuration.
string(TOLOWER "${CMAKE_BUILD_TYPE}" _build_type)
string(TOUPPER "${CMAKE_BUILD_TYPE}" _build_type_l)
set(_mapnik_plugin_file_name "mapnikPlugins-${_build_type}")
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/${_mapnik_plugin_file_name}.cmake.in "set(MAPNIK_PLUGINS_DIR_${_build_type_l} \"@PACKAGE_PLUGINS_INSTALL_DIR@\" CACHE STRING \"\")\n")
set(m_mapnik_plugin_file_name mapnikPlugins-${_build_type})
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/${m_mapnik_plugin_file_name}.cmake.in" "set(MAPNIK_PLUGINS_DIR_${_build_type_l} \"@PACKAGE_PLUGINS_INSTALL_DIR@\" CACHE STRING \"\")\n")
include(CMakePackageConfigHelpers)
configure_package_config_file(
${CMAKE_CURRENT_BINARY_DIR}/${_mapnik_plugin_file_name}.cmake.in
${CMAKE_CURRENT_BINARY_DIR}/${_mapnik_plugin_file_name}.cmake
"${CMAKE_CURRENT_BINARY_DIR}/${m_mapnik_plugin_file_name}.cmake.in"
"${CMAKE_CURRENT_BINARY_DIR}/${m_mapnik_plugin_file_name}.cmake"
PATH_VARS PLUGINS_INSTALL_DIR
INSTALL_DESTINATION ${MAPNIK_CMAKE_DIR}
)
install(
FILES ${CMAKE_CURRENT_BINARY_DIR}/${_mapnik_plugin_file_name}.cmake
FILES "${CMAKE_CURRENT_BINARY_DIR}/${m_mapnik_plugin_file_name}.cmake"
DESTINATION ${MAPNIK_CMAKE_DIR}
)

62
cmake/MapnikFindPackage.cmake
View file

@ -1,28 +1,50 @@
macro(mapnik_print_version)
string(TOUPPER ${ARGV0} TLNUP)
set(TLN ${ARGV0})
if(${TLN}_VERSION_STRING)
message(STATUS "Using ${ARGV0} version: ${${TLN}_VERSION_STRING}")
elseif(${TLN}_VERSION)
message(STATUS "Using ${ARGV0} version: ${${TLN}_VERSION}")
elseif(${TLNUP}_VERSION_STRING)
message(STATUS "Using ${ARGV0} version: ${${TLNUP}_VERSION_STRING}")
elseif(${TLNUP}_VERSION)
message(STATUS "Using ${ARGV0} version: ${${TLNUP}_VERSION}")
function(mapnik_set_dep_version dep var)
string(TOUPPER ${dep} m_package_name_upc)
set(m_package_name ${dep})
if(${m_package_name}_VERSION_STRING)
set(${var} ${${m_package_name}_VERSION_STRING} PARENT_SCOPE)
elseif(${m_package_name}_VERSION)
set(${var} ${${m_package_name}_VERSION} PARENT_SCOPE)
elseif(${m_package_name_upc}_VERSION_STRING)
set(${var} ${${m_package_name_upc}_VERSION_STRING} PARENT_SCOPE)
elseif(${m_package_name_upc}_VERSION)
set(${var} ${${m_package_name_upc}_VERSION} PARENT_SCOPE)
endif()
endfunction()
function(mapnik_print_package_info dep)
message(STATUS "Using ${dep} version: ${mapnik_${dep}_version}")
endfunction()
macro(mapnik_find_package dep)
find_package(${dep} ${ARGN})
if(${dep}_FOUND)
list(APPEND mapnik_deps ${dep})
if(mapnik_${dep}_find_args)
list(APPEND mapnik_${dep}_find_args ${ARGN})
else()
message(STATUS "Using ${ARGV0}")
set(mapnik_${dep}_find_args ${ARGN})
endif()
mapnik_set_dep_version(${dep} mapnik_${dep}_version)
mapnik_print_package_info(${dep})
else()
message(STATUS "not found: ${dep}")
endif()
endmacro()
macro(mapnik_find_package)
find_package(${ARGN})
if(${ARGV0}_FOUND)
set(MAPNIK_TMP_DEP ${ARGN})
list(JOIN MAPNIK_TMP_DEP " " MAPNIK_TMP_DEP)
list(APPEND MAPNIK_DEPENDENCIES "find_dependency(${MAPNIK_TMP_DEP})")
mapnik_print_version(${ARGV0})
macro(mapnik_pkg_check_modules dep)
pkg_check_modules(${dep} ${ARGN})
if(${dep}_FOUND)
list(APPEND mapnik_deps ${dep})
set(mapnik_${dep}_pkg_args ${ARGN})
mapnik_set_dep_version(${dep} mapnik_${dep}_version)
mapnik_print_package_info(${dep})
else()
message(STATUS "not found: ${ARGV0}")
message(STATUS "not found: ${dep}")
endif()
endmacro()

3
cmake/MapnikInstall.cmake
View file

@ -23,6 +23,9 @@ endfunction()
# Install plugins
#
function(mapnik_install_plugin _target)
if(NOT BUILD_SHARED_PLUGINS)
return()
endif()
install(TARGETS ${_target}
RUNTIME DESTINATION ${PLUGINS_INSTALL_DIR}
COMPONENT MapnikPluginRuntime

2
cmake/mapnikConfig.cmake.in
View file

@ -8,7 +8,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_LIST_DIR}/Modules/")
include(CMakeFindDependencyMacro)
find_dependency(Threads REQUIRED)
@MAPNIK_DEPENDENCIES@
@mapnik_find_deps@
include("${CMAKE_CURRENT_LIST_DIR}/mapnikTargets.cmake")

10
demo/c++/CMakeLists.txt
View file

@ -1,8 +1,6 @@
add_executable(mapnik-demo rundemo.cpp)
set_target_properties(mapnik-demo PROPERTIES
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
target_link_libraries(mapnik-demo PRIVATE
mapnik::agg
mapnik::mapnik
ICU::data ICU::i18n ICU::uc # needed for the static build (TODO: why isn't this correctly propagated from mapnik::mapnik?)
)
target_link_libraries(mapnik-demo PRIVATE mapnik::agg mapnik::mapnik)

23
demo/c++/rundemo.cpp
View file

@ -20,6 +20,7 @@
*
*****************************************************************************/
#include <mapnik/mapnik.hpp>
#include <mapnik/map.hpp>
#include <mapnik/layer.hpp>
#include <mapnik/rule.hpp>
@ -52,7 +53,7 @@ int main(int, char**)
"+proj=lcc +ellps=GRS80 +lat_0=49 +lon_0=-95 +lat+1=49 +lat_2=77 +datum=NAD83 +units=m +no_defs";
const std::string srs_merc = "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0.0 +k=1.0 "
"+units=m +nadgrids=@null +wktext +no_defs +over";
mapnik::setup();
try
{
std::cout << " running demo ... \n";
@ -131,8 +132,8 @@ int main(int, char**)
line_symbolizer line_sym;
put(line_sym, keys::stroke, color(171, 158, 137));
put(line_sym, keys::stroke_width, 2.0);
put(line_sym, keys::stroke_linecap, ROUND_CAP);
put(line_sym, keys::stroke_linejoin, ROUND_JOIN);
put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP);
put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN);
r.append(std::move(line_sym));
}
roads34_style.add_rule(std::move(r));
@ -148,8 +149,8 @@ int main(int, char**)
line_symbolizer line_sym;
put(line_sym, keys::stroke, color(171, 158, 137));
put(line_sym, keys::stroke_width, 4.0);
put(line_sym, keys::stroke_linecap, ROUND_CAP);
put(line_sym, keys::stroke_linejoin, ROUND_JOIN);
put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP);
put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN);
r.append(std::move(line_sym));
}
roads2_style_1.add_rule(std::move(r));
@ -164,8 +165,8 @@ int main(int, char**)
line_symbolizer line_sym;
put(line_sym, keys::stroke, color(255, 250, 115));
put(line_sym, keys::stroke_width, 2.0);
put(line_sym, keys::stroke_linecap, ROUND_CAP);
put(line_sym, keys::stroke_linejoin, ROUND_JOIN);
put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP);
put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN);
r.append(std::move(line_sym));
}
roads2_style_2.add_rule(std::move(r));
@ -181,8 +182,8 @@ int main(int, char**)
line_symbolizer line_sym;
put(line_sym, keys::stroke, color(188, 149, 28));
put(line_sym, keys::stroke_width, 7.0);
put(line_sym, keys::stroke_linecap, ROUND_CAP);
put(line_sym, keys::stroke_linejoin, ROUND_JOIN);
put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP);
put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN);
r.append(std::move(line_sym));
}
roads1_style_1.add_rule(std::move(r));
@ -197,8 +198,8 @@ int main(int, char**)
line_symbolizer line_sym;
put(line_sym, keys::stroke, color(242, 191, 36));
put(line_sym, keys::stroke_width, 5.0);
put(line_sym, keys::stroke_linecap, ROUND_CAP);
put(line_sym, keys::stroke_linejoin, ROUND_JOIN);
put(line_sym, keys::stroke_linecap, line_cap_enum::ROUND_CAP);
put(line_sym, keys::stroke_linejoin, line_join_enum::ROUND_JOIN);
r.append(std::move(line_sym));
}
roads1_style_2.add_rule(std::move(r));

4
demo/viewer/CMakeLists.txt
View file

@ -40,15 +40,13 @@ set_target_properties(mapnik-viewer PROPERTIES
AUTORCC ON
AUTOUIC ON
AUTOMOC ON
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
)
target_link_libraries(mapnik-viewer PRIVATE
Qt${QT_VERSION_MAJOR}::Widgets
mapnik::agg
mapnik::mapnik
ICU::data ICU::i18n ICU::uc # needed for the static build (TODO: why isn't this correctly propagated from mapnik::mapnik?)
)
file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/viewer.ini

2
demo/viewer/main.cpp
View file

@ -23,12 +23,14 @@
#include <QSettings>
#include <mapnik/datasource_cache.hpp>
#include <mapnik/font_engine_freetype.hpp>
#include <mapnik/mapnik.hpp>
#include "mainwindow.hpp"
int main(int argc, char** argv)
{
using mapnik::datasource_cache;
using mapnik::freetype_engine;
mapnik::setup();
try
{
#if QT_VERSION >= QT_VERSION_CHECK(5, 6, 0)

8
include/mapnik/adaptive_smooth.hpp
View file

@ -4,6 +4,8 @@
#include <mapnik/util/math.hpp>
#include <mapnik/warning.hpp>
#include <mapnik/symbolizer_enumerations.hpp>
#include <mapnik/util/variant.hpp>
MAPNIK_DISABLE_WARNING_PUSH
#include <mapnik/warning_ignore_agg.hpp>
#include "agg_conv_smooth_poly1.h"
@ -80,9 +82,9 @@ class smooth_converter
{
switch (algo)
{
case SMOOTH_ALGORITHM_ADAPTIVE:
case smooth_algorithm_enum::SMOOTH_ALGORITHM_ADAPTIVE:
return adaptive_impl_type(geom);
case SMOOTH_ALGORITHM_BASIC:
case smooth_algorithm_enum::SMOOTH_ALGORITHM_BASIC:
default:
break;
}
@ -92,7 +94,7 @@ class smooth_converter
public:
smooth_converter(Geometry& geom)
: geom_(geom)
, impl_(std::move(init_impl(SMOOTH_ALGORITHM_BASIC, geom)))
, impl_(std::move(init_impl(smooth_algorithm_enum::SMOOTH_ALGORITHM_BASIC, geom)))
{}
void algorithm(smooth_algorithm_enum algo) { impl_ = init_impl(algo, geom_); }

10
include/mapnik/agg_helpers.hpp
View file

@ -39,19 +39,19 @@ void set_gamma_method(T& ras_ptr, double gamma, gamma_method_enum method)
{
switch (method)
{
case GAMMA_POWER:
case gamma_method_enum::GAMMA_POWER:
ras_ptr->gamma(agg::gamma_power(gamma));
break;
case GAMMA_LINEAR:
case gamma_method_enum::GAMMA_LINEAR:
ras_ptr->gamma(agg::gamma_linear(0.0, gamma));
break;
case GAMMA_NONE:
case gamma_method_enum::GAMMA_NONE:
ras_ptr->gamma(agg::gamma_none());
break;
case GAMMA_THRESHOLD:
case gamma_method_enum::GAMMA_THRESHOLD:
ras_ptr->gamma(agg::gamma_threshold(gamma));
break;
case GAMMA_MULTIPLY:
case gamma_method_enum::GAMMA_MULTIPLY:
ras_ptr->gamma(agg::gamma_multiply(gamma));
break;
default:

14
include/mapnik/config.hpp
View file

@ -24,15 +24,23 @@
#define MAPNIK_CONFIG_HPP
// Windows DLL support
// clang-format off
#ifdef _WIN32
#ifdef MAPNIK_STATIC_DEFINE
# define MAPNIK_DECL
# define MAPNIK_EXP
#else
# define MAPNIK_EXP __declspec(dllexport)
#define MAPNIK_IMP __declspec(dllimport)
# ifndef MAPNIK_DECL
# ifdef MAPNIK_EXPORTS
/* We are building this library */
# define MAPNIK_DECL __declspec(dllexport)
# else
/* We are using this library */
# define MAPNIK_DECL __declspec(dllimport)
# endif
# endif
#endif
# pragma warning( disable: 4251 )
# pragma warning( disable: 4275 )
# if (_MSC_VER >= 1400) // vc8
@ -49,7 +57,7 @@
# define MAPNIK_IMP
# endif
#endif
// clang-format on
#define PROJ_ENVELOPE_POINTS 20
#endif // MAPNIK_CONFIG_HPP

50
include/mapnik/css/css_color_grammar_x3_def.hpp
View file

@ -48,11 +48,9 @@ namespace css_color_grammar {
using x3::attr;
using x3::double_;
using x3::hex;
using x3::lit;
using x3::no_case;
using x3::no_skip;
using x3::omit;
using x3::symbols;
using x3::uint_parser;
@ -214,11 +212,11 @@ struct named_colors_ : x3::symbols<color>
;
// clang-format on
}
} named_colors;
} const named_colors;
x3::uint_parser<std::uint8_t, 16, 2, 2> hex2;
x3::uint_parser<std::uint8_t, 16, 1, 1> hex1;
x3::uint_parser<std::uint16_t, 10, 1, 3> dec3;
const x3::uint_parser<std::uint8_t, 16, 2, 2> hex2;
const x3::uint_parser<std::uint8_t, 16, 1, 1> hex1;
const x3::uint_parser<std::uint16_t, 10, 1, 3> dec3;
// rules
x3::rule<class hex2_color, color> const hex2_color("hex2_color");
@ -245,67 +243,67 @@ struct percent_converter
static std::uint8_t call(double val) { return safe_cast<std::uint8_t>(std::lround((255.0 * val) / 100.0)); }
};
auto dec_red = [](auto& ctx) {
const auto dec_red = [](auto& ctx) {
_val(ctx).red_ = _attr(ctx);
};
auto dec_green = [](auto& ctx) {
const auto dec_green = [](auto& ctx) {
_val(ctx).green_ = _attr(ctx);
};
auto dec_blue = [](auto& ctx) {
const auto dec_blue = [](auto& ctx) {
_val(ctx).blue_ = _attr(ctx);
};
auto opacity = [](auto& ctx) {
const auto opacity = [](auto& ctx) {
_val(ctx).alpha_ = uint8_t((255.0 * clip_opacity::call(_attr(ctx))) + 0.5);
};
auto percent_red = [](auto& ctx) {
const auto percent_red = [](auto& ctx) {
_val(ctx).red_ = percent_converter::call(_attr(ctx));
};
auto percent_green = [](auto& ctx) {
const auto percent_green = [](auto& ctx) {
_val(ctx).green_ = percent_converter::call(_attr(ctx));
};
auto percent_blue = [](auto& ctx) {
const auto percent_blue = [](auto& ctx) {
_val(ctx).blue_ = percent_converter::call(_attr(ctx));
};
auto hex1_red = [](auto& ctx) {
const auto hex1_red = [](auto& ctx) {
_val(ctx).red_ = _attr(ctx) | _attr(ctx) << 4;
};
auto hex1_green = [](auto& ctx) {
const auto hex1_green = [](auto& ctx) {
_val(ctx).green_ = _attr(ctx) | _attr(ctx) << 4;
};
auto hex1_blue = [](auto& ctx) {
const auto hex1_blue = [](auto& ctx) {
_val(ctx).blue_ = _attr(ctx) | _attr(ctx) << 4;
};
auto hex1_opacity = [](auto& ctx) {
const auto hex1_opacity = [](auto& ctx) {
_val(ctx).alpha_ = _attr(ctx) | _attr(ctx) << 4;
};
auto hex2_red = [](auto& ctx) {
const auto hex2_red = [](auto& ctx) {
_val(ctx).red_ = _attr(ctx);
};
auto hex2_green = [](auto& ctx) {
const auto hex2_green = [](auto& ctx) {
_val(ctx).green_ = _attr(ctx);
};
auto hex2_blue = [](auto& ctx) {
const auto hex2_blue = [](auto& ctx) {
_val(ctx).blue_ = _attr(ctx);
};
auto hex2_opacity = [](auto& ctx) {
const auto hex2_opacity = [](auto& ctx) {
_val(ctx).alpha_ = _attr(ctx);
};
auto hsl_to_rgba = [](auto& ctx) {
const auto hsl_to_rgba = [](auto& ctx) {
double h = std::get<0>(_attr(ctx));
double s = std::get<1>(_attr(ctx));
double l = std::get<2>(_attr(ctx));
@ -325,10 +323,10 @@ auto hsl_to_rgba = [](auto& ctx) {
}
m1 = l * 2 - m2;
double r = hue_to_rgb(m1, m2, h + 1.0 / 3.0);
double g = hue_to_rgb(m1, m2, h);
double b = hue_to_rgb(m1, m2, h - 1.0 / 3.0);
uint8_t alpha = uint8_t((255.0 * clip_opacity::call(std::get<3>(_attr(ctx)))) + 0.5);
const double r = hue_to_rgb(m1, m2, h + 1.0 / 3.0);
const double g = hue_to_rgb(m1, m2, h);
const double b = hue_to_rgb(m1, m2, h - 1.0 / 3.0);
const uint8_t alpha = uint8_t((255.0 * clip_opacity::call(std::get<3>(_attr(ctx)))) + 0.5);
_val(ctx) = color(safe_cast<uint8_t>(std::lround(255.0 * r)),
safe_cast<uint8_t>(std::lround(255.0 * g)),
safe_cast<uint8_t>(std::lround(255.0 * b)),

13
include/mapnik/css/css_grammar_x3_def.hpp
View file

@ -150,32 +150,27 @@ namespace css_grammar {
using x3::alnum;
using x3::alpha;
using x3::attr;
using x3::char_;
using x3::lexeme;
using x3::lit;
using x3::no_case;
using x3::no_skip;
using x3::raw;
using x3::standard::space;
// import unicode string rule
namespace {
auto const& css_string = mapnik::json::grammar::unicode_string;
}
const auto css_string = mapnik::json::grammar::unicode_string;
auto assign_def = [](auto const& ctx) {
const auto assign_def = [](auto const& ctx) {
for (auto const& k : std::get<0>(_attr(ctx)))
{
_val(ctx).emplace(k, std::get<1>(_attr(ctx)));
}
};
auto assign_key = [](auto const& ctx) {
const auto assign_key = [](auto const& ctx) {
_val(ctx).first = std::move(_attr(ctx));
};
auto assign_value = [](auto const& ctx) {
const auto assign_value = [](auto const& ctx) {
_val(ctx).second = std::move(_attr(ctx));
};

8
include/mapnik/csv/csv_grammar_x3_def.hpp
View file

@ -39,9 +39,9 @@ using standard::char_;
using x3::lexeme;
using x3::lit;
struct unesc_char_ : x3::symbols<char>
struct unesc_char_csv_ : x3::symbols<char>
{
unesc_char_()
unesc_char_csv_()
{
add("\\a", '\a') //
("\\b", '\b') //
@ -56,7 +56,7 @@ struct unesc_char_ : x3::symbols<char>
("\"\"", '\"') // double quote
;
}
} unesc_char;
} const unesc_char_csv;
template<typename T>
struct literal : x3::parser<literal<T>>
@ -93,7 +93,7 @@ auto const column_def = quoted_text | *(char_ - separator);
auto const quoted_text_def = quote > text > quote // support unmatched quotes or not (??)
;
auto const text_def = *(unesc_char | (char_ - quote));
auto const text_def = *(unesc_char_csv | (char_ - quote));
BOOST_SPIRIT_DEFINE(line, column, quoted_text, text);

19
include/mapnik/datasource.hpp
View file

@ -113,25 +113,6 @@ class datasource_deleter
};
using datasource_ptr = std::shared_ptr<datasource>;
#ifdef MAPNIK_STATIC_PLUGINS
#define DATASOURCE_PLUGIN(classname)
#else
#define DATASOURCE_PLUGIN(classname) \
extern "C" MAPNIK_EXP const char* datasource_name() \
{ \
return classname::name(); \
} \
extern "C" MAPNIK_EXP datasource* create(parameters const& params) \
{ \
return new classname(params); \
} \
extern "C" MAPNIK_EXP void destroy(datasource* ds) \
{ \
delete ds; \
}
#endif
} // namespace mapnik
#endif // MAPNIK_DATASOURCE_HPP

5
include/mapnik/datasource_cache.hpp
View file

@ -47,7 +47,8 @@ class MAPNIK_DECL datasource_cache : public singleton<datasource_cache, CreateSt
friend class CreateStatic<datasource_cache>;
public:
std::vector<std::string> plugin_names();
bool plugin_registered(const std::string& plugin_name) const;
std::vector<std::string> plugin_names() const;
std::string plugin_directories();
bool register_datasources(std::string const& path, bool recurse = false);
bool register_datasource(std::string const& path);
@ -62,7 +63,7 @@ class MAPNIK_DECL datasource_cache : public singleton<datasource_cache, CreateSt
// but the instance also needs its own mutex to protect the
// plugins_ and plugin_directories_ members which are potentially
// modified recusrively by register_datasources(path, true);
std::recursive_mutex instance_mutex_;
mutable std::recursive_mutex instance_mutex_;
};
extern template class MAPNIK_DECL singleton<datasource_cache, CreateStatic>;

313
include/mapnik/enumeration.hpp
View file

@ -31,6 +31,13 @@
#include <iostream>
#include <cstdlib>
#include <algorithm>
#include <array>
#include <tuple>
#include <stdexcept>
#include <map>
#if __cpp_lib_string_view >= 201606L
#include <string_view>
#endif
#include <mapnik/warning.hpp>
@ -51,9 +58,160 @@ class illegal_enum_value : public std::exception
virtual const char* what() const noexcept { return what_.c_str(); }
protected:
std::string what_;
const std::string what_;
};
namespace detail {
#if __cpp_lib_string_view >= 201606L
using mapnik_string_view = std::string_view;
#else
class mapnik_string_view // use std::string_view in C++17
{
public:
template<std::size_t N>
constexpr mapnik_string_view(const char (&s)[N])
: size_(N)
, data_(s)
{}
constexpr mapnik_string_view(const char* s, std::size_t N)
: size_(N)
, data_(s)
{}
constexpr char operator[](std::size_t index) const
{
return (index >= size_) ? throw std::out_of_range("Invalid index.") : data_[index];
}
constexpr char const* data() const { return data_; }
private:
std::size_t size_;
const char* data_;
};
constexpr bool mapnik_string_view_equals(mapnik_string_view const& a, char const* b, std::size_t i)
{
if (a[i] != b[i])
{
return false;
}
else if (a[i] == 0 || b[i] == 0)
{
return true;
}
else
{
return mapnik_string_view_equals(a, b, i + 1);
}
}
constexpr bool operator==(mapnik_string_view const& a, char const* b)
{
return mapnik_string_view_equals(a, b, 0);
}
#endif
template<class EnumT>
using EnumStringT = std::tuple<EnumT, mapnik_string_view>;
template<class EnumT, std::size_t N>
using EnumMapT = std::array<EnumStringT<EnumT>, N>;
template<class EnumT, std::size_t N>
constexpr char const* EnumGetValue(EnumMapT<EnumT, N> const& map, EnumT key, std::size_t i = 0)
{
if (i >= map.size())
{
throw illegal_enum_value{"Enum value not present in map."};
}
return (std::get<0>(map[i]) == key) ? std::get<1>(map[i]).data() : EnumGetValue(map, key, i + 1);
}
template<class EnumT, std::size_t N>
constexpr EnumT EnumGetKey(EnumMapT<EnumT, N> const& map, char const* value, std::size_t i = 0)
{
if (i >= map.size())
{
throw illegal_enum_value{"Enum key not present in map."};
}
return (std::get<1>(map[i]) == value) ? std::get<0>(map[i]) : EnumGetKey(map, value, i + 1);
}
} // namespace detail
template<typename ENUM,
char const* (*F_TO_STRING)(ENUM),
ENUM (*F_FROM_STRING)(const char*),
std::map<ENUM, std::string> (*F_LOOKUP)()>
struct MAPNIK_DECL enumeration
{
using native_type = ENUM;
constexpr operator ENUM() const { return value_; }
// constexpr bool operator==(const enumeration_new& rhs) { return value_ == rhs.value_; }
void operator=(ENUM v) { value_ = v; }
void operator=(const enumeration& other) { value_ = other.value_; }
enumeration()
: value_()
{}
enumeration(ENUM v)
: value_(v)
{}
void from_string(const std::string& str) { value_ = F_FROM_STRING(str.c_str()); }
std::string as_string() const { return F_TO_STRING(value_); }
static std::map<ENUM, std::string> lookupMap() { return F_LOOKUP(); }
ENUM value_;
};
#define DEFINE_ENUM_FNCS(fnc_name, enum_class) \
MAPNIK_DECL char const* fnc_name##_to_string(enum_class value); \
MAPNIK_DECL enum_class fnc_name##_from_string(const char* value); \
MAPNIK_DECL std::ostream& operator<<(std::ostream& stream, enum_class value); \
MAPNIK_DECL std::map<enum_class, std::string> fnc_name##_lookup();
#define IMPLEMENT_ENUM_FNCS(fnc_name, enum_class) \
char const* fnc_name##_to_string(enum_class value) \
{ \
return mapnik::detail::EnumGetValue(fnc_name##_map, value); \
} \
enum_class fnc_name##_from_string(const char* value) \
{ \
return mapnik::detail::EnumGetKey(fnc_name##_map, value); \
} \
std::ostream& operator<<(std::ostream& stream, enum_class value) \
{ \
stream << fnc_name##_to_string(value); \
return stream; \
} \
std::map<enum_class, std::string> fnc_name##_lookup() \
{ \
std::map<enum_class, std::string> val_map; \
std::transform( \
fnc_name##_map.begin(), \
fnc_name##_map.end(), \
std::inserter(val_map, val_map.end()), \
[](const mapnik::detail::EnumStringT<enum_class>& val) { \
return std::pair<enum_class, std::string>{std::get<0>(val), std::string{std::get<1>(val).data()}}; \
}); \
return val_map; \
}
#define DEFINE_ENUM(type_alias, enum_class) \
DEFINE_ENUM_FNCS(type_alias, enum_class) \
using type_alias = enumeration<enum_class, type_alias##_to_string, type_alias##_from_string, type_alias##_lookup>; \
extern template struct MAPNIK_DECL \
enumeration<enum_class, type_alias##_to_string, type_alias##_from_string, type_alias##_lookup>;
#define IMPLEMENT_ENUM(type_alias, enum_class) \
IMPLEMENT_ENUM_FNCS(type_alias, enum_class) \
template class MAPNIK_DECL \
enumeration<enum_class, type_alias##_to_string, type_alias##_from_string, type_alias##_lookup>;
/** Slim wrapper for enumerations. It creates a new type from a native enum and
* a char pointer array. It almost exactly behaves like a native enumeration
* type. It supports string conversion through stream operators. This is useful
@ -133,159 +291,6 @@ class illegal_enum_value : public std::exception
* @endcode
*/
template<typename ENUM, int THE_MAX>
class MAPNIK_DECL enumeration
{
public:
using native_type = ENUM;
enumeration()
: value_()
{}
enumeration(ENUM v)
: value_(v)
{}
enumeration(enumeration const& other)
: value_(other.value_)
{}
/** Assignment operator for native enum values. */
void operator=(ENUM v) { value_ = v; }
/** Assignment operator. */
void operator=(enumeration const& other) { value_ = other.value_; }
/** Conversion operator for native enum values. */
operator ENUM() const { return value_; }
enum Max { MAX = THE_MAX };
/** Converts @p str to an enum.
* @throw illegal_enum_value @p str is not a legal identifier.
* */
void from_string(std::string const& str)
{
// TODO: Enum value strings with underscore are deprecated in Mapnik 3.x
// and support will be removed in Mapnik 4.x.
bool deprecated = false;
std::string str_copy(str);
if (str_copy.find('_') != std::string::npos)
{
std::replace(str_copy.begin(), str_copy.end(), '_', '-');
deprecated = true;
}
for (unsigned i = 0; i < THE_MAX; ++i)
{
MAPNIK_DISABLE_WARNING_PUSH
MAPNIK_DISABLE_WARNING_UNKNOWN_PRAGMAS
MAPNIK_DISABLE_WARNING_PRAGMAS
MAPNIK_DISABLE_LONG_LONG
if (str_copy == our_strings_[i])
MAPNIK_DISABLE_WARNING_POP
{
value_ = static_cast<ENUM>(i);
if (deprecated)
{
MAPNIK_LOG_ERROR(enumerations)
<< "enumeration value (" << str
<< ") using \"_\" is deprecated and will be removed in Mapnik 4.x, use '" << str_copy
<< "' instead";
}
return;
}
}
MAPNIK_DISABLE_WARNING_PUSH
MAPNIK_DISABLE_WARNING_UNKNOWN_PRAGMAS
MAPNIK_DISABLE_WARNING_PRAGMAS
MAPNIK_DISABLE_LONG_LONG
throw illegal_enum_value(std::string("Illegal enumeration value '") + str + "' for enum " + our_name_);
MAPNIK_DISABLE_WARNING_POP
}
/** Returns the current value as a string identifier. */
std::string as_string() const
{
MAPNIK_DISABLE_WARNING_PUSH
MAPNIK_DISABLE_WARNING_UNKNOWN_PRAGMAS
MAPNIK_DISABLE_WARNING_PRAGMAS
MAPNIK_DISABLE_LONG_LONG
return our_strings_[value_];
MAPNIK_DISABLE_WARNING_POP
}
/** Static helper function to iterate over valid identifiers. */
static const char* get_string(unsigned i) { return our_strings_[i]; }
/** Performs some simple checks and quits the application if
* any error is detected. Tries to print helpful error messages.
*/
static bool verify_mapnik_enum(const char* filename, unsigned line_no)
{
for (unsigned i = 0; i < THE_MAX; ++i)
{
if (our_strings_[i] == 0)
{
std::cerr << "### FATAL: Not enough strings for enum " << our_name_ << " defined in file '" << filename
<< "' at line " << line_no;
}
}
if (std::string("") != our_strings_[THE_MAX])
{
std::cerr << "### FATAL: The string array for enum " << our_name_ << " defined in file '" << filename
<< "' at line " << line_no << " has too many items or is not terminated with an "
<< "empty string";
}
return true;
}
private:
ENUM value_;
static const char** our_strings_;
static std::string our_name_;
static bool our_verified_flag_;
};
/** ostream operator for enumeration
* @relates mapnik::enumeration
*/
template<class ENUM, int THE_MAX>
std::ostream& operator<<(std::ostream& os, const mapnik::enumeration<ENUM, THE_MAX>& e)
{
return os << e.as_string();
}
} // namespace mapnik
/** Helper macro.
* @relates mapnik::enumeration
*/
#ifdef _MSC_VER
#define DEFINE_ENUM(name, e) \
template enumeration<e, e##_MAX>; \
using name = enumeration<e, e##_MAX>;
#else
#define DEFINE_ENUM(name, e) \
using name = enumeration<e, e##_MAX>; \
template<> \
MAPNIK_DECL const char** name ::our_strings_; \
template<> \
MAPNIK_DECL std::string name ::our_name_; \
template<> \
MAPNIK_DECL bool name ::our_verified_flag_;
#endif
/** Helper macro. Runs the verify_mapnik_enum() method during static initialization.
* @relates mapnik::enumeration
*/
#define IMPLEMENT_ENUM(name, strings) \
template<> \
MAPNIK_DECL const char** name ::our_strings_ = strings; \
template<> \
MAPNIK_DECL std::string name ::our_name_ = #name; \
template<> \
MAPNIK_DECL bool name ::our_verified_flag_(name ::verify_mapnik_enum(__FILE__, __LINE__));
#endif // MAPNIK_ENUMERATION_HPP

66
include/mapnik/expression_grammar_x3_def.hpp
View file

@ -51,23 +51,17 @@ namespace grammar {
namespace x3 = boost::spirit::x3;
namespace ascii = boost::spirit::x3::ascii;
using ascii::char_;
using ascii::string;
using x3::_attr;
using x3::_val;
using x3::alnum;
using x3::alpha;
using x3::bool_;
using x3::double_;
using x3::int_;
using x3::lexeme;
using x3::lit;
using x3::no_case;
using x3::no_skip;
x3::uint_parser<char, 16, 2, 2> const hex2{};
namespace {
auto const& escaped_unicode = json::grammar::escaped_unicode;
}
const auto escaped_unicode = json::grammar::escaped_unicode;
template<typename Context>
inline mapnik::transcoder const& extract_transcoder(Context const& ctx)
@ -75,19 +69,19 @@ inline mapnik::transcoder const& extract_transcoder(Context const& ctx)
return x3::get<transcoder_tag>(ctx);
}
auto append = [](auto const& ctx) {
const auto append = [](auto const& ctx) {
_val(ctx) += _attr(ctx);
};
auto do_assign = [](auto const& ctx) {
const auto do_assign = [](auto const& ctx) {
_val(ctx) = std::move(_attr(ctx));
};
auto do_negate = [](auto const& ctx) {
const auto do_negate = [](auto const& ctx) {
_val(ctx) = std::move(unary_node<mapnik::tags::negate>(_attr(ctx)));
};
auto do_attribute = [](auto const& ctx) {
const auto do_attribute = [](auto const& ctx) {
auto const& attr = _attr(ctx);
if (attr == "mapnik::geometry_type")
{
@ -99,84 +93,84 @@ auto do_attribute = [](auto const& ctx) {
}
};
auto do_global_attribute = [](auto const& ctx) {
const auto do_global_attribute = [](auto const& ctx) {
_val(ctx) = std::move(global_attribute(_attr(ctx)));
};
auto do_add = [](auto const& ctx) {
const auto do_add = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::plus>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_subt = [](auto const& ctx) {
const auto do_subt = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::minus>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_mult = [](auto const& ctx) {
const auto do_mult = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::mult>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_div = [](auto const& ctx) {
const auto do_div = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::div>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_mod = [](auto const& ctx) {
const auto do_mod = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::mod>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_unicode = [](auto const& ctx) {
const auto do_unicode = [](auto const& ctx) {
auto const& tr = extract_transcoder(ctx);
_val(ctx) = std::move(tr.transcode(_attr(ctx).c_str()));
};
auto do_null = [](auto const& ctx) {
const auto do_null = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::value_null());
};
auto do_not = [](auto const& ctx) {
const auto do_not = [](auto const& ctx) {
mapnik::unary_node<mapnik::tags::logical_not> node(_attr(ctx));
_val(ctx) = std::move(node);
};
auto do_and = [](auto const& ctx) {
const auto do_and = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::logical_and>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_or = [](auto const& ctx) {
const auto do_or = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::logical_or>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_equal = [](auto const& ctx) {
const auto do_equal = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::equal_to>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_not_equal = [](auto const& ctx) {
const auto do_not_equal = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::not_equal_to>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_less = [](auto const& ctx) {
const auto do_less = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::less>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_less_equal = [](auto const& ctx) {
const auto do_less_equal = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::less_equal>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_greater = [](auto const& ctx) {
const auto do_greater = [](auto const& ctx) {
_val(ctx) = std::move(mapnik::binary_node<mapnik::tags::greater>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_greater_equal = [](auto const& ctx) {
const auto do_greater_equal = [](auto const& ctx) {
_val(ctx) =
std::move(mapnik::binary_node<mapnik::tags::greater_equal>(std::move(_val(ctx)), std::move(_attr(ctx))));
};
// regex
auto do_regex_match = [](auto const& ctx) {
const auto do_regex_match = [](auto const& ctx) {
auto const& tr = extract_transcoder(ctx);
_val(ctx) = std::move(mapnik::regex_match_node(tr, std::move(_val(ctx)), std::move(_attr(ctx))));
};
auto do_regex_replace = [](auto const& ctx) {
const auto do_regex_replace = [](auto const& ctx) {
auto const& tr = extract_transcoder(ctx);
auto const& pair = _attr(ctx);
auto const& pattern = std::get<0>(pair);
@ -197,7 +191,7 @@ struct boolean_ : x3::symbols<mapnik::value_bool>
("false", false) //
;
}
} boolean;
} const boolean;
struct floating_point_constants : x3::symbols<mapnik::value_double>
{
@ -208,7 +202,7 @@ struct floating_point_constants : x3::symbols<mapnik::value_double>
("rad_to_deg", 57.295779513082320876798154814105) //
;
}
} float_const;
} const float_const;
// unary functions
struct unary_function_types_ : x3::symbols<unary_function_impl>
@ -225,7 +219,7 @@ struct unary_function_types_ : x3::symbols<unary_function_impl>
("length", length_impl()) //
;
}
} unary_func_types;
} const unary_func_types;
// binary functions
@ -238,7 +232,7 @@ struct binary_function_types_ : x3::symbols<binary_function_impl>
("pow", binary_function_impl(pow_impl)) //
;
}
} binary_func_types;
} const binary_func_types;
// geometry types
struct geometry_types_ : x3::symbols<mapnik::value_integer>
@ -251,7 +245,7 @@ struct geometry_types_ : x3::symbols<mapnik::value_integer>
("collection", 4) //
;
}
} geometry_type;
} const geometry_type;
struct unesc_chars_ : x3::symbols<char>
{
@ -269,7 +263,7 @@ struct unesc_chars_ : x3::symbols<char>
("\\\"", '\"') //
;
}
} unesc_char;
} const unesc_char;
// rules
x3::rule<class logical_expression, mapnik::expr_node> const logical_expression("logical expression");

2
include/mapnik/feature_style_processor_impl.hpp
View file

@ -592,7 +592,7 @@ void feature_style_processor<Processor>::render_style(Processor& p,
util::apply_visitor(symbolizer_dispatch<Processor>(p, *feature, prj_trans), sym);
}
}
if (style->get_filter_mode() == FILTER_FIRST)
if (style->get_filter_mode() == filter_mode_enum::FILTER_FIRST)
{
// Stop iterating over rules and proceed with next feature.
do_also = false;

2
include/mapnik/feature_type_style.hpp
View file

@ -43,7 +43,7 @@ namespace mapnik {
class rule;
enum filter_mode_enum { FILTER_ALL, FILTER_FIRST, filter_mode_enum_MAX };
enum class filter_mode_enum { FILTER_ALL, FILTER_FIRST, filter_mode_enum_MAX };
DEFINE_ENUM(filter_mode_e, filter_mode_enum);

18
include/mapnik/image_filter_grammar_x3_def.hpp
View file

@ -57,41 +57,35 @@ namespace x3 = boost::spirit::x3;
namespace image_filter {
using x3::attr;
using x3::char_;
using x3::double_;
using x3::hex;
using x3::lit;
using x3::no_case;
using x3::no_skip;
using x3::omit;
using x3::symbols;
using x3::uint_parser;
auto push_back = [](auto& ctx) {
const auto push_back = [](auto& ctx) {
_val(ctx).push_back(_attr(ctx));
};
auto set_rx_ry = [](auto& ctx) {
const auto set_rx_ry = [](auto& ctx) {
_val(ctx).rx = _val(ctx).ry = _attr(ctx);
};
auto set_ry = [](auto& ctx) {
const auto set_ry = [](auto& ctx) {
_val(ctx).ry = _attr(ctx);
};
auto offset_value = [](auto& ctx) {
const auto offset_value = [](auto& ctx) {
_val(ctx) = _attr(ctx);
};
auto percent = [](auto& ctx) {
const auto percent = [](auto& ctx) {
double val = std::abs(_val(ctx) / 100.0);
if (val > 1.0)
val = 1.0;
_val(ctx) = val;
};
x3::uint_parser<unsigned, 10, 1, 3> radius;
const x3::uint_parser<unsigned, 10, 1, 3> radius;
// Import the expression rule
namespace {

8
include/mapnik/json/feature_grammar_x3_def.hpp
View file

@ -154,14 +154,14 @@ struct geometry_type_ : x3::symbols<mapnik::geometry::geometry_types>
("\"GeometryCollection\"", mapnik::geometry::geometry_types::GeometryCollection) //
;
}
} geometry_type_symbols;
} const geometry_type_symbols;
namespace {
auto assign_name = [](auto const& ctx) {
const auto assign_name = [](auto const& ctx) {
std::get<0>(_val(ctx)) = std::move(_attr(ctx));
};
auto assign_value = [](auto const& ctx) {
const auto assign_value = [](auto const& ctx) {
std::get<1>(_val(ctx)) = std::move(_attr(ctx));
};
@ -207,7 +207,7 @@ auto const assign_collection = [](auto const& ctx) {
std::get<2>(_val(ctx)) = std::move(_attr(ctx));
};
auto assign_property = [](auto const& ctx) {
const auto assign_property = [](auto const& ctx) {
mapnik::feature_impl& feature = x3::get<grammar::feature_tag>(ctx);
mapnik::transcoder const& tr = x3::get<grammar::transcoder_tag>(ctx);
feature.put_new(std::get<0>(_attr(ctx)),

17
include/mapnik/json/generic_json_grammar_x3_def.hpp
View file

@ -35,39 +35,36 @@ namespace x3 = boost::spirit::x3;
namespace {
auto make_null = [](auto const& ctx) {
const auto make_null = [](auto const& ctx) {
_val(ctx) = mapnik::value_null{};
};
auto make_true = [](auto const& ctx) {
const auto make_true = [](auto const& ctx) {
_val(ctx) = true;
};
auto make_false = [](auto const& ctx) {
const auto make_false = [](auto const& ctx) {
_val(ctx) = false;
};
auto assign = [](auto const& ctx) {
const auto assign = [](auto const& ctx) {
_val(ctx) = std::move(_attr(ctx));
};
auto assign_key = [](auto const& ctx) {
const auto assign_key = [](auto const& ctx) {
std::get<0>(_val(ctx)) = std::move(_attr(ctx));
};
auto assign_value = [](auto const& ctx) {
const auto assign_value = [](auto const& ctx) {
std::get<1>(_val(ctx)) = std::move(_attr(ctx));
};
} // namespace
using x3::lit;
using x3::string;
// import unicode string rule
namespace {
auto const& json_string = mapnik::json::grammar::unicode_string;
}
const auto json_string = mapnik::json::grammar::unicode_string;
// rules
x3::rule<class json_object_tag, json_object> const object("JSON Object");

22
include/mapnik/json/geojson_grammar_x3_def.hpp
View file

@ -35,30 +35,30 @@ namespace grammar {
namespace x3 = boost::spirit::x3;
auto make_null = [](auto const& ctx) {
const auto make_null = [](auto const& ctx) {
_val(ctx) = mapnik::value_null{};
};
auto make_true = [](auto const& ctx) {
const auto make_true = [](auto const& ctx) {
_val(ctx) = true;
};
auto make_false = [](auto const& ctx) {
const auto make_false = [](auto const& ctx) {
_val(ctx) = false;
};
auto assign = [](auto const& ctx) {
const auto assign = [](auto const& ctx) {
_val(ctx) = std::move(_attr(ctx));
};
auto assign_key = [](auto const& ctx) {
const auto assign_key = [](auto const& ctx) {
std::string const& name = _attr(ctx);
keys_map& keys = x3::get<keys_tag>(ctx);
auto result = keys.insert(keys_map::value_type(name, keys.size() + 1));
std::get<0>(_val(ctx)) = result.first->right;
};
auto assign_value = [](auto const& ctx) {
const auto assign_value = [](auto const& ctx) {
std::get<1>(_val(ctx)) = std::move(_attr(ctx));
};
@ -81,7 +81,7 @@ struct geometry_type_ : x3::symbols<mapnik::geometry::geometry_types>
("\"GeometryCollection\"", mapnik::geometry::geometry_types::GeometryCollection) //
;
}
} geometry_type_sym;
} const geometry_type_sym;
// rules
x3::rule<class json_object_tag, geojson_object> const object("JSON Object");
@ -95,13 +95,9 @@ auto const geojson_double = x3::real_parser<value_double, x3::strict_real_polici
auto const geojson_integer = x3::int_parser<value_integer, 10, 1, -1>();
// import unicode string rule
namespace {
auto const& geojson_string = unicode_string;
}
const auto geojson_string = unicode_string;
// import positions rule
namespace {
auto const& positions_rule = positions;
}
const auto positions_rule = positions;
// GeoJSON types
// clang-format off

5
include/mapnik/json/positions_grammar_x3_def.hpp
View file

@ -33,14 +33,11 @@ namespace grammar {
namespace x3 = boost::spirit::x3;
using x3::double_;
using x3::lit;
using x3::no_case;
using x3::omit;
namespace {
auto assign_helper = [](auto const& ctx) {
const auto assign_helper = [](auto const& ctx) {
_val(ctx) = std::move(_attr(ctx));
};
} // namespace
// rules
x3::rule<class point_class, point> const point("Position");

34
include/mapnik/json/topojson_grammar_x3_def.hpp
View file

@ -169,7 +169,7 @@ struct create_multi_polygon
}
};
auto create_geometry = [](auto const& ctx) {
const auto create_geometry = [](auto const& ctx) {
auto const geom_type = std::get<0>(_attr(ctx));
auto const& coord = std::get<1>(_attr(ctx));
auto const& arcs = std::get<2>(_attr(ctx));
@ -199,27 +199,27 @@ auto create_geometry = [](auto const& ctx) {
_val(ctx) = std::move(geom);
};
auto assign_bbox = [](auto const& ctx) {
const auto assign_bbox = [](auto const& ctx) {
_val(ctx).bbox = std::move(_attr(ctx));
};
auto assign_transform = [](auto const& ctx) {
const auto assign_transform = [](auto const& ctx) {
_val(ctx).tr = std::move(_attr(ctx));
};
auto assign_arcs = [](auto const& ctx) {
const auto assign_arcs = [](auto const& ctx) {
_val(ctx).arcs = std::move(_attr(ctx));
};
auto assign_objects = [](auto const& ctx) {
const auto assign_objects = [](auto const& ctx) {
_val(ctx).geometries = std::move(_attr(ctx));
};
auto push_geometry = [](auto const& ctx) {
const auto push_geometry = [](auto const& ctx) {
_val(ctx).push_back(std::move(_attr(ctx)));
};
auto push_collection = [](auto const& ctx) {
const auto push_collection = [](auto const& ctx) {
auto& dest = _val(ctx);
auto& src = _attr(ctx);
if (dest.empty())
@ -231,27 +231,27 @@ auto push_collection = [](auto const& ctx) {
}
};
auto assign_geometry_type = [](auto const& ctx) {
const auto assign_geometry_type = [](auto const& ctx) {
std::get<0>(_val(ctx)) = _attr(ctx);
};
auto assign_coordinates = [](auto const& ctx) {
const auto assign_coordinates = [](auto const& ctx) {
std::get<1>(_val(ctx)) = std::move(_attr(ctx));
};
auto assign_rings = [](auto const& ctx) {
const auto assign_rings = [](auto const& ctx) {
std::get<2>(_val(ctx)) = std::move(_attr(ctx));
};
auto assign_properties = [](auto const& ctx) {
const auto assign_properties = [](auto const& ctx) {
std::get<3>(_val(ctx)) = std::move(_attr(ctx));
};
auto assign_prop_name = [](auto const& ctx) {
const auto assign_prop_name = [](auto const& ctx) {
std::get<0>(_val(ctx)) = std::move(_attr(ctx));
};
auto assign_prop_value = [](auto const& ctx) {
const auto assign_prop_value = [](auto const& ctx) {
std::get<1>(_val(ctx)) = std::move(_attr(ctx));
};
@ -262,12 +262,10 @@ using x3::int_;
using x3::lit;
using x3::omit;
namespace {
// import unicode string rule
auto const& json_string = json::grammar::unicode_string;
const auto json_string = json::grammar::unicode_string;
// json value
auto const& json_value = json::grammar::value;
} // namespace
const auto json_value = json::grammar::value;
using coordinates_type = util::variant<topojson::coordinate, std::vector<topojson::coordinate>>;
using arcs_type = util::variant<std::vector<index_type>,
@ -287,7 +285,7 @@ struct topojson_geometry_type_ : x3::symbols<int>
("\"MultiPolygon\"", 6) //
;
}
} topojson_geometry_type;
} const topojson_geometry_type;
// rules
x3::rule<class transform_tag, mapnik::topojson::transform> const transform = "Transform";

10
include/mapnik/json/unicode_string_grammar_x3_def.hpp
View file

@ -35,7 +35,7 @@ namespace x3 = boost::spirit::x3;
using uchar = std::uint32_t; // a unicode code point
auto append = [](auto const& ctx) {
const auto append = [](auto const& ctx) {
_val(ctx) += _attr(ctx);
};
@ -50,15 +50,15 @@ static inline void push_utf8_impl(std::string& str, uchar code_point)
}
} // namespace detail
auto push_char = [](auto const& ctx) {
const auto push_char = [](auto const& ctx) {
_val(ctx).push_back(_attr(ctx));
};
auto push_utf8 = [](auto const& ctx) {
const auto push_utf8 = [](auto const& ctx) {
detail::push_utf8_impl(_val(ctx), _attr(ctx));
};
auto push_utf16 = [](auto const& ctx) {
const auto push_utf16 = [](auto const& ctx) {
using iterator_type = std::vector<std::uint16_t>::const_iterator;
auto const& utf16 = _attr(ctx);
try
@ -76,7 +76,7 @@ auto push_utf16 = [](auto const& ctx) {
}
};
auto push_esc = [](auto const& ctx) {
const auto push_esc = [](auto const& ctx) {
std::string& utf8 = _val(ctx);
char c = _attr(ctx);
switch (c)

9
include/mapnik/mapnik.hpp Normal file
View file

@ -0,0 +1,9 @@
#ifndef MAPNIK_MAPNIK_HPP
#define MAPNIK_MAPNIK_HPP
#include "config.hpp"
namespace mapnik {
MAPNIK_DECL void setup();
}
#endif

46
include/mapnik/markers_placement.hpp
View file

@ -46,26 +46,26 @@ class markers_placement_finder : util::noncopyable
switch (marker_placement_enum(placement_type))
{
default:
case MARKER_POINT_PLACEMENT:
case marker_placement_enum::MARKER_POINT_PLACEMENT:
construct(&point_, locator, detector, params);
break;
case MARKER_ANGLED_POINT_PLACEMENT:
case marker_placement_enum::MARKER_ANGLED_POINT_PLACEMENT:
construct(&point_, locator, detector, params);
point_.use_angle(true);
break;
case MARKER_INTERIOR_PLACEMENT:
case marker_placement_enum::MARKER_INTERIOR_PLACEMENT:
construct(&interior_, locator, detector, params);
break;
case MARKER_LINE_PLACEMENT:
case marker_placement_enum::MARKER_LINE_PLACEMENT:
construct(&line_, locator, detector, params);
break;
case MARKER_VERTEX_FIRST_PLACEMENT:
case marker_placement_enum::MARKER_VERTEX_FIRST_PLACEMENT:
construct(&vertex_first_, locator, detector, params);
break;
case MARKER_VERTEX_LAST_PLACEMENT:
case marker_placement_enum::MARKER_VERTEX_LAST_PLACEMENT:
construct(&vertex_last_, locator, detector, params);
break;
case MARKER_POLYLABEL_PLACEMENT:
case marker_placement_enum::MARKER_POLYLABEL_PLACEMENT:
construct(&polylabel_, locator, detector, params);
break;
}
@ -73,26 +73,26 @@ class markers_placement_finder : util::noncopyable
~markers_placement_finder()
{
switch (marker_placement_enum(placement_type_))
switch (marker_placement_enum{placement_type_})
{
default:
case MARKER_POINT_PLACEMENT:
case MARKER_ANGLED_POINT_PLACEMENT:
case marker_placement_enum::MARKER_POINT_PLACEMENT:
case marker_placement_enum::MARKER_ANGLED_POINT_PLACEMENT:
destroy(&point_);
break;
case MARKER_INTERIOR_PLACEMENT:
case marker_placement_enum::MARKER_INTERIOR_PLACEMENT:
destroy(&interior_);
break;
case MARKER_LINE_PLACEMENT:
case marker_placement_enum::MARKER_LINE_PLACEMENT:
destroy(&line_);
break;
case MARKER_VERTEX_FIRST_PLACEMENT:
case marker_placement_enum::MARKER_VERTEX_FIRST_PLACEMENT:
destroy(&vertex_first_);
break;
case MARKER_VERTEX_LAST_PLACEMENT:
case marker_placement_enum::MARKER_VERTEX_LAST_PLACEMENT:
destroy(&vertex_last_);
break;
case MARKER_POLYLABEL_PLACEMENT:
case marker_placement_enum::MARKER_POLYLABEL_PLACEMENT:
destroy(&polylabel_);
break;
}
@ -101,21 +101,21 @@ class markers_placement_finder : util::noncopyable
// Get next point where the marker should be placed. Returns true if a place is found, false if none is found.
bool get_point(double& x, double& y, double& angle, bool ignore_placement)
{
switch (marker_placement_enum(placement_type_))
switch (marker_placement_enum{placement_type_})
{
default:
case MARKER_POINT_PLACEMENT:
case MARKER_ANGLED_POINT_PLACEMENT:
case marker_placement_enum::MARKER_POINT_PLACEMENT:
case marker_placement_enum::MARKER_ANGLED_POINT_PLACEMENT:
return point_.get_point(x, y, angle, ignore_placement);
case MARKER_INTERIOR_PLACEMENT:
case marker_placement_enum::MARKER_INTERIOR_PLACEMENT:
return interior_.get_point(x, y, angle, ignore_placement);
case MARKER_LINE_PLACEMENT:
case marker_placement_enum::MARKER_LINE_PLACEMENT:
return line_.get_point(x, y, angle, ignore_placement);
case MARKER_VERTEX_FIRST_PLACEMENT:
case marker_placement_enum::MARKER_VERTEX_FIRST_PLACEMENT:
return vertex_first_.get_point(x, y, angle, ignore_placement);
case MARKER_VERTEX_LAST_PLACEMENT:
case marker_placement_enum::MARKER_VERTEX_LAST_PLACEMENT:
return vertex_last_.get_point(x, y, angle, ignore_placement);
case MARKER_POLYLABEL_PLACEMENT:
case marker_placement_enum::MARKER_POLYLABEL_PLACEMENT:
return polylabel_.get_point(x, y, angle, ignore_placement);
}
}

17
include/mapnik/markers_placements/basic.hpp
View file

@ -32,7 +32,6 @@
#include <mapnik/warning.hpp>
MAPNIK_DISABLE_WARNING_PUSH
#include <mapnik/warning_ignore_agg.hpp>
#include "agg_basics.h"
#include "agg_trans_affine.h"
MAPNIK_DISABLE_WARNING_POP
@ -72,32 +71,32 @@ class markers_basic_placement : util::noncopyable
{
switch (params_.direction)
{
case DIRECTION_UP:
case direction_enum::DIRECTION_UP:
angle = 0;
return true;
case DIRECTION_DOWN:
case direction_enum::DIRECTION_DOWN:
angle = util::pi;
return true;
case DIRECTION_AUTO:
case direction_enum::DIRECTION_AUTO:
angle = util::normalize_angle(angle);
if (std::abs(angle) > util::pi / 2)
angle += util::pi;
return true;
case DIRECTION_AUTO_DOWN:
case direction_enum::DIRECTION_AUTO_DOWN:
angle = util::normalize_angle(angle);
if (std::abs(angle) < util::pi / 2)
angle += util::pi;
return true;
case DIRECTION_LEFT:
case direction_enum::DIRECTION_LEFT:
angle += util::pi;
return true;
case DIRECTION_LEFT_ONLY:
case direction_enum::DIRECTION_LEFT_ONLY:
angle = util::normalize_angle(angle + util::pi);
return std::fabs(angle) < util::pi / 2;
case DIRECTION_RIGHT_ONLY:
case direction_enum::DIRECTION_RIGHT_ONLY:
angle = util::normalize_angle(angle);
return std::fabs(angle) < util::pi / 2;
case DIRECTION_RIGHT:
case direction_enum::DIRECTION_RIGHT:
default:
return true;
}

2
include/mapnik/memory_datasource.hpp
View file

@ -26,12 +26,14 @@
// mapnik
#include <mapnik/datasource.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/datasource_plugin.hpp>
// stl
#include <deque>
namespace mapnik {
DATASOURCE_PLUGIN_DEF(memory_datasource_plugin, memory)
class MAPNIK_DECL memory_datasource : public datasource
{
friend class memory_featureset;

4
include/mapnik/path_expression_grammar_x3_def.hpp
View file

@ -32,10 +32,10 @@ namespace grammar {
namespace x3 = boost::spirit::x3;
using x3::lexeme;
using x3::standard_wide::char_;
auto create_string = [](auto& ctx) {
const auto create_string = [](auto& ctx) {
_val(ctx).push_back(_attr(ctx));
};
auto create_attribute = [](auto& ctx) {
const auto create_attribute = [](auto& ctx) {
_val(ctx).push_back(mapnik::attribute(_attr(ctx)));
};
// rules

7
include/mapnik/plugin.hpp
View file

@ -25,9 +25,9 @@
// mapnik
#include <mapnik/util/noncopyable.hpp>
// stl
#include <string>
#include <memory>
namespace mapnik {
@ -45,13 +45,10 @@ class PluginInfo : util::noncopyable
bool valid() const;
std::string get_error() const;
void* get_symbol(std::string const& sym_name) const;
static void init();
static void exit();
private:
std::string filename_;
std::string name_;
mapnik_lib_t* module_;
std::unique_ptr<mapnik_lib_t> module_;
};
} // namespace mapnik

10
include/mapnik/raster_colorizer.hpp
View file

@ -57,7 +57,7 @@ class feature_impl;
class raster;
//! \brief Enumerates the modes of interpolation
enum colorizer_mode_enum : std::uint8_t {
enum class colorizer_mode_enum : std::uint8_t {
COLORIZER_INHERIT = 0, //!< The stop inherits the mode from the colorizer
COLORIZER_LINEAR = 1, //!< Linear interpolation between colors, each channel separately
COLORIZER_DISCRETE = 2, //!< Single color for stop
@ -80,7 +80,7 @@ class MAPNIK_DECL colorizer_stop
//! \param[in] mode The stop mode
//! \param[in] _color The stop color
colorizer_stop(float value = 0,
colorizer_mode mode = COLORIZER_INHERIT,
colorizer_mode mode = colorizer_mode_enum::COLORIZER_INHERIT,
color const& _color = color(0, 0, 0, 0),
std::string const& label = "");
@ -146,7 +146,8 @@ class MAPNIK_DECL raster_colorizer
{
public:
//! \brief Constructor
raster_colorizer(colorizer_mode mode = COLORIZER_LINEAR, color const& _color = color(0, 0, 0, 0));
raster_colorizer(colorizer_mode mode = colorizer_mode_enum::COLORIZER_LINEAR,
color const& _color = color(0, 0, 0, 0));
//! \brief Destructor
~raster_colorizer();
@ -158,7 +159,8 @@ class MAPNIK_DECL raster_colorizer
void set_default_mode(colorizer_mode mode)
{
default_mode_ = (mode == COLORIZER_INHERIT) ? COLORIZER_LINEAR : static_cast<colorizer_mode_enum>(mode);
default_mode_ =
(mode == colorizer_mode_enum::COLORIZER_INHERIT) ? colorizer_mode_enum::COLORIZER_LINEAR : mode.value_;
}
void set_default_mode_enum(colorizer_mode_enum mode) { set_default_mode(mode); }

22
include/mapnik/renderer_common/process_point_symbolizer.hpp
View file

@ -52,28 +52,28 @@ void render_point_symbolizer(point_symbolizer const& sym,
if (!mark->is<mapnik::marker_null>())
{
value_double opacity = get<value_double, keys::opacity>(sym, feature, common.vars_);
value_bool allow_overlap = get<value_bool, keys::allow_overlap>(sym, feature, common.vars_);
value_bool ignore_placement = get<value_bool, keys::ignore_placement>(sym, feature, common.vars_);
point_placement_enum placement =
const value_double opacity = get<value_double, keys::opacity>(sym, feature, common.vars_);
const value_bool allow_overlap = get<value_bool, keys::allow_overlap>(sym, feature, common.vars_);
const value_bool ignore_placement = get<value_bool, keys::ignore_placement>(sym, feature, common.vars_);
const point_placement_enum placement =
get<point_placement_enum, keys::point_placement_type>(sym, feature, common.vars_);
box2d<double> const& bbox = mark->bounding_box();
coord2d center = bbox.center();
const box2d<double>& bbox = mark->bounding_box();
const coord2d center = bbox.center();
agg::trans_affine tr;
auto image_transform = get_optional<transform_type>(sym, keys::image_transform);
const auto image_transform = get_optional<transform_type>(sym, keys::image_transform);
if (image_transform)
evaluate_transform(tr, feature, common.vars_, *image_transform, common.scale_factor_);
agg::trans_affine_translation recenter(-center.x, -center.y);
agg::trans_affine recenter_tr = recenter * tr;
const agg::trans_affine_translation recenter(-center.x, -center.y);
const agg::trans_affine recenter_tr = recenter * tr;
box2d<double> label_ext = bbox * recenter_tr * agg::trans_affine_scaling(common.scale_factor_);
mapnik::geometry::geometry<double> const& geometry = feature.get_geometry();
const mapnik::geometry::geometry<double>& geometry = feature.get_geometry();
mapnik::geometry::point<double> pt;
geometry::geometry_types type = geometry::geometry_type(geometry);
if (placement == CENTROID_POINT_PLACEMENT || type == geometry::geometry_types::Point ||
if (placement == point_placement_enum::CENTROID_POINT_PLACEMENT || type == geometry::geometry_types::Point ||
type == geometry::geometry_types::MultiPoint)
{
if (!geometry::centroid(geometry, pt))

43
include/mapnik/symbolizer.hpp
View file

@ -147,14 +147,14 @@ struct enum_traits<simplify_algorithm_e>
static result_type from_string(std::string const& str) { return simplify_algorithm_from_string(str); }
};
#define ENUM_FROM_STRING(e) \
#define ENUM_FROM_STRING(alias, e) \
template<> \
struct enum_traits<e> \
{ \
using result_type = boost::optional<e>; \
static result_type from_string(std::string const& str) \
{ \
enumeration<e, e##_MAX> enum_; \
enumeration<e, alias##_to_string, alias##_from_string, alias##_lookup> enum_; \
try \
{ \
enum_.from_string(str); \
@ -166,26 +166,25 @@ struct enum_traits<simplify_algorithm_e>
} \
} \
};
ENUM_FROM_STRING(line_cap_enum)
ENUM_FROM_STRING(line_join_enum)
ENUM_FROM_STRING(point_placement_enum)
ENUM_FROM_STRING(line_rasterizer_enum)
ENUM_FROM_STRING(marker_placement_enum)
ENUM_FROM_STRING(marker_multi_policy_enum)
ENUM_FROM_STRING(debug_symbolizer_mode_enum)
ENUM_FROM_STRING(pattern_alignment_enum)
ENUM_FROM_STRING(halo_rasterizer_enum)
ENUM_FROM_STRING(label_placement_enum)
ENUM_FROM_STRING(vertical_alignment_enum)
ENUM_FROM_STRING(horizontal_alignment_enum)
ENUM_FROM_STRING(justify_alignment_enum)
ENUM_FROM_STRING(text_transform_enum)
ENUM_FROM_STRING(text_upright_enum)
ENUM_FROM_STRING(direction_enum)
ENUM_FROM_STRING(gamma_method_enum)
ENUM_FROM_STRING(line_pattern_enum)
ENUM_FROM_STRING(smooth_algorithm_enum)
ENUM_FROM_STRING(line_cap_e, line_cap_enum)
ENUM_FROM_STRING(line_join_e, line_join_enum)
ENUM_FROM_STRING(point_placement_e, point_placement_enum)
ENUM_FROM_STRING(line_rasterizer_e, line_rasterizer_enum)
ENUM_FROM_STRING(marker_placement_e, marker_placement_enum)
ENUM_FROM_STRING(marker_multi_policy_e, marker_multi_policy_enum)
ENUM_FROM_STRING(debug_symbolizer_mode_e, debug_symbolizer_mode_enum)
ENUM_FROM_STRING(pattern_alignment_e, pattern_alignment_enum)
ENUM_FROM_STRING(halo_rasterizer_e, halo_rasterizer_enum)
ENUM_FROM_STRING(label_placement_e, label_placement_enum)
ENUM_FROM_STRING(vertical_alignment_e, vertical_alignment_enum)
ENUM_FROM_STRING(horizontal_alignment_e, horizontal_alignment_enum)
ENUM_FROM_STRING(justify_alignment_e, justify_alignment_enum)
ENUM_FROM_STRING(text_transform_e, text_transform_enum)
ENUM_FROM_STRING(text_upright_e, text_upright_enum)
ENUM_FROM_STRING(direction_e, direction_enum)
ENUM_FROM_STRING(gamma_method_e, gamma_method_enum)
ENUM_FROM_STRING(line_pattern_e, line_pattern_enum)
ENUM_FROM_STRING(smooth_algorithm_e, smooth_algorithm_enum)
// enum
template<typename T, bool is_enum = true>

2
include/mapnik/symbolizer_base.hpp
View file

@ -69,7 +69,7 @@ struct enumeration_wrapper
enumeration_wrapper() = delete;
template<typename T>
explicit enumeration_wrapper(T value_)
: value(value_)
: value(static_cast<int>(value_))
{}
inline bool operator==(enumeration_wrapper const& rhs) const { return value == rhs.value; }

26
include/mapnik/symbolizer_default_values.hpp
View file

@ -50,7 +50,7 @@ struct symbolizer_default<value_double, keys::gamma>
template<>
struct symbolizer_default<gamma_method_enum, keys::gamma_method>
{
static gamma_method_enum value() { return GAMMA_POWER; }
static gamma_method_enum value() { return gamma_method_enum::GAMMA_POWER; }
};
// opacity
@ -64,7 +64,7 @@ struct symbolizer_default<value_double, keys::opacity>
template<>
struct symbolizer_default<pattern_alignment_enum, keys::alignment>
{
static pattern_alignment_enum value() { return GLOBAL_ALIGNMENT; }
static pattern_alignment_enum value() { return pattern_alignment_enum::GLOBAL_ALIGNMENT; }
};
// offset
@ -127,14 +127,14 @@ struct symbolizer_default<value_double, keys::stroke_opacity>
template<>
struct symbolizer_default<line_join_enum, keys::stroke_linejoin>
{
static line_join_enum value() { return MITER_JOIN; }
static line_join_enum value() { return line_join_enum::MITER_JOIN; }
};
// stroke-linecap
template<>
struct symbolizer_default<line_cap_enum, keys::stroke_linecap>
{
static line_cap_enum value() { return BUTT_CAP; }
static line_cap_enum value() { return line_cap_enum::BUTT_CAP; }
};
// stroke-gamma
@ -148,7 +148,7 @@ struct symbolizer_default<value_double, keys::stroke_gamma>
template<>
struct symbolizer_default<gamma_method_enum, keys::stroke_gamma_method>
{
static gamma_method_enum value() { return GAMMA_POWER; }
static gamma_method_enum value() { return gamma_method_enum::GAMMA_POWER; }
};
// stroke-dashoffset
@ -173,7 +173,7 @@ struct symbolizer_default<value_double, keys::stroke_miterlimit>
template<>
struct symbolizer_default<line_rasterizer_enum, keys::line_rasterizer>
{
static line_rasterizer_enum value() { return RASTERIZER_FULL; }
static line_rasterizer_enum value() { return line_rasterizer_enum::RASTERIZER_FULL; }
};
// transform
@ -315,7 +315,7 @@ struct symbolizer_default<value_double, keys::simplify_tolerance>
template<>
struct symbolizer_default<halo_rasterizer_enum, keys::halo_rasterizer>
{
static halo_rasterizer_enum value() { return HALO_RASTERIZER_FULL; }
static halo_rasterizer_enum value() { return halo_rasterizer_enum::HALO_RASTERIZER_FULL; }
};
// text-placements
@ -324,28 +324,28 @@ struct symbolizer_default<halo_rasterizer_enum, keys::halo_rasterizer>
template<>
struct symbolizer_default<point_placement_enum, keys::point_placement_type>
{
static point_placement_enum value() { return CENTROID_POINT_PLACEMENT; }
static point_placement_enum value() { return point_placement_enum::CENTROID_POINT_PLACEMENT; }
};
// marker placement
template<>
struct symbolizer_default<marker_placement_enum, keys::markers_placement_type>
{
static marker_placement_enum value() { return MARKER_POINT_PLACEMENT; }
static marker_placement_enum value() { return marker_placement_enum::MARKER_POINT_PLACEMENT; }
};
// multi-policy
template<>
struct symbolizer_default<marker_multi_policy_enum, keys::markers_multipolicy>
{
static marker_multi_policy_enum value() { return MARKER_EACH_MULTI; }
static marker_multi_policy_enum value() { return marker_multi_policy_enum::MARKER_EACH_MULTI; }
};
// direction
template<>
struct symbolizer_default<direction_enum, keys::direction>
{
static direction_enum value() { return DIRECTION_RIGHT; }
static direction_enum value() { return direction_enum::DIRECTION_RIGHT; }
};
// placement
@ -380,7 +380,7 @@ struct symbolizer_default<value_bool, keys::avoid_edges>
template<>
struct symbolizer_default<line_pattern_enum, keys::line_pattern>
{
static line_pattern_enum value() { return LINE_PATTERN_WARP; }
static line_pattern_enum value() { return line_pattern_enum::LINE_PATTERN_WARP; }
};
// extend
@ -393,7 +393,7 @@ struct symbolizer_default<value_double, keys::extend>
template<>
struct symbolizer_default<smooth_algorithm_enum, keys::smooth_algorithm>
{
static smooth_algorithm_enum value() { return SMOOTH_ALGORITHM_BASIC; }
static smooth_algorithm_enum value() { return smooth_algorithm_enum::SMOOTH_ALGORITHM_BASIC; }
};
} // namespace mapnik

63
include/mapnik/symbolizer_enumerations.hpp
View file

@ -27,50 +27,43 @@
namespace mapnik {
enum line_cap_enum : std::uint8_t { BUTT_CAP, SQUARE_CAP, ROUND_CAP, line_cap_enum_MAX };
enum class line_cap_enum : std::uint8_t { BUTT_CAP, SQUARE_CAP, ROUND_CAP, line_cap_enum_MAX };
DEFINE_ENUM(line_cap_e, line_cap_enum);
enum line_join_enum : std::uint8_t { MITER_JOIN, MITER_REVERT_JOIN, ROUND_JOIN, BEVEL_JOIN, line_join_enum_MAX };
enum class line_join_enum : std::uint8_t { MITER_JOIN, MITER_REVERT_JOIN, ROUND_JOIN, BEVEL_JOIN, line_join_enum_MAX };
DEFINE_ENUM(line_join_e, line_join_enum);
enum line_rasterizer_enum : std::uint8_t {
enum class line_rasterizer_enum : std::uint8_t {
RASTERIZER_FULL, // agg::renderer_scanline_aa_solid
RASTERIZER_FAST, // agg::rasterizer_outline_aa, twice as fast but only good for thin lines
line_rasterizer_enum_MAX
};
DEFINE_ENUM(line_rasterizer_e, line_rasterizer_enum);
enum halo_rasterizer_enum : std::uint8_t { HALO_RASTERIZER_FULL, HALO_RASTERIZER_FAST, halo_rasterizer_enum_MAX };
enum class halo_rasterizer_enum : std::uint8_t { HALO_RASTERIZER_FULL, HALO_RASTERIZER_FAST, halo_rasterizer_enum_MAX };
DEFINE_ENUM(halo_rasterizer_e, halo_rasterizer_enum);
enum point_placement_enum : std::uint8_t {
enum class point_placement_enum : std::uint8_t {
CENTROID_POINT_PLACEMENT,
INTERIOR_POINT_PLACEMENT,
point_placement_enum_MAX
};
DEFINE_ENUM(point_placement_e, point_placement_enum);
enum pattern_alignment_enum : std::uint8_t { LOCAL_ALIGNMENT, GLOBAL_ALIGNMENT, pattern_alignment_enum_MAX };
enum class pattern_alignment_enum : std::uint8_t { LOCAL_ALIGNMENT, GLOBAL_ALIGNMENT, pattern_alignment_enum_MAX };
DEFINE_ENUM(pattern_alignment_e, pattern_alignment_enum);
enum debug_symbolizer_mode_enum : std::uint8_t {
enum class debug_symbolizer_mode_enum : std::uint8_t {
DEBUG_SYM_MODE_COLLISION,
DEBUG_SYM_MODE_VERTEX,
DEBUG_SYM_MODE_RINGS,
debug_symbolizer_mode_enum_MAX
};
DEFINE_ENUM(debug_symbolizer_mode_e, debug_symbolizer_mode_enum);
// markers
// TODO - consider merging with text_symbolizer label_placement_e
enum marker_placement_enum : std::uint8_t {
enum class marker_placement_enum : std::uint8_t {
MARKER_POINT_PLACEMENT,
MARKER_INTERIOR_PLACEMENT,
MARKER_LINE_PLACEMENT,
@ -80,19 +73,17 @@ enum marker_placement_enum : std::uint8_t {
MARKER_POLYLABEL_PLACEMENT,
marker_placement_enum_MAX
};
DEFINE_ENUM(marker_placement_e, marker_placement_enum);
enum marker_multi_policy_enum : std::uint8_t {
enum class marker_multi_policy_enum : std::uint8_t {
MARKER_EACH_MULTI, // each component in a multi gets its marker
MARKER_WHOLE_MULTI, // consider all components of a multi as a whole
MARKER_LARGEST_MULTI, // only the largest component of a multi gets a marker
marker_multi_policy_enum_MAX
};
DEFINE_ENUM(marker_multi_policy_e, marker_multi_policy_enum);
enum text_transform_enum : std::uint8_t {
enum class text_transform_enum : std::uint8_t {
NONE = 0,
UPPERCASE,
LOWERCASE,
@ -100,10 +91,9 @@ enum text_transform_enum : std::uint8_t {
REVERSE,
text_transform_enum_MAX
};
DEFINE_ENUM(text_transform_e, text_transform_enum);
enum label_placement_enum : std::uint8_t {
enum class label_placement_enum : std::uint8_t {
POINT_PLACEMENT,
LINE_PLACEMENT,
VERTEX_PLACEMENT,
@ -113,14 +103,18 @@ enum label_placement_enum : std::uint8_t {
ALTERNATING_GRID_PLACEMENT,
label_placement_enum_MAX
};
DEFINE_ENUM(label_placement_e, label_placement_enum);
enum vertical_alignment_enum : std::uint8_t { V_TOP = 0, V_MIDDLE, V_BOTTOM, V_AUTO, vertical_alignment_enum_MAX };
enum class vertical_alignment_enum : std::uint8_t {
V_TOP = 0,
V_MIDDLE,
V_BOTTOM,
V_AUTO,
vertical_alignment_enum_MAX
};
DEFINE_ENUM(vertical_alignment_e, vertical_alignment_enum);
enum horizontal_alignment_enum : std::uint8_t {
enum class horizontal_alignment_enum : std::uint8_t {
H_LEFT = 0,
H_MIDDLE,
H_RIGHT,
@ -128,14 +122,12 @@ enum horizontal_alignment_enum : std::uint8_t {
H_ADJUST,
horizontal_alignment_enum_MAX
};
DEFINE_ENUM(horizontal_alignment_e, horizontal_alignment_enum);
enum justify_alignment_enum : std::uint8_t { J_LEFT = 0, J_MIDDLE, J_RIGHT, J_AUTO, justify_alignment_enum_MAX };
enum class justify_alignment_enum : std::uint8_t { J_LEFT = 0, J_MIDDLE, J_RIGHT, J_AUTO, justify_alignment_enum_MAX };
DEFINE_ENUM(justify_alignment_e, justify_alignment_enum);
enum text_upright_enum : std::uint8_t {
enum class text_upright_enum : std::uint8_t {
UPRIGHT_AUTO,
UPRIGHT_AUTO_DOWN,
UPRIGHT_LEFT,
@ -144,10 +136,9 @@ enum text_upright_enum : std::uint8_t {
UPRIGHT_RIGHT_ONLY,
text_upright_enum_MAX
};
DEFINE_ENUM(text_upright_e, text_upright_enum);
enum direction_enum : std::uint8_t {
enum class direction_enum : std::uint8_t {
DIRECTION_LEFT,
DIRECTION_RIGHT,
DIRECTION_LEFT_ONLY,
@ -158,10 +149,9 @@ enum direction_enum : std::uint8_t {
DIRECTION_DOWN,
direction_enum_MAX
};
DEFINE_ENUM(direction_e, direction_enum);
enum gamma_method_enum : std::uint8_t {
enum class gamma_method_enum : std::uint8_t {
GAMMA_POWER, // agg::gamma_power
GAMMA_LINEAR, // agg::gamma_linear
GAMMA_NONE, // agg::gamma_none
@ -169,19 +159,16 @@ enum gamma_method_enum : std::uint8_t {
GAMMA_MULTIPLY, // agg::gamma_multiply
gamma_method_enum_MAX
};
DEFINE_ENUM(gamma_method_e, gamma_method_enum);
enum line_pattern_enum : std::uint8_t { LINE_PATTERN_WARP, LINE_PATTERN_REPEAT, line_pattern_enum_MAX };
enum class line_pattern_enum : std::uint8_t { LINE_PATTERN_WARP, LINE_PATTERN_REPEAT, line_pattern_enum_MAX };
DEFINE_ENUM(line_pattern_e, line_pattern_enum);
enum smooth_algorithm_enum : std::uint8_t {
enum class smooth_algorithm_enum : std::uint8_t {
SMOOTH_ALGORITHM_BASIC = 0,
SMOOTH_ALGORITHM_ADAPTIVE,
smooth_algorithm_enum_MAX
};
DEFINE_ENUM(smooth_algorithm_e, smooth_algorithm_enum);
} // namespace mapnik

6
include/mapnik/text/placement_finder_impl.hpp
View file

@ -65,12 +65,14 @@ bool placement_finder::find_line_placements(T& path, bool points)
// horizontal_alignment_e halign = layouts_.back()->horizontal_alignment();
// halign == H_LEFT -> don't move
if (horizontal_alignment_ == H_MIDDLE || horizontal_alignment_ == H_AUTO || horizontal_alignment_ == H_ADJUST)
if (horizontal_alignment_ == horizontal_alignment_enum::H_MIDDLE ||
horizontal_alignment_ == horizontal_alignment_enum::H_AUTO ||
horizontal_alignment_ == horizontal_alignment_enum::H_ADJUST)
{
if (!pp.forward(spacing / 2.0))
continue;
}
else if (horizontal_alignment_ == H_RIGHT)
else if (horizontal_alignment_ == horizontal_alignment_enum::H_RIGHT)
{
if (!pp.forward(pp.length()))
continue;

4
include/mapnik/text/properties_util.hpp
View file

@ -46,7 +46,7 @@ struct is_mapnik_enumeration
};
template<typename T>
struct is_mapnik_enumeration<T, typename std::enable_if<std::is_enum<typename T::native_type>::value>::type>
struct is_mapnik_enumeration<T, typename std::enable_if_t<std::is_enum<typename T::native_type>::value>>
{
static constexpr bool value = true;
};
@ -117,7 +117,7 @@ struct set_property_from_xml_impl<T0, true>
{
target_enum_type e;
e.from_string(*enum_str);
val = enumeration_wrapper(e);
val = enumeration_wrapper(e.value_);
}
}
catch (...)

4
include/mapnik/text/text_properties.hpp
View file

@ -159,7 +159,7 @@ struct MAPNIK_DECL text_layout_properties
struct text_properties_expressions
{
symbolizer_base::value_type label_placement = enumeration_wrapper(POINT_PLACEMENT);
symbolizer_base::value_type label_placement = enumeration_wrapper(label_placement_enum::POINT_PLACEMENT);
symbolizer_base::value_type label_spacing = 0.0;
symbolizer_base::value_type label_position_tolerance = 0.0;
symbolizer_base::value_type avoid_edges = false;
@ -171,7 +171,7 @@ struct text_properties_expressions
symbolizer_base::value_type max_char_angle_delta = 22.5;
symbolizer_base::value_type allow_overlap = false;
symbolizer_base::value_type largest_bbox_only = true;
symbolizer_base::value_type upright = enumeration_wrapper(UPRIGHT_AUTO);
symbolizer_base::value_type upright = enumeration_wrapper(text_upright_enum::UPRIGHT_AUTO);
symbolizer_base::value_type grid_cell_width = 0.0;
symbolizer_base::value_type grid_cell_height = 0.0;
};

16
include/mapnik/vertex_converters.hpp
View file

@ -46,7 +46,6 @@ MAPNIK_DISABLE_WARNING_PUSH
#include "agg_trans_affine.h"
#include "agg_conv_clip_polygon.h"
#include "agg_conv_clip_polyline.h"
#include "agg_conv_smooth_poly1.h"
#include "agg_conv_stroke.h"
#include "agg_conv_dash.h"
#include "agg_conv_transform.h"
@ -156,30 +155,29 @@ struct converter_traits<T, mapnik::dash_tag>
template<typename Symbolizer, typename PathType, typename Feature>
void set_join_caps(Symbolizer const& sym, PathType& stroke, Feature const& feature, attributes const& vars)
{
line_join_enum join = get<line_join_enum, keys::stroke_linejoin>(sym, feature, vars);
const line_join_enum join = get<line_join_enum, keys::stroke_linejoin>(sym, feature, vars);
switch (join)
{
case MITER_JOIN:
case line_join_enum::MITER_JOIN:
stroke.generator().line_join(agg::miter_join);
break;
case MITER_REVERT_JOIN:
case line_join_enum::MITER_REVERT_JOIN:
stroke.generator().line_join(agg::miter_join);
break;
case ROUND_JOIN:
case line_join_enum::ROUND_JOIN:
stroke.generator().line_join(agg::round_join);
break;
default:
stroke.generator().line_join(agg::bevel_join);
}
line_cap_enum cap = get<line_cap_enum, keys::stroke_linecap>(sym, feature, vars);
const line_cap_enum cap = get<line_cap_enum, keys::stroke_linecap>(sym, feature, vars);
switch (cap)
{
case BUTT_CAP:
case line_cap_enum::BUTT_CAP:
stroke.generator().line_cap(agg::butt_cap);
break;
case SQUARE_CAP:
case line_cap_enum::SQUARE_CAP:
stroke.generator().line_cap(agg::square_cap);
break;
default:

41
include/mapnik/webp_io.hpp
View file

@ -24,6 +24,7 @@
#define MAPNIK_WEBP_IO_HPP
// mapnik
#include <mapnik/config.hpp>
#include <mapnik/image.hpp>
#include <mapnik/util/conversions.hpp>
@ -50,45 +51,7 @@ int webp_stream_write(const uint8_t* data, size_t data_size, const WebPPicture*
return true;
}
std::string webp_encoding_error(WebPEncodingError error)
{
std::string os;
switch (error)
{
case VP8_ENC_ERROR_OUT_OF_MEMORY:
os = "memory error allocating objects";
break;
case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY:
os = "memory error while flushing bits";
break;
case VP8_ENC_ERROR_NULL_PARAMETER:
os = "a pointer parameter is NULL";
break;
case VP8_ENC_ERROR_INVALID_CONFIGURATION:
os = "configuration is invalid";
break;
case VP8_ENC_ERROR_BAD_DIMENSION:
os = "picture has invalid width/height";
break;
case VP8_ENC_ERROR_PARTITION0_OVERFLOW:
os = "partition is bigger than 512k";
break;
case VP8_ENC_ERROR_PARTITION_OVERFLOW:
os = "partition is bigger than 16M";
break;
case VP8_ENC_ERROR_BAD_WRITE:
os = "error while flushing bytes";
break;
case VP8_ENC_ERROR_FILE_TOO_BIG:
os = "file is bigger than 4G";
break;
default:
mapnik::util::to_string(os, error);
os = "unknown error (" + os + ")";
break;
}
return os;
}
std::string MAPNIK_DECL webp_encoding_error(WebPEncodingError error);
template<typename T2>
inline int import_image(T2 const& im_in, WebPPicture& pic, bool alpha)

3
include/mapnik/well_known_srs.hpp
View file

@ -39,8 +39,7 @@ MAPNIK_DISABLE_WARNING_POP
namespace mapnik {
enum well_known_srs_enum : std::uint8_t { WGS_84, WEB_MERC, well_known_srs_enum_MAX };
enum class well_known_srs_enum : std::uint8_t { WGS_84, WEB_MERC, well_known_srs_enum_MAX };
DEFINE_ENUM(well_known_srs_e, well_known_srs_enum);
constexpr double EARTH_RADIUS = 6378137.0;

5
include/mapnik/wkt/wkt_grammar_x3_def.hpp
View file

@ -47,17 +47,16 @@ namespace mapnik {
namespace grammar {
namespace x3 = boost::spirit::x3;
namespace ascii = boost::spirit::x3::ascii;
using x3::double_;
using x3::lit;
using x3::no_case;
// functors
auto make_empty = [](auto const& ctx) {
const auto make_empty = [](auto const& ctx) {
_val(ctx) = geometry::geometry_empty();
};
auto add_ring = [](auto const& ctx) {
const auto add_ring = [](auto const& ctx) {
auto& ring = reinterpret_cast<geometry::linear_ring<double>&>(_attr(ctx));
_val(ctx).push_back(std::move(ring));
};

17
include/mapnik/xml_attribute_cast.hpp
View file

@ -161,17 +161,20 @@ struct do_xml_attribute_cast<double>
}
};
// specialization for mapnik::enumeration<T,int>
template<typename T, int MAX>
struct do_xml_attribute_cast<mapnik::enumeration<T, MAX>>
// specialization for mapnik::enumeration<...>
template<typename ENUM,
char const* (*F_TO_STRING)(ENUM),
ENUM (*F_FROM_STRING)(const char*),
std::map<ENUM, std::string> (*F_LOOKUP)()>
struct do_xml_attribute_cast<mapnik::enumeration<ENUM, F_TO_STRING, F_FROM_STRING, F_LOOKUP>>
{
static inline boost::optional<mapnik::enumeration<T, MAX>> xml_attribute_cast_impl(xml_tree const& /*tree*/,
std::string const& source)
using Enum = mapnik::enumeration<ENUM, F_TO_STRING, F_FROM_STRING, F_LOOKUP>;
static inline boost::optional<Enum> xml_attribute_cast_impl(xml_tree const& /*tree*/, std::string const& source)
{
using result_type = typename boost::optional<mapnik::enumeration<T, MAX>>;
using result_type = typename boost::optional<Enum>;
try
{
mapnik::enumeration<T, MAX> e;
Enum e;
e.from_string(source);
return result_type(e);
}

25
plugins/input/CMakeLists.txt
View file

@ -1,5 +1,28 @@
set(_plugin_prefix "")
set(_plugin_suffix ".input")
set(_plugin_library_output "${MAPNIK_OUTPUT_DIR}/plugins/input")
set(_plugin_fpic ON)
set(_plugin_linkage MODULE)
set(_plugin_visibility PRIVATE)
if(NOT BUILD_SHARED_PLUGINS)
set(_plugin_linkage INTERFACE)
set(_plugin_visibility INTERFACE)
endif()
macro(add_plugin_target plugin_target output_name)
add_library(${plugin_target} ${_plugin_linkage})
set_target_properties(${plugin_target} PROPERTIES
OUTPUT_NAME "${output_name}"
POSITION_INDEPENDENT_CODE ${_plugin_fpic}
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${_plugin_library_output}"
)
mapnik_install_plugin(${plugin_target})
endmacro()
add_subdirectory(base)
# add a list with all build plugins so the copy dependencies command can wait for all build events
set(m_build_plugins "")
@ -51,7 +74,7 @@ endif()
#
# Copy all plugin dlls, so that these are in the main output dir, since cmake copies those into ${MAPNIK_OUTPUT_DIR}/plugins/input, too.
#
if(WIN32)
if(BUILD_SHARED_PLUGINS AND WIN32)
list(LENGTH m_build_plugins m_number_plugins)
if(m_number_plugins GREATER 0)
string(CONFIGURE

12
plugins/input/base/CMakeLists.txt Normal file
View file

@ -0,0 +1,12 @@
add_library(datasource-base INTERFACE)
add_library(mapnik::datasource-base ALIAS datasource-base)
target_include_directories(datasource-base INTERFACE
$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
$<INSTALL_INTERFACE:include>
)
target_link_libraries(datasource-base INTERFACE mapnik::core)
mapnik_install(datasource-base)
install(DIRECTORY include/ DESTINATION "${MAPNIK_INCLUDE_DIR}")

54
plugins/input/base/include/mapnik/datasource_plugin.hpp Normal file
View file

@ -0,0 +1,54 @@
#ifndef DATASOURCE_PLUGIN_HPP
#define DATASOURCE_PLUGIN_HPP
#include <string>
#include <mapnik/config.hpp>
#include <mapnik/datasource.hpp>
namespace mapnik {
class MAPNIK_DECL datasource_plugin
{
public:
datasource_plugin() = default;
virtual ~datasource_plugin() = default;
virtual void after_load() const = 0;
virtual void before_unload() const = 0;
virtual const char* name() const = 0;
virtual datasource_ptr create(parameters const& params) const = 0;
};
} // namespace mapnik
#define DATASOURCE_PLUGIN_DEF(classname, pluginname) \
class classname : public mapnik::datasource_plugin \
{ \
public: \
static constexpr const char* kName = #pluginname; \
void after_load() const override; \
void before_unload() const override; \
const char* name() const override; \
mapnik::datasource_ptr create(mapnik::parameters const& params) const override; \
};
#define DATASOURCE_PLUGIN_IMPL(classname, pluginclassname) \
const char* classname::name() const \
{ \
return kName; \
} \
mapnik::datasource_ptr classname::create(mapnik::parameters const& params) const \
{ \
return std::make_shared<pluginclassname>(params); \
}
#define DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(classname) \
void classname::after_load() const {}
#define DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(classname) \
void classname::before_unload() const {}
#ifndef MAPNIK_STATIC_PLUGINS
#define DATASOURCE_PLUGIN_EXPORT(classname) \
extern "C" MAPNIK_EXP classname plugin; \
classname plugin;
#else
#define DATASOURCE_PLUGIN_EXPORT(classname) // export classname
#endif
#endif

16
plugins/input/csv/CMakeLists.txt
View file

@ -1,21 +1,15 @@
add_library(input-csv MODULE
add_plugin_target(input-csv "csv")
target_sources(input-csv ${_plugin_visibility}
csv_datasource.cpp
csv_featureset.cpp
csv_index_featureset.cpp
csv_inline_featureset.cpp
csv_utils.cpp
)
target_link_libraries(input-csv PRIVATE
target_link_libraries(input-csv ${_plugin_visibility}
mapnik::mapnik
mapnik::wkt
mapnik::json
mapnik::datasource-base
)
set_target_properties(input-csv PROPERTIES
OUTPUT_NAME "csv"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
)
mapnik_install_plugin(input-csv)

5
plugins/input/csv/csv_datasource.cpp
View file

@ -65,7 +65,10 @@ MAPNIK_DISABLE_WARNING_POP
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(csv_datasource)
DATASOURCE_PLUGIN_IMPL(csv_datasource_plugin, csv_datasource);
DATASOURCE_PLUGIN_EXPORT(csv_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(csv_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(csv_datasource_plugin);
csv_datasource::csv_datasource(parameters const& params)
: datasource(params)

4
plugins/input/csv/csv_datasource.hpp
View file

@ -48,6 +48,8 @@ MAPNIK_DISABLE_WARNING_POP
#include <vector>
#include <string>
#include <mapnik/datasource_plugin.hpp>
template<std::size_t Max, std::size_t Min>
struct csv_linear : boost::geometry::index::linear<Max, Min>
{};
@ -79,6 +81,8 @@ struct options_type<csv_linear<Max, Min>>
} // namespace geometry
} // namespace boost
DATASOURCE_PLUGIN_DEF(csv_datasource_plugin, csv);
class csv_datasource : public mapnik::datasource,
private csv_utils::csv_file_parser
{

17
plugins/input/gdal/CMakeLists.txt
View file

@ -1,20 +1,13 @@
find_package(GDAL REQUIRED)
add_library(input-gdal MODULE
add_plugin_target(input-gdal "gdal")
target_sources(input-gdal ${_plugin_visibility}
gdal_datasource.cpp
gdal_featureset.cpp
)
target_include_directories(input-gdal PRIVATE ${GDAL_INCLUDE_DIRS})
target_link_libraries(input-gdal PRIVATE
target_include_directories(input-gdal ${_plugin_visibility} ${GDAL_INCLUDE_DIRS})
target_link_libraries(input-gdal ${_plugin_visibility}
mapnik::mapnik
mapnik::datasource-base
${GDAL_LIBRARIES}
)
set_target_properties(input-gdal PROPERTIES
OUTPUT_NAME "gdal"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
)
mapnik_install_plugin(input-gdal)

16
plugins/input/gdal/gdal_datasource.cpp
View file

@ -37,8 +37,6 @@
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(gdal_datasource)
using mapnik::box2d;
using mapnik::coord2d;
using mapnik::datasource_exception;
@ -46,12 +44,16 @@ using mapnik::featureset_ptr;
using mapnik::layer_descriptor;
using mapnik::query;
static std::once_flag once_flag;
extern "C" MAPNIK_EXP void on_plugin_load()
DATASOURCE_PLUGIN_IMPL(gdal_datasource_plugin, gdal_datasource);
DATASOURCE_PLUGIN_EXPORT(gdal_datasource_plugin);
void gdal_datasource_plugin::after_load() const
{
// initialize gdal formats
std::call_once(once_flag, []() { GDALAllRegister(); });
GDALAllRegister();
}
void gdal_datasource_plugin::before_unload() const
{
GDALDestroyDriverManager();
}
gdal_datasource::gdal_datasource(parameters const& params)

4
plugins/input/gdal/gdal_datasource.hpp
View file

@ -31,7 +31,7 @@
#include <mapnik/geometry/box2d.hpp>
#include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/datasource_plugin.hpp>
// boost
#include <boost/optional.hpp>
@ -42,6 +42,8 @@
// gdal
#include <gdal_priv.h>
DATASOURCE_PLUGIN_DEF(gdal_datasource_plugin, gdal);
class gdal_datasource : public mapnik::datasource
{
public:

16
plugins/input/geobuf/CMakeLists.txt
View file

@ -1,14 +1,10 @@
add_library(input-geobuf MODULE
add_plugin_target(input-geobuf "geobuf")
target_sources(input-geobuf ${_plugin_visibility}
geobuf_datasource.cpp
geobuf_featureset.cpp
)
target_link_libraries(input-geobuf PRIVATE mapnik::mapnik)
set_target_properties(input-geobuf PROPERTIES
OUTPUT_NAME "geobuf"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
target_link_libraries(input-geobuf ${_plugin_visibility}
mapnik::mapnik
mapnik::datasource-base
)
mapnik_install_plugin(input-geobuf)

5
plugins/input/geobuf/geobuf_datasource.cpp
View file

@ -48,7 +48,10 @@
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(geobuf_datasource)
DATASOURCE_PLUGIN_IMPL(geobuf_datasource_plugin, geobuf_datasource);
DATASOURCE_PLUGIN_EXPORT(geobuf_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(geobuf_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(geobuf_datasource_plugin);
struct attr_value_converter
{

2
plugins/input/geobuf/geobuf_datasource.hpp
View file

@ -32,6 +32,7 @@
#include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/datasource_plugin.hpp>
// boost
#include <boost/optional.hpp>
#include <mapnik/warning.hpp>
@ -84,6 +85,7 @@ struct options_type<geobuf_linear<Max, Min>>
} // namespace geometry
} // namespace boost
DATASOURCE_PLUGIN_DEF(geobuf_datasource_plugin, geobuf);
class geobuf_datasource : public mapnik::datasource
{
public:

15
plugins/input/geojson/CMakeLists.txt
View file

@ -1,19 +1,12 @@
add_library(input-geojson MODULE
add_plugin_target(input-geojson "geojson")
target_sources(input-geojson ${_plugin_visibility}
geojson_datasource.cpp
geojson_featureset.cpp
geojson_index_featureset.cpp
geojson_memory_index_featureset.cpp
)
target_link_libraries(input-geojson PRIVATE
target_link_libraries(input-geojson ${_plugin_visibility}
mapnik::mapnik
mapnik::json
mapnik::datasource-base
)
set_target_properties(input-geojson PROPERTIES
OUTPUT_NAME "geojson"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
)
mapnik_install_plugin(input-geojson)

5
plugins/input/geojson/geojson_datasource.cpp
View file

@ -67,7 +67,10 @@ MAPNIK_DISABLE_WARNING_POP
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(geojson_datasource)
DATASOURCE_PLUGIN_IMPL(geojson_datasource_plugin, geojson_datasource);
DATASOURCE_PLUGIN_EXPORT(geojson_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(geojson_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(geojson_datasource_plugin);
struct attr_value_converter
{

3
plugins/input/geojson/geojson_datasource.hpp
View file

@ -32,6 +32,7 @@
#include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/datasource_plugin.hpp>
#include <mapnik/warning.hpp>
MAPNIK_DISABLE_WARNING_PUSH
@ -82,6 +83,8 @@ struct options_type<geojson_linear<Max, Min>>
} // namespace geometry
} // namespace boost
DATASOURCE_PLUGIN_DEF(geojson_datasource_plugin, geojson);
class geojson_datasource : public mapnik::datasource
{
public:

17
plugins/input/ogr/CMakeLists.txt
View file

@ -1,22 +1,15 @@
find_package(GDAL REQUIRED)
add_library(input-ogr MODULE
add_plugin_target(input-ogr "ogr")
target_sources(input-ogr ${_plugin_visibility}
ogr_converter.cpp
ogr_datasource.cpp
ogr_featureset.cpp
ogr_index_featureset.cpp
)
target_include_directories(input-ogr PRIVATE ${GDAL_INCLUDE_DIRS})
target_link_libraries(input-ogr PRIVATE
target_include_directories(input-ogr ${_plugin_visibility} ${GDAL_INCLUDE_DIRS})
target_link_libraries(input-ogr ${_plugin_visibility}
mapnik::mapnik
mapnik::datasource-base
${GDAL_LIBRARIES}
)
set_target_properties(input-ogr PROPERTIES
OUTPUT_NAME "ogr"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
)
mapnik_install_plugin(input-ogr)

17
plugins/input/ogr/ogr_datasource.cpp
View file

@ -33,6 +33,7 @@
#include <mapnik/timer.hpp>
#include <mapnik/util/utf_conv_win.hpp>
#include <mapnik/util/trim.hpp>
#include <mapnik/datasource_plugin.hpp>
#include <mapnik/warning.hpp>
MAPNIK_DISABLE_WARNING_PUSH
@ -49,8 +50,6 @@ MAPNIK_DISABLE_WARNING_POP
using mapnik::datasource;
using mapnik::parameters;
DATASOURCE_PLUGIN(ogr_datasource)
using mapnik::attribute_descriptor;
using mapnik::box2d;
using mapnik::coord2d;
@ -63,11 +62,21 @@ using mapnik::query;
static std::once_flag once_flag;
extern "C" MAPNIK_EXP void on_plugin_load()
DATASOURCE_PLUGIN_IMPL(ogr_datasource_plugin, ogr_datasource);
DATASOURCE_PLUGIN_EXPORT(ogr_datasource_plugin);
void ogr_datasource_plugin::after_load() const
{
// initialize ogr formats
// NOTE: in GDAL >= 2.0 this is the same as GDALAllRegister()
std::call_once(once_flag, []() { OGRRegisterAll(); });
OGRRegisterAll();
}
void ogr_datasource_plugin::before_unload() const
{
// initialize ogr formats
// NOTE: in GDAL >= 2.0 this is the same as GDALDestroyDriverManager()
OGRCleanupAll();
}
ogr_datasource::ogr_datasource(parameters const& params)

3
plugins/input/ogr/ogr_datasource.hpp
View file

@ -31,6 +31,7 @@
#include <mapnik/geometry/box2d.hpp>
#include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/datasource_plugin.hpp>
// boost
#include <boost/optional.hpp>
@ -47,6 +48,8 @@ MAPNIK_DISABLE_WARNING_PUSH
MAPNIK_DISABLE_WARNING_POP
#include "ogr_layer_ptr.hpp"
DATASOURCE_PLUGIN_DEF(ogr_datasource_plugin, ogr);
class ogr_datasource : public mapnik::datasource
{
public:

17
plugins/input/pgraster/CMakeLists.txt
View file

@ -1,20 +1,13 @@
find_package(PostgreSQL REQUIRED)
mapnik_find_package(PostgreSQL REQUIRED)
add_library(input-pgraster MODULE
add_plugin_target(input-pgraster "pgraster")
target_sources(input-pgraster ${_plugin_visibility}
pgraster_datasource.cpp
pgraster_featureset.cpp
pgraster_wkb_reader.cpp
)
target_link_libraries(input-pgraster PRIVATE
target_link_libraries(input-pgraster ${_plugin_visibility}
mapnik::mapnik
mapnik::datasource-base
PostgreSQL::PostgreSQL
)
set_target_properties(input-pgraster PROPERTIES
OUTPUT_NAME "pgraster"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
)
mapnik_install_plugin(input-pgraster)

5
plugins/input/pgraster/pgraster_datasource.cpp
View file

@ -51,7 +51,10 @@ MAPNIK_DISABLE_WARNING_POP
#include <set>
#include <sstream>
DATASOURCE_PLUGIN(pgraster_datasource)
DATASOURCE_PLUGIN_IMPL(pgraster_datasource_plugin, pgraster_datasource);
DATASOURCE_PLUGIN_EXPORT(pgraster_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(pgraster_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(pgraster_datasource_plugin);
const std::string pgraster_datasource::RASTER_COLUMNS = "raster_columns";
const std::string pgraster_datasource::RASTER_OVERVIEWS = "raster_overviews";

2
plugins/input/pgraster/pgraster_datasource.hpp
View file

@ -37,6 +37,7 @@
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/value/types.hpp>
#include <mapnik/datasource_plugin.hpp>
// boost
#include <boost/optional.hpp>
@ -73,6 +74,7 @@ struct pgraster_overview
float scale; // max absolute scale between x and y
};
DATASOURCE_PLUGIN_DEF(pgraster_datasource_plugin, pgraster);
class pgraster_datasource : public datasource
{
public:

17
plugins/input/postgis/CMakeLists.txt
View file

@ -1,19 +1,12 @@
find_package(PostgreSQL REQUIRED)
mapnik_find_package(PostgreSQL REQUIRED)
add_library(input-postgis MODULE
add_plugin_target(input-postgis "postgis")
target_sources(input-postgis ${_plugin_visibility}
postgis_datasource.cpp
postgis_featureset.cpp
)
target_link_libraries(input-postgis PRIVATE
target_link_libraries(input-postgis ${_plugin_visibility}
mapnik::mapnik
mapnik::datasource-base
PostgreSQL::PostgreSQL
)
set_target_properties(input-postgis PROPERTIES
OUTPUT_NAME "postgis"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
)
mapnik_install_plugin(input-postgis)

5
plugins/input/postgis/postgis_datasource.cpp
View file

@ -48,7 +48,10 @@ MAPNIK_DISABLE_WARNING_POP
#include <set>
#include <sstream>
DATASOURCE_PLUGIN(postgis_datasource)
DATASOURCE_PLUGIN_IMPL(postgis_datasource_plugin, postgis_datasource);
DATASOURCE_PLUGIN_EXPORT(postgis_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(postgis_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(postgis_datasource_plugin);
const std::string postgis_datasource::GEOMETRY_COLUMNS = "geometry_columns";
const std::string postgis_datasource::SPATIAL_REF_SYS = "spatial_ref_system";

2
plugins/input/postgis/postgis_datasource.hpp
View file

@ -34,6 +34,7 @@
#include <mapnik/unicode.hpp>
#include <mapnik/value/types.hpp>
#include <mapnik/attribute.hpp>
#include <mapnik/datasource_plugin.hpp>
// boost
#include <boost/optional.hpp>
@ -62,6 +63,7 @@ using mapnik::transcoder;
using CnxPool_ptr = std::shared_ptr<ConnectionManager::PoolType>;
DATASOURCE_PLUGIN_DEF(postgis_datasource_plugin, postgis);
class postgis_datasource : public datasource
{
public:

15
plugins/input/raster/CMakeLists.txt
View file

@ -1,15 +1,10 @@
add_library(input-raster MODULE
add_plugin_target(input-raster "raster")
target_sources(input-raster ${_plugin_visibility}
raster_datasource.cpp
raster_featureset.cpp
raster_info.cpp
)
target_link_libraries(input-raster PRIVATE mapnik::mapnik)
set_target_properties(input-raster PROPERTIES
OUTPUT_NAME "raster"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
target_link_libraries(input-raster ${_plugin_visibility}
mapnik::mapnik
mapnik::datasource-base
)
mapnik_install_plugin(input-raster)

5
plugins/input/raster/raster_datasource.cpp
View file

@ -43,7 +43,10 @@ using mapnik::layer_descriptor;
using mapnik::parameters;
using mapnik::query;
DATASOURCE_PLUGIN(raster_datasource)
DATASOURCE_PLUGIN_IMPL(raster_datasource_plugin, raster_datasource);
DATASOURCE_PLUGIN_EXPORT(raster_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(raster_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(raster_datasource_plugin);
raster_datasource::raster_datasource(parameters const& params)
: datasource(params)

3
plugins/input/raster/raster_datasource.hpp
View file

@ -31,6 +31,7 @@
#include <mapnik/geometry/box2d.hpp>
#include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/datasource_plugin.hpp>
// boost
#include <boost/optional.hpp>
@ -40,6 +41,8 @@
#include <vector>
#include <string>
DATASOURCE_PLUGIN_DEF(raster_datasource_plugin, raster);
class raster_datasource : public mapnik::datasource
{
public:

15
plugins/input/shape/CMakeLists.txt
View file

@ -1,4 +1,5 @@
add_library(input-shape MODULE
add_plugin_target(input-shape "shape")
target_sources(input-shape ${_plugin_visibility}
dbfile.cpp
dbf_test.cpp
shape_datasource.cpp
@ -6,13 +7,7 @@ add_library(input-shape MODULE
shape_index_featureset.cpp
shape_io.cpp shape_utils.cpp
)
target_link_libraries(input-shape PRIVATE mapnik::mapnik)
set_target_properties(input-shape PROPERTIES
OUTPUT_NAME "shape"
PREFIX "${_plugin_prefix}"
SUFFIX "${_plugin_suffix}"
LIBRARY_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/plugins/input"
RUNTIME_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}"
ARCHIVE_OUTPUT_DIRECTORY "${MAPNIK_OUTPUT_DIR}/lib"
target_link_libraries(input-shape ${_plugin_visibility}
mapnik::mapnik
mapnik::datasource-base
)
mapnik_install_plugin(input-shape)

5
plugins/input/shape/shape_datasource.cpp
View file

@ -47,7 +47,10 @@ MAPNIK_DISABLE_WARNING_POP
#include <sstream>
#include <stdexcept>
DATASOURCE_PLUGIN(shape_datasource)
DATASOURCE_PLUGIN_IMPL(shape_datasource_plugin, shape_datasource);
DATASOURCE_PLUGIN_EXPORT(shape_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_AFTER_LOAD(shape_datasource_plugin);
DATASOURCE_PLUGIN_EMPTY_BEFORE_UNLOAD(shape_datasource_plugin);
using mapnik::attribute_descriptor;
using mapnik::Boolean;

3
plugins/input/shape/shape_datasource.hpp
View file

@ -32,6 +32,7 @@
#include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp>
#include <mapnik/value/types.hpp>
#include <mapnik/datasource_plugin.hpp>
// boost
#include <boost/optional.hpp>
@ -50,6 +51,8 @@ using mapnik::layer_descriptor;
using mapnik::parameters;
using mapnik::query;
DATASOURCE_PLUGIN_DEF(shape_datasource_plugin, shape);
class shape_datasource : public datasource
{
public:

Some files were not shown because too many files have changed in this diff Show more