NodeXML< T > Class Template Reference

#include <TreeXML.h>

Inheritance diagram for NodeXML< T >:

Collaboration diagram for NodeXML< T >:

Public Types
typedef T	elem_t
	Tag type, CTEXT or COMMENT.
typedef NodeXML< T >	xml_node_t
typedef UnorderedMultiTree< NodeXML< T >, false, path_t >	xml_tree_t
typedef std::map< T, std::string >	tag_map_t
typedef T	xml_tag_t
typedef NodeXML< T >	xml_node_t
typedef drain::Path< std::string,'/'>	path_t
typedef UnorderedMultiTree< xml_node_t, false, path_t >	xml_tree_t
typedef std::map< xml_tag_t, xml_tag_t >	xml_default_elem_map_t
Public Types inherited from XML
enum	tag_display_mode {   FLEXIBLE_TAG = 0 , OPENING_TAG = 1 , CLOSING_TAG = 2 , EMPTY_TAG = OPENING_TAG | CLOSING_TAG ,   NON_EMPTY_TAG }
typedef ReferenceMap2< FlexibleVariable >	map_t
typedef drain::Path< std::string,'/'>	path_t
	Tree path type.
typedef path_t::elem_t	path_elem_t
typedef std::list< path_t >	path_list_t
typedef int	intval_t
typedef ReferenceMap2< FlexibleVariable >	map_t

Public Member Functions
	NodeXML (const elem_t &t=elem_t(0))
	NodeXML (const NodeXML &node)
virtual void	setType (const elem_t &t)
const elem_t &	getType () const
bool	typeIs (const elem_t &t) const
bool	isComment () const
bool	isCText () const
bool	isUndefined () const
bool	isSelfClosing () const
const std::string &	getTag () const
void	set (const NodeXML &node)
void	set (const elem_t &type)
void	set (const std::string &s)
void	set (const char *s)
void	set (const drain::Castable &s)
void	set (const std::initializer_list< Variable::init_pair_t > &l)
template<class X >
void	set (const std::map< std::string, X > &args)
template<class V >
void	set (const std::string &key, const V &value)
NodeXML &	operator= (const T &x)
NodeXML &	operator= (const Castable &c)
NodeXML &	operator= (const std::string &s)
NodeXML &	operator= (const char *s)
NodeXML &	operator= (const std::initializer_list< std::pair< const char *, const drain::Variable > > &l)
NodeXML &	setComment (const std::string &text="")
	Make this node a comment. Contained tree will not be delete. In current version, attributes will be rendered.
template<class S >
NodeXML &	setText (const S &value)
	Assign the text content of this node. If the node type is undefined, set it to CTEXT.
NodeXML &	setText (const char *value)
template<class S >
void	setStyle (const S &value)
void	setStyle (const std::string &value)
void	setStyle (const char *value)
void	setStyle (const std::string &key, const std::string &value)
template<class V >
void	setStyle (const std::string &key, const std::initializer_list< V > &l)
	Set style of an element.
template<class V >
void	setStyle (const std::string &key, const V &value)
	For element/class/id, assign ...
void	setStyle (const std::initializer_list< std::pair< const char *, const drain::Variable > > &l)
	NodeXML (const intval_t &t=intval_t(0))
	NodeXML (const NodeXML &node)
template<class T2 >
void	setType (const T2 &t)
const intval_t &	getType () const
T	getNativeType () const
virtual const std::string &	getTag () const
void	set (const NodeXML &node)
void	set (const intval_t &type)
void	set (const std::string &s)
void	set (const char *s)
void	set (const drain::Castable &s)
void	set (const std::initializer_list< std::pair< const char *, const Variable > > &args)
template<class V >
void	set (const std::map< std::string, V > &args)
template<class V >
void	set (const std::string &key, const V &value)
NodeXML &	operator= (const NodeXML &node)
NodeXML &	operator= (const xml_tag_t &x)
NodeXML &	operator= (const Castable &c)
NodeXML &	operator= (const std::string &s)
NodeXML &	operator= (const char *s)
NodeXML &	operator= (const std::initializer_list< std::pair< const char *, const drain::Variable > > &l)
virtual std::ostream &	nodeToStream (std::ostream &ostr, tag_display_mode mode=EMPTY_TAG) const
	Dumps info. Future option: outputs leading and ending tag.
std::map< int, std::string >	tags
template<class T >
std::ostream &	toStream (std::ostream &ostr, const T &tree, const std::string &defaultTag, int indent)
	XML output function shared for all XML documents, ie versions defined in subclasses.
const NodeXML< drain::image::SLD::tag_t >::xml_default_elem_map_t	xml_default_elems
const NodeXML< image::SLD::tag_t >::xml_default_elem_map_t	xml_default_elems
const NodeXML< drain::image::svg::tag_t >::xml_default_elem_map_t	xml_default_elems
const NodeXML< image::svg::tag_t >::xml_default_elem_map_t	xml_default_elems
const NodeXML< html::tag_t >::xml_default_elem_map_t	xml_default_elems
std::ostream &	docTypeToStream (std::ostream &ostr)
const NodeXML< html::tag_t >::xml_default_elem_map_t	xml_default_elems
const NodeXML< int >::xml_default_elem_map_t	xml_default_elems
const std::string &	getTag () const
Public Member Functions inherited from XML
void	setId ()
	Makes ID a visible attribute.
void	setId (const std::string &s)
	Makes ID a visible attribute, with a given value.
template<char C = '\0', typename ... TT>
void	setId (const TT &...args)
const std::string &	getId () const
	Returns ID of this element. Hopefully a unique ID...
bool	empty () const
const map_t &	getAttributes () const
map_t &	getAttributes ()
virtual void	setAttribute (const std::string &key, const std::string &value)
	Default implementation. Needed for handling units in strings, like "50%" or "640px".
virtual void	setAttribute (const std::string &key, const char *value)
	Default implementation. Needed for handling units in strings, like "50%" or "640px".
template<class V >
void	setAttribute (const std::string &key, const V &value)
	"Final" implementation.
void	remove (const std::string &s)
const drain::FlexibleVariable &	get (const std::string &key) const
drain::FlexibleVariable &	get (const std::string &key)
template<class V >
V	get (const std::string &key, const V &defaultValue) const
std::string	get (const std::string &key, const char *defaultValue) const
template<typename ... TT>
void	addClass (const TT &... args)
	Style class.
template<class V >
bool	hasClass (const V &cls) const
void	removeClass (const std::string &s)
void	clearClasses ()
template<class T2 , class ... T3>
bool	typeIs (const T2 &arg, const T3... args) const
	Return true, if type is any of the arguments.
bool	isUndefined () const
bool	isComment () const
bool	isCText () const
bool	isStyle () const
bool	isScript () const
virtual bool	isSingular () const
	Tell if this element should always have an explicit closing tag even when empty, like <STYLE></STYLE>
virtual bool	isExplicit () const
	Tell if this element should always have an explicit closing tag even when empty, like <STYLE></STYLE>
virtual void	clear ()
	Clear style, class and string data but keep the element type.
void	reset ()
	Clear style, class and string data as well as the element type.
void	setId ()
	Makes ID a visible attribute.
void	setId (const std::string &s)
	Makes ID a visible attribute, with a given value.
template<char C = '\0', typename ... TT>
void	setId (const TT &...args)
	Concatenates arguments to an id.
const std::string &	getId () const
	Returns ID of this element. Hopefully a unique ID...
template<class ... T>
void	setComment (const T &...args)
	Make this node a comment. Contained tree will not be deleted. In current version, attributes WILL be rendered.
virtual void	setText (const std::string &s)
	Assign the text content of this node. If the node type is undefined, set it to CTEXT.
template<class ... T>
void	setText (const T &...args)
virtual const std::string &	getText () const
const std::string &	getUrl ()
void	setUrl (const std::string &s)
template<class ... T>
void	setName (const T &...args)
virtual bool	empty () const
const map_t &	getAttributes () const
map_t &	getAttributes ()
const drain::FlexibleVariable &	get (const std::string &key) const
drain::FlexibleVariable &	get (const std::string &key)
template<class V >
V	get (const std::string &key, const V &defaultValue) const
std::string	get (const std::string &key, const char *defaultValue) const
virtual void	setAttribute (const std::string &key, const std::string &value)
	Default implementation. Needed for handling units in strings, like "50%" or "640px".
virtual void	setAttribute (const std::string &key, const char *value)
	Default implementation. Needed for handling units in strings, like "50%" or "640px".
template<class V >
void	setAttribute (const std::string &key, const V &value)
	"Final" implementation.
void	removeAttribute (const std::string &s)
const StyleXML &	getStyle () const
void	setStyle (const StyleXML &s)
void	setStyle (const std::string &value)
void	setStyle (const char *value)
void	setStyle (const std::string &key, const std::string &value)
template<class V >
void	setStyle (const std::string &key, const std::initializer_list< V > &l)
	Set style of an element.
template<class V >
void	setStyle (const std::string &key, const V &value)
	For element/class/id, assign ...
void	setStyle (const std::initializer_list< std::pair< const char *, const drain::Variable > > &args)
const ClassListXML &	getClasses () const
template<typename ... TT>
void	addClass (const TT &... args)
template<class V >
bool	hasClass (const V &cls) const
void	removeClass (const std::string &s)
void	clearClasses ()
virtual void	specificAttributesToStream (std::ostream &ostr) const
template<class T >
bool	findById (const T &t, const std::string &id, typename T::path_t &result, const typename T::path_t &path)
template<class T >
bool	findById (const T &t, const std::string &id, NodeXML<>::path_list_t &result, const path_t &path)
template<class T , class N >
bool	findByTag (const T &t, const N &tag, NodeXML<>::path_list_t &result, const path_t &path)
template<class T , class N >
bool	findByTags (const T &t, const std::set< N > &tags, NodeXML<>::path_list_t &result, const path_t &path)
template<class T2 , class C >
bool	findByClass (const T2 &t, const C &cls, XML::path_list_t &result, const path_t &path)

Static Public Member Functions
static const std::string &	getTag (unsigned int index)
template<class V >
static std::ostream &	docToStream (std::ostream &ostr, const V &tree)
template<class V >
static std::ostream &	toStream (std::ostream &ostr, const V &t, const std::string &defaultTag="", int indent=0)
	"Forward definition" of Tree::toOstream
static std::ostream &	docTypeToStream (std::ostream &ostr)
	Write the XML definition beginning any XML document.
template<int E>
static const std::pair< key_t, NodeXML< T > > &	entry ()
static const std::string &	getTag (const T &type)
template<class V >
static std::ostream &	docToStream (std::ostream &ostr, const V &tree)
static std::ostream &	docTypeToStream (std::ostream &ostr)
	Write the XML definition beginning any XML document.
Static Public Member Functions inherited from XML
template<class V >
static void	attribToStream (std::ostream &ostr, const std::string &key, const V &value)
static int	getCount ()
template<class V >
static bool	findById (const V &tree, const std::string &tag, typename V::path_t &result, const typename V::path_t &path=path_t())
	Find the first occurrence of given id using recursive breath-first search.
template<class V >
static bool	findById (const V &tree, const std::string &tag, path_list_t &result, const path_t &path=path_t())
	Find the occurrence(s) of given ID using recursive breath-first search.
template<class V , class T >
static bool	findByTag (const V &tree, const T &tag, path_list_t &result, const path_t &path=path_t())
template<class V , class T >
static bool	findByTags (const V &tree, const std::set< T > &tags, path_list_t &result, const path_t &path=path_t())
	"Forward definition"
template<class T2 , class C >
static bool	findByClass (const T2 &t, const C &cls, std::list< path_elem_t > &result)
	Finds child elements in an XML structure by class name.
template<class V , class C >
static bool	findByClass (const V &t, const C &cls, path_list_t &result, const path_t &path=path_t())
	Finds elements recursively in an XML structure by class name supplied as an enumeration type.
static int	getCount ()
template<class TR >
static std::ostream &	toStream (std::ostream &ostr, const TR &tree, const std::string &defaultTag="ELEM", int indent=0)
template<class V >
static void	xmlAttribToStream (std::ostream &ostr, const std::string &key, const V &value)
template<typename TX >
static TX &	xmlAssign (TX &dst, const TX &src)
	Assign another tree structure to another.
template<typename TX >
static TX &	xmlAssign (TX &dst, const typename TX::xml_node_t &src)
	Assign another tree structure to another.
template<typename X >
static X &	xmlAssignNode (X &dst, const X &src)
	Assign another tree structure to another.
template<typename TX , typename V >
static TX &	xmlAssign (TX &tree, const V &arg)
	Assign another tree structure to another.
template<typename TX >
static TX &	xmlAssign (TX &tree, std::initializer_list< std::pair< const char *, const Variable > > l)
	Tree.
template<typename TX >
static TX &	xmlAssignString (TX &tree, const std::string &s)
	When assigning a string, create new element unless the element itself is of type CTEXT.
template<typename TX >
static TX &	xmlAppendString (TX &tree, const std::string &s)
template<typename TX >
static TX &	xmlSetType (TX &tree, const typename TX::node_data_t::xml_tag_t &type)
template<typename T >
static T &	xmlAddChild (T &tree, const std::string &key)
template<typename N >
static N::xml_tag_t	xmlRetrieveDefaultType (const N &parentNode)

Public Attributes
elem_t	type
Public Attributes inherited from XML
std::string	id
	Some general-purpose.
std::string	ctext
std::string	url
ClassListXML	classList
StyleXML	style

Static Public Attributes
static tag_map_t	tags
static const xml_default_elem_map_t	xml_default_elems
Static Public Attributes inherited from XML
static const int	UNDEFINED = 0
static const int	COMMENT = 1
static const int	CTEXT = 2
static const int	STYLE = 3
static const int	SCRIPT = 4
static int	nextID = 0
static const intval_t	UNDEFINED = 0
static const intval_t	COMMENT = 1
static const intval_t	CTEXT = 2
static const intval_t	SCRIPT = 3
static const intval_t	STYLE = 4
static const intval_t	STYLE_SELECT = 5
static const std::map< char, std::string >	encodingMap
	User may optionally filter attributes and CTEST with this using StringTools::replace(XML::encodingMap);.

Protected Types
typedef std::map< std::string, std::string >	xmldoc_attrib_map_t
typedef std::list< std::pair< std::string, std::string > >	xmldoc_attrib_map_t
	NOTE: these could/should be templated, in TreeXML<...> right?
Protected Types inherited from ReferenceMap2< FlexibleVariable >
enum	extLinkPolicy
typedef FlexibleVariable	ref_t
typedef SmartMap< FlexibleVariable >	map_t
Protected Types inherited from SmartMap< T >
typedef SmartMap< T >	smap_t
typedef std::map< std::string, T >	map_t
typedef map_t::key_type	key_t
typedef map_t::mapped_type	value_t
typedef map_t::value_type	entry_t
typedef std::list< std::string >	keylist_t
typedef map_t::iterator	iterator
	Needed?
typedef map_t::const_iterator	const_iterator

Protected Member Functions
virtual void	handleType (const T &type)
	Internal function called after setType()
NodeXML< int >::xmldoc_attrib_map_t	xmldoc_attribs
NodeXML< int >::xmldoc_attrib_map_t	xmldoc_attribs
Protected Member Functions inherited from XML
bool	typeIs () const
Protected Member Functions inherited from ReferenceMap2< FlexibleVariable >
ref_t &	link (const std::string &key, F &x)
	Associates a map entry with a variable.
ref_t &	link (const std::string &key, void *ptr, const std::type_info &type, size_t count=1)
	Create a reference to a basic type or std::string. (Also for basetype arrays.)
void	unlink (const std::string &key)
void	copyStruct (const ReferenceMap2< FlexibleVariable > &m, const T2 &src, T2 &dst, extLinkPolicy policy=RESERVE)
	Experimental. Copies references and values of a structure to another.
Protected Member Functions inherited from SmartMap< T >
	SmartMap (char separator='\0', char arraySeparator=':')
	SmartMap (const SmartMap &smap)
bool	hasKey (const std::string &key) const
std::string	get (const std::string &key, const std::string &defaultValue) const
	Retrieves a value, or default value if value is unset.
std::string	get (const std::string &key, const char *defaultValue) const
template<class T2 >
T2	get (const std::string &key, const T2 &defaultValue) const
	Retrieves a value, if set, else returns the given default value.
virtual T &	operator[] (const std::string &key)
	Returns an element. Creates one, conditionally.
virtual const T &	operator[] (const std::string &key) const
	Unlike with std::map, operator[] const is defined, returning reference to a static empty instance.
virtual const keylist_t &	getKeyList () const
	Derived versions may produce an ordered set of keys.
const map_t &	getMap () const
template<class T2 >
void	exportMap (std::map< std::string, T2 > &m) const
	Copies the contents to another map.
template<bool STRICT = true>
void	importEntries (const std::string &entries, char assignmentSymbol='=', char separatorSymbol=0)
	Assigns a value to given key; if the entry does not exist, tries to create it with directly with operator[].
template<bool STRICT = true>
void	importEntries (const std::list< std::string > &entries, char assignmentSymbol='=')
template<class S , bool STRICT = true>
void	importMap (const std::map< std::string, S > &m)
	Assign values from a map, overriding existing entries.
template<class T2 , bool STRICT = true>
void	importCastableMap (const drain::SmartMap< T2 > &m)
	Assign values from a map, possibly extending the map.
template<class T2 >
void	updateFromMap (const std::map< std::string, T2 > &m)
	Assign values from a map. Updates existing entries only.
template<class T2 >
void	updateFromCastableMap (const drain::SmartMap< T2 > &m)
	Convenience.
void	setValues (const std::string &entries, char assignmentSymbol='=', char separatorSymbol=0)
	Sets values. If strictness==STRICTLY_CLOSED, throws exception if tries to assign a non-existing entry.
void	setValues (const char *entries, char assignmentSymbol='=', char separatorSymbol=0)
template<class S >
void	setValuesSEQ (const S &sequence)
void	updateValues (const std::string &entries, char assignmentSymbol='=', char separatorSymbol=0)
	Sets applicable values ie. modifies existing entries only. In ordered maps, skips extra entries silently.
void	getKeys (std::ostream &ostr) const
std::string	getKeys () const
	Convenience function for std::string output.
void	getValues (std::ostream &ostr) const
	Dumps the values.
std::string	getValues () const
	Convenience function for std::string output.
std::ostream &	toStream (std::ostream &ostr, char equal='=', char startChar='{', char endChar='}', char separatorChar=',') const
	Note: parameters discarded.
std::string	toStr (char equal='=', char start=0, char end=0, char separator=0) const
void	dump (std::ostream &ostr=std::cout) const
	Write map as a JSON code.

Static Protected Attributes
static xmldoc_attrib_map_t	xmldoc_attribs

Additional Inherited Members
Protected Attributes inherited from XML
intval_t	type = XML::UNDEFINED
Protected Attributes inherited from SmartMap< T >
std::list< std::string >	keyList
	Assigns values from std::string of type "value,value2,...valueN".
char	separator
	Default character used for splitting input and output. See setValues.
char	arraySeparator
	Default separator character for array elements (std::vector's)

Detailed Description

template<class T = int>
class drain::NodeXML< T >

Template Parameters

T	- index type; may be enum.

Member Function Documentation

docToStream()

template<class T = int>

template<class V >

static std::ostream & docToStream ( std::ostream &  ostr, const V &  tree  )

inlinestatic

Finds elements in an XML structure by class name. Finds elements in an XML structure by class name. Redirects to findByClass(t, std::string(cls),

docTypeToStream() [1/2]

template<class T = int>

static std::ostream & docTypeToStream ( std::ostream &  ostr )

inlinestatic

Write the XML definition beginning any XML document.

Each derived class should have a definition compatible with the structure generated by the class.

docTypeToStream() [2/2]

template<class T = int>

static std::ostream & docTypeToStream ( std::ostream &  ostr )

inlinestatic

Write the XML definition beginning any XML document.

Each derived class should have a definition compatible with the structure generated by the class.

To override, use specialization of the template(d) base type:

template <>
std::ostream & NodeXML<BaseHTML::tag_t>::docTypeToStream(std::ostream &ostr){
  ostr << "<!DOCTYPE html>\n";
  return ostr;
}

getTag() [1/2]

template<class T = int>

virtual const std::string & getTag ( ) const

inlinevirtual

This function should not be called upon construction, as the dictionary does not exist.

getTag() [2/2]

template<class T = int>

static const std::string & getTag ( const T &  type )

inlinestatic

This function should not be called upon construction. Consider dynamic getDict() to skip

handleType()

template<class T = int>

virtual void handleType ( const T &  type )

inlineprotectedvirtual

Internal function called after setType()

Reimplemented in NodeHTML, NodeSLD, NodeSVG, and NodeGDAL.

nodeToStream()

template<class N >

std::ostream & nodeToStream ( std::ostream &  ostr, tag_display_mode  mode = EMPTY_TAG  ) const

virtual

Dumps info. Future option: outputs leading and ending tag.

See also

XML::toStream()

Implements XML.

set()

template<class T = int>

void set ( const std::initializer_list< std::pair< const char *, const Variable > > &  args )

inline

drain::SmartMapTools::setValues(getAttributes(), l); // add new keys

setComment()

template<class T = int>

NodeXML & setComment ( const std::string &  text = "" )

inline

Make this node a comment. Contained tree will not be delete. In current version, attributes will be rendered.

Parameters

text	- if given, replaces current CTEXT.

setStyle()

template<class T = int>

template<class V >

void setStyle ( const std::string &  key, const std::initializer_list< V > &  l  )

inline

Set style of an element.

rect.setStyle("dash-array",{2,5,3});

setText()

template<class T = int>

template<class S >

NodeXML & setText ( const S &  value )

inline

Assign the text content of this node. If the node type is undefined, set it to CTEXT.

Parameters

text	- assigned to text content.

toStream()

template<class T = int>

template<class T >

std::ostream & toStream	(	std::ostream &	ostr,
		const T &	tree,
		const std::string &	defaultTag,
		int	indent
	)

XML output function shared for all XML documents, ie versions defined in subclasses.

TODO: preamble/prologToStream()

Parameters

defaultTag

- important for

iterate children - note the use of default tag

---

The documentation for this class was generated from the following files:

• bak/TreeXML.h
• src/drain/util/TreeXML.h