[arch-commits] Commit in mapnik/repos (4 files)

Felix Yan felixonmars at archlinux.org
Sat Dec 12 15:34:30 UTC 2020


    Date: Saturday, December 12, 2020 @ 15:34:29
  Author: felixonmars
Revision: 773319

archrelease: copy trunk to community-staging-x86_64

Added:
  mapnik/repos/community-staging-x86_64/
  mapnik/repos/community-staging-x86_64/PKGBUILD
    (from rev 773318, mapnik/trunk/PKGBUILD)
  mapnik/repos/community-staging-x86_64/mapnik-boost173.patch
    (from rev 773318, mapnik/trunk/mapnik-boost173.patch)
  mapnik/repos/community-staging-x86_64/mapnik-std-c++14.patch
    (from rev 773318, mapnik/trunk/mapnik-std-c++14.patch)

------------------------+
 PKGBUILD               |   54 +++++
 mapnik-boost173.patch  |  492 +++++++++++++++++++++++++++++++++++++++++++++++
 mapnik-std-c++14.patch |   89 ++++++++
 3 files changed, 635 insertions(+)

Copied: mapnik/repos/community-staging-x86_64/PKGBUILD (from rev 773318, mapnik/trunk/PKGBUILD)
===================================================================
--- community-staging-x86_64/PKGBUILD	                        (rev 0)
+++ community-staging-x86_64/PKGBUILD	2020-12-12 15:34:29 UTC (rev 773319)
@@ -0,0 +1,54 @@
+# Maintainer: Jaroslav Lichtblau <svetlemodry at archlinux.org>
+# Contributor: Sergej Pupykin <pupykin.s+arch at gmail.com>
+# Contributor: David Dent <thewinch at gmail.com>
+# Contributor: orbisvicis <orbisvicis at gmail.com>
+
+pkgname=mapnik
+pkgver=3.0.23
+pkgrel=4
+pkgdesc="Free Toolkit for developing mapping applications and rendering beautiful maps"
+arch=('x86_64')
+url="https://mapnik.org/"
+license=('LGPL')
+depends=('boost-libs' 'cairo' 'freetype2' 'gdal' 'harfbuzz' 'icu' 'libjpeg-turbo' 'libpng'
+         'libtiff' 'libwebp' 'libxml2' 'postgresql-libs' 'proj' 'sqlite' 'zlib')
+makedepends=('boost' 'scons')
+source=(https://github.com/$pkgname/$pkgname/releases/download/v$pkgver/$pkgname-v$pkgver.tar.bz2
+        mapnik-boost173.patch
+        mapnik-std-c++14.patch
+        mapnik-freetype2.patch::https://github.com/mapnik/mapnik/pull/3892.patch)
+sha256sums=('4b1352e01f7ce25ab099e586d7ae98e0b74145a3bf94dd365cb0a2bdab3b9dc2'
+            'fc6fb17c90dd1b2d861a5d8886797a5536bc31ab4b018ba1688f41fb25be27b4'
+            '89b6f6be54feca2ba120516a39e20d3ae9706b7fbde140d73538f2727ab31fbe'
+            '774a8590b698e9dc2a483e6ff48781ed0400ba06b901f12a1ed50c9114833d47')
+
+prepare() {
+  cd "${srcdir}"/$pkgname-v$pkgver
+
+  patch -Np1 -i ../mapnik-boost173.patch
+
+  # C++14 mode required by Boost.Geometry 1.75
+  patch -Np1 -i ../mapnik-std-c++14.patch
+
+  # Use pkg-config to find FreeType2 if available
+  # https://github.com/mapnik/mapnik/pull/3892
+  patch -Np1 -i "${srcdir}"/mapnik-freetype2.patch
+}
+
+build() {
+  cd "${srcdir}"/$pkgname-v$pkgver
+  scons configure  FAST=True \
+    PREFIX="/usr" \
+    INPUT_PLUGINS=all \
+    XMLPARSER=libxml2 \
+    DESTDIR="$pkgdir" \
+    CUSTOM_CXXFLAGS="$CXXFLAGS" \
+    CUSTOM_LDFLAGS="$LDFLAGS" \
+    CUSTOM_DEFINES="-DACCEPT_USE_OF_DEPRECATED_PROJ_API_H=1"
+  scons $(expr "$MAKEFLAGS" : '.*\(\-j[0-9]\+\)')
+}
+
+package(){
+  cd "${srcdir}"/$pkgname-v$pkgver
+  scons install
+}

Copied: mapnik/repos/community-staging-x86_64/mapnik-boost173.patch (from rev 773318, mapnik/trunk/mapnik-boost173.patch)
===================================================================
--- community-staging-x86_64/mapnik-boost173.patch	                        (rev 0)
+++ community-staging-x86_64/mapnik-boost173.patch	2020-12-12 15:34:29 UTC (rev 773319)
@@ -0,0 +1,492 @@
+commit 7a25bedb31159093300f525a6cda46cce5cfc450
+Author: Artem Pavlenko <artem at mapnik.org>
+Date:   Mon May 11 22:18:55 2020 +0100
+
+    Add support for boost 1.73
+
+diff --git a/include/mapnik/json/feature_generator_grammar.hpp b/include/mapnik/json/feature_generator_grammar.hpp
+index 7bfbbc5e2..5df0cf938 100644
+--- a/include/mapnik/json/feature_generator_grammar.hpp
++++ b/include/mapnik/json/feature_generator_grammar.hpp
+@@ -30,88 +30,86 @@
+ #include <mapnik/json/properties_generator_grammar.hpp>
+ 
+ // boost
++#include <boost/spirit/home/support/attributes.hpp>
+ #include <boost/spirit/include/karma.hpp>
++#include <boost/fusion/include/adapt_adt.hpp>
++#include <boost/spirit/include/support_adapt_adt_attributes.hpp>
++
++namespace mapnik {
++
++struct kv_store
++{
++    using value_type = mapnik::feature_impl::value_type;
++    using iterator_type = mapnik::feature_kv_iterator2;
++    kv_store(mapnik::feature_impl const& f)
++        : start_(mapnik::value_not_null(),f.begin(),f.end()),
++          end_(mapnik::value_not_null(),f.end(),f.end())
++    {}
++    iterator_type start_;
++    iterator_type end_;
++};
++
++}
+ 
+ namespace boost { namespace spirit { namespace traits {
+ 
+ template <>
+-struct is_container<mapnik::feature_impl const> : mpl::false_ {} ;
++struct is_container<mapnik::kv_store const> : mpl::false_ {} ;
+ 
+ template <>
+-struct container_iterator<mapnik::feature_impl const>
++struct container_iterator<mapnik::kv_store const>
+ {
+-    using type = mapnik::feature_kv_iterator2;
++    using type = mapnik::kv_store::iterator_type;
+ };
+ 
+ template <>
+-struct begin_container<mapnik::feature_impl const>
++struct begin_container<mapnik::kv_store const>
+ {
+-    static mapnik::feature_kv_iterator2
+-    call (mapnik::feature_impl const& f)
++    static mapnik::kv_store::iterator_type
++    call (mapnik::kv_store const& kv)
+     {
+-        return mapnik::feature_kv_iterator2(mapnik::value_not_null(),f.begin(),f.end());
++        return kv.start_;
+     }
+ };
+ 
+ template <>
+-struct end_container<mapnik::feature_impl const>
++struct end_container<mapnik::kv_store const>
+ {
+-    static mapnik::feature_kv_iterator2
+-    call (mapnik::feature_impl const& f)
++    static mapnik::kv_store::iterator_type
++    call (mapnik::kv_store const& kv)
+     {
+-        return mapnik::feature_kv_iterator2(mapnik::value_not_null(),f.end(),f.end());
++        return kv.end_;
+     }
+ };
+ 
+-#if BOOST_VERSION >= 106900
+-template <>
+-struct transform_attribute<const mapnik::feature_impl, const mapnik::feature_impl &, boost::spirit::karma::domain, void>
+-    : detail::transform_attribute_base<mapnik::feature_impl const, mapnik::feature_impl const&,  boost::spirit::karma::domain>
+-{};
+-
+-template <>
+-struct transform_attribute<const boost::fusion::cons<const mapnik::feature_impl &, boost::fusion::nil_>, const mapnik::feature_impl &,
+-      boost::spirit::karma::domain, void>
+-    : detail::transform_attribute_base<const boost::fusion::cons<const mapnik::feature_impl &, boost::fusion::nil_>, mapnik::feature_impl const&,  boost::spirit::karma::domain>
+-{};
+-#endif
+ }}}
+ 
+-namespace mapnik { namespace json {
+-
+-namespace karma = boost::spirit::karma;
++BOOST_FUSION_ADAPT_ADT(
++    mapnik::feature_impl,
++    (int, int, obj.id(), /**/)
++    (mapnik::geometry::geometry<double>const&, mapnik::geometry::geometry<double> const&, obj.get_geometry(),/**/)
++    (mapnik::kv_store const, mapnik::kv_store const, mapnik::kv_store(obj), /**/))
+ 
++namespace mapnik { namespace json {
++namespace detail {
+ template <typename T>
+-struct get_id
+-{
+-    using feature_type = T;
+-    using result_type = mapnik::value_integer;
+-    result_type operator() (feature_type const& f) const
+-    {
+-        return f.id();
+-    }
+-};
++#if BOOST_VERSION >= 107000
++struct attribute_type { using type = T();};
++#else
++struct attribute_type { using type = T const&();};
++#endif
++}
+ 
+-struct extract_geometry
+-{
+-    using result_type = mapnik::geometry::geometry<double> const&;
+-    template <typename T>
+-    result_type operator() (T const& f) const
+-    {
+-        return f.get_geometry();
+-    }
+-};
++namespace karma = boost::spirit::karma;
+ 
+ template <typename OutputIterator, typename FeatureType>
+ struct feature_generator_grammar :
+-        karma::grammar<OutputIterator, FeatureType const&()>
++        karma::grammar<OutputIterator, typename detail::attribute_type<FeatureType>::type>
+ {
+     feature_generator_grammar();
+-    karma::rule<OutputIterator, FeatureType const&()> feature;
+-    geometry_generator_grammar<OutputIterator, mapnik::geometry::geometry<double> > geometry;
+-    properties_generator_grammar<OutputIterator, FeatureType> properties;
+-    boost::phoenix::function<get_id<FeatureType> > id_;
+-    boost::phoenix::function<extract_geometry> geom_;
++    karma::rule<OutputIterator, typename detail::attribute_type<FeatureType>::type> feature;
++    geometry_generator_grammar<OutputIterator, mapnik::geometry::geometry<double>> geometry;
++    properties_generator_grammar<OutputIterator, mapnik::kv_store> properties;
+ };
+ 
+ }}
+diff --git a/include/mapnik/json/feature_generator_grammar_impl.hpp b/include/mapnik/json/feature_generator_grammar_impl.hpp
+index baf4be853..fd65e7320 100644
+--- a/include/mapnik/json/feature_generator_grammar_impl.hpp
++++ b/include/mapnik/json/feature_generator_grammar_impl.hpp
+@@ -29,13 +29,11 @@ feature_generator_grammar<OutputIterator, FeatureType>::feature_generator_gramma
+   : feature_generator_grammar::base_type(feature)
+ {
+     boost::spirit::karma::lit_type lit;
+-    boost::spirit::karma::uint_type uint_;
+-    boost::spirit::karma::_val_type _val;
+-    boost::spirit::karma::_1_type _1;
++    boost::spirit::karma::int_type int_;
+ 
+-    feature = lit("{\"type\":\"Feature\",\"id\":")
+-        << uint_[_1 = id_(_val)]
+-        << lit(",\"geometry\":") << geometry[_1 = geom_(_val)]
++    feature  = lit("{\"type\":\"Feature\"")
++        << lit(",\"id\":") << int_
++        << lit(",\"geometry\":") << geometry
+         << lit(",\"properties\":") << properties
+         << lit('}')
+         ;
+diff --git a/include/mapnik/json/properties_generator_grammar.hpp b/include/mapnik/json/properties_generator_grammar.hpp
+index 69145b8ab..4eb3123cc 100644
+--- a/include/mapnik/json/properties_generator_grammar.hpp
++++ b/include/mapnik/json/properties_generator_grammar.hpp
+@@ -30,6 +30,7 @@
+ #include <mapnik/warning_ignore.hpp>
+ #include <boost/spirit/include/karma.hpp>
+ #include <boost/spirit/include/phoenix_function.hpp>
++#include <boost/spirit/home/karma/domain.hpp>
+ #pragma GCC diagnostic pop
+ 
+ #include <string>
+@@ -50,7 +51,7 @@ struct escaped_string
+ 
+ struct extract_string
+ {
+-    using result_type = std::tuple<std::string,bool>;
++    using result_type = std::tuple<std::string, bool>;
+ 
+     result_type operator() (mapnik::value const& val) const
+     {
+@@ -60,19 +61,17 @@ struct extract_string
+ };
+ 
+ template <typename OutputIterator, typename KeyValueStore>
+-struct properties_generator_grammar : karma::grammar<OutputIterator, KeyValueStore const&()>
+-
++struct properties_generator_grammar
++    : karma::grammar<OutputIterator, KeyValueStore()>
+ {
+     using pair_type = std::tuple<std::string, mapnik::value>;
+     properties_generator_grammar();
+     // rules
+-    karma::rule<OutputIterator, KeyValueStore const&()> properties;
++    karma::rule<OutputIterator, KeyValueStore()> properties;
+     karma::rule<OutputIterator, pair_type()> pair;
+     karma::rule<OutputIterator, std::tuple<std::string,bool>()> value;
+-    karma::rule<OutputIterator, mapnik::value_null()> value_null_;
+-    karma::rule<OutputIterator, mapnik::value_unicode_string()> ustring;
++    //
+     escaped_string<OutputIterator> escaped_string_;
+-    typename karma::int_generator<mapnik::value_integer,10, false> int__;
+     boost::phoenix::function<extract_string> extract_string_;
+     std::string quote_;
+ };
+diff --git a/include/mapnik/json/properties_generator_grammar_impl.hpp b/include/mapnik/json/properties_generator_grammar_impl.hpp
+index 8f694f6ca..a81c75fa4 100644
+--- a/include/mapnik/json/properties_generator_grammar_impl.hpp
++++ b/include/mapnik/json/properties_generator_grammar_impl.hpp
+@@ -69,6 +69,7 @@ properties_generator_grammar<OutputIterator,KeyValueStore>::properties_generator
+     boost::spirit::karma::string_type kstring;
+     boost::spirit::karma::eps_type eps;
+     using boost::phoenix::at_c;
++
+     properties = lit('{')
+         << -(pair % lit(','))
+         << lit('}')
+@@ -84,7 +85,6 @@ properties_generator_grammar<OutputIterator,KeyValueStore>::properties_generator
+         |
+         kstring[_1 = at_c<0>(_val)]
+         ;
+-
+ }
+ 
+ }}
+diff --git a/include/mapnik/util/spirit_transform_attribute.hpp b/include/mapnik/util/spirit_transform_attribute.hpp
+deleted file mode 100644
+index c4176f1fa..000000000
+--- a/include/mapnik/util/spirit_transform_attribute.hpp
++++ /dev/null
+@@ -1,216 +0,0 @@
+-/*****************************************************************************
+- *
+- * This file is part of Mapnik (c++ mapping toolkit)
+- *
+- * Copyright (C) 2015 Artem Pavlenko
+- *
+- * This library is free software; you can redistribute it and/or
+- * modify it under the terms of the GNU Lesser General Public
+- * License as published by the Free Software Foundation; either
+- * version 2.1 of the License, or (at your option) any later version.
+- *
+- * This library is distributed in the hope that it will be useful,
+- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+- * Lesser General Public License for more details.
+- *
+- * You should have received a copy of the GNU Lesser General Public
+- * License along with this library; if not, write to the Free Software
+- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+- *
+- *****************************************************************************/
+-
+-#ifndef MAPNIK_UTIL_SPIRIT_TRANSFORM_ATTRIBUTE_HPP
+-#define MAPNIK_UTIL_SPIRIT_TRANSFORM_ATTRIBUTE_HPP
+-
+-#include <mapnik/geometry.hpp>
+-#include <mapnik/util/variant.hpp>
+-
+-#include <cstdint>
+-
+-#pragma GCC diagnostic push
+-#include <mapnik/warning_ignore.hpp>
+-#include <boost/spirit/include/karma.hpp>
+-#pragma GCC diagnostic pop
+-
+-namespace boost { namespace spirit { namespace traits {
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<double> const,
+-                               mapnik::geometry::point<double> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::point<double> const&;
+-        static type pre(mapnik::geometry::geometry<double> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::point<double> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<double> const,
+-                               mapnik::geometry::line_string<double> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::line_string<double> const&;
+-        static type pre(mapnik::geometry::geometry<double> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::line_string<double> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<double> const,
+-                               mapnik::geometry::polygon<double> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::polygon<double> const&;
+-        static type pre(mapnik::geometry::geometry<double> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::polygon<double> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::polygon<double> const,
+-                               mapnik::geometry::polygon<double>::rings_container const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::polygon<double>::rings_container const&;
+-        static type pre(mapnik::geometry::polygon<double> const& poly)
+-        {
+-            return poly.interior_rings;
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<double> const,
+-                               mapnik::geometry::multi_point<double> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::multi_point<double> const&;
+-        static type pre(mapnik::geometry::geometry<double> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::multi_point<double> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<double> const,
+-                               mapnik::geometry::multi_line_string<double> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::multi_line_string<double> const&;
+-        static type pre(mapnik::geometry::geometry<double> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::multi_line_string<double> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<double> const,
+-                               mapnik::geometry::multi_polygon<double> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::multi_polygon<double> const&;
+-        static type pre(mapnik::geometry::geometry<double> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::multi_polygon<double> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<double> const,
+-                               mapnik::geometry::geometry_collection<double> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::geometry_collection<double> const&;
+-        static type pre(mapnik::geometry::geometry<double> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::geometry_collection<double> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<std::int64_t> const,
+-                               mapnik::geometry::point<std::int64_t> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::point<std::int64_t> const&;
+-        static type pre(mapnik::geometry::geometry<std::int64_t> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::point<std::int64_t> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<std::int64_t> const,
+-                               mapnik::geometry::line_string<std::int64_t> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::line_string<std::int64_t> const&;
+-        static type pre(mapnik::geometry::geometry<std::int64_t> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::line_string<std::int64_t> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<std::int64_t> const,
+-                               mapnik::geometry::polygon<std::int64_t> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::polygon<std::int64_t> const&;
+-        static type pre(mapnik::geometry::geometry<std::int64_t> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::polygon<std::int64_t> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::polygon<std::int64_t> const,
+-                               mapnik::geometry::polygon<std::int64_t>::rings_container const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::polygon<std::int64_t>::rings_container const&;
+-        static type pre(mapnik::geometry::polygon<std::int64_t> const& poly)
+-        {
+-            return poly.interior_rings;
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<std::int64_t> const,
+-                               mapnik::geometry::multi_point<std::int64_t> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::multi_point<std::int64_t> const&;
+-        static type pre(mapnik::geometry::geometry<std::int64_t> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::multi_point<std::int64_t> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<std::int64_t> const,
+-                               mapnik::geometry::multi_line_string<std::int64_t> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::multi_line_string<std::int64_t> const&;
+-        static type pre(mapnik::geometry::geometry<std::int64_t> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::multi_line_string<std::int64_t> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<std::int64_t> const,
+-                               mapnik::geometry::multi_polygon<std::int64_t> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::multi_polygon<std::int64_t> const&;
+-        static type pre(mapnik::geometry::geometry<std::int64_t> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::multi_polygon<std::int64_t> >(geom);
+-        }
+-    };
+-
+-    template <>
+-    struct transform_attribute<mapnik::geometry::geometry<std::int64_t> const,
+-                               mapnik::geometry::geometry_collection<std::int64_t> const&, karma::domain>
+-    {
+-        using type = mapnik::geometry::geometry_collection<std::int64_t> const&;
+-        static type pre(mapnik::geometry::geometry<std::int64_t> const& geom)
+-        {
+-            return mapnik::util::get<mapnik::geometry::geometry_collection<std::int64_t> >(geom);
+-        }
+-    };
+-
+-}}}
+-
+-#endif // MAPNIK_UTIL_SPIRIT_TRANSFORM_ATTRIBUTE_HPP
+diff --git a/include/mapnik/wkt/wkt_grammar.hpp b/include/mapnik/wkt/wkt_grammar.hpp
+index 9d23f81ca..e7fd8fd99 100644
+--- a/include/mapnik/wkt/wkt_grammar.hpp
++++ b/include/mapnik/wkt/wkt_grammar.hpp
+@@ -29,6 +29,7 @@
+ #pragma GCC diagnostic push
+ #include <mapnik/warning_ignore.hpp>
+ #include <boost/assert.hpp>
++#include <boost/phoenix/core/reference.hpp>
+ #include <boost/spirit/include/qi.hpp>
+ #include <boost/spirit/include/phoenix_function.hpp>
+ #pragma GCC diagnostic pop
+diff --git a/src/json/mapnik_json_generator_grammar.cpp b/src/json/mapnik_json_generator_grammar.cpp
+index 72a1a74c9..b5aeecc94 100644
+--- a/src/json/mapnik_json_generator_grammar.cpp
++++ b/src/json/mapnik_json_generator_grammar.cpp
+@@ -29,6 +29,6 @@
+ 
+ using sink_type = std::back_insert_iterator<std::string>;
+ 
+-template struct mapnik::json::properties_generator_grammar<sink_type, mapnik::feature_impl>;
++template struct mapnik::json::properties_generator_grammar<sink_type, mapnik::kv_store>;
+ template struct mapnik::json::feature_generator_grammar<sink_type, mapnik::feature_impl>;
+ template struct mapnik::json::geometry_generator_grammar<sink_type, mapnik::geometry::geometry<double> >;
+diff --git a/src/tiff_reader.cpp b/src/tiff_reader.cpp
+index 65850e4c7..d1481f6b7 100644
+--- a/src/tiff_reader.cpp
++++ b/src/tiff_reader.cpp
+@@ -39,6 +39,7 @@ extern "C"
+ #endif
+ 
+ // stl
++#include <algorithm>
+ #include <memory>
+ #include <fstream>
+ 

Copied: mapnik/repos/community-staging-x86_64/mapnik-std-c++14.patch (from rev 773318, mapnik/trunk/mapnik-std-c++14.patch)
===================================================================
--- community-staging-x86_64/mapnik-std-c++14.patch	                        (rev 0)
+++ community-staging-x86_64/mapnik-std-c++14.patch	2020-12-12 15:34:29 UTC (rev 773319)
@@ -0,0 +1,89 @@
+From 3b184fb55efbf36511c7bb453a284b1c1afdd595 Mon Sep 17 00:00:00 2001
+From: artemp <artem at mapnik.org>
+Date: Thu, 8 Dec 2016 10:43:25 +0100
+Subject: [PATCH] SConstruct - require c++14
+
+(cherry picked from commit 1372ca48ef841e548241552671831ac1736e91e6)
+---
+ SConstruct | 26 +++++++++++++-------------
+ 1 file changed, 13 insertions(+), 13 deletions(-)
+
+diff --git a/SConstruct b/SConstruct
+index 960c9087e..f47f268a6 100644
+--- a/SConstruct
++++ b/SConstruct
+@@ -42,8 +42,8 @@ ICU_LIBS_DEFAULT='/usr/'
+ 
+ DEFAULT_CC = "cc"
+ DEFAULT_CXX = "c++"
+-DEFAULT_CXX11_CXXFLAGS = " -std=c++11 -DU_USING_ICU_NAMESPACE=0"
+-DEFAULT_CXX11_LINKFLAGS = ""
++DEFAULT_CXX14_CXXFLAGS = " -std=c++14 -DU_USING_ICU_NAMESPACE=0"
++DEFAULT_CXX14_LINKFLAGS = ""
+ if sys.platform == 'darwin':
+     # homebrew default
+     ICU_INCLUDES_DEFAULT='/usr/local/opt/icu4c/include/'
+@@ -1168,12 +1168,12 @@ int main()
+         return True
+     return False
+ 
+-def supports_cxx11(context,silent=False):
++def supports_cxx14(context,silent=False):
+     ret = context.TryRun("""
+ 
+ int main()
+ {
+-#if __cplusplus >= 201103
++#if __cplusplus >= 201402L
+     return 0;
+ #else
+     return -1;
+@@ -1182,7 +1182,7 @@ int main()
+ 
+ """, '.cpp')
+     if not silent:
+-        context.Message('Checking if compiler (%s) supports -std=c++11 flag... ' % context.env.get('CXX','CXX'))
++        context.Message('Checking if compiler (%s) supports -std=c++14 flag... ' % context.env.get('CXX','CXX'))
+     if silent:
+         context.did_show_result=1
+     context.Result(ret[0])
+@@ -1214,7 +1214,7 @@ conf_tests = { 'prioritize_paths'      : prioritize_paths,
+                'harfbuzz_with_freetype_support': harfbuzz_with_freetype_support,
+                'boost_regex_has_icu'   : boost_regex_has_icu,
+                'sqlite_has_rtree'      : sqlite_has_rtree,
+-               'supports_cxx11'        : supports_cxx11,
++               'supports_cxx14'        : supports_cxx14,
+                'CheckBoostScopedEnum'  : CheckBoostScopedEnum,
+                }
+ 
+@@ -1351,13 +1351,13 @@ if not preconfigured:
+ 
+     # set any custom cxxflags and ldflags to come first
+     if sys.platform == 'darwin' and not env['HOST']:
+-        DEFAULT_CXX11_CXXFLAGS += ' -stdlib=libc++'
+-        DEFAULT_CXX11_LINKFLAGS = ' -stdlib=libc++'
++        DEFAULT_CXX14_CXXFLAGS += ' -stdlib=libc++'
++        DEFAULT_CXX14_LINKFLAGS = ' -stdlib=libc++'
+     env.Append(CPPDEFINES = env['CUSTOM_DEFINES'])
+-    env.Append(CXXFLAGS = DEFAULT_CXX11_CXXFLAGS)
++    env.Append(CXXFLAGS = DEFAULT_CXX14_CXXFLAGS)
+     env.Append(CXXFLAGS = env['CUSTOM_CXXFLAGS'])
+     env.Append(CFLAGS = env['CUSTOM_CFLAGS'])
+-    env.Append(LINKFLAGS = DEFAULT_CXX11_LINKFLAGS)
++    env.Append(LINKFLAGS = DEFAULT_CXX14_LINKFLAGS)
+     env.Append(LINKFLAGS = env['CUSTOM_LDFLAGS'])
+ 
+     ### platform specific bits
+@@ -1488,9 +1488,9 @@ if not preconfigured:
+     if env['PRIORITIZE_LINKING']:
+         conf.prioritize_paths(silent=True)
+ 
+-    # test for C++11 support, which is required
+-    if not env['HOST'] and not conf.supports_cxx11():
+-        color_print(1,"C++ compiler does not support C++11 standard (-std=c++11), which is required. Please upgrade your compiler")
++    # test for C++14 support, which is required
++    if not env['HOST'] and not conf.supports_cxx14():
++        color_print(1,"C++ compiler does not support C++14 standard (-std=c++14), which is required. Please upgrade your compiler")
+         Exit(1)
+ 
+     if not env['HOST']:



More information about the arch-commits mailing list