SerializableXmlReader00.cpp

Go to the documentation of this file.

/*
 * 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 3 of the License, or
 * (at your option) any later version.
 *
 * Written (W) 2010 Soeren Sonnenburg
 * Copyright (C) 2010 Berlin Institute of Technology
 */

#include <shogun/lib/config.h>
#ifdef HAVE_XML

#include <shogun/lib/common.h>
#include <shogun/io/SerializableXmlReader00.h>

using namespace shogun;

SerializableXmlReader00::SerializableXmlReader00(
    CSerializableXmlFile* file) { m_file = file; }

SerializableXmlReader00::~SerializableXmlReader00() {}

bool
SerializableXmlReader00::read_scalar_wrapped(
    const TSGDataType* type, void* param)
{
    xmlNode* m = m_file->m_stack_stream.back();

    bool result = true;
    xmlChar* xml_buf;
    if ((xml_buf = xmlNodeGetContent(m)) == NULL) return false;
    const char* buf = (const char*) xml_buf;

    switch (type->m_ptype) {
    case PT_BOOL:
        string_t bool_buf;

        if (sscanf(buf, "%" STRING_LEN_STR "s", bool_buf) != 1)
            result = false;

        if (strcmp(buf, STR_TRUE) == 0) *(bool*) param = true;
        else if (strcmp(buf, STR_FALSE) == 0) *(bool*) param = false;
        else result = false;

        break;
    case PT_CHAR:
        if (sscanf(buf, "%c", (char*) param) != 1)
            result = false;
        break;
    case PT_INT8:
        if (sscanf(buf, "%" SCNi8, (int8_t*) param) != 1)
            result = false;
        break;
    case PT_UINT8:
        if (sscanf(buf, "%" SCNu8, (uint8_t*) param) != 1)
            result = false;
        break;
    case PT_INT16:
        if (sscanf(buf, "%" SCNi16, (int16_t*) param) != 1)
            result = false;
        break;
    case PT_UINT16:
        if (sscanf(buf, "%" SCNu16, (uint16_t*) param) != 1)
            result = false;
        break;
    case PT_INT32:
        if (sscanf(buf, "%" SCNi32, (int32_t*) param) != 1)
            result = false;
        break;
    case PT_UINT32:
        if (sscanf(buf, "%" SCNu32, (uint32_t*) param) != 1)
            result = false;
        break;
    case PT_INT64:
        if (sscanf(buf, "%" SCNi64, (int64_t*) param) != 1)
            result = false;
        break;
    case PT_UINT64:
        if (sscanf(buf, "%" SCNu64, (uint64_t*) param) != 1)
            result = false;
        break;
    case PT_FLOAT32:
        result = CMath::strtof(buf, (float32_t*) param);
        break;
    case PT_FLOAT64:
        result = CMath::strtod(buf, (float64_t*) param);
        break;
    case PT_FLOATMAX:
        result = CMath::strtold(buf, (floatmax_t*) param);
        break;
    case PT_COMPLEX128:
        float64_t c_real, c_imag;
        if (sscanf(buf, "(%lg,%lg)", &c_real, &c_imag) != 2)
            result = false;
#if defined(HAVE_CXX0X) || defined(HAVE_CXX11) || defined(_LIBCPP_VERSION)
        ((complex128_t*) param)->real(c_real);
        ((complex128_t*) param)->imag(c_imag);
#else
        ((complex128_t*) param)->real()=c_real;
        ((complex128_t*) param)->imag()=c_imag;
#endif
        break;
    case PT_UNDEFINED:
    case PT_SGOBJECT:
        SG_ERROR("read_scalar_wrapped(): Implementation error during"
                 " reading XmlFile!");
        result = false;
    }

    xmlFree(xml_buf);
    return result;
}

bool
SerializableXmlReader00::read_cont_begin_wrapped(
    const TSGDataType* type, index_t* len_read_y, index_t* len_read_x)
{
    xmlNode* m = m_file->m_stack_stream.back();

    switch (type->m_ctype) {
    case CT_NDARRAY:
        SG_NOTIMPLEMENTED
    case CT_SCALAR: break;
    case CT_VECTOR: case CT_SGVECTOR:
        *len_read_y = xmlChildElementCount(m);
        break;
    case CT_MATRIX: case CT_SGMATRIX:
        *len_read_x = xmlChildElementCount(m);

        for (xmlNode* cur=m->children; cur != NULL; cur=cur->next) {
            if (cur->type != XML_ELEMENT_NODE) continue;

            if (*len_read_y == 0)
                *len_read_y = xmlChildElementCount(cur);

            if (*len_read_y != (index_t) xmlChildElementCount(cur))
                return false;
        }
        break;
    case CT_UNDEFINED:
        SG_ERROR("type undefined\n");
    }

    return true;
}

bool
SerializableXmlReader00::read_cont_end_wrapped(
    const TSGDataType* type, index_t len_read_y, index_t len_read_x)
{
    if (len_read_y > 0) m_file->pop_node();

    if (type->m_ctype==CT_MATRIX || type->m_ctype==CT_SGMATRIX)
    {
        if (len_read_y*len_read_x>0)
            m_file->pop_node();
    }

    return true;
}

bool
SerializableXmlReader00::read_string_begin_wrapped(
    const TSGDataType* type, index_t* length)
{
    xmlNode* m = m_file->m_stack_stream.back();

    *length = xmlChildElementCount(m);

    return true;
}

bool
SerializableXmlReader00::read_string_end_wrapped(
    const TSGDataType* type, index_t length)
{
    if (length > 0) m_file->pop_node();

    return true;
}

bool
SerializableXmlReader00::read_stringentry_begin_wrapped(
    const TSGDataType* type, index_t y)
{
    if (y == 0) {
        if (!m_file->join_node(BAD_CAST STR_STRING)) return false;
        return true;
    }

    if (!m_file->next_node(BAD_CAST STR_STRING)) return false;

    return true;
}

bool
SerializableXmlReader00::read_stringentry_end_wrapped(
    const TSGDataType* type, index_t y)
{
    return true;
}

bool
SerializableXmlReader00::read_sparse_begin_wrapped(
    const TSGDataType* type, index_t* length)
{
    return true;
}

bool
SerializableXmlReader00::read_sparse_end_wrapped(
    const TSGDataType* type, index_t length)
{
    if (length > 0) m_file->pop_node();

    return true;
}

bool
SerializableXmlReader00::read_sparseentry_begin_wrapped(
    const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
    index_t* feat_index, index_t y)
{
    bool result = true;
    xmlChar* buf;

    if (y == 0) {
        if (!m_file->join_node(BAD_CAST STR_SPARSE)) return false;
    } else {
        if (!m_file->next_node(BAD_CAST STR_SPARSE)) return false;
    }

    if ((buf = xmlGetProp(m_file->m_stack_stream.back(), BAD_CAST
                          STR_PROP_FEATINDEX)) == NULL) return false;
    if (sscanf((const char*) buf, "%" PRIi32, feat_index) != 1)
        result = false;
    xmlFree(buf); if (!result) return false;

    return true;
}

bool
SerializableXmlReader00::read_sparseentry_end_wrapped(
    const TSGDataType* type, SGSparseVectorEntry<char>* first_entry,
    index_t* feat_index, index_t y)
{
    return true;
}

bool
SerializableXmlReader00::read_item_begin_wrapped(
    const TSGDataType* type, index_t y, index_t x)
{
    switch (type->m_ctype) {
    case CT_NDARRAY:
        SG_NOTIMPLEMENTED
    case CT_SCALAR: break;
    case CT_VECTOR: case CT_SGVECTOR:
        if (y == 0) {
            if (!m_file->join_node(BAD_CAST STR_ITEM)) return false;
            return true;
        }
        break;
    case CT_MATRIX: case CT_SGMATRIX:
        if (y==0)
        {
            if (x != 0) { m_file->pop_node(); m_file->pop_node(); }

            string_t buf_x; snprintf(buf_x, STRING_LEN, "x%" PRIi32, x);
            if (!m_file->join_node(BAD_CAST buf_x)) return false;
            if (!m_file->join_node(BAD_CAST STR_ITEM)) return false;
            return true;
        }
        break;
    case CT_UNDEFINED:
        SG_ERROR("type undefined\n");
    }

    if (!m_file->next_node(BAD_CAST STR_ITEM)) return false;

    return true;
}

bool
SerializableXmlReader00::read_item_end_wrapped(
    const TSGDataType* type, index_t y, index_t x)
{
    return true;
}

bool
SerializableXmlReader00::read_sgserializable_begin_wrapped(
    const TSGDataType* type, char* sgserializable_name,
    EPrimitiveType* generic)
{
    xmlNode* m = m_file->m_stack_stream.back();
    xmlChar* buf;

    if ((buf = xmlGetProp(m, BAD_CAST STR_PROP_IS_NULL)) != NULL) {
        xmlFree(buf);
        *sgserializable_name = '\0';
        return true;
    }

    if ((buf = xmlGetProp(m, BAD_CAST STR_PROP_INSTANCE_NAME)) == NULL)
        return false;
    strncpy(sgserializable_name, (const char*) buf, STRING_LEN);
    xmlFree(buf);

    if ((buf = xmlGetProp(m, BAD_CAST STR_PROP_GENERIC_NAME))
        != NULL) {
        if (!TSGDataType::string_to_ptype(generic, (const char*) buf))
            return false;
        xmlFree(buf);
    }

    return true;
}

bool
SerializableXmlReader00::read_sgserializable_end_wrapped(
    const TSGDataType* type, const char* sgserializable_name,
    EPrimitiveType generic)
{
    return true;
}

bool
SerializableXmlReader00::read_type_begin_wrapped(
    const TSGDataType* type, const char* name, const char* prefix)
{
    bool result = true;

    SG_SET_LOCALE_C;

    if (!m_file->join_node(BAD_CAST name)) return false;

    string_t buf; type->to_string(buf, STRING_LEN);
    xmlChar* t;
    if ((t = xmlGetProp(m_file->m_stack_stream.back(),
                        BAD_CAST STR_PROP_TYPE)) == NULL) return false;
    if (xmlStrcmp(BAD_CAST buf, t) != 0) result = false;
    xmlFree(t); if (!result) return false;

    return true;
}

bool
SerializableXmlReader00::read_type_end_wrapped(
    const TSGDataType* type, const char* name, const char* prefix)
{
    m_file->pop_node();

    SG_RESET_LOCALE;

    return true;
}

#endif /* HAVE_XML  */