OneLevelXmlOpr/src/xml_opr.cpp

#include "xml_opr.h"

CXmlOpr::CXmlOpr() = default;
CXmlOpr::~CXmlOpr() = default;

bool CXmlOpr::open(const std::string& xml_path)
{
    if (doc_.LoadFile(xml_path.c_str()) != tinyxml2::XML_SUCCESS) {
        return false;
    }
    xml_path_ = xml_path;
    return true;
}

void CXmlOpr::set_baseinfo(const OprBase& base)
{
    opr_base_ = base;
}

bool CXmlOpr::parse_xml(std::vector<tinyxml2::XMLElement*>& vec)
{
    std::string next_node{};
    std::string node_path = opr_base_.node_path;
    keys_.clear();
    auto keys = splitString(opr_base_.purpose, ",");
    for (const auto& item : keys) {
        if (item.empty()) {
            continue;
        }
        keys_.push_back(item);
    }

    auto nodes = splitString(opr_base_.node_path, "/");
    for (const auto& item : nodes) {

        if (item.empty()) {
            continue;
        }

        if (parent_node_ == nullptr) {
            parent_node_ = doc_.FirstChildElement(item.c_str());
        } else {
            parent_node_ = parent_node_->FirstChildElement(item.c_str());
        }
    }
    vec.clear();
    Element_t* purpose_node = parent_node_->FirstChildElement(opr_base_.the_node.c_str());
    while (purpose_node) {
        vec.push_back(purpose_node);
        purpose_node = purpose_node->NextSiblingElement();
    }
    return true;
}

void CXmlOpr::insert_brother_node(Element_t* brother, Element_t* newer)
{
    if (!brother || !newer) {
        return;
    }
    parent_node_->InsertAfterChild(brother, newer);
}

Element_t* CXmlOpr::copy_element(Element_t* ele)
{
    if (!ele) {
        return nullptr;
    }
    Element_t*  ret = doc_.NewElement(ele->Name());
    const auto* attribute = ele->FirstAttribute();
    while (attribute) {
        ret->SetAttribute(attribute->Name(), attribute->Value());
        attribute = attribute->Next();
    }
    return ret;
}

void CXmlOpr::del_element(Element_t* ele)
{
    parent_node_->DeleteChild(ele);
}

bool CXmlOpr::check_key_exists(const Property_t& property)
{
    if (keys_.size() < 1 || property.size() < 1) {
        return false;
    }
    Element_t* purpose_node = parent_node_->FirstChildElement(opr_base_.the_node.c_str());
    while (purpose_node) {
        const char* value = purpose_node->Attribute(keys_[0].c_str());
        if (property[0].value == std::string(value)) {
            return true;
        }
        purpose_node = purpose_node->NextSiblingElement();
    }
    return false;
}

bool CXmlOpr::save()
{
    auto ret = doc_.SaveFile(xml_path_.c_str());
    if (ret != tinyxml2::XML_SUCCESS) {
        return false;
    }
    return true;
}

void CXmlOpr::get_key_value(Element_t* ele, Property_t& vec)
{
    if (ele == nullptr) {
        return;
    }
    vec.clear();
    const auto* attribute = ele->FirstAttribute();
    while (attribute) {
        vec.emplace_back(attribute->Name(), attribute->Value());
        attribute = attribute->Next();
    }
}

void CXmlOpr::key_value_to_element(Element_t* ele, const Property_t& vec)
{
    if (ele == nullptr) {
        return;
    }
    for (const auto& data : vec) {
        ele->SetAttribute(data.key.c_str(), data.value.c_str());
    }
}

SKeyValue::SKeyValue(const char* pkey, const char* pvalue)
{
    key = std::string(pkey);
    value = std::string(pvalue);
}