mapnik/src/xml_tree.cpp

450 lines
12 KiB
C++
Raw Normal View History

/*****************************************************************************
*
* This file is part of Mapnik (c++ mapping toolkit)
*
2015-06-16 10:49:16 +00:00
* 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
*
*****************************************************************************/
//mapnik
#include <mapnik/debug.hpp>
#include <mapnik/make_unique.hpp>
#include <mapnik/xml_tree.hpp>
#include <mapnik/xml_attribute_cast.hpp>
#include <mapnik/util/conversions.hpp>
#include <mapnik/enumeration.hpp>
2012-03-06 14:47:08 +00:00
#include <mapnik/color_factory.hpp>
2013-01-04 02:05:40 +00:00
#include <mapnik/rule.hpp>
2012-03-07 18:16:41 +00:00
#include <mapnik/feature_type_style.hpp>
2013-11-08 04:09:22 +00:00
#include <mapnik/text/text_properties.hpp>
2012-03-12 00:09:26 +00:00
#include <mapnik/config_error.hpp>
#include <mapnik/raster_colorizer.hpp>
#include <mapnik/expression.hpp>
2014-09-11 18:58:26 +00:00
#include <mapnik/text/font_feature_settings.hpp>
2013-11-29 15:46:23 +00:00
// stl
#include <type_traits>
namespace mapnik
{
class boolean_type;
template <typename T>
struct name_trait
{
static std::string name()
{
return "<unknown>";
}
// missing name_trait for type ...
// if you get here you are probably using a new type
// in the XML file. Just add a name trait for the new
// type below.
2013-11-29 15:46:23 +00:00
static_assert( sizeof(T) == 0, "missing name_trait for the type");
};
2012-03-13 14:56:11 +00:00
#define DEFINE_NAME_TRAIT( type, type_name ) \
template <> \
struct name_trait<type> \
{ \
static std::string name() { return std::string("type ") + type_name; } \
};
DEFINE_NAME_TRAIT( double, "double")
DEFINE_NAME_TRAIT( float, "float")
DEFINE_NAME_TRAIT( unsigned, "unsigned")
DEFINE_NAME_TRAIT( int, "int")
DEFINE_NAME_TRAIT( boolean_type, "boolean_type")
#ifdef BIGINT
DEFINE_NAME_TRAIT( mapnik::value_integer, "long long" )
#else
DEFINE_NAME_TRAIT( mapnik::value_integer, "int" )
#endif
DEFINE_NAME_TRAIT( std::string, "string" )
DEFINE_NAME_TRAIT( color, "color" )
2014-09-11 18:58:26 +00:00
DEFINE_NAME_TRAIT( expression_ptr, "expression_ptr" )
DEFINE_NAME_TRAIT( font_feature_settings, "font-feature-settings" )
template <typename ENUM, int MAX>
struct name_trait< mapnik::enumeration<ENUM, MAX> >
{
using Enum = enumeration<ENUM, MAX>;
static std::string name()
{
std::string value_list("one of [");
for (unsigned i = 0; i < Enum::MAX; ++i)
{
value_list += Enum::get_string( i );
if ( i + 1 < Enum::MAX ) value_list += ", ";
}
value_list += "]";
return value_list;
}
};
xml_tree::xml_tree()
2012-03-11 22:24:28 +00:00
: node_(*this, "<root>"),
file_()
{
2012-03-12 01:12:58 +00:00
node_.set_processed(true); //root node is always processed
}
2014-03-10 20:00:14 +00:00
void xml_tree::set_filename(std::string const& fn)
{
file_ = fn;
}
2012-03-12 00:09:26 +00:00
std::string const& xml_tree::filename() const
{
return file_;
}
xml_node & xml_tree::root()
{
return node_;
}
const xml_node & xml_tree::root() const
{
return node_;
}
xml_attribute::xml_attribute(const char * value_)
: value(value_),
processed(false) {}
2012-03-07 02:57:31 +00:00
node_not_found::node_not_found(std::string const& node_name)
: node_name_(node_name),
msg_() {}
2012-03-07 02:57:31 +00:00
const char* node_not_found::what() const throw()
{
msg_ = std::string("Node "+node_name_+ "not found");
return msg_.c_str();
2012-03-07 02:57:31 +00:00
}
node_not_found::~node_not_found() throw() {}
2012-03-07 02:57:31 +00:00
attribute_not_found::attribute_not_found(std::string const& node_name,
std::string const& attribute_name)
: node_name_(node_name),
attribute_name_(attribute_name),
msg_() {}
2012-03-07 02:57:31 +00:00
const char* attribute_not_found::what() const throw()
{
msg_ = std::string("Attribute '" + attribute_name_ +"' not found in node '"+node_name_+ "'");
return msg_.c_str();
2012-03-07 02:57:31 +00:00
}
attribute_not_found::~attribute_not_found() throw() {}
2012-03-07 02:57:31 +00:00
more_than_one_child::more_than_one_child(std::string const& node_name)
: node_name_(node_name),
msg_() {}
2012-03-07 02:57:31 +00:00
const char* more_than_one_child::what() const throw()
{
msg_ = std::string("More than one child node in node '" + node_name_ +"'");
return msg_.c_str();
2012-03-07 02:57:31 +00:00
}
more_than_one_child::~more_than_one_child() throw() {}
xml_node::xml_node(xml_tree &tree, std::string && name, unsigned line, bool is_text)
: tree_(tree),
name_(std::move(name)),
is_text_(is_text),
line_(line),
processed_(false),
ignore_(false) {}
2012-03-12 00:09:26 +00:00
std::string xml_node::xml_text = "<xmltext>";
std::string const& xml_node::name() const
{
if (!is_text_)
2013-02-23 02:58:36 +00:00
{
return name_;
2013-02-23 02:58:36 +00:00
}
else
2013-02-23 02:58:36 +00:00
{
2012-03-12 00:09:26 +00:00
return xml_text;
2013-02-23 02:58:36 +00:00
}
}
2012-03-12 00:09:26 +00:00
std::string const& xml_node::text() const
{
if (is_text_)
2012-03-12 01:12:58 +00:00
{
processed_ = true;
return name_;
2013-02-23 02:58:36 +00:00
}
else
2012-03-12 01:12:58 +00:00
{
2012-03-12 00:09:26 +00:00
throw config_error("text() called on non-text node", *this);
2012-03-12 01:12:58 +00:00
}
2012-03-12 00:09:26 +00:00
}
std::string const& xml_node::filename() const
{
return tree_.filename();
}
2012-03-07 02:57:31 +00:00
bool xml_node::is_text() const
{
return is_text_;
2012-03-07 02:57:31 +00:00
}
bool xml_node::is(std::string const& name) const
{
if (name_ == name)
{
processed_ = true;
return true;
}
return false;
}
xml_node & xml_node::add_child(const char * name, unsigned line, bool is_text)
{
children_.emplace_back(tree_, name, line, is_text);
return children_.back();
}
void xml_node::add_attribute(const char * name, const char * value)
2012-03-07 02:57:31 +00:00
{
auto result = attributes_.emplace(name,xml_attribute(value));
if (!result.second)
{
MAPNIK_LOG_ERROR(xml_tree) << "ignoring duplicate attribute '" << name << "'";
}
2012-03-07 02:57:31 +00:00
}
2012-03-08 00:29:19 +00:00
xml_node::attribute_map const& xml_node::get_attributes() const
{
return attributes_;
}
2012-03-07 02:57:31 +00:00
void xml_node::set_processed(bool processed) const
{
processed_ = processed;
}
2012-03-08 17:51:23 +00:00
bool xml_node::processed() const
{
return processed_;
}
void xml_node::set_ignore(bool ignore) const
{
ignore_ = ignore;
}
bool xml_node::ignore() const
{
return ignore_;
}
std::size_t xml_node::size() const
{
return children_.size();
}
2012-03-07 02:57:31 +00:00
xml_node::const_iterator xml_node::begin() const
{
return children_.begin();
}
xml_node::const_iterator xml_node::end() const
{
return children_.end();
}
xml_node & xml_node::get_child(std::string const& name)
{
std::list<xml_node>::iterator itr = children_.begin();
std::list<xml_node>::iterator end = children_.end();
2014-07-08 15:38:15 +00:00
for (; itr != end; ++itr)
{
if (!(itr->is_text_) && itr->name_ == name)
{
itr->set_processed(true);
return *itr;
}
}
throw node_not_found(name);
}
2012-03-07 02:57:31 +00:00
xml_node const& xml_node::get_child(std::string const& name) const
{
xml_node const* node = get_opt_child(name);
if (!node) throw node_not_found(name);
return *node;
}
xml_node const* xml_node::get_opt_child(std::string const& name) const
{
const_iterator itr = children_.begin();
const_iterator end = children_.end();
for (; itr != end; itr++)
{
if (!(itr->is_text_) && itr->name_ == name)
2012-03-07 02:57:31 +00:00
{
itr->set_processed(true);
return &(*itr);
}
}
return 0;
}
bool xml_node::has_child(std::string const& name) const
{
return get_opt_child(name) != 0;
}
bool xml_node::has_attribute(std::string const& name) const
{
return attributes_.count(name) == 1 ? true : false;
}
template <typename T>
boost::optional<T> xml_node::get_opt_attr(std::string const& name) const
{
if (attributes_.empty()) return boost::optional<T>();
std::map<std::string, xml_attribute>::const_iterator itr = attributes_.find(name);
if (itr == attributes_.end()) return boost::optional<T>();
2012-03-07 02:57:31 +00:00
itr->second.processed = true;
boost::optional<T> result = xml_attribute_cast<T>(tree_, std::string(itr->second.value));
if (!result)
{
throw config_error(std::string("Failed to parse attribute '") +
name + "'. Expected " + name_trait<T>::name() +
2012-03-12 01:12:58 +00:00
" but got '" + itr->second.value + "'", *this);
2012-03-07 02:57:31 +00:00
}
return result;
}
template <typename T>
2013-01-04 02:05:40 +00:00
T xml_node::get_attr(std::string const& name, T const& default_opt_value) const
2012-03-07 02:57:31 +00:00
{
boost::optional<T> value = get_opt_attr<T>(name);
if (value) return *value;
2013-01-04 02:05:40 +00:00
return default_opt_value;
2012-03-07 02:57:31 +00:00
}
template <typename T>
T xml_node::get_attr(std::string const& name) const
{
boost::optional<T> value = get_opt_attr<T>(name);
if (value) return *value;
throw attribute_not_found(name_, name);
}
std::string const& xml_node::get_text() const
2012-03-07 02:57:31 +00:00
{
// FIXME : return boost::optional<std::string const&>
if (children_.empty())
2012-03-07 02:57:31 +00:00
{
if (is_text_)
{
return name_;
2013-02-23 02:58:36 +00:00
}
else
{
const static std::string empty;
return empty;
}
2012-03-07 02:57:31 +00:00
}
if (children_.size() == 1)
{
return children_.front().text();
}
throw more_than_one_child(name_);
}
template <typename T>
T xml_node::get_value() const
{
boost::optional<T> result = xml_attribute_cast<T>(tree_, get_text());
2012-03-07 02:57:31 +00:00
if (!result)
{
2012-03-12 00:09:26 +00:00
throw config_error(std::string("Failed to parse value. Expected ")
+ name_trait<T>::name() +
" but got '" + get_text() + "'", *this);
}
2012-03-07 18:16:41 +00:00
return *result;
}
2012-03-08 17:51:23 +00:00
unsigned xml_node::line() const
{
return line_;
}
std::string xml_node::line_to_string() const
{
std::string number;
util::to_string(number,line_);
return number;
}
2012-03-07 02:57:31 +00:00
#define compile_get_opt_attr(T) template boost::optional<T> xml_node::get_opt_attr<T>(std::string const&) const
2012-03-07 18:16:41 +00:00
#define compile_get_attr(T) template T xml_node::get_attr<T>(std::string const&) const; template T xml_node::get_attr<T>(std::string const&, T const&) const
#define compile_get_value(T) template T xml_node::get_value<T>() const
compile_get_opt_attr(boolean_type);
2012-03-07 02:57:31 +00:00
compile_get_opt_attr(std::string);
compile_get_opt_attr(int);
2012-03-07 02:57:31 +00:00
compile_get_opt_attr(unsigned);
compile_get_opt_attr(mapnik::value_integer);
2012-03-07 02:57:31 +00:00
compile_get_opt_attr(float);
compile_get_opt_attr(double);
compile_get_opt_attr(color);
compile_get_opt_attr(gamma_method_e);
2012-03-07 18:16:41 +00:00
compile_get_opt_attr(line_join_e);
compile_get_opt_attr(line_cap_e);
compile_get_opt_attr(text_transform_e);
compile_get_opt_attr(label_placement_e);
compile_get_opt_attr(vertical_alignment_e);
compile_get_opt_attr(horizontal_alignment_e);
compile_get_opt_attr(justify_alignment_e);
compile_get_opt_attr(text_upright_e);
2015-01-19 13:47:46 +00:00
compile_get_opt_attr(direction_e);
compile_get_opt_attr(halo_rasterizer_e);
2012-03-11 22:24:28 +00:00
compile_get_opt_attr(expression_ptr);
compile_get_opt_attr(font_feature_settings);
2012-03-07 18:16:41 +00:00
compile_get_attr(std::string);
compile_get_attr(filter_mode_e);
compile_get_attr(point_placement_e);
compile_get_attr(debug_symbolizer_mode_e);
2012-03-07 18:16:41 +00:00
compile_get_attr(marker_placement_e);
compile_get_attr(marker_multi_policy_e);
2012-03-07 18:16:41 +00:00
compile_get_attr(pattern_alignment_e);
compile_get_attr(line_rasterizer_e);
2012-03-07 18:16:41 +00:00
compile_get_attr(colorizer_mode);
compile_get_attr(double);
compile_get_value(value_integer);
2012-03-07 18:16:41 +00:00
compile_get_value(double);
compile_get_value(expression_ptr);
} //ns mapnik