xmlFile.hpp

Go to the documentation of this file.

#ifndef IV_SRC_FILEHANDLERS_XMLFILE_HPP_
#define IV_SRC_FILEHANDLERS_XMLFILE_HPP_
 
#include "core/assert.hpp"
#include "core/defines.hpp"
#include "third_party/pugiXML/pugixml.hpp"
 
#include <limits>
#include <vector>
 
namespace iv::file::xml
{
 
class node : public pugi::xml_node
{
public:
    node() = default;
    // ReSharper disable once CppNonExplicitConvertingConstructor
    node(const pugi::xml_node &_node);
    node(const node &other) = default;
    node(node &&other) = default;
    ~node() = default;
 
    node &operator=(const node &other) = default;
    node &operator=(node &&other) = default;
 
    [[nodiscard]] bool emptyNode() const;
    [[nodiscard]] bool isNull() const;
 
    void removeAttributes();
 
    template<typename T>
    T getAttribute(const std::string_view key, T defaultValue) const
    {
        auto attr = pugi::xml_node::attribute(key.data());
 
        if constexpr (std::is_same_v<T, double>)
        {
            return attr.as_double(defaultValue);
        }
        else if constexpr (std::is_same_v<T, float>)
        {
            return attr.as_float(defaultValue);
        }
        else if constexpr (std::is_same_v<T, int32_t> || std::is_same_v<T, int16_t> || std::is_same_v<T, int8_t>)
        {
            return attr.as_int(defaultValue);
        }
        else if constexpr (std::is_same_v<T, int64_t>)
        {
            return attr.as_llong(defaultValue);
        }
        else if constexpr (std::is_same_v<T, uint32_t> || std::is_same_v<T, uint16_t> || std::is_same_v<T, uint8_t>)
        {
            return attr.as_uint(defaultValue);
        }
        else if constexpr (std::is_same_v<T, uint64_t>)
        {
            return attr.as_ullong(defaultValue);
        }
        else if constexpr (std::is_same_v<T, bool>)
        {
            return attr.as_bool(defaultValue);
        }
        else if constexpr (std::is_same_v<T, std::string>)
        {
            return std::string(attr.as_string(defaultValue.c_str()));
        }
        else
        {
            static_assert(iv::assert::always_false<T>, "Unreachable code");
            return T {};
        }
    }
 
    template<typename T>
    bool addAttribute(const std::string_view key, T value)
    {
        pugi::xml_attribute attribute = pugi::xml_node::append_attribute(key.data());
 
        if constexpr (std::is_same_v<T, std::string>)
        {
            attribute.set_value(value.c_str());
        }
        else if constexpr (std::is_same_v<T, std::string_view>)
        {
            attribute.set_value(std::string(value).c_str());
        }
        else
        {
            attribute.set_value(value);
        }
 
        const bool inserted = attribute != nullptr;
 
        if (not inserted)
        {
            IV_ASSERT_MSG("[CFileXML] Attribute '%s' can't inserted in node '%s'.", keyName.c_str(),
                          pugi::xml_node::name());
        }
 
        return inserted;
    }
 
    void setText(const std::string_view text) const
    {
        pugi::xml_node::text().set(text.data());
    }
 
    [[nodiscard]] std::string getText() const
    {
        return pugi::xml_node::text().as_string();
    }
 
    void removeChild(std::string_view name);
    void removeChildren();
    [[nodiscard]] bool hasChild(std::string_view name) const;
    void appendNode(const iv::file::xml::node &_node);
    [[nodiscard]] iv::file::xml::node getChild(std::string_view name) const;
    [[nodiscard]] std::vector<node> getChildren() const;
    iv::file::xml::node appendChild(std::string_view name);
 
private:
    std::string m_nodeName;
};
 
class File final
{
public:
    static File fromString(std::string_view xmlString);
 
    File() = default;
    explicit File(std::string_view pathFile);
    File(const File &other) = delete;
    File(File &&other) = default;
    ~File() = default;
 
    File &operator=(const File &other) = delete;
    File &operator=(File &&other) = delete;
 
    bool read(bool checkIntegrity = true);
    [[nodiscard]] bool save();
    [[nodiscard]] bool hasChanges() const;
 
    [[nodiscard]] iv::types::timestamp lastTimeEdited() const;
 
    [[nodiscard]] iv::file::xml::node getChild(std::string_view name) const;
    iv::file::xml::node setChild(std::string_view name, std::string_view parentName = "");
 
    template<typename T>
    T getAttribute(const std::string_view node, std::string_view key, T defaultValue) const
    {
        return getChild(node).getAttribute(key, defaultValue);
    }
 
    template<typename T>
    bool addAttribute(const std::string_view node, std::string_view key, T value)
    {
        return getChild(node).addAttribute(key, value);
    }
 
    [[nodiscard]] std::string toString() const;
 
private:
    [[nodiscard]] uint16_t prvCalculateFileValidation() const;
    [[nodiscard]] bool setMetadata(uint16_t crcValue) const;
    bool prvCheckFileValidation(uint16_t crcValue) const;
 
    std::string m_pathFile;
    pugi::xml_document m_xml;
 
    struct Files
    {
        static constexpr std::string_view fileNameTmp = "/tmp/diamar_serialized.xml";
    };
 
    struct Keys
    {
        static constexpr std::string_view fileIntegrity = "FileIntegrity";
        static constexpr std::string_view lastTimeEdited = "LastTimeEdited";
        static constexpr std::string_view lastUserEdited = "LastUserEdited";
        static constexpr std::string_view lastPCEdited = "LastPCEdited";
    };
 
    struct Sections
    {
        static constexpr std::string metadata {"Metadata"};
    };
 
    struct DefaultValues
    {
        static constexpr uint64_t fileIntegrityInvalid = std::numeric_limits<uint64_t>::max();
    };
};
 
}// namespace iv::file::xml
 
#endif//IV_SRC_FILEHANDLERS_XMLFILE_HPP_