.. _program_listing_file_src_rdf4cpp_Graph.hpp:

Program Listing for File Graph.hpp
==================================

|exhale_lsh| :ref:`Return to documentation for file <file_src_rdf4cpp_Graph.hpp>` (``src/rdf4cpp/Graph.hpp``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   #ifndef RDF4CPP_GRAPH_HPP
   #define RDF4CPP_GRAPH_HPP
   
   #include <rdf4cpp/Statement.hpp>
   #include <rdf4cpp/query/TriplePattern.hpp>
   #include <rdf4cpp/query/Solution.hpp>
   #include <rdf4cpp/writer/BufWriter.hpp>
   #include <rdf4cpp/writer/SerializationState.hpp>
   #include <rdf4cpp/parser/RDFFileParser.hpp>
   #include <rdf4cpp/util/Anonymizer.hpp>
   
   #include <dice/sparse-map/sparse_set.hpp>
   
   
   namespace rdf4cpp {
   
   struct Graph {
       using value_type = Statement;
       using size_type = size_t;
       using difference_type = ptrdiff_t;
       using reference = Statement const &;
       using const_reference = reference;
       using pointer = Statement const *;
       using const_pointer = pointer;
   
   private:
       using triple = std::array<storage::identifier::NodeBackendID, 3>;
   
       struct triple_hash {
           size_t operator()(triple const &trip) const noexcept {
               return dice::hash::dice_hash_templates<dice::hash::Policies::wyhash>::dice_hash(trip);
           }
       };
   
       using triple_storage_type = dice::sparse_map::sparse_set<triple, triple_hash>;
   
   public:
       using sentinel = std::default_sentinel_t;
   
       struct iterator {
           using iterator_category = std::input_iterator_tag;
           using value_type = Statement;
           using difference_type = ptrdiff_t;
           using pointer = value_type const *;
           using reference = value_type const &;
   
       private:
           Graph const *parent_;
           typename triple_storage_type::const_iterator iter_{};
           typename triple_storage_type::const_iterator end_{};
   
           Statement cur_;
   
       public:
           iterator() noexcept = default;
           iterator(Graph const *parent, typename triple_storage_type::const_iterator beg, typename triple_storage_type::const_iterator end) noexcept;
   
           iterator &operator++() noexcept;
           void operator++(int) noexcept;
   
           reference operator*() const noexcept;
           pointer operator->() const noexcept;
   
           friend bool operator==(iterator const &self, sentinel) noexcept;
           friend bool operator==(sentinel, iterator const &self) noexcept;
       };
   
       using const_iterator = iterator;
   
       struct solution_iterator {
           using iterator_category = std::input_iterator_tag;
           using value_type = query::Solution;
           using difference_type = ptrdiff_t;
           using pointer = value_type const *;
           using reference = value_type const &;
   
       private:
           typename Graph::iterator iter_;
           query::TriplePattern pat_;
           value_type cur_;
   
           bool check_solution() noexcept;
           void forward_to_solution() noexcept;
   
       public:
           solution_iterator() noexcept = default;
           solution_iterator(typename Graph::iterator beg,
                             query::TriplePattern const &pat) noexcept;
   
           solution_iterator &operator++() noexcept;
           void operator++(int) noexcept;
           reference operator*() const noexcept;
           pointer operator->() const noexcept;
   
           friend bool operator==(solution_iterator const &self, sentinel) noexcept;
           friend bool operator==(sentinel, solution_iterator const &self) noexcept;
       };
   
       struct solution_sequence {
           using value_type = query::Solution;
           using size_type = size_t;
           using difference_type = ptrdiff_t;
           using reference = value_type const &;
           using const_reference = reference;
           using pointer = value_type const *;
           using const_pointer = pointer;
           using iterator = solution_iterator;
           using const_iterator = solution_iterator;
           using sentinel = std::default_sentinel_t;
   
       private:
           iterator beg_;
   
       public:
           explicit solution_sequence(iterator beg) noexcept : beg_{beg} {
           }
   
           [[nodiscard]] iterator begin() const noexcept {
               return beg_;
           }
   
           [[nodiscard]] static sentinel end() noexcept {
               return sentinel{};
           }
       };
   
   private:
       storage::DynNodeStoragePtr node_storage_;
       triple_storage_type triples_;
   
       static storage::identifier::NodeBackendID to_node_id(Node node) noexcept;
       static triple to_id_triple(Statement const &stmt) noexcept;
   
       [[nodiscard]] Node to_node(storage::identifier::NodeBackendID id) const noexcept;
       [[nodiscard]] Statement to_statement(triple const &t) const noexcept;
   
   public:
       explicit Graph(storage::DynNodeStoragePtr node_storage = storage::default_node_storage) noexcept;
   
       void add(Statement const &statement);
   
       [[nodiscard]] size_t size() const noexcept;
       [[nodiscard]] bool contains(Statement const &statement) const noexcept;
   
       [[nodiscard]] solution_sequence match(query::TriplePattern const &triple_pattern) const noexcept;
   
       [[nodiscard]] iterator begin() const noexcept;
       [[nodiscard]] sentinel end() const noexcept;
   
       template<typename ErrF = decltype([](parser::ParsingError) noexcept {})>
       void load_rdf_data(std::istream &rdf_file,
                          parser::ParsingFlags flags = parser::ParsingFlags::none(),
                          parser::ParsingState *state = nullptr,
                          ErrF &&errf = {}) requires std::invocable<decltype(errf), parser::ParsingError> {
   
           if (state != nullptr && state->node_storage != node_storage_) {
               throw std::invalid_argument{"NodeStorage of the parsing state must be the same as NodeStorage of the Dataset"};
           }
   
           parser::IStreamQuadIterator parser{rdf_file, flags, state};
           for (; parser != std::default_sentinel; ++parser) {
               auto const &quad = *parser;
               if (quad.has_value()) {
                   add(Statement{quad->subject(), quad->predicate(), quad->object()});
               } else {
                   std::invoke(errf, quad.error());
               }
           }
       }
   
       bool serialize(writer::BufWriterParts writer) const noexcept;
   
       bool serialize_turtle(writer::SerializationState &state, writer::BufWriterParts writer) const noexcept;
   
       bool serialize_turtle(writer::BufWriterParts writer) const noexcept;
   
       friend std::ostream &operator<<(std::ostream &os, Graph const &graph);
   
       [[nodiscard]] Graph anonymize(util::Anonymizer &anonymizer) const;
   
       // TODO: support union (+) and difference (-); open question: which graph name should be assigned?
       // TODO: add empty
   };
   }  // namespace rdf4cpp
   
   #endif  //RDF4CPP_GRAPH_HPP