xml_attributes.h

/*********************************************************************************************************************************************/
/*  DocWire SDK: Award-winning modern data processing in C++20. SourceForge Community Choice & Microsoft support. AI-driven processing.      */
/*  Supports nearly 100 data formats, including email boxes and OCR. Boost efficiency in text extraction, web data extraction, data mining,  */
/*  document analysis. Offline processing possible for security and confidentiality                                                          */
/*                                                                                                                                           */
/*  Copyright (c) SILVERCODERS Ltd, http://silvercoders.com                                                                                  */
/*  Project homepage: https://github.com/docwire/docwire                                                                                     */
/*                                                                                                                                           */
/*  SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-DocWire-Commercial                                                                  */
/*********************************************************************************************************************************************/
 
#ifndef DOCWIRE_XML_ATTRIBUTES_H
#define DOCWIRE_XML_ATTRIBUTES_H
 
#include "safety_policy.h"
#include "xml_node_ref.h"
#include "xml_attribute_ref.h"
#include "sentinel.h"
#include "checked.h"
#include "convert_base.h"
#include <algorithm>
#include <optional>
#include <ranges>

namespace docwire::xml
{

template <safety_policy safety_level = default_safety_level>
class attributes_view : public std::ranges::view_base
{
public:
    class iterator;
    iterator begin() const { return iterator{m_reader}; }
    ~attributes_view() noexcept(noexcept(m_reader.get().move_to_element()))
    {
        m_reader.get().move_to_element();
    }
    sentinel end() const { return {}; }

    explicit attributes_view(reader<safety_level>& reader) : m_reader(reader) {}
private:
    std::reference_wrapper<reader<safety_level>> m_reader;
};

template<safety_policy safety_level>
attributes_view<safety_level> attributes(const node_ref<safety_level>& node)
{
    return attributes_view<safety_level>{node.state()->xml_reader};
}

template<safety_policy safety_level>
checked<std::optional<std::string_view>, safety_level> attribute_value(const node_ref<safety_level>& node, std::string_view name)
{
    auto attrs = attributes<safety_level>(node);
    if (auto it = std::ranges::find_if(attrs, [name](const auto& attr) { return attr.name() == name; }); it != attrs.end())
        return (*it).value();
    return std::nullopt;
}

template<typename T, safety_policy safety_level>
requires convert::conversion_implementation_exists<T, std::string_view>
checked<std::optional<T>, safety_level> attribute_value(const node_ref<safety_level>& node, std::string_view name)
{
    if (auto sv = attribute_value(node, name))
        return convert::try_to<T>(*sv);
    return std::nullopt;
}

template<safety_policy safety_level>
class attributes_view<safety_level>::iterator
{
public:
    using iterator_concept  = std::input_iterator_tag;
    using difference_type   = std::ptrdiff_t;
    using value_type        = attribute_ref<safety_level>;
    using pointer           = const value_type*;
    using reference         = const value_type&;
 
    bool operator==(const sentinel&) const {
        return !m_attribute.has_value();
    }
 
    reference operator*() const {
        return *m_attribute;
    }
 
    pointer operator->() const {
        return &operator*();
    }
 
    iterator& operator++() {
        if (m_attribute.has_value() && !m_reader.get().move_to_next_attribute()) {
            m_attribute.reset();
        }
        return *this;
    }
 
    void operator++(int) {
        ++(*this);
    }
 
private:
    friend class attributes_view<safety_level>;
    explicit iterator(std::reference_wrapper<reader<safety_level>> reader)
        : m_reader(reader) {
        if (m_reader.get().move_to_first_attribute()) {
            m_attribute.emplace(m_reader.get());
        }
    }
    std::reference_wrapper<reader<safety_level>> m_reader;
    checked<std::optional<value_type>, safety_level> m_attribute; // The presence of a value indicates a valid iterator.
};
 
} // namespace docwire::xml
 
#endif // DOCWIRE_XML_ATTRIBUTES_H