kitparser.cpp

Go to the documentation of this file.

/*

    This file is part of Kitlist, a program to maintain a simple list
    of items and assign items to one or more categories.

    Copyright (C) 2008,2009 Frank Dean

    Kitlist 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.

    Kitlist 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.

    You should have received a copy of the GNU General Public License
    along with Kitlist.  If not, see <http://www.gnu.org/licenses/>.

*/

#include "kitparser.hpp"

#include <algorithm>
#include <iostream>

void KitParser::on_start_document() {
//     std::cout << "on_start_document()" << std::endl;
}


void KitParser::on_end_document() {
//     std::cout << "on_end_document()" << std::endl;
}


void KitParser::process_item(const AttributeList& attributes) {
    m_item = new ModelItem();
    xmlpp::SaxParser::AttributeList::const_iterator attribute =
        std::find_if(attributes.begin(), attributes.end(), AttributeHasName("id"));
    if (attribute != attributes.end()) {
        m_item->set_id(atol(attribute->value.c_str()));
    } else {
        std::cout << "WARNING: Missing id attribute for a item element " << std::endl;
    }
    attribute =
        std::find_if(attributes.begin(), attributes.end(), AttributeHasName("checked"));
    if (attribute != attributes.end()) {
        m_item->set_checked(attribute->value.casefold().compare("false") != 0);
    }
    m_model.add_item(m_item);
}


void KitParser::process_category(const AttributeList& attributes) {
    xmlpp::SaxParser::AttributeList::const_iterator attribute =
        std::find_if(attributes.begin(), attributes.end(), AttributeHasName("id"));
    if (attribute != attributes.end()) {
        m_category = new ModelCategory();
        m_category->set_id(atol(attribute->value.c_str()));
        m_model.add_category(m_category);
    } else {
        std::cout << "WARNING: Missing id attribute for a category element " << std::endl;
    }
}


void KitParser::process_category_item(const AttributeList& attributes) {
    xmlpp::SaxParser::AttributeList::const_iterator attribute =
        std::find_if(attributes.begin(), attributes.end(), AttributeHasName("id"));
    if (attribute != attributes.end()) {
        if (m_category != NULL) {
            ModelItem* item = m_model.find_item(atol(attribute->value.c_str()));
            if (item) {
                m_category->add_item(item);
            } else {
                std::cout << "Unable to find item id: " 
                          << attribute->value
                          << "belonging to category id: "
                          << m_category->get_id()
                          << std::endl;
            }
        }
    } else {
        std::cout << "WARNING: Missing id attribute for a category-item element " << std::endl;
    }
}


void KitParser::on_start_element(const Glib::ustring& name, const AttributeList& attributes) {
    // reset the CDATA store at the start of a new element
    m_cdata.clear();
//     std::cout << "on_start_element(): " << name << std::endl;
    if (name.compare("item")  == 0) {
        process_item(attributes);
    } else if (name.compare("category") == 0) {
        process_category(attributes);
    } else if (name.compare("category-item") == 0) {
        process_category_item(attributes);
    }
    // Attributes
//     for (xmlpp::SaxParser::AttributeList::const_iterator
//              iter = attributes.begin(); iter != attributes.end(); ++iter) {
//         std::cout << "    Attribute: " << iter->name << " = \"" << iter->value << "\"" << std::endl;
//     }
}


void KitParser::on_end_element(const Glib::ustring& name) {
//     std::cout << "on_end_element(): " << name << std::endl;
    if (name.compare("item")  == 0 && m_item != NULL && m_cdata.size() > 0) {
        m_item->set_description(m_cdata.c_str());
    } else if (name.compare("category-name") == 0 && m_category != NULL  && m_cdata.size() > 0) {
//         std::cout << "Setting category name to: " << name << std::endl;
        m_category->set_name(m_cdata.c_str());
    }
}


void KitParser::on_characters(const Glib::ustring& text) {
//     std::cout << "on_characters(): " << text << std::endl;
    m_cdata += text;
}


void KitParser::on_comment(const Glib::ustring& text) {
//     std::cout << "on_comment(): " << text << std::endl;
}


void KitParser::on_warning(const Glib::ustring& text) {
    std::cout << "on_warning(): " << text << std::endl;
}


void KitParser::on_error(const Glib::ustring& text) {
    std::cout << "on_error(): " << text << std::endl;
}


void KitParser::on_fatal_error(const Glib::ustring& text) {
    std::cout << "on_fatal_error: " << text << std::endl;
}