170 lines
3.3 KiB
C
170 lines
3.3 KiB
C
/**
|
|
* @file xml.c
|
|
*
|
|
* @brief Implementation of xml_t.
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2007 Martin Willi
|
|
* Hochschule fuer Technik Rapperswil
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the
|
|
* Free Software Foundation; either version 2 of the License, or (at your
|
|
* option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>.
|
|
*
|
|
* This program 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 General Public License
|
|
* for more details.
|
|
*/
|
|
|
|
#include "xml.h"
|
|
|
|
#include <libxml/parser.h>
|
|
#include <libxml/tree.h>
|
|
|
|
|
|
typedef struct private_xml_t private_xml_t;
|
|
|
|
/**
|
|
* private data of xml
|
|
*/
|
|
struct private_xml_t {
|
|
|
|
/**
|
|
* public functions
|
|
*/
|
|
xml_t public;
|
|
|
|
/**
|
|
* root node of this xml (part)
|
|
*/
|
|
xmlNode *node;
|
|
|
|
/**
|
|
* document, only for root xml_t
|
|
*/
|
|
xmlDoc *doc;
|
|
|
|
/**
|
|
* Root xml_t*
|
|
*/
|
|
private_xml_t *root;
|
|
|
|
/**
|
|
* number of enumerator instances
|
|
*/
|
|
int enums;
|
|
};
|
|
|
|
/**
|
|
* child element enumerator
|
|
*/
|
|
typedef struct {
|
|
/** enumerator interface */
|
|
enumerator_t e;
|
|
/** current child context (returned to enumerate() caller) */
|
|
private_xml_t child;
|
|
/** currently processing node */
|
|
xmlNode *node;
|
|
} child_enum_t;
|
|
|
|
/**
|
|
* Implementation of xml_t.children().enumerate().
|
|
*/
|
|
static bool child_enumerate(child_enum_t *e, private_xml_t **child,
|
|
char **name, char **value)
|
|
{
|
|
while (e->node && e->node->type != XML_ELEMENT_NODE)
|
|
{
|
|
e->node = e->node->next;
|
|
}
|
|
if (e->node)
|
|
{
|
|
xmlNode *text;
|
|
|
|
text = e->node->children;
|
|
*value = NULL;
|
|
|
|
while (text && text->type != XML_TEXT_NODE)
|
|
{
|
|
text = text->next;
|
|
}
|
|
if (text)
|
|
{
|
|
*value = text->content;
|
|
}
|
|
*name = (char*)e->node->name;
|
|
*child = &e->child;
|
|
e->child.node = e->node->children;
|
|
e->node = e->node->next;
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* Implementation of xml_t.get_attribute.
|
|
*/
|
|
static char* get_attribute(private_xml_t *this, char *name)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* destroy enumerator, and complete tree if this was the last enumerator
|
|
*/
|
|
static void child_destroy(child_enum_t *this)
|
|
{
|
|
if (--this->child.root->enums == 0)
|
|
{
|
|
xmlFreeDoc(this->child.root->doc);
|
|
free(this->child.root);
|
|
}
|
|
free(this);
|
|
}
|
|
|
|
/**
|
|
* Implementation of xml_t.children.
|
|
*/
|
|
static enumerator_t* children(private_xml_t *this)
|
|
{
|
|
child_enum_t *ce = malloc_thing(child_enum_t);
|
|
ce->e.enumerate = (void*)child_enumerate;
|
|
ce->e.destroy = (void*)child_destroy;
|
|
ce->node = this->node;
|
|
ce->child.public.children = (void*)children;
|
|
ce->child.public.get_attribute = (void*)get_attribute;
|
|
ce->child.node = NULL;
|
|
ce->child.doc = this->doc;
|
|
ce->child.root = this->root;
|
|
this->root->enums++;
|
|
return &ce->e;
|
|
}
|
|
|
|
/*
|
|
* see header file
|
|
*/
|
|
xml_t *xml_create(char *xml)
|
|
{
|
|
private_xml_t *this = malloc_thing(private_xml_t);
|
|
|
|
this->public.get_attribute = (char*(*)(xml_t*,char*))get_attribute;
|
|
this->public.children = (enumerator_t*(*)(xml_t*))children;
|
|
|
|
this->doc = xmlReadMemory(xml, strlen(xml), NULL, NULL, 0);
|
|
if (this->doc == NULL)
|
|
{
|
|
free(this);
|
|
return NULL;
|
|
}
|
|
this->node = xmlDocGetRootElement(this->doc);
|
|
this->root = this;
|
|
this->enums = 0;
|
|
|
|
return &this->public;
|
|
}
|
|
|