XmlInterface.h

/*
 * Copyright (C) 2025, Robert Patterson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <string>
#include <memory>
#include <vector>
#include <sstream>
#include <stdexcept>
#include <algorithm>
#include <functional>
#include <type_traits>
#include <utility>
 
// Do not add header dependencies from musx.
 
namespace musx {
 
namespace factory {
class ConstructionContext;
} // factory
 
namespace xml {
 
class load_error : public std::runtime_error
{
public:
    using std::runtime_error::runtime_error;
};
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
inline std::string trim(const std::string& str)
{
    auto start = std::find_if_not(str.begin(), str.end(), ::isspace);
    auto end = std::find_if_not(str.rbegin(), str.rend(), ::isspace).base();
    return (start < end) ? std::string(start, end) : std::string();
}
#endif // DOXYGEN_SHOULD_IGNORE_THIS
 
class IXmlAttribute
{
public:
    virtual ~IXmlAttribute() = default;
 
    virtual std::string getName() const = 0;
 
    virtual std::string getValue() const = 0;
 
    std::string getValueTrimmed() const { return trim(getValue()); }
 
    template <typename T>
    T getValueAs() const {
        std::istringstream iss(getValueTrimmed());
        T value;
        if constexpr (std::is_same_v<T, bool>) {
            std::string str;
            iss >> str;
            std::transform(str.begin(), str.end(), str.begin(), ::tolower); // Ensure case insensitivity
            if (str == "true") {
                return true;
            }
            else if (str == "false") {
                return false;
            }
        }
        if (!(iss >> value)) {
            throw std::invalid_argument("Failed to convert attribute value [" + iss.str() + "] to the specified type");
        }
        return value;
    }
 
    virtual std::shared_ptr<IXmlAttribute> nextAttribute() const = 0;
};
 
class IXmlElement;
using XmlElementPtr = std::shared_ptr<IXmlElement>; 
template <typename T>
using XmlElementPopulator = std::function<void(factory::ConstructionContext&, const XmlElementPtr&, const std::shared_ptr<T>&)>; 
template <typename T>
using XmlElementDescriptor = std::tuple<const std::string_view, XmlElementPopulator<T>>; 
template <typename T>
using XmlElementArray = std::vector<XmlElementDescriptor<T>>; 
 
class IXmlElement
{
public:
    virtual ~IXmlElement() = default;
 
    virtual std::string getTagName() const = 0;
 
    virtual std::string getText() const = 0;
 
    std::string getTextTrimmed() const { return trim(getText()); }
 
    template <typename T>
    T getTextAs(T defaultValue = {}) const
    {
        static_assert(std::is_arithmetic_v<T>,
            "getTextAs requires a numeric type. Use getText for string content.");
        static_assert(!std::is_same_v<T, bool>, "Do not use getTextAs with bool type. Simply assign true. (The presence of the node means true.)");
 
        std::istringstream iss(getTextTrimmed());
        if (iss.str().empty()) {
            return defaultValue;
        }
 
        using ValueType = std::conditional_t<
                            std::is_same_v<T, char>
                            || std::is_same_v<T, uint8_t>
                            || std::is_same_v<T, char16_t>
                            || std::is_same_v<T, char32_t>, int, T>;
        ValueType value = ValueType(defaultValue);
 
        if (!(iss >> value)) {
            throw std::invalid_argument("Failed to convert text content [" + iss.str() + "] to the specified type");
        }
 
        return T(value);
    }
 
    virtual std::shared_ptr<IXmlAttribute> getFirstAttribute() const = 0;
 
    virtual std::shared_ptr<IXmlAttribute> findAttribute(const std::string& name) const = 0;
 
    virtual XmlElementPtr getFirstChildElement(const std::string& tagName = {}) const = 0;
 
    virtual XmlElementPtr getNextSibling(const std::string& tagName = {}) const = 0;
 
    virtual XmlElementPtr getPreviousSibling(const std::string& tagName = {}) const = 0;
 
    virtual XmlElementPtr getParent() const = 0;
};
 
class IXmlDocument
{
public:
    virtual ~IXmlDocument() = default;
 
    virtual void loadFromBuffer(const char * data, size_t size) = 0;
 
    virtual void loadFromString(const std::string& xmlContent) = 0;
 
    void loadFromString(const std::vector<char>& xmlContent)
    {
        loadFromBuffer(xmlContent.data(), xmlContent.size());
    }
 
    virtual std::shared_ptr<IXmlElement> getRootElement() const = 0;
};
 
} // namespace xml
} // namespace musx