node.cpp

彩信浏览器

		e = e->next();
		while(e) {
			c->append_child(e->clone());
			e = e->next();
		}
	}
	return c;
}

////////////////////////
// data queries
// some are inline

lib::xml_string 
lib::node_impl::get_trimmed_data() const { 
	return trim(m_data);
}

#ifndef _WIN32_WCE
bool 
lib::node_impl::has_graph_data() const { 
	if(m_data.empty()) return false;
	return std::find_if(m_data.begin(), m_data.end(), isgraph) != m_data.end();
}
#endif

const char *
lib::node_impl::get_attribute(const char *name) const {
	if(!name || !name[0]) return 0;
	q_attributes_list::const_iterator it;
	for(it = m_qattrs.begin(); it != m_qattrs.end(); it++)
		if((*it).first.second == name) return (*it).second.c_str();
	return 0;
}

const char *
lib::node_impl::get_attribute(const std::string& name) const {
	return get_attribute(name.c_str());
}

void
lib::node_impl::del_attribute(const char *name) {
	if(!name || !name[0]) return;
	q_attributes_list::const_iterator it;
	// Cannot use a for loop here because we may modify the list
	it = m_qattrs.begin();
	while (it != m_qattrs.end()) {
		if((*it).first.second == name) {
			m_qattrs.remove(*it);
			it = m_qattrs.begin();
		} else {
			it++;
		}
	}
	return;
}

// returns the resolved url of an attribute
net::url 
lib::node_impl::get_url(const char *attrname) const {
	const char *rurl = get_attribute(attrname);
	if(!rurl) return net::url();
	net::url url = net::url::from_url(rurl);
	return m_context ? m_context->resolve_url(url) : url;
}

const char *
lib::node_impl::get_container_attribute(const char *name) const {
	if(!name || !name[0]) return 0;
	const node_impl *n = this;
	const char *p = 0;
	while(n->up()) {
		n = n->up();
		p = n->get_attribute(name);
		if(p) break;
	}
	return p;

}

/////////////////////
// string repr

lib::xml_string 
lib::node_impl::xmlrepr() const {
	xml_string s(m_qname.second);
	q_attributes_list::const_iterator it = m_qattrs.begin();
	while(it!=m_qattrs.end()) {
		s += " ";
		s += (*it).first.second;
		s += "=\"";
		s += (*it).second;
		s += "\"";
		it++;
	}
	return s;
}

std::string lib::node_impl::get_sig() const {
	std::string s = "<";
	s += m_qname.second;
	const char *pid = get_attribute("id");
	if (pid) {
		s += " id=\"";
		s += pid;
		s += "\"";
	}
	s += ">";
	return s;
}

unsigned int 
lib::node_impl::size() const {
	const_iterator it;
	const_iterator e = end();
	unsigned int count = 0;
	for(it = begin(); it != e; it++)
		if((*it).first) count++;
	return count;
}

#ifndef AMBULANT_NO_IOSTREAMS
lib::xml_string 
lib::node_impl::to_string() const {
	std::ostringstream os;
	output_visitor<node_impl> visitor(os);
	const_iterator it;
	const_iterator e = end();
	for(it = begin(); it != e; it++) visitor(*it);
	return os.str();
}
#endif
	
#ifndef AMBULANT_NO_IOSTREAMS
lib::xml_string 
lib::node_impl::to_trimmed_string() const {
	std::ostringstream os;
	trimmed_output_visitor<node_impl> visitor(os);
	const_iterator it;
	const_iterator e = end();
	for(it = begin(); it != e; it++) visitor(*it);
	return os.str();
}
#endif


void lib::node_impl::create_idmap(std::map<std::string, node_impl*>& m) const {
	attr_collector<node_impl> visitor(m);
	const_iterator it;
	const_iterator e = end();
	for(it = begin(); it != e; it++) visitor(*it);
}

#ifndef AMBULANT_NO_IOSTREAMS
void lib::node_impl::dump(std::ostream& os) const {
	output_visitor<ambulant::lib::node_impl> visitor(os);
	const_iterator it;
	const_iterator e = end();
	for(it = begin(); it != e; it++) visitor(*it);
}
#endif

void
lib::node_impl::down(lib::node_interface *n)
{
#if WITH_EXTERNAL_DOM
	down(dynamic_cast<node_impl*>(n));
#else
	assert(0);
#endif
}

void
lib::node_impl::up(lib::node_interface *n)
{
#if WITH_EXTERNAL_DOM
	up(dynamic_cast<node_impl*>(n));
#else
	assert(0);
#endif
}

void
lib::node_impl::next(lib::node_interface *n)
{
#if WITH_EXTERNAL_DOM
	next(dynamic_cast<node_impl*>(n));
#else
	assert(0);
#endif
}

lib::node_interface*
lib::node_impl::append_child(lib::node_interface* child)
{
#if WITH_EXTERNAL_DOM
	return append_child(dynamic_cast<node_impl*>(child));
#else
	assert(0);
	return NULL;
#endif
}

#ifndef AMBULANT_NO_IOSTREAMS
std::ostream& operator<<(std::ostream& os, const ambulant::lib::node_impl& n) {
	os << "node(" << (void *)&n << ", \"" << n.get_qname() << "\"";
	std::string url = repr(n.get_url("src"));
	if (url != "")
		os << ", url=\"" << url << "\"";
	os << ")";
	return os;
}
#endif

//////////////////////////////////////////////
//////////////////////////////////////////////
// Visitors implementations

////////////////////////
// output_visitor

#ifndef AMBULANT_NO_IOSTREAMS
template<class Node>
void output_visitor<Node>::operator()(std::pair<bool, const Node*> x) {
	const Node*& pe = x.second;
	if(x.first) {
		// start tag
		if(!pe->down()) 
			write_start_tag_no_children(pe);
		else 
			write_start_tag_with_children(pe);
		}
	else if(pe->down())
		write_end_tag_with_children(pe);
}

template<class Node>
void output_visitor<Node>::write_start_tag_no_children(const Node*& pe) {
	const std::string& data = pe->get_data();
	if(data.length()==0 || !pe->has_graph_data())
		os <<  writesp << "<" + pe->xmlrepr() + "/>" << std::endl;
	else {
		os <<  writesp << "<" + pe->xmlrepr() + ">";
		os << pe->get_data();
		os << "</" << pe->get_local_name() << ">" << std::endl;
	}
}

template<class Node>
void output_visitor<Node>::write_start_tag_with_children(const Node*& pe) {
	os <<  writesp << "<" + pe->xmlrepr() + ">";
	const std::string& data = pe->get_data();
	if(data.length()>0 && pe->has_graph_data())
		os << pe->get_data();
	os << std::endl;
	writesp += strincr;
}

template<class Node>
void output_visitor<Node>::write_end_tag_with_children(const Node*& pe) {
	writesp = writesp.substr(0,writesp.length()-ns);
	os << writesp << "</" + pe->get_local_name() << ">" << std::endl;
}
#endif // AMBULANT_NO_IOSTREAMS


////////////////////////
// trimmed_output_visitor

#ifndef AMBULANT_NO_IOSTREAMS
template <class Node>
void trimmed_output_visitor<Node>::operator()(std::pair<bool, const Node*> x) {
	const Node*& pe = x.second;
	if(x.first) {
		// start tag
		if(!pe->down()) 
			write_start_tag_no_children(pe);
		else 
			write_start_tag_with_children(pe);
	}
	else if(pe->down())
		write_end_tag_with_children(pe);
}

template <class Node>
void trimmed_output_visitor<Node>::write_start_tag_no_children(const Node*& pe) {
	std::string data = pe->get_trimmed_data();
	if(data.length()==0)
		os <<  "<" + pe->xmlrepr() + "/>";
	else {
		os <<  "<" << pe->xmlrepr() << ">";
		os << data;
		os << "</" << pe->get_local_name() << ">";
	}
}

template <class Node>
void trimmed_output_visitor<Node>::write_start_tag_with_children(const Node*& pe) {
	os <<  "<" + pe->xmlrepr() + ">";
	std::string data = pe->get_trimmed_data();
	if(data.length()>0)
		os << data;
}

template <class Node>
void trimmed_output_visitor<Node>::write_end_tag_with_children(const Node*& pe) {
	os << "</" + pe->get_local_name() << ">";
}
#endif // AMBULANT_NO_IOSTREAMS

class builtin_node_factory : public lib::node_factory {
  public:
	lib::node *new_node(const char *local_name, const char **attrs, const lib::node_context *ctx);
	lib::node *new_node(const lib::xml_string& local_name, const char **attrs = 0, const lib::node_context *ctx = 0);
	lib::node *new_node(const lib::q_name_pair& qn, const lib::q_attributes_list& qattrs, const lib::node_context *ctx = 0);
	lib::node *new_node(const lib::node* other);
};

// If we are building a player with an (optional) external DOM implementation
// we need to define a couple more things:
// - factory functions (which are defined inline for non-external DOM builds)
// - a couple of methods that accept node_interface parameters and do
//   dynamic typechecks that the arguments are actually node_impl's.

// Factory functions
lib::node *
builtin_node_factory::new_node(const char *local_name, const char **attrs, const lib::node_context *ctx)
{
	return new lib::node_impl(local_name, attrs, ctx);
}

/// Construct a new, unconnected, node.
/// Note: attrs are as per expat parser
/// e.g. const char* attrs[] = {"attr_name", "attr_value", ..., 0};
lib::node *
builtin_node_factory::new_node(const lib::xml_string& local_name, const char **attrs, const lib::node_context *ctx)
{
	return new lib::node_impl(local_name, attrs, ctx);
}

/// Construct a new, unconnected, node.
/// Note: attrs are as per expat parser
/// e.g. const char* attrs[] = {"attr_name", "attr_value", ..., 0};
lib::node *
builtin_node_factory::new_node(const lib::q_name_pair& qn, const lib::q_attributes_list& qattrs, const lib::node_context *ctx)
{
	return new lib::node_impl(qn, qattrs, ctx);
}

// shallow copy from other.
lib::node *
builtin_node_factory::new_node(const lib::node* other)
{
#if WITH_EXTERNAL_DOM
	return new lib::node_impl(dynamic_cast<const lib::node_impl*>(other));
#else
	return new lib::node_impl(other);
#endif
}

lib::node_factory *lib::get_builtin_node_factory()
{
	static builtin_node_factory nf;
	
	return &nf;
}