C++ DomNode::is_element方法代码示例

	DomElement DomElement::get_next_sibling_element() const
	{
		DomNode node = get_next_sibling();
		while (!node.is_null() && !node.is_element())
			node = node.get_next_sibling();
		return node.to_element();
	}

	std::string DomNode::select_string(const DomString &xpath_expression) const
	{
		DomNode node = select_node(xpath_expression);
		if (node.is_element())
			return node.to_element().get_text();
		else
			return node.get_node_value();
	}

	DomElement DomDocument::get_document_element()
	{
		DomNode cur = get_first_child();
		while (!cur.is_null())
		{
			if (cur.is_element())
				return cur.to_element();
			cur = cur.get_next_sibling();
		}
		return DomElement();
	}

	std::string DomElement::get_text() const
	{
		std::string str;
		if (has_child_nodes() == false)
			return str;

		DomNode cur = get_first_child();
		while (!cur.is_null())
		{
			if (cur.is_text() || cur.is_cdata_section())
				str.append(cur.get_node_value());
			if (cur.is_element())
				str.append(cur.to_element().get_text());
			cur = cur.get_next_sibling();
		}
		return str;
	}

ProgramObject ProgramObject::load(
    GraphicContext &gc,
    const std::string &resource_id,
    const XMLResourceDocument &resources)
{
    ProgramObject program_object(gc);

    XMLResourceNode resource = resources.get_resource(resource_id);

    DomNode node = resource.get_element().get_first_child();

    while (!node.is_null())
    {
        if (node.is_element())
        {
            DomElement element = node.to_element();
            if (element.get_tag_name() == "shader")
            {
                ShaderObject shader = ShaderObject::load(gc, element.get_attribute("name"), resources);
                program_object.attach(shader);
            }
            else if (element.get_tag_name() == "bind-attribute")
            {
                program_object.bind_attribute_location(
                    StringHelp::text_to_int(element.get_attribute("index")),
                    element.get_attribute("name"));
            }
        }
        node = node.get_next_sibling();
    }

    if (!resource.get_element().get_attribute("shader").empty())
    {
        ShaderObject shader = ShaderObject::load(gc, resource.get_element().get_attribute("shader"), resources);
        program_object.attach(shader);
    }

    if (resource.get_element().get_attribute("link", "true") == "true")
        if(!program_object.link())
            throw Exception(string_format("Unable to link program object: %1", program_object.get_info_log()));

    return program_object;
}

	std::vector<DomNode> DomDocument::load(
		IODevice &input,
		bool eat_whitespace,
		DomNode insert_point)
	{
		clear_all();

		XMLTokenizer tokenizer(input);
		tokenizer.set_eat_whitespace(eat_whitespace);

		if (insert_point.is_element() == false)
			insert_point = *this;

		std::vector<DomNode> node_stack;
		node_stack.push_back(insert_point);

		std::vector<DomNode> result;
		try
		{
			XMLToken cur_token;
			tokenizer.next(&cur_token);
			while (cur_token.type != XMLToken::NULL_TOKEN)
			{
				switch (cur_token.type)
				{
				case XMLToken::TEXT_TOKEN:
					node_stack.back().append_child(create_text_node(cur_token.value));
					if (node_stack.back() == insert_point)
						result.push_back(node_stack.back().get_last_child());
					break;

				case XMLToken::CDATA_SECTION_TOKEN:
					node_stack.back().append_child(create_cdata_section(cur_token.value));
					if (node_stack.back() == insert_point)
						result.push_back(node_stack.back().get_last_child());
					break;

				case XMLToken::ELEMENT_TOKEN:
					if (cur_token.variant != XMLToken::END)
					{
						DomString namespace_uri = DomDocument_Impl::find_namespace_uri(cur_token.name, cur_token, node_stack.back());
						DomElement element = create_element_ns(namespace_uri, cur_token.name);
						node_stack.back().append_child(element);
						if (node_stack.back() == insert_point)
							result.push_back(node_stack.back().get_last_child());

						int size = (int)cur_token.attributes.size();
						for (int i = 0; i < size; i++)
						{
							XMLToken::Attribute &attribute = cur_token.attributes[i];
							DomString attribute_namespace_uri = DomDocument_Impl::find_namespace_uri(attribute.first, cur_token, node_stack.back());
							element.set_attribute_ns(
								attribute_namespace_uri,
								attribute.first,
								attribute.second);
						}

						if (cur_token.variant == XMLToken::BEGIN)
							node_stack.push_back(element);
					}
					else
					{
						node_stack.pop_back();
						if (node_stack.empty()) throw Exception("Malformed XML tree!");
					}
					break;

				case XMLToken::NULL_TOKEN:
					break;

				case XMLToken::ENTITY_REFERENCE_TOKEN:
					break;

				case XMLToken::ENTITY_TOKEN:
					break;

				case XMLToken::COMMENT_TOKEN:
					node_stack.back().append_child(create_comment(cur_token.value));
					if (node_stack.back() == insert_point)
						result.push_back(node_stack.back().get_last_child());
					break;

				case XMLToken::DOCUMENT_TYPE_TOKEN:
					break;

				case XMLToken::NOTATION_TOKEN:
					break;

				case XMLToken::PROCESSING_INSTRUCTION_TOKEN:
					node_stack.back().append_child(create_processing_instruction(cur_token.name, cur_token.value));
					if (node_stack.back() == insert_point)
						result.push_back(node_stack.back().get_last_child());
					break;
				}

				tokenizer.next(&cur_token);
			}
		}
		catch (const Exception& e)
		{
//.........这里部分代码省略.........

	DomNode DomDocument::import_node(const DomNode &node, bool deep)
	{
		DomNode imported_node;
		switch (node.get_node_type())
		{
		case NULL_NODE:
			return imported_node;
		case ELEMENT_NODE:
			imported_node = create_element_ns(node.get_namespace_uri(), node.get_node_name());
			break;
		case ATTRIBUTE_NODE:
			imported_node = create_attribute_ns(node.get_namespace_uri(), node.get_node_name());
			imported_node.set_node_value(node.get_node_value());
			break;
		case TEXT_NODE:
			imported_node = create_text_node(node.get_node_value());
			break;
		case CDATA_SECTION_NODE:
			imported_node = create_cdata_section(node.get_node_value());
			break;
		case ENTITY_REFERENCE_NODE:
			imported_node = create_entity_reference(node.get_node_name());
			break;
		case ENTITY_NODE:
			return imported_node;
		case PROCESSING_INSTRUCTION_NODE:
			imported_node = create_processing_instruction(node.to_processing_instruction().get_target(), node.to_processing_instruction().get_data());
			break;
		case COMMENT_NODE:
			imported_node = create_comment(node.get_node_value());
			break;
		case DOCUMENT_NODE:
			imported_node = create_document_fragment();
			break;
		case DOCUMENT_TYPE_NODE:
			return imported_node;
		case DOCUMENT_FRAGMENT_NODE:
			imported_node = create_document_fragment();
			break;
		case NOTATION_NODE:
			return imported_node;
		}

		if (node.is_element())
		{
			DomElement import_element = imported_node.to_element();
			DomNamedNodeMap node_attributes = node.get_attributes();
			int size = node_attributes.get_length();
			for (int index = 0; index < size; index++)
			{
				DomNode attr = node_attributes.item(index);
				import_element.set_attribute_node_ns(import_node(attr, deep).to_attr());
			}
		}

		if (deep)
		{
			DomNode cur = node.get_first_child();
			while (!cur.is_null())
			{
				imported_node.append_child(import_node(cur, true));
				cur = cur.get_next_sibling();
			}
		}

		return imported_node;
	}

XMLResourceNode XMLResourceDocument::create_resource(const std::string &resource_id, const std::string &type)
{
	if (resource_exists(resource_id))
		throw Exception(string_format("Resource %1 already exists", resource_id));

	std::vector<std::string> path_elements = PathHelp::split_basepath(resource_id);
	std::string name = PathHelp::get_filename(resource_id);

	// Walk tree as deep as we can get:
	DomNode parent = impl->document.get_document_element();
	DomNode cur = parent.get_first_child();
	auto path_it = path_elements.begin();
	while (!cur.is_null() && path_it != path_elements.end())
	{
		if (cur.is_element() &&
			cur.get_namespace_uri() == impl->ns_resources &&
			cur.get_local_name() == "section")
		{
			DomElement element = cur.to_element();
			std::string name = element.get_attribute_ns(impl->ns_resources, "name");
			if (name == *path_it)
			{
				++path_it;
				parent = cur;
				cur = cur.get_first_child();
				continue;
			}
		}
		cur = cur.get_next_sibling();
	}

	// Create any missing parent nodes:
	std::string prefix = parent.get_prefix();
	while (path_it != path_elements.end())
	{
		DomElement section;
		if (prefix.empty())
		{
			section = impl->document.create_element_ns( impl->ns_resources, (*path_it) );
		}
		else
		{
			section = impl->document.create_element_ns( impl->ns_resources,(prefix + ":" + *path_it));
		}
		parent.append_child(section);
		parent = section;
		++path_it;
	}

	// Create node:
	DomElement resource_node;
	if (prefix.empty())
	{
		resource_node = impl->document.create_element_ns( impl->ns_resources, (type));
	}
	else
	{
		resource_node = impl->document.create_element_ns( impl->ns_resources,(prefix + ":" + type));
	}

	resource_node.set_attribute_ns(
		impl->ns_resources,
		prefix.empty() ? "name" : (prefix + ":name"),
		name);
	parent.append_child(resource_node);

	// Create resource:
	impl->resources[resource_id] = XMLResourceNode(resource_node, *this);
	return impl->resources[resource_id];
}