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

Merge commit 'a01a998aff27036ceee231ecc71156dcacc3e298' into harfbuzz

Browse source 
Conflicts:
	include/mapnik/agg_renderer.hpp
	include/mapnik/text/text_properties.hpp
This commit is contained in:
Hermann Kraus 2013-03-16 15:14:24 +01:00
commit 20272a7396
68 changed files with 529 additions and 348 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
include/mapnik/agg_renderer.hpp
View file

@ -24,34 +24,34 @@
#define MAPNIK_AGG_RENDERER_HPP #define MAPNIK_AGG_RENDERER_HPP
// mapnik // mapnik
#include <mapnik/config.hpp> #include <mapnik/config.hpp> // for MAPNIK_DECL
#include <mapnik/feature_style_processor.hpp> #include <mapnik/feature_style_processor.hpp>
#include <mapnik/font_engine_freetype.hpp> #include <mapnik/font_engine_freetype.hpp> // for face_manager, etc
#include <mapnik/label_collision_detector.hpp> #include <mapnik/noncopyable.hpp> // for noncopyable
#include <mapnik/map.hpp> #include <mapnik/rule.hpp> // for rule, symbolizers
#include <mapnik/box2d.hpp> // for box2d
#include <mapnik/pixel_position.hpp> #include <mapnik/pixel_position.hpp>
#include <mapnik/rule.hpp> // for all symbolizers #include <mapnik/color.hpp> // for color
#include <mapnik/noncopyable.hpp> #include <mapnik/ctrans.hpp> // for CoordTransform
#include <mapnik/image_compositing.hpp> // for composite_mode_e
// boost // boost
#include <boost/scoped_ptr.hpp> #include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp> #include <boost/shared_ptr.hpp>
#include <boost/optional.hpp>
// FIXME namespace agg { struct trans_affine; }
// forward declare so that namespace mapnik { class Map; }
// apps using mapnik do not namespace mapnik { class feature_impl; }
// need agg headers namespace mapnik { class feature_type_style; }
namespace agg { namespace mapnik { class label_collision_detector4; }
struct trans_affine; namespace mapnik { class layer; }
} namespace mapnik { class marker; }
namespace mapnik { class proj_transform; }
namespace mapnik { struct rasterizer; }
struct pixel_position;
namespace mapnik { namespace mapnik {
class marker;
struct rasterizer;
template <typename T> template <typename T>
class MAPNIK_DECL agg_renderer : public feature_style_processor<agg_renderer<T> >, class MAPNIK_DECL agg_renderer : public feature_style_processor<agg_renderer<T> >,
private mapnik::noncopyable private mapnik::noncopyable

3
include/mapnik/filter_featureset.hpp
View file

@ -24,7 +24,8 @@
#define MAPNIK_FILTER_FEATURESET_HPP #define MAPNIK_FILTER_FEATURESET_HPP
// mapnik // mapnik
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp> // for featureset_ptr
#include <mapnik/feature.hpp>
namespace mapnik { namespace mapnik {

30
include/mapnik/grid/grid_renderer.hpp
View file

@ -27,30 +27,32 @@
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#include <mapnik/feature_style_processor.hpp> #include <mapnik/feature_style_processor.hpp>
#include <mapnik/font_engine_freetype.hpp> #include <mapnik/font_engine_freetype.hpp>
#include <mapnik/label_collision_detector.hpp>
#include <mapnik/map.hpp>
#include <mapnik/rule.hpp> // for all symbolizers
#include <mapnik/grid/grid.hpp> #include <mapnik/grid/grid.hpp>
#include <mapnik/pixel_position.hpp> #include <mapnik/pixel_position.hpp>
#include <mapnik/noncopyable.hpp> #include <mapnik/noncopyable.hpp>
#include <mapnik/rule.hpp> // for rule, symbolizers
#include <mapnik/box2d.hpp> // for box2d
#include <mapnik/color.hpp> // for color
#include <mapnik/ctrans.hpp> // for CoordTransform
#include <mapnik/image_compositing.hpp> // for composite_mode_e
// boost // boost
#include <boost/scoped_ptr.hpp> #include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
// FIXME namespace agg { struct trans_affine; }
// forward declare so that namespace mapnik { class Map; }
// apps using mapnik do not namespace mapnik { class feature_impl; }
// need agg headers namespace mapnik { class feature_type_style; }
namespace agg { namespace mapnik { class label_collision_detector4; }
struct trans_affine; namespace mapnik { class layer; }
} namespace mapnik { class marker; }
namespace mapnik { class proj_transform; }
namespace mapnik { struct grid_rasterizer; }
struct pixel_position;
namespace mapnik { namespace mapnik {
class marker;
struct grid_rasterizer;
template <typename T> template <typename T>
class MAPNIK_DECL grid_renderer : public feature_style_processor<grid_renderer<T> >, class MAPNIK_DECL grid_renderer : public feature_style_processor<grid_renderer<T> >,
private mapnik::noncopyable private mapnik::noncopyable

6
include/mapnik/map.hpp
View file

@ -24,9 +24,10 @@
#define MAPNIK_MAP_HPP #define MAPNIK_MAP_HPP
// mapnik // mapnik
#include <mapnik/color.hpp>
#include <mapnik/font_set.hpp>
#include <mapnik/enumeration.hpp> #include <mapnik/enumeration.hpp>
#include <mapnik/feature_type_style.hpp> #include <mapnik/datasource.hpp> // for featureset_ptr
#include <mapnik/datasource.hpp>
#include <mapnik/layer.hpp> #include <mapnik/layer.hpp>
#include <mapnik/params.hpp> #include <mapnik/params.hpp>
#include <mapnik/ctrans.hpp> #include <mapnik/ctrans.hpp>
@ -37,6 +38,7 @@
namespace mapnik namespace mapnik
{ {
class feature_type_style;
class CoordTransform; class CoordTransform;
class MAPNIK_DECL Map class MAPNIK_DECL Map

63
include/mapnik/params.hpp
View file

@ -24,10 +24,8 @@
#define MAPNIK_PARAMS_HPP #define MAPNIK_PARAMS_HPP
// boost // boost
#include <boost/variant.hpp> #include <boost/variant/variant.hpp>
#include <boost/optional.hpp> #include <boost/optional.hpp>
#include <boost/none.hpp>
#include <boost/lexical_cast.hpp>
// mapnik // mapnik
#include <mapnik/value.hpp> #include <mapnik/value.hpp>
@ -42,67 +40,16 @@ typedef boost::variant<value_null,value_integer,value_double,std::string> value_
typedef std::pair<std::string, value_holder> parameter; typedef std::pair<std::string, value_holder> parameter;
typedef std::map<std::string, value_holder> param_map; typedef std::map<std::string, value_holder> param_map;
template <typename T>
struct value_extractor_visitor : public boost::static_visitor<>
{
value_extractor_visitor(boost::optional<T> & var)
:var_(var) {}
void operator () (T val) const
{
var_ = val;
}
template <typename T1>
void operator () (T1 val) const
{
try
{
var_ = boost::lexical_cast<T>(val);
}
catch (boost::bad_lexical_cast & ) {}
}
boost::optional<T> & var_;
};
class parameters : public param_map class parameters : public param_map
{ {
template <typename T>
struct converter
{
typedef boost::optional<T> return_type;
static return_type extract(parameters const& params,
std::string const& name,
boost::optional<T> const& default_opt_value)
{
boost::optional<T> result(default_opt_value);
parameters::const_iterator itr = params.find(name);
if (itr != params.end())
{
boost::apply_visitor(value_extractor_visitor<T>(result),itr->second);
}
return result;
}
};
public: public:
parameters();
parameters() {}
template <typename T> template <typename T>
boost::optional<T> get(std::string const& key) const boost::optional<T> get(std::string const& key) const;
{
return converter<T>::extract(*this,key, boost::none);
}
template <typename T> template <typename T>
boost::optional<T> get(std::string const& key, T const& default_opt_value) const boost::optional<T> get(std::string const& key, T const& default_opt_value) const;
{
return converter<T>::extract(*this,key,boost::optional<T>(default_opt_value));
}
}; };
} }
#endif // MAPNIK_PARAMS_HPP #endif // MAPNIK_PARAMS_HPP

3
include/mapnik/rule.hpp
View file

@ -41,9 +41,6 @@
#include <mapnik/config.hpp> // MAPNIK_DECL #include <mapnik/config.hpp> // MAPNIK_DECL
// boost // boost
#include <boost/concept_check.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>
#include <boost/variant.hpp> #include <boost/variant.hpp>
// stl // stl

143
include/mapnik/sql_utils.hpp
View file

@ -23,37 +23,36 @@
#ifndef MAPNIK_SQL_UTILS_HPP #ifndef MAPNIK_SQL_UTILS_HPP
#define MAPNIK_SQL_UTILS_HPP #define MAPNIK_SQL_UTILS_HPP
// mapnik
#include <mapnik/util/trim.hpp> // for trim
// boost // boost
#include <boost/algorithm/string.hpp> #include "boost/algorithm/string/replace.hpp" // for ireplace_all, etc
#include <boost/scoped_array.hpp>
// stl
#include <sstream>
#include <vector>
#include <string>
namespace mapnik { namespace sql_utils { namespace mapnik { namespace sql_utils {
inline std::string unquote_double(std::string const& sql) inline std::string unquote_double(std::string const& sql)
{ {
std::string table_name = sql; std::string table_name = sql;
boost::algorithm::trim_if(table_name,boost::algorithm::is_any_of("\"")); util::unquote_double(table_name);
return table_name; return table_name;
} }
inline std::string unquote(std::string const& sql) inline std::string unquote(std::string const& sql)
{ {
std::string table_name = sql; std::string table_name = sql;
boost::algorithm::trim_if(table_name,boost::algorithm::is_any_of("\"\'")); util::unquote(table_name);
return table_name; return table_name;
} }
inline void quote_attr(std::ostringstream& s, std::string const& field) inline void quote_attr(std::ostringstream & s, std::string const& field)
{ {
if (boost::algorithm::icontains(field,".")) { s << ",\"" << field << "\"";
std::vector<std::string> parts;
boost::split(parts, field, boost::is_any_of("."));
s << ",\"" << parts[0] << "\".\"" << parts[1] << "\"";
}
else
{
s << ",\"" + field + "\"";
}
} }
inline std::string table_from_sql(std::string const& sql) inline std::string table_from_sql(std::string const& sql)
@ -78,120 +77,6 @@ namespace mapnik { namespace sql_utils {
} }
return table_name; return table_name;
} }
}}
inline std::string numeric2string(const char* buf)
{
int16_t ndigits = int2net(buf);
int16_t weight = int2net(buf+2);
int16_t sign = int2net(buf+4);
int16_t dscale = int2net(buf+6);
boost::scoped_array<int16_t> digits(new int16_t[ndigits]);
for (int n=0; n < ndigits ;++n)
{
digits[n] = int2net(buf+8+n*2);
}
std::ostringstream ss;
if (sign == 0x4000) ss << "-";
int i = std::max(weight,int16_t(0));
int d = 0;
// Each numeric "digit" is actually a value between 0000 and 9999 stored in a 16 bit field.
// For example, the number 1234567809990001 is stored as four digits: [1234] [5678] [999] [1].
// Note that the last two digits show that the leading 0's are lost when the number is split.
// We must be careful to re-insert these 0's when building the string.
while ( i >= 0)
{
if (i <= weight && d < ndigits)
{
// All digits after the first must be padded to make the field 4 characters long
if (d != 0)
{
#ifdef _WINDOWS
int dig = digits[d];
if (dig < 10)
{
ss << "000"; // 0000 - 0009
}
else if (dig < 100)
{
ss << "00"; // 0010 - 0099
}
else
{
ss << "0"; // 0100 - 0999;
}
#else
switch(digits[d])
{
case 0 ... 9:
ss << "000"; // 0000 - 0009
break;
case 10 ... 99:
ss << "00"; // 0010 - 0099
break;
case 100 ... 999:
ss << "0"; // 0100 - 0999
break;
}
#endif
}
ss << digits[d++];
}
else
{
if (d == 0)
ss << "0";
else
ss << "0000";
}
i--;
}
if (dscale > 0)
{
ss << '.';
// dscale counts the number of decimal digits following the point, not the numeric digits
while (dscale > 0)
{
int value;
if (i <= weight && d < ndigits)
value = digits[d++];
else
value = 0;
// Output up to 4 decimal digits for this value
if (dscale > 0) {
ss << (value / 1000);
value %= 1000;
dscale--;
}
if (dscale > 0) {
ss << (value / 100);
value %= 100;
dscale--;
}
if (dscale > 0) {
ss << (value / 10);
value %= 10;
dscale--;
}
if (dscale > 0) {
ss << value;
dscale--;
}
i--;
}
}
return ss.str();
}
}
}
#endif // MAPNIK_SQL_UTILS_HPP #endif // MAPNIK_SQL_UTILS_HPP

24
include/mapnik/svg/output/svg_renderer.hpp
View file

@ -24,15 +24,37 @@
#define MAPNIK_SVG_RENDERER_HPP #define MAPNIK_SVG_RENDERER_HPP
// mapnik // mapnik
#include <mapnik/config.hpp>
#include <mapnik/feature_style_processor.hpp> #include <mapnik/feature_style_processor.hpp>
#include <mapnik/map.hpp> #include <mapnik/font_engine_freetype.hpp>
#include <mapnik/svg/output/svg_generator.hpp> #include <mapnik/svg/output/svg_generator.hpp>
#include <mapnik/svg/output/svg_output_attributes.hpp> #include <mapnik/svg/output/svg_output_attributes.hpp>
#include <mapnik/noncopyable.hpp> #include <mapnik/noncopyable.hpp>
#include <mapnik/rule.hpp> // for rule, symbolizers
#include <mapnik/box2d.hpp> // for box2d
#include <mapnik/color.hpp> // for color
#include <mapnik/ctrans.hpp> // for CoordTransform
#include <mapnik/image_compositing.hpp> // for composite_mode_e
// boost
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
// stl // stl
#include <string> #include <string>
namespace agg { struct trans_affine; }
namespace mapnik { class Map; }
namespace mapnik { class feature_impl; }
namespace mapnik { class feature_type_style; }
namespace mapnik { class label_collision_detector4; }
namespace mapnik { class layer; }
namespace mapnik { class marker; }
namespace mapnik { class proj_transform; }
namespace mapnik { struct grid_rasterizer; }
struct pixel_position;
namespace mapnik namespace mapnik
{ {
// parameterized with the type of output iterator it will use for output. // parameterized with the type of output iterator it will use for output.

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

@ -25,6 +25,7 @@
// mapnik // mapnik
#include <mapnik/text/char_properties_ptr.hpp> #include <mapnik/text/char_properties_ptr.hpp>
#include <mapnik/color.hpp> #include <mapnik/color.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/font_set.hpp> #include <mapnik/font_set.hpp>
#include <mapnik/enumeration.hpp> #include <mapnik/enumeration.hpp>
#include <mapnik/expression.hpp> #include <mapnik/expression.hpp>
@ -143,7 +144,7 @@ struct text_symbolizer_properties
/** Takes a feature and produces formated text as output. /** Takes a feature and produces formated text as output.
* The output object has to be created by the caller and passed in for thread safety. * The output object has to be created by the caller and passed in for thread safety.
*/ */
void process(text_layout &output, Feature const& feature) const; void process(text_layout &output, feature_impl const& feature) const;
/** Automatically create processing instructions for a single expression. */ /** Automatically create processing instructions for a single expression. */
void set_old_style_expression(expression_ptr expr); void set_old_style_expression(expression_ptr expr);
/** Sets new format tree. */ /** Sets new format tree. */

4
include/mapnik/transform_processor.hpp
View file

@ -25,7 +25,9 @@
// mapnik // mapnik
#include <mapnik/config.hpp> #include <mapnik/config.hpp>
#ifdef MAPNIK_LOG
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#endif
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
#include <mapnik/value.hpp> #include <mapnik/value.hpp>
#include <mapnik/transform_expression.hpp> #include <mapnik/transform_expression.hpp>
@ -225,7 +227,7 @@ struct transform_processor
} }
}; };
typedef mapnik::transform_processor<Feature> transform_processor_type; typedef mapnik::transform_processor<feature_impl> transform_processor_type;
} // namespace mapnik } // namespace mapnik

4
include/mapnik/util/container_adapter.hpp
View file

@ -24,13 +24,11 @@
#define CONTAINER_ADAPTER_HPP #define CONTAINER_ADAPTER_HPP
// mapnik // mapnik
#include <mapnik/global.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/util/path_iterator.hpp> #include <mapnik/util/path_iterator.hpp>
// boost // boost
#include <boost/tuple/tuple.hpp> #include <boost/spirit/home/support/container.hpp>
#include <boost/spirit/include/karma.hpp>
namespace boost { namespace spirit { namespace traits { namespace boost { namespace spirit { namespace traits {

23
include/mapnik/util/trim.hpp
View file

@ -68,6 +68,29 @@ static inline std::string trim_copy(std::string s)
return ltrim(rtrim(s)); return ltrim(rtrim(s));
} }
static inline bool not_double_quote(int ch)
{
if (ch == '"') return false;
return true;
}
static inline void unquote_double(std::string & s)
{
s.erase(s.begin(), std::find_if(s.begin(), s.end(), not_double_quote));
s.erase(std::find_if(s.rbegin(), s.rend(), not_double_quote).base(), s.end());
}
static inline bool not_quoted(int ch)
{
if (ch == '"' || ch == '\'') return false;
return true;
}
static inline void unquote(std::string & s)
{
s.erase(s.begin(), std::find_if(s.begin(), s.end(), not_quoted));
s.erase(std::find_if(s.rbegin(), s.rend(), not_quoted).base(), s.end());
}
}} // end of namespace mapnik }} // end of namespace mapnik

54
include/mapnik/value.hpp
View file

@ -24,6 +24,7 @@
#define MAPNIK_VALUE_HPP #define MAPNIK_VALUE_HPP
// mapnik // mapnik
#include <mapnik/value_types.hpp>
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
@ -69,54 +70,6 @@ inline void to_utf8(UnicodeString const& input, std::string & target)
} }
} }
struct value_null
{
template <typename T>
value_null operator+ (T const& other) const
{
boost::ignore_unused_variable_warning(other);
return *this;
}
template <typename T>
value_null operator- (T const& other) const
{
boost::ignore_unused_variable_warning(other);
return *this;
}
template <typename T>
value_null operator* (T const& other) const
{
boost::ignore_unused_variable_warning(other);
return *this;
}
template <typename T>
value_null operator/ (T const& other) const
{
boost::ignore_unused_variable_warning(other);
return *this;
}
template <typename T>
value_null operator% (T const& other) const
{
boost::ignore_unused_variable_warning(other);
return *this;
}
};
#ifdef BIGINT
typedef long long value_integer;
#else
typedef int value_integer;
#endif
typedef double value_double;
typedef UnicodeString value_unicode_string;
typedef bool value_bool;
typedef boost::variant<value_null,value_bool,value_integer,value_double,value_unicode_string> value_base; typedef boost::variant<value_null,value_bool,value_integer,value_double,value_unicode_string> value_base;
namespace impl { namespace impl {
@ -798,11 +751,7 @@ struct to_int : public boost::static_visitor<value_integer>
value_integer operator() (std::string const& val) const value_integer operator() (std::string const& val) const
{ {
value_integer result; value_integer result;
#ifdef BIGINT
if (util::string2longlong(val,result))
#else
if (util::string2int(val,result)) if (util::string2int(val,result))
#endif
return result; return result;
return value_integer(0); return value_integer(0);
} }
@ -912,7 +861,6 @@ public:
{ {
return boost::apply_visitor(impl::to_int(),base_); return boost::apply_visitor(impl::to_int(),base_);
} }
}; };
inline const value operator+(value const& p1,value const& p2) inline const value operator+(value const& p1,value const& p2)

88
include/mapnik/value_types.hpp Normal file
View file

@ -0,0 +1,88 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2012 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_VALUE_TYPES_HPP
#define MAPNIK_VALUE_TYPES_HPP
// icu
#include <unicode/unistr.h> // for UnicodeString
// boost
//#include <boost/cstdint.hpp>
// stl
#include <iosfwd> // for ostream
namespace mapnik {
#ifdef BIGINT
//typedef boost::long_long_type value_integer;
typedef long long value_integer;
#else
typedef int value_integer;
#endif
typedef double value_double;
typedef UnicodeString value_unicode_string;
typedef bool value_bool;
struct value_null
{
template <typename T>
value_null operator+ (T const& /*other*/) const
{
return *this;
}
template <typename T>
value_null operator- (T const& /*other*/) const
{
return *this;
}
template <typename T>
value_null operator* (T const& /*other*/) const
{
return *this;
}
template <typename T>
value_null operator/ (T const& /*other*/) const
{
return *this;
}
template <typename T>
value_null operator% (T const& /*other*/) const
{
return *this;
}
};
inline std::ostream& operator<< (std::ostream & out,value_null const& v)
{
return out;
}
} // namespace mapnik
#endif // MAPNIK_VALUE_TYPES_HPP

1
include/mapnik/xml_tree.hpp
View file

@ -31,6 +31,7 @@
#include <mapnik/image_filter_grammar.hpp> #include <mapnik/image_filter_grammar.hpp>
#include <mapnik/image_filter.hpp> #include <mapnik/image_filter.hpp>
#include <mapnik/css_color_grammar.hpp> #include <mapnik/css_color_grammar.hpp>
#include <mapnik/unicode.hpp>
// boost // boost
#include <boost/format.hpp> #include <boost/format.hpp>

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

@ -41,6 +41,7 @@
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
#include <mapnik/boolean.hpp> #include <mapnik/boolean.hpp>
#include <mapnik/util/trim.hpp> #include <mapnik/util/trim.hpp>
#include <mapnik/value.hpp>
// stl // stl
#include <sstream> #include <sstream>
@ -62,7 +63,7 @@ csv_datasource::csv_datasource(parameters const& params)
filename_(), filename_(),
inline_string_(), inline_string_(),
file_length_(0), file_length_(0),
row_limit_(*params.get<int>("row_limit", 0)), row_limit_(*params.get<mapnik::value_integer>("row_limit", 0)),
features_(), features_(),
escape_(*params.get<std::string>("escape", "")), escape_(*params.get<std::string>("escape", "")),
separator_(*params.get<std::string>("separator", "")), separator_(*params.get<std::string>("separator", "")),
@ -70,7 +71,7 @@ csv_datasource::csv_datasource(parameters const& params)
headers_(), headers_(),
manual_headers_(mapnik::util::trim_copy(*params.get<std::string>("headers", ""))), manual_headers_(mapnik::util::trim_copy(*params.get<std::string>("headers", ""))),
strict_(*params.get<mapnik::boolean>("strict", false)), strict_(*params.get<mapnik::boolean>("strict", false)),
filesize_max_(*params.get<float>("filesize_max", 20.0)), // MB filesize_max_(*params.get<double>("filesize_max", 20.0)), // MB
ctx_(boost::make_shared<mapnik::context_type>()) ctx_(boost::make_shared<mapnik::context_type>())
{ {
/* TODO: /* TODO:
@ -701,7 +702,7 @@ void csv_datasource::parse_csv(T & stream,
else else
{ {
mapnik::value_integer int_val = 0; mapnik::value_integer int_val = 0;
if (mapnik::util::string2longlong(value,int_val)) if (mapnik::util::string2int(value,int_val))
{ {
matched = true; matched = true;
feature->put(fld_name,int_val); feature->put(fld_name,int_val);

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

@ -31,6 +31,7 @@
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/coord.hpp> #include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp> #include <mapnik/feature_layer_desc.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>
@ -64,7 +65,7 @@ private:
std::string filename_; std::string filename_;
std::string inline_string_; std::string inline_string_;
unsigned file_length_; unsigned file_length_;
int row_limit_; mapnik::value_integer row_limit_;
std::vector<mapnik::feature_ptr> features_; std::vector<mapnik::feature_ptr> features_;
std::string escape_; std::string escape_;
std::string separator_; std::string separator_;

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

@ -28,6 +28,7 @@
#include <mapnik/boolean.hpp> #include <mapnik/boolean.hpp>
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp> #include <mapnik/timer.hpp>
#include <mapnik/value.hpp>
#include <gdal_version.h> #include <gdal_version.h>

5
plugins/input/gdal/gdal_featureset.cpp
View file

@ -23,11 +23,15 @@
// mapnik // mapnik
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/image_data.hpp>
#include <mapnik/raster.hpp>
#include <mapnik/ctrans.hpp> #include <mapnik/ctrans.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/feature_factory.hpp> #include <mapnik/feature_factory.hpp>
// boost // boost
#include <boost/format.hpp> #include <boost/format.hpp>
#include <boost/make_shared.hpp>
#include "gdal_featureset.hpp" #include "gdal_featureset.hpp"
#include <gdal_priv.h> #include <gdal_priv.h>
@ -35,7 +39,6 @@
using mapnik::query; using mapnik::query;
using mapnik::coord2d; using mapnik::coord2d;
using mapnik::box2d; using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::CoordTransform; using mapnik::CoordTransform;
using mapnik::geometry_type; using mapnik::geometry_type;

1
plugins/input/gdal/gdal_featureset.hpp
View file

@ -25,7 +25,6 @@
// mapnik // mapnik
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp>
// boost // boost
#include <boost/variant.hpp> #include <boost/variant.hpp>

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

@ -36,7 +36,11 @@
#include <boost/geometry/geometries/geometries.hpp> #include <boost/geometry/geometries/geometries.hpp>
#include <boost/geometry.hpp> #include <boost/geometry.hpp>
#include <boost/geometry/extensions/index/rtree/rtree.hpp> #include <boost/geometry/extensions/index/rtree/rtree.hpp>
// mapnik // mapnik
#include <mapnik/unicode.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/feature_kv_iterator.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/proj_transform.hpp> #include <mapnik/proj_transform.hpp>

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

@ -31,6 +31,7 @@
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/coord.hpp> #include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp> #include <mapnik/feature_layer_desc.hpp>
#include <mapnik/unicode.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>

2
plugins/input/geojson/geojson_featureset.hpp
View file

@ -1,7 +1,7 @@
#ifndef GEOJSON_FEATURESET_HPP #ifndef GEOJSON_FEATURESET_HPP
#define GEOJSON_FEATURESET_HPP #define GEOJSON_FEATURESET_HPP
#include <mapnik/datasource.hpp> #include <mapnik/feature.hpp>
#include "geojson_datasource.hpp" #include "geojson_datasource.hpp"
#include <vector> #include <vector>

1
plugins/input/geos/geos_datasource.cpp
View file

@ -34,6 +34,7 @@
#include <mapnik/boolean.hpp> #include <mapnik/boolean.hpp>
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp> #include <mapnik/timer.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>

5
plugins/input/geos/geos_featureset.cpp
View file

@ -23,7 +23,6 @@
// mapnik // mapnik
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
@ -34,9 +33,11 @@
#include "geos_featureset.hpp" #include "geos_featureset.hpp"
// boost
#include <boost/make_shared.hpp>
using mapnik::query; using mapnik::query;
using mapnik::box2d; using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_utils; using mapnik::geometry_utils;
using mapnik::transcoder; using mapnik::transcoder;

1
plugins/input/geos/geos_featureset.hpp
View file

@ -24,6 +24,7 @@
#define GEOS_FEATURESET_HPP #define GEOS_FEATURESET_HPP
// mapnik // mapnik
#include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>

4
plugins/input/kismet/kismet_datasource.cpp
View file

@ -85,10 +85,10 @@ kismet_datasource::kismet_datasource(parameters const& params)
throw datasource_exception("Kismet Plugin: missing <host> parameter"); throw datasource_exception("Kismet Plugin: missing <host> parameter");
} }
boost::optional<unsigned int> port = params.get<unsigned int>("port", 2501); boost::optional<int> port = params.get<int>("port", 2501);
if (port) if (port)
{ {
port_ = *port; port_ = static_cast<unsigned>(*port);
} }
boost::optional<std::string> srs = params.get<std::string>("srs"); boost::optional<std::string> srs = params.get<std::string>("srs");

5
plugins/input/kismet/kismet_featureset.cpp
View file

@ -22,7 +22,6 @@
// mapnik // mapnik
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
@ -33,7 +32,9 @@
#include "kismet_featureset.hpp" #include "kismet_featureset.hpp"
using mapnik::Feature; // boost
#include <boost/make_shared.hpp>
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_type; using mapnik::geometry_type;
using mapnik::geometry_utils; using mapnik::geometry_utils;

1
plugins/input/kismet/kismet_featureset.hpp
View file

@ -24,6 +24,7 @@
#define KISMET_FEATURESET_HPP #define KISMET_FEATURESET_HPP
// mapnik // mapnik
#include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>
#include <mapnik/wkb.hpp> #include <mapnik/wkb.hpp>

1
plugins/input/kismet/kismet_types.hpp
View file

@ -24,7 +24,6 @@
#define KISMET_TYPES_HPP #define KISMET_TYPES_HPP
// mapnik // mapnik
#include <mapnik/datasource.hpp>
#include <mapnik/params.hpp> #include <mapnik/params.hpp>
// boost // boost

3
plugins/input/occi/occi_datasource.cpp
View file

@ -28,6 +28,7 @@
#include <mapnik/boolean.hpp> #include <mapnik/boolean.hpp>
#include <mapnik/sql_utils.hpp> #include <mapnik/sql_utils.hpp>
#include <mapnik/timer.hpp> #include <mapnik/timer.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
@ -77,7 +78,7 @@ occi_datasource::occi_datasource(parameters const& params)
extent_initialized_(false), extent_initialized_(false),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")), desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")),
use_wkb_(*params.get<mapnik::boolean>("use_wkb", false)), use_wkb_(*params.get<mapnik::boolean>("use_wkb", false)),
row_limit_(*params.get<int>("row_limit", 0)), row_limit_(*params.get<mapnik::value_integer>("row_limit", 0)),
row_prefetch_(*params.get<int>("row_prefetch", 100)), row_prefetch_(*params.get<int>("row_prefetch", 100)),
pool_(0), pool_(0),
conn_(0) conn_(0)

3
plugins/input/occi/occi_datasource.hpp
View file

@ -31,6 +31,7 @@
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/coord.hpp> #include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp> #include <mapnik/feature_layer_desc.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>
@ -70,7 +71,7 @@ private:
mutable mapnik::box2d<double> extent_; mutable mapnik::box2d<double> extent_;
mapnik::layer_descriptor desc_; mapnik::layer_descriptor desc_;
bool use_wkb_; bool use_wkb_;
int row_limit_; mapnik::value_integer row_limit_;
int row_prefetch_; int row_prefetch_;
oracle::occi::StatelessConnectionPool* pool_; oracle::occi::StatelessConnectionPool* pool_;
oracle::occi::Connection* conn_; oracle::occi::Connection* conn_;

2
plugins/input/occi/occi_featureset.cpp
View file

@ -23,7 +23,6 @@
// mapnik // mapnik
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
@ -37,7 +36,6 @@
using mapnik::query; using mapnik::query;
using mapnik::box2d; using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_type; using mapnik::geometry_type;
using mapnik::geometry_utils; using mapnik::geometry_utils;

1
plugins/input/occi/occi_featureset.hpp
View file

@ -24,6 +24,7 @@
#define OCCI_FEATURESET_HPP #define OCCI_FEATURESET_HPP
// mapnik // mapnik
#include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>

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

@ -139,7 +139,7 @@ void ogr_datasource::init(mapnik::parameters const& params)
// initialize layer // initialize layer
boost::optional<std::string> layer_by_name = params.get<std::string>("layer"); boost::optional<std::string> layer_by_name = params.get<std::string>("layer");
boost::optional<unsigned> layer_by_index = params.get<unsigned>("layer_by_index"); boost::optional<int> layer_by_index = params.get<int>("layer_by_index");
boost::optional<std::string> layer_by_sql = params.get<std::string>("layer_by_sql"); boost::optional<std::string> layer_by_sql = params.get<std::string>("layer_by_sql");
int passed_parameters = 0; int passed_parameters = 0;

3
plugins/input/ogr/ogr_featureset.cpp
View file

@ -22,8 +22,8 @@
// mapnik // mapnik
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/value.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
@ -38,7 +38,6 @@
using mapnik::query; using mapnik::query;
using mapnik::box2d; using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_utils; using mapnik::geometry_utils;
using mapnik::transcoder; using mapnik::transcoder;

1
plugins/input/ogr/ogr_featureset.hpp
View file

@ -24,6 +24,7 @@
#define OGR_FEATURESET_HPP #define OGR_FEATURESET_HPP
// mapnik // mapnik
#include <mapnik/feature.hpp>
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>

3
plugins/input/ogr/ogr_index_featureset.cpp
View file

@ -21,9 +21,9 @@
*****************************************************************************/ *****************************************************************************/
// mapnik // mapnik
#include <mapnik/value.hpp>
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
@ -43,7 +43,6 @@
using mapnik::query; using mapnik::query;
using mapnik::box2d; using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_utils; using mapnik::geometry_utils;
using mapnik::transcoder; using mapnik::transcoder;

1
plugins/input/ogr/ogr_index_featureset.hpp
View file

@ -26,6 +26,7 @@
#include <set> #include <set>
#include <vector> #include <vector>
#include <boost/scoped_ptr.hpp> #include <boost/scoped_ptr.hpp>
#include <mapnik/feature.hpp>
#include "ogr_featureset.hpp" #include "ogr_featureset.hpp"
template <typename filterT> template <typename filterT>

6
plugins/input/osm/osm_featureset.cpp
View file

@ -23,12 +23,16 @@
// mapnik // mapnik
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/feature_factory.hpp> #include <mapnik/feature_factory.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/unicode.hpp>
// boost
#include <boost/make_shared.hpp>
#include "osm_featureset.hpp" #include "osm_featureset.hpp"
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_type; using mapnik::geometry_type;
using mapnik::feature_factory; using mapnik::feature_factory;

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

@ -31,6 +31,7 @@
#include <mapnik/sql_utils.hpp> #include <mapnik/sql_utils.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
#include <mapnik/timer.hpp> #include <mapnik/timer.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
@ -62,7 +63,7 @@ postgis_datasource::postgis_datasource(parameters const& params)
geometry_table_(*params.get<std::string>("geometry_table", "")), geometry_table_(*params.get<std::string>("geometry_table", "")),
geometry_field_(*params.get<std::string>("geometry_field", "")), geometry_field_(*params.get<std::string>("geometry_field", "")),
key_field_(*params.get<std::string>("key_field", "")), key_field_(*params.get<std::string>("key_field", "")),
cursor_fetch_size_(*params.get<int>("cursor_size", 0)), cursor_fetch_size_(*params.get<mapnik::value_integer>("cursor_size", 0)),
row_limit_(*params.get<int>("row_limit", 0)), row_limit_(*params.get<int>("row_limit", 0)),
type_(datasource::Vector), type_(datasource::Vector),
srid_(*params.get<int>("srid", 0)), srid_(*params.get<int>("srid", 0)),

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

@ -31,6 +31,8 @@
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/coord.hpp> #include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp> #include <mapnik/feature_layer_desc.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>
@ -72,7 +74,6 @@ private:
std::string sql_bbox(box2d<double> const& env) const; std::string sql_bbox(box2d<double> const& env) const;
std::string populate_tokens(std::string const& sql, double scale_denom, box2d<double> const& env, double pixel_width, double pixel_height) const; std::string populate_tokens(std::string const& sql, double scale_denom, box2d<double> const& env, double pixel_width, double pixel_height) const;
std::string populate_tokens(std::string const& sql) const; std::string populate_tokens(std::string const& sql) const;
static std::string unquote(std::string const& sql);
boost::shared_ptr<IResultSet> get_resultset(boost::shared_ptr<Connection> const &conn, std::string const& sql) const; boost::shared_ptr<IResultSet> get_resultset(boost::shared_ptr<Connection> const &conn, std::string const& sql) const;
static const std::string GEOMETRY_COLUMNS; static const std::string GEOMETRY_COLUMNS;
@ -87,8 +88,8 @@ private:
std::string geometry_table_; std::string geometry_table_;
const std::string geometry_field_; const std::string geometry_field_;
std::string key_field_; std::string key_field_;
const int cursor_fetch_size_; mapnik::value_integer cursor_fetch_size_;
const int row_limit_; mapnik::value_integer row_limit_;
std::string geometryColumn_; std::string geometryColumn_;
mapnik::datasource::datasource_t type_; mapnik::datasource::datasource_t type_;
int srid_; int srid_;

125
plugins/input/postgis/postgis_featureset.cpp
View file

@ -29,13 +29,16 @@
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/wkb.hpp> #include <mapnik/wkb.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>
#include <mapnik/sql_utils.hpp> #include <mapnik/value.hpp>
#include <mapnik/feature_factory.hpp> #include <mapnik/feature_factory.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
#include <mapnik/util/trim.hpp> #include <mapnik/util/trim.hpp>
#include <mapnik/global.hpp> // for int2net
#include <boost/scoped_array.hpp>
// boost // boost
#include <boost/spirit/include/qi.hpp> #include <boost/cstdint.hpp> // for boost::int16_t
// stl // stl
#include <sstream> #include <sstream>
@ -60,6 +63,8 @@ postgis_featureset::postgis_featureset(boost::shared_ptr<IResultSet> const& rs,
{ {
} }
std::string numeric2string(const char* buf);
feature_ptr postgis_featureset::next() feature_ptr postgis_featureset::next()
{ {
while (rs_->next()) while (rs_->next())
@ -156,7 +161,7 @@ feature_ptr postgis_featureset::next()
{ {
float val; float val;
float4net(val, buf); float4net(val, buf);
feature->put(name, val); feature->put(name, static_cast<double>(val));
break; break;
} }
@ -186,7 +191,7 @@ feature_ptr postgis_featureset::next()
case 1700: //numeric case 1700: //numeric
{ {
double val; double val;
std::string str = mapnik::sql_utils::numeric2string(buf); std::string str = numeric2string(buf);
if (mapnik::util::string2double(str, val)) if (mapnik::util::string2double(str, val))
{ {
feature->put(name, val); feature->put(name, val);
@ -213,3 +218,115 @@ postgis_featureset::~postgis_featureset()
{ {
rs_->close(); rs_->close();
} }
std::string numeric2string(const char* buf)
{
boost::int16_t ndigits = int2net(buf);
boost::int16_t weight = int2net(buf+2);
boost::int16_t sign = int2net(buf+4);
boost::int16_t dscale = int2net(buf+6);
boost::scoped_array<boost::int16_t> digits(new boost::int16_t[ndigits]);
for (int n=0; n < ndigits ;++n)
{
digits[n] = int2net(buf+8+n*2);
}
std::ostringstream ss;
if (sign == 0x4000) ss << "-";
int i = std::max(weight,boost::int16_t(0));
int d = 0;
// Each numeric "digit" is actually a value between 0000 and 9999 stored in a 16 bit field.
// For example, the number 1234567809990001 is stored as four digits: [1234] [5678] [999] [1].
// Note that the last two digits show that the leading 0's are lost when the number is split.
// We must be careful to re-insert these 0's when building the string.
while ( i >= 0)
{
if (i <= weight && d < ndigits)
{
// All digits after the first must be padded to make the field 4 characters long
if (d != 0)
{
#ifdef _WINDOWS
int dig = digits[d];
if (dig < 10)
{
ss << "000"; // 0000 - 0009
}
else if (dig < 100)
{
ss << "00"; // 0010 - 0099
}
else
{
ss << "0"; // 0100 - 0999;
}
#else
switch(digits[d])
{
case 0 ... 9:
ss << "000"; // 0000 - 0009
break;
case 10 ... 99:
ss << "00"; // 0010 - 0099
break;
case 100 ... 999:
ss << "0"; // 0100 - 0999
break;
}
#endif
}
ss << digits[d++];
}
else
{
if (d == 0)
ss << "0";
else
ss << "0000";
}
i--;
}
if (dscale > 0)
{
ss << '.';
// dscale counts the number of decimal digits following the point, not the numeric digits
while (dscale > 0)
{
int value;
if (i <= weight && d < ndigits)
value = digits[d++];
else
value = 0;
// Output up to 4 decimal digits for this value
if (dscale > 0) {
ss << (value / 1000);
value %= 1000;
dscale--;
}
if (dscale > 0) {
ss << (value / 100);
value %= 100;
dscale--;
}
if (dscale > 0) {
ss << (value / 10);
value %= 10;
dscale--;
}
if (dscale > 0) {
ss << value;
dscale--;
}
i--;
}
}
return ss.str();
}

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

@ -28,9 +28,9 @@
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
#include <mapnik/unicode.hpp>
// boost // boost
#include <boost/scoped_ptr.hpp> #include <boost/scoped_ptr.hpp>
using mapnik::Featureset; using mapnik::Featureset;

4
plugins/input/python/python_featureset.hpp
View file

@ -1,6 +1,9 @@
#ifndef PYTHON_FEATURESET_HPP #ifndef PYTHON_FEATURESET_HPP
#define PYTHON_FEATURESET_HPP #define PYTHON_FEATURESET_HPP
// mapnik
#include <mapnik/feature.hpp>
// boost // boost
#include <boost/python.hpp> #include <boost/python.hpp>
#include <boost/python/stl_iterator.hpp> #include <boost/python/stl_iterator.hpp>
@ -8,7 +11,6 @@
// mapnik // mapnik
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
// extend the mapnik::Featureset defined in include/mapnik/datasource.hpp
class python_featureset : public mapnik::Featureset class python_featureset : public mapnik::Featureset
{ {
public: public:

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

@ -61,9 +61,9 @@ raster_datasource::raster_datasource(parameters const& params)
else else
filename_ = *file; filename_ = *file;
multi_tiles_ = *params.get<bool>("multi", false); multi_tiles_ = *params.get<mapnik::boolean>("multi", false);
tile_size_ = *params.get<unsigned>("tile_size", 256); tile_size_ = *params.get<int>("tile_size", 256);
tile_stride_ = *params.get<unsigned>("tile_stride", 1); tile_stride_ = *params.get<int>("tile_stride", 1);
format_ = *params.get<std::string>("format","tiff"); format_ = *params.get<std::string>("format","tiff");
@ -91,8 +91,8 @@ raster_datasource::raster_datasource(parameters const& params)
if (multi_tiles_) if (multi_tiles_)
{ {
boost::optional<unsigned> x_width = params.get<unsigned>("x_width"); boost::optional<int> x_width = params.get<int>("x_width");
boost::optional<unsigned> y_width = params.get<unsigned>("y_width"); boost::optional<int> y_width = params.get<int>("y_width");
if (! x_width) if (! x_width)
{ {

4
plugins/input/raster/raster_featureset.cpp
View file

@ -22,6 +22,8 @@
// mapnik // mapnik
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/image_data.hpp>
#include <mapnik/raster.hpp>
#include <mapnik/ctrans.hpp> #include <mapnik/ctrans.hpp>
#include <mapnik/image_reader.hpp> #include <mapnik/image_reader.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
@ -29,12 +31,12 @@
// boost // boost
#include <boost/algorithm/string/replace.hpp> #include <boost/algorithm/string/replace.hpp>
#include <boost/make_shared.hpp>
#include "raster_featureset.hpp" #include "raster_featureset.hpp"
using mapnik::query; using mapnik::query;
using mapnik::image_reader; using mapnik::image_reader;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::image_data_32; using mapnik::image_data_32;
using mapnik::raster; using mapnik::raster;

1
plugins/input/raster/raster_featureset.hpp
View file

@ -27,6 +27,7 @@
#include "raster_info.hpp" #include "raster_info.hpp"
// mapnik // mapnik
#include <mapnik/feature.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
// stl // stl

2
plugins/input/rasterlite/rasterlite_featureset.cpp
View file

@ -25,6 +25,7 @@
// mapnik // mapnik
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/image_util.hpp> #include <mapnik/image_util.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/feature_factory.hpp> #include <mapnik/feature_factory.hpp>
// boost // boost
@ -34,7 +35,6 @@
using mapnik::query; using mapnik::query;
using mapnik::coord2d; using mapnik::coord2d;
using mapnik::box2d; using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_type; using mapnik::geometry_type;
using mapnik::query; using mapnik::query;

2
plugins/input/rasterlite/rasterlite_featureset.hpp
View file

@ -24,7 +24,7 @@
#define RASTERLITE_FEATURESET_HPP #define RASTERLITE_FEATURESET_HPP
// mapnik // mapnik
#include <mapnik/datasource.hpp> #include <mapnik/feature.hpp>
// boost // boost
#include <boost/variant.hpp> #include <boost/variant.hpp>

3
plugins/input/shape/dbfile.cpp
View file

@ -20,6 +20,7 @@
* *
*****************************************************************************/ *****************************************************************************/
// mapnik // mapnik
#include <mapnik/value.hpp>
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/utils.hpp> #include <mapnik/utils.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>
@ -124,7 +125,7 @@ const field_descriptor& dbf_file::descriptor(int col) const
} }
void dbf_file::add_attribute(int col, mapnik::transcoder const& tr, Feature & f) const throw() void dbf_file::add_attribute(int col, mapnik::transcoder const& tr, mapnik::feature_impl & f) const throw()
{ {
using namespace boost::spirit; using namespace boost::spirit;

6
plugins/input/shape/dbfile.hpp
View file

@ -26,6 +26,7 @@
// mapnik // mapnik
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
#include <mapnik/noncopyable.hpp> #include <mapnik/noncopyable.hpp>
#include <mapnik/unicode.hpp>
// boost // boost
#include <boost/interprocess/streams/bufferstream.hpp> #include <boost/interprocess/streams/bufferstream.hpp>
@ -36,9 +37,6 @@
#include <cassert> #include <cassert>
#include <fstream> #include <fstream>
using mapnik::transcoder;
using mapnik::Feature;
struct field_descriptor struct field_descriptor
{ {
int index_; int index_;
@ -73,7 +71,7 @@ public:
field_descriptor const& descriptor(int col) const; field_descriptor const& descriptor(int col) const;
void move_to(int index); void move_to(int index);
std::string string_value(int col) const; std::string string_value(int col) const;
void add_attribute(int col, transcoder const& tr, Feature & f) const throw(); void add_attribute(int col, mapnik::transcoder const& tr, mapnik::feature_impl & f) const throw();
private: private:
void read_header(); void read_header();
int read_short(); int read_short();

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

@ -35,10 +35,10 @@
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/boolean.hpp> #include <mapnik/boolean.hpp>
#include <mapnik/sql_utils.hpp>
#include <mapnik/util/conversions.hpp> #include <mapnik/util/conversions.hpp>
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>
#include <mapnik/timer.hpp> #include <mapnik/timer.hpp>
#include <mapnik/value.hpp>
// stl // stl
#include <fstream> #include <fstream>
@ -60,7 +60,7 @@ shape_datasource::shape_datasource(const parameters &params)
type_(datasource::Vector), type_(datasource::Vector),
file_length_(0), file_length_(0),
indexed_(false), indexed_(false),
row_limit_(*params.get<int>("row_limit",0)), row_limit_(*params.get<mapnik::value_integer>("row_limit",0)),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8")) desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding","utf-8"))
{ {
#ifdef MAPNIK_STATS #ifdef MAPNIK_STATS

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

@ -31,6 +31,7 @@
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/coord.hpp> #include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp> #include <mapnik/feature_layer_desc.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>

4
plugins/input/shape/shape_featureset.cpp
View file

@ -26,6 +26,10 @@
// mapnik // mapnik
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/feature_factory.hpp> #include <mapnik/feature_factory.hpp>
#include <mapnik/unicode.hpp>
// boost
#include <boost/make_shared.hpp>
#include "shape_featureset.hpp" #include "shape_featureset.hpp"
#include "shape_utils.hpp" #include "shape_utils.hpp"

6
plugins/input/shape/shape_featureset.hpp
View file

@ -25,7 +25,9 @@
//mapnik //mapnik
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>
#include <mapnik/datasource.hpp> #include <mapnik/feature.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/value.hpp>
#include "shape_io.hpp" #include "shape_io.hpp"
@ -60,7 +62,7 @@ private:
boost::scoped_ptr<transcoder> tr_; boost::scoped_ptr<transcoder> tr_;
long file_length_; long file_length_;
std::vector<int> attr_ids_; std::vector<int> attr_ids_;
const int row_limit_; mapnik::value_integer row_limit_;
mutable int count_; mutable int count_;
context_ptr ctx_; context_ptr ctx_;
}; };

3
plugins/input/shape/shape_index_featureset.cpp
View file

@ -30,6 +30,7 @@
// boost // boost
#include <boost/algorithm/string.hpp> #include <boost/algorithm/string.hpp>
#include <boost/interprocess/streams/bufferstream.hpp> #include <boost/interprocess/streams/bufferstream.hpp>
#include <boost/make_shared.hpp>
#include "shape_index_featureset.hpp" #include "shape_index_featureset.hpp"
#include "shape_utils.hpp" #include "shape_utils.hpp"
@ -47,7 +48,7 @@ shape_index_featureset<filterT>::shape_index_featureset(filterT const& filter,
: filter_(filter), : filter_(filter),
ctx_(boost::make_shared<mapnik::context_type>()), ctx_(boost::make_shared<mapnik::context_type>()),
shape_(shape), shape_(shape),
tr_(new transcoder(encoding)), tr_(new mapnik::transcoder(encoding)),
row_limit_(row_limit), row_limit_(row_limit),
count_(0), count_(0),
feature_bbox_() feature_bbox_()

7
plugins/input/shape/shape_index_featureset.hpp
View file

@ -29,6 +29,9 @@
// mapnik // mapnik
#include <mapnik/geom_util.hpp> #include <mapnik/geom_util.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/unicode.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/scoped_ptr.hpp> #include <boost/scoped_ptr.hpp>
@ -59,11 +62,11 @@ private:
filterT filter_; filterT filter_;
context_ptr ctx_; context_ptr ctx_;
shape_io & shape_; shape_io & shape_;
boost::scoped_ptr<transcoder> tr_; boost::scoped_ptr<mapnik::transcoder> tr_;
std::vector<std::streampos> offsets_; std::vector<std::streampos> offsets_;
std::vector<std::streampos>::iterator itr_; std::vector<std::streampos>::iterator itr_;
std::vector<int> attr_ids_; std::vector<int> attr_ids_;
const int row_limit_; mapnik::value_integer row_limit_;
mutable int count_; mutable int count_;
mutable box2d<double> feature_bbox_; mutable box2d<double> feature_bbox_;
}; };

1
plugins/input/sqlite/sqlite_connection.hpp
View file

@ -29,7 +29,6 @@
// mapnik // mapnik
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
#include <mapnik/params.hpp> #include <mapnik/params.hpp>
#include <mapnik/sql_utils.hpp>
#include <mapnik/timer.hpp> #include <mapnik/timer.hpp>
// boost // boost

6
plugins/input/sqlite/sqlite_datasource.cpp
View file

@ -65,8 +65,8 @@ sqlite_datasource::sqlite_datasource(parameters const& params)
geometry_field_(*params.get<std::string>("geometry_field", "")), geometry_field_(*params.get<std::string>("geometry_field", "")),
index_table_(*params.get<std::string>("index_table", "")), index_table_(*params.get<std::string>("index_table", "")),
key_field_(*params.get<std::string>("key_field", "")), key_field_(*params.get<std::string>("key_field", "")),
row_offset_(*params.get<int>("row_offset", 0)), row_offset_(*params.get<mapnik::value_integer>("row_offset", 0)),
row_limit_(*params.get<int>("row_limit", 0)), row_limit_(*params.get<mapnik::value_integer>("row_limit", 0)),
intersects_token_("!intersects!"), intersects_token_("!intersects!"),
desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")), desc_(*params.get<std::string>("type"), *params.get<std::string>("encoding", "utf-8")),
format_(mapnik::wkbAuto) format_(mapnik::wkbAuto)
@ -142,7 +142,7 @@ sqlite_datasource::sqlite_datasource(parameters const& params)
// now actually create the connection and start executing setup sql // now actually create the connection and start executing setup sql
dataset_ = boost::make_shared<sqlite_connection>(dataset_name_); dataset_ = boost::make_shared<sqlite_connection>(dataset_name_);
boost::optional<unsigned> table_by_index = params.get<unsigned>("table_by_index"); boost::optional<int> table_by_index = params.get<int>("table_by_index");
int passed_parameters = 0; int passed_parameters = 0;
passed_parameters += params.get<std::string>("table") ? 1 : 0; passed_parameters += params.get<std::string>("table") ? 1 : 0;

3
plugins/input/sqlite/sqlite_datasource.hpp
View file

@ -32,6 +32,7 @@
#include <mapnik/coord.hpp> #include <mapnik/coord.hpp>
#include <mapnik/feature_layer_desc.hpp> #include <mapnik/feature_layer_desc.hpp>
#include <mapnik/wkb.hpp> #include <mapnik/wkb.hpp>
#include <mapnik/value.hpp>
// boost // boost
#include <boost/optional.hpp> #include <boost/optional.hpp>
@ -77,7 +78,7 @@ private:
std::string index_table_; std::string index_table_;
std::string key_field_; std::string key_field_;
int row_offset_; int row_offset_;
int row_limit_; mapnik::value_integer row_limit_;
// TODO - also add to postgis.input // TODO - also add to postgis.input
const std::string intersects_token_; const std::string intersects_token_;
mapnik::layer_descriptor desc_; mapnik::layer_descriptor desc_;

2
plugins/input/sqlite/sqlite_featureset.cpp
View file

@ -23,7 +23,6 @@
// mapnik // mapnik
#include <mapnik/global.hpp> #include <mapnik/global.hpp>
#include <mapnik/debug.hpp> #include <mapnik/debug.hpp>
#include <mapnik/datasource.hpp>
#include <mapnik/box2d.hpp> #include <mapnik/box2d.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
#include <mapnik/feature.hpp> #include <mapnik/feature.hpp>
@ -38,7 +37,6 @@
using mapnik::query; using mapnik::query;
using mapnik::box2d; using mapnik::box2d;
using mapnik::Feature;
using mapnik::feature_ptr; using mapnik::feature_ptr;
using mapnik::geometry_utils; using mapnik::geometry_utils;
using mapnik::transcoder; using mapnik::transcoder;

2
plugins/input/sqlite/sqlite_featureset.hpp
View file

@ -24,7 +24,7 @@
#define MAPNIK_SQLITE_FEATURESET_HPP #define MAPNIK_SQLITE_FEATURESET_HPP
// mapnik // mapnik
#include <mapnik/datasource.hpp> #include <mapnik/feature.hpp>
#include <mapnik/unicode.hpp> #include <mapnik/unicode.hpp>
#include <mapnik/wkb.hpp> #include <mapnik/wkb.hpp>

1
plugins/input/sqlite/sqlite_utils.hpp
View file

@ -644,7 +644,6 @@ public:
std::string fld_type(rs->column_text(2)); std::string fld_type(rs->column_text(2));
sqlite_int64 fld_pk = rs->column_integer64(5); sqlite_int64 fld_pk = rs->column_integer64(5);
std::transform(fld_type.begin(), fld_type.end(), fld_type.begin(), ::tolower); std::transform(fld_type.begin(), fld_type.end(), fld_type.begin(), ::tolower);
// TODO - how to handle primary keys on multiple columns ? // TODO - how to handle primary keys on multiple columns ?
if (key_field.empty() && ! found_pk && fld_pk != 0) if (key_field.empty() && ! found_pk && fld_pk != 0)
{ {

3
plugins/input/templates/helloworld/hello_featureset.cpp
View file

@ -2,6 +2,9 @@
#include <mapnik/feature_factory.hpp> #include <mapnik/feature_factory.hpp>
#include <mapnik/geometry.hpp> #include <mapnik/geometry.hpp>
// boost
#include <boost/make_shared.hpp>
#include "hello_featureset.hpp" #include "hello_featureset.hpp"
hello_featureset::hello_featureset(mapnik::box2d<double> const& box, std::string const& encoding) hello_featureset::hello_featureset(mapnik::box2d<double> const& box, std::string const& encoding)

3
plugins/input/templates/helloworld/hello_featureset.hpp
View file

@ -3,11 +3,12 @@
// mapnik // mapnik
#include <mapnik/datasource.hpp> #include <mapnik/datasource.hpp>
#include <mapnik/feature.hpp>
#include <mapnik/unicode.hpp>
// boost // boost
#include <boost/scoped_ptr.hpp> // needed for wrapping the transcoder #include <boost/scoped_ptr.hpp> // needed for wrapping the transcoder
// extend the mapnik::Featureset defined in include/mapnik/datasource.hpp
class hello_featureset : public mapnik::Featureset class hello_featureset : public mapnik::Featureset
{ {
public: public:

1
src/build.py
View file

@ -100,6 +100,7 @@ else: # unix, non-macos
source = Split( source = Split(
""" """
params.cpp
image_filter_types.cpp image_filter_types.cpp
miniz_png.cpp miniz_png.cpp
color.cpp color.cpp

109
src/params.cpp Normal file
View file

@ -0,0 +1,109 @@
/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
* Copyright (C) 2012 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
*
*****************************************************************************/
// mapnik
#include <mapnik/boolean.hpp>
#include <mapnik/params.hpp>
#include <mapnik/value.hpp>
// boost
#include <boost/variant/static_visitor.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/none.hpp>
#include <boost/optional.hpp>
namespace mapnik {
namespace params_detail {
// TODO - rewrite to avoid usage of lexical_cast
template <typename T>
struct value_extractor_visitor : public boost::static_visitor<>
{
value_extractor_visitor(boost::optional<T> & var)
:var_(var) {}
void operator () (T val) const
{
var_ = val;
}
template <typename T1>
void operator () (T1 val) const
{
try
{
var_ = boost::lexical_cast<T>(val);
}
catch (boost::bad_lexical_cast & ) {}
}
boost::optional<T> & var_;
};
template <typename T>
struct converter
{
typedef boost::optional<T> return_type;
static return_type extract(parameters const& params,
std::string const& name,
boost::optional<T> const& default_opt_value)
{
boost::optional<T> result(default_opt_value);
parameters::const_iterator itr = params.find(name);
if (itr != params.end())
{
boost::apply_visitor(value_extractor_visitor<T>(result),itr->second);
}
return result;
}
};
} // end namespace params_detail
// parameters
parameters::parameters() {}
template <typename T>
boost::optional<T> parameters::get(std::string const& key) const
{
return params_detail::converter<T>::extract(*this,key, boost::none);
}
template <typename T>
boost::optional<T> parameters::get(std::string const& key, T const& default_opt_value) const
{
return params_detail::converter<T>::extract(*this,key,boost::optional<T>(default_opt_value));
}
#define compile_params_get(T) template boost::optional<T> parameters::get(std::string const& key) const; template boost::optional<T> parameters::get(std::string const& key, T const& default_opt_value) const
compile_params_get(std::string);
compile_params_get(value_double);
compile_params_get(int);
#ifdef BIGINT
compile_params_get(value_integer);
#endif
compile_params_get(mapnik::boolean);
}