gboolean
xml_reader_move_to_element (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (xmlTextReaderMoveToElement (reader->xml) == 1);
}
xmlReaderTypes
xml_reader_get_node_type (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), 0);
return xmlTextReaderNodeType (reader->xml);
}
gboolean
xml_reader_is_empty_element (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return xmlTextReaderIsEmptyElement (reader->xml);
}
gint
xml_reader_get_depth (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER(reader), -1);
return xmlTextReaderDepth (reader->xml);
}
gboolean
xml_reader_move_to_next_attribute (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (xmlTextReaderMoveToNextAttribute (reader->xml) == 1);
}
gboolean
xml_reader_read (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (xmlTextReaderRead (reader->xml) == 1);
}
gint
xml_reader_count_attributes (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return xmlTextReaderAttributeCount (reader->xml);
}
/**
* xml_reader_load_from_file:
* @reader: a #XmlReader
* @filename: the full path to an XML file
* @error: return location for a #GError, or %NULL
*
* Loads an XML file at @filename into @reader and sets the #XmlReader
* to be ready to walk the XML document object model.
*
* See also xml_reader_load_from_file().
*
* Return value: %TRUE if the file was successfully loaded.
*/
gboolean
xml_reader_load_from_file (XmlReader *reader,
const gchar *filename,
GError **error)
{
XmlReaderPrivate *priv;
GError *internal_error;
gchar *buffer;
gboolean retval;
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
g_return_val_if_fail (filename != NULL, FALSE);
priv = reader->priv;
internal_error = NULL;
if (!g_file_get_contents (filename, &buffer, NULL, &internal_error))
{
g_propagate_error (error, internal_error);
return FALSE;
}
g_free (priv->filename);
priv->is_filename = TRUE;
priv->filename = g_strdup (filename);
retval = xml_reader_load_from_data (reader, buffer, &internal_error);
if (!retval)
g_propagate_error (error, internal_error);
g_free (buffer);
return retval;
}
gchar*
xml_reader_read_outer_xml (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
RETURN_STRDUP_AND_XMLFREE (xmlTextReaderReadOuterXml (reader->xml));
}
/**
* xml_reader_count_attributes:
* @reader: a #XmlReader
*
* Counts the attributes on the current element.
*
* Return value: the number of elements, or -1 on failure
*/
gint
xml_reader_count_attributes (XmlReader *reader)
{
XmlReaderPrivate *priv;
xmlAttrPtr attr;
gint count;
g_return_val_if_fail (XML_IS_READER (reader), -1);
if (xml_reader_get_error (reader, NULL))
return -1;
priv = reader->priv;
if (!priv->node_cursor)
return -1;
if (!xml_reader_has_attributes (reader))
return 0;
count = 0;
for (attr = priv->node_cursor->properties; attr != NULL; attr = attr->next)
count += 1;
return count;
}
static gboolean
read_to_type_and_name (XmlReader *reader,
gint type,
const gchar *name)
{
gboolean success = FALSE;
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
g_return_val_if_fail (reader->xml != NULL, FALSE);
while (xmlTextReaderRead (reader->xml) == 1)
{
if (xmlTextReaderNodeType (reader->xml) == type)
{
if (g_strcmp0 (XML_TO_CHAR (xmlTextReaderConstName (reader->xml)), name) == 0)
{
success = TRUE;
break;
}
}
}
return success;
}
/**
* xml_reader_read_attribute_name:
* @reader: a #XmlReader
* @attribute_name: the name of the attribute to read
*
* Moves the internal cursor to the @attribute_name of the current
* element inside the XML document object model:
*
* |[
* /* inspect "node" */
* xml_reader_read_start_element (reader, "node");
*
* /* inspect the node attributes */
* xml_reader_read_attribute_name (reader, "role");
* role = g_strdup (xml_reader_get_attribute_value (reader));
* xml_reader_read_attribute_name (reader, "direction");
* direction = g_strdup (xml_reader_get_attribute_value (reader));
*
* /* retrieve the node content */
* node = g_strdup (xml_reader_get_element_value (reader));
*
* xml_reader_read_end_element (reader);
*
* g_print ("Node has role of '%s' and direction '%s': %s\n",
* role, direction, node);
*
* g_free (role);
* g_free (direction);
* g_free (node);
* ]|
*
* Return value: %TRUE if the attribute was found
*/
gboolean
xml_reader_read_attribute_name (XmlReader *reader,
const gchar *attribute_name)
{
XmlReaderPrivate *priv;
xmlAttrPtr attr;
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
g_return_val_if_fail (attribute_name != NULL, FALSE);
priv = reader->priv;
if (!priv->node_cursor)
return FALSE;
if (!xml_reader_has_attributes (reader))
return FALSE;
for (attr = priv->node_cursor->properties;
attr != NULL;
attr = attr->next)
{
if (strcmp (XML_TO_CHAR (attr->name), attribute_name) == 0)
{
priv->attr_cursor = attr;
priv->attr_value = xmlGetProp (priv->node_cursor, attr->name);
return TRUE;
}
}
return FALSE;
}
gboolean
xml_reader_load_from_stream (XmlReader *reader,
GInputStream *stream,
GError **error)
{
g_return_val_if_fail (XML_IS_READER(reader), FALSE);
xml_reader_clear (reader);
reader->xml = xmlReaderForIO (xml_reader_io_read_cb,
xml_reader_io_close_cb,
stream,
reader->uri,
reader->encoding,
XML_PARSE_RECOVER | XML_PARSE_NOBLANKS | XML_PARSE_COMPACT);
if (!reader->xml)
{
g_set_error (error,
XML_READER_ERROR,
XML_READER_ERROR_INVALID,
_("Could not parse XML from stream"));
return FALSE;
}
reader->stream = g_object_ref (stream);
xmlTextReaderSetErrorHandler (reader->xml, xml_reader_error_cb, reader);
return TRUE;
}
G_CONST_RETURN gchar *
xml_reader_get_local_name (XmlReader *reader)
{
g_return_val_if_fail(XML_IS_READER (reader), NULL);
return XML_TO_CHAR (xmlTextReaderConstLocalName (reader->xml));
}
/**
* xml_writer_write_attributes:
* @writer: A #XmlWriter
* @reader: A #XmlReader
*
* Writes the attributes found at the current position of @reader.
*/
void
xml_writer_write_attributes (XmlWriter *writer,
XmlReader *reader)
{
XmlWriterPrivate *priv;
const gchar *name;
const gchar *value;
gint count;
gint i;
g_return_if_fail (XML_IS_WRITER (writer));
g_return_if_fail (XML_IS_READER (reader));
priv = writer->priv;
count = xml_reader_count_attributes (reader);
for (i = 0; i < count; i++)
{
xml_reader_read_attribute_pos (reader, i);
name = xml_reader_get_attribute_name (reader);
value = xml_reader_get_attribute_value (reader);
xml_writer_write_attribute_string (writer, name, value);
}
}
gchar *
xml_reader_read_string (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), NULL);
g_return_val_if_fail (reader->xml != NULL, NULL);
RETURN_STRDUP_AND_XMLFREE (xmlTextReaderReadString (reader->xml));
}
gboolean
xml_reader_is_namespace (XmlReader *reader,
const gchar *ns)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (g_strcmp0 (XML_TO_CHAR(xmlTextReaderConstNamespaceUri (reader->xml)), ns) == 0);
}
static void
xml_reader_set_uri (XmlReader *reader,
const gchar *uri)
{
g_return_if_fail (XML_IS_READER (reader));
g_free (reader->uri);
reader->uri = g_strdup (uri);
}
gboolean
xml_reader_move_to_nth_attribute (XmlReader *reader,
gint nth)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (xmlTextReaderMoveToAttributeNo (reader->xml, nth) == 1);
}
static void
xml_reader_set_encoding (XmlReader *reader,
const gchar *encoding)
{
g_return_if_fail (XML_IS_READER (reader));
g_free (reader->encoding);
reader->encoding = g_strdup (encoding);
}
gboolean
xml_reader_move_to_attribute (XmlReader *reader,
const gchar *name)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (xmlTextReaderMoveToAttribute (reader->xml, CHAR_TO_XML (name)) == 1);
}
G_CONST_RETURN gchar *
xml_reader_get_value (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), NULL);
g_return_val_if_fail (reader->xml != NULL, NULL);
return XML_TO_CHAR (xmlTextReaderConstValue (reader->xml));
}
gchar *
xml_reader_get_attribute (XmlReader *reader,
const gchar *name)
{
g_return_val_if_fail (XML_IS_READER (reader), NULL);
g_return_val_if_fail (reader->xml != NULL, NULL);
RETURN_STRDUP_AND_XMLFREE (xmlTextReaderGetAttribute (reader->xml, CHAR_TO_XML (name)));
}
gboolean
xml_reader_read_to_next_sibling (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
xmlTextReaderMoveToElement (reader->xml);
return (xmlTextReaderNextSibling (reader->xml) == 1);
}
void
xml_reader_move_up_to_depth (XmlReader *reader,
gint depth)
{
g_return_if_fail(XML_IS_READER(reader));
while (xml_reader_get_depth(reader) > depth)
xml_reader_read_end_element(reader);
}
gint
xml_reader_get_line_number (XmlReader *reader)
{
g_return_val_if_fail(XML_IS_READER(reader), -1);
if (reader->xml)
return xmlTextReaderGetParserLineNumber(reader->xml);
return -1;
}
/**
* xml_reader_get_attribute_value:
* @reader: a #XmlReader
*
* Retrieves the value of the currently read attribute.
*
* Return value: the content of the attribute, or %NULL
*/
G_CONST_RETURN gchar *
xml_reader_get_attribute_value (XmlReader *reader)
{
XmlReaderPrivate *priv;
g_return_val_if_fail (XML_IS_READER (reader), NULL);
priv = reader->priv;
return XML_TO_CHAR (priv->attr_value);
}
/**
* xml_reader_read_end_element:
* @reader: a #XmlReader
*
* Positions the internal cursor at the end of the current element
*/
void
xml_reader_read_end_element (XmlReader *reader)
{
XmlReaderPrivate *priv;
g_return_if_fail (XML_IS_READER (reader));
priv = reader->priv;
/* if we are in error state, end-element will unset the
* error state
*/
if (xml_reader_get_error (reader, NULL))
{
priv->error_state = FALSE;
priv->node_cursor = priv->parent;
if (!priv->node_cursor)
{
priv->node_cursor = priv->current_doc->xmlRootNode;
priv->parent = NULL;
}
else
priv->parent = priv->node_cursor->parent;
return;
}
if (!priv->node_cursor)
{
g_warning ("No cursor set");
return;
}
if (priv->cursor_value)
{
xmlFree (priv->cursor_value);
priv->cursor_value = NULL;
}
if (priv->attr_value)
{
xmlFree (priv->attr_value);
priv->attr_value = NULL;
}
priv->depth -= 1;
priv->node_cursor = priv->parent;
priv->parent = priv->parent ? priv->parent->parent : NULL;
if (!priv->node_cursor)
priv->node_cursor = priv->current_doc->xmlRootNode;
priv->attr_cursor = NULL;
}
gboolean
xml_reader_read_end_element (XmlReader *reader)
{
gboolean success = FALSE;
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
if (reader->cur_name)
success = read_to_type_and_name (reader, XML_NODE_TYPE_END_ELEMENT, reader->cur_name);
return success;
}
static void
xml_reader_error_cb (void *arg,
const char *msg,
xmlParserSeverities severity,
xmlTextReaderLocatorPtr locator)
{
XmlReader *reader = arg;
g_assert (XML_IS_READER (reader));
g_signal_emit (reader, signals [ERROR], 0, msg);
}
