.. _program_listing_file_src_rdf4cpp_IRIView.hpp:

Program Listing for File IRIView.hpp
====================================

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

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

.. code-block:: cpp

   #ifndef RDF4CPP_IRIVIEW_HPP
   #define RDF4CPP_IRIVIEW_HPP
   
   #include <format>
   #include <optional>
   #include <string>
   #include <string_view>
   
   namespace rdf4cpp {
   enum struct IRIFactoryError {
       Ok,
       UnknownPrefix,
       Relative,
       InvalidScheme,
       InvalidUserinfo,
       InvalidHost,
       InvalidPort,
       InvalidPath,
       InvalidQuery,
       InvalidFragment,
       InvalidPrefix,
   };
   
   struct IRIView {
   private:
       std::string_view data;
   
   public:
       explicit IRIView(std::string_view iri) noexcept;
   
   private:
       struct IRIPart {
           size_t start, len;
           bool defined;
       };
   
       [[nodiscard]] IRIPart get_scheme_part() const noexcept;
       [[nodiscard]] IRIPart get_authority_part(const IRIPart &scheme) const noexcept;
       [[nodiscard]] IRIPart get_path_part(const IRIPart &auth) const noexcept;
       [[nodiscard]] IRIPart get_query_part(const IRIPart &path) const noexcept;
       [[nodiscard]] IRIPart get_fragment_part(const IRIPart &query) const noexcept;
   
       [[nodiscard]] IRIPart get_userinfo_part(const IRIPart& auth) const noexcept;
       [[nodiscard]] IRIPart get_host_part(const IRIPart& auth, const IRIPart& uinfo) const noexcept;
       [[nodiscard]] IRIPart get_port_part(const IRIPart& auth, const IRIPart& host) const noexcept;
   
       [[nodiscard]] std::string_view apply(const IRIPart &r) const noexcept;
       [[nodiscard]] std::optional<std::string_view> apply_opt(const IRIPart &r) const noexcept;
   
   public:
       [[nodiscard]] bool is_relative() const noexcept;
       [[nodiscard]] std::optional<std::string_view> scheme() const noexcept;
       [[nodiscard]] std::optional<std::string_view> authority() const noexcept;
       [[nodiscard]] std::string_view path() const noexcept;
       [[nodiscard]] std::optional<std::string_view> query() const noexcept;
       [[nodiscard]] std::optional<std::string_view> fragment() const noexcept;
   
       struct AllParts {
           std::optional<std::string_view> scheme;
           std::optional<std::string_view> authority;
           std::string_view path;
           std::optional<std::string_view> query;
           std::optional<std::string_view> fragment;
       };
       [[nodiscard]] AllParts all_parts() const noexcept;
   
       [[nodiscard]] std::string_view to_absolute() const noexcept;
   
       [[nodiscard]] std::optional<std::string_view> userinfo() const noexcept;
       [[nodiscard]] std::optional<std::string_view> host() const noexcept;
       [[nodiscard]] std::optional<std::string_view> port() const noexcept;
   
       struct AuthorityParts {
           std::optional<std::string_view> userinfo, host, port;
       };
       [[nodiscard]] AuthorityParts all_authority_parts() const noexcept;
   
       [[nodiscard]] IRIFactoryError quick_validate(bool allow_relative = false) const noexcept;
   };
   }
   
   template<>
   struct std::formatter<rdf4cpp::IRIFactoryError> : std::formatter<string_view> {
       auto format(rdf4cpp::IRIFactoryError p, format_context& ctx) const {
           std::string_view s{};
           switch (p) {
               case rdf4cpp::IRIFactoryError::Ok:
                   s = "Ok";
                   break;
               case rdf4cpp::IRIFactoryError::UnknownPrefix:
                   s = "UnknownPrefix";
                   break;
               case rdf4cpp::IRIFactoryError::Relative:
                   s = "Relative";
                   break;
               case rdf4cpp::IRIFactoryError::InvalidScheme:
                   s = "InvalidScheme";
                   break;
               case rdf4cpp::IRIFactoryError::InvalidUserinfo:
                   s = "InvalidUserinfo";
                   break;
               case rdf4cpp::IRIFactoryError::InvalidHost:
                   s = "InvalidHost";
                   break;
               case rdf4cpp::IRIFactoryError::InvalidPort:
                   s = "InvalidPort";
                   break;
               case rdf4cpp::IRIFactoryError::InvalidPath:
                   s = "InvalidPath";
                   break;
               case rdf4cpp::IRIFactoryError::InvalidQuery:
                   s = "InvalidQuery";
                   break;
               case rdf4cpp::IRIFactoryError::InvalidFragment:
                   s = "InvalidFragment";
                   break;
               default:
                   s = "Unknown";
                   break;
           }
           return std::formatter<std::string_view>::format(s, ctx);
       }
   };
   
   #endif  //RDF4CPP_IRIVIEW_HPP