.. _program_listing_file_uri-template_Template.h:

Program Listing for File Template.h
===================================

|exhale_lsh| :ref:`Return to documentation for file <file_uri-template_Template.h>` (``uri-template/Template.h``)

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

.. code-block:: cpp

   #pragma once
   
   #include "Operator.h"
   #include "Variable.h"
   
   namespace URI {
   namespace Template {
   
   namespace detail { // NOLINT(readability-identifier-naming)
   template <typename...>
   struct typelist;
   }
   
   class Literal
   {
   public:
       static const std::unordered_set<char> kNotAllowedChars;
   
       Literal(std::string&& lit_string);
   
       Literal(const Literal&) = default;
       Literal& operator=(const Literal&) = default;
       Literal(Literal&&) noexcept = default;
       Literal& operator=(Literal&&) noexcept = default;
   
       ~Literal() = default;
   
       std::size_t Size() const;
   
       const std::string& String() const noexcept;
   
       bool operator==(const Literal& rhs) const;
       bool operator!=(const Literal& rhs) const;
   
   private:
       std::string lit_string_; 
   };
   
   class Expression
   {
   public:
       Expression(std::shared_ptr<Operator>&& oper, std::vector<Variable>&& variables);
   
       Expression(const Expression&) = default;
       Expression& operator=(const Expression&) = default;
       Expression(Expression&&) noexcept = default;
       Expression& operator=(Expression&&) noexcept = default;
   
       ~Expression() = default;
   
       const Operator& Oper() const;
   
       const std::vector<Variable>& Vars() const;
   
       std::string String() const noexcept;
   
       bool operator==(const Expression& rhs) const;
       bool operator!=(const Expression& rhs) const;
   
   private:
       std::shared_ptr<Operator> oper_; 
       std::vector<Variable> var_list_; 
   };
   
   enum class PartType
   {
       LITERAL, 
       EXPRESSION 
   };
   
   class Part
   {
   public:
       template <typename... Args, typename = std::enable_if_t<!std::is_same<
                                       detail::typelist<Part>, detail::typelist<std::decay_t<Args>...>>::value>>
       Part(Args&&... args)
           : part_(std::forward<Args>(args)...)
       {
           if (std::holds_alternative<Literal>(part_)) {
               type_ = PartType::LITERAL;
           } else {
               type_ = PartType::EXPRESSION;
           }
       }
   
       Part(const Part&) = default;
       Part& operator=(const Part&) = default;
       Part(Part&&) noexcept = default;
       Part& operator=(Part&&) noexcept = default;
   
       ~Part() = default;
   
       template <class T>
       T& Get()
       {
           return std::get<T>(part_);
       }
   
       template <class T>
       const T& Get() const
       {
           return std::get<T>(part_);
       }
   
       inline PartType Type() const
       {
           return type_;
       }
   
       inline std::string String() const noexcept
       {
           if (std::holds_alternative<Literal>(part_)) {
               return Get<Literal>().String();
           }
           return Get<Expression>().String();
       }
   
       inline bool operator==(const Part& rhs) const
       {
           return type_ == rhs.type_ && part_ == rhs.part_;
       }
   
       inline bool operator!=(const Part& rhs) const
       {
           return !(*this == rhs);
       }
   
   private:
       PartType type_; 
       std::variant<Literal, Expression> part_; 
   };
   
   class Template
   {
   public:
       Template() = default;
   
       Template(const Template&) = default;
       Template& operator=(const Template&) = default;
       Template(Template&&) noexcept = default;
       Template& operator=(Template&&) noexcept = default;
   
       ~Template() = default;
   
       template <class... Args>
       Part& EmplaceBack(Args&&... args)
       {
           return parts_.emplace_back(std::forward<Args>(args)...);
       }
   
       bool IsTemplated() const;
   
       std::size_t Size() const;
   
       std::vector<Part>& Parts();
   
       const std::vector<Part>& Parts() const;
   
       Part& operator[](std::size_t pos);
   
       const Part& operator[](std::size_t pos) const;
   
       std::string String() const noexcept;
   
   private:
       std::vector<Part> parts_; 
   };
   
   } // namespace Template
   } // namespace URI