-replace getInterface with dynamic_cast based as method

src/attribute_node.cpp

@@ -2,6 +2,7 @@
 #include "errors.h"
 #include "streamreader.h"
 #include <gsl/assert>
+#include <gsl/narrow>
 
 namespace htcpp {
 
@@ -23,7 +24,8 @@ std::string_view AttributeNode::value() const
 
 void AttributeNode::load(StreamReader& stream)
 {
-    Expects(stream.read(name_.size()) == name_);
+    Expects(stream.read(gsl::narrow_cast<int>(std::ssize(name_))) == name_);
+
     stream.skipWhitespace();
     if (stream.peek() != "=")
         throw TemplateError{stream.position(), "Attribute '" + name_ + "'s value is missing"};

src/attribute_node.h

@@ -1,15 +1,15 @@
 #pragma once
 #include "iattribute.h"
 #include "idocumentnode.h"
+#include <string>
+#include <string_view>
 
 namespace htcpp {
 
 class StreamReader;
 
 class AttributeNode : public IDocumentNode,
                       public IAttribute {
-    DOCUMENT_NODE_INTERFACE_ACCESS(IAttribute)
-
 public:
     explicit AttributeNode(std::string name, StreamReader& stream);
     std::string_view name() const override;

src/codenode.cpp

@@ -1,7 +1,8 @@
 #include "codenode.h"
-#include "streamreader.h"
 #include "errors.h"
+#include "streamreader.h"
 #include "utils.h"
+#include <gsl/assert>
 #include <utility>
 
 namespace htcpp{

src/codenode.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "document_node_interface_access.h"
 #include "idocumentnode.h"
 #include "idocumentnoderenderer.h"
 #include "nodeextension.h"
@@ -27,7 +26,6 @@ class CodeNode {
 
 class ExpressionNode : public IDocumentNode,
                        public IDocumentNodeRenderer {
-    DOCUMENT_NODE_INTERFACE_ACCESS(IDocumentNodeRenderer)
 public:
     explicit ExpressionNode(StreamReader& stream);
     std::string renderingCode() const override;
@@ -38,8 +36,6 @@ class ExpressionNode : public IDocumentNode,
 
 class StatementNode : public IDocumentNode,
                       public IDocumentNodeRenderer {
-    DOCUMENT_NODE_INTERFACE_ACCESS(IDocumentNodeRenderer)
-
 public:
     explicit StatementNode(StreamReader& stream);
     std::string renderingCode() const override;
@@ -50,7 +46,6 @@ class StatementNode : public IDocumentNode,
 
 class GlobalStatementNode : public IDocumentNode,
                             public IDocumentNodeRenderer {
-    DOCUMENT_NODE_INTERFACE_ACCESS(IDocumentNodeRenderer)
 public:
     explicit GlobalStatementNode(StreamReader& stream);
     std::string renderingCode() const override;

src/control_flow_statement_node.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "document_node_interface_access.h"
 #include "idocumentnode.h"
 #include "idocumentnoderenderer.h"
 #include "nodeextension.h"
@@ -15,8 +14,6 @@ enum class ControlFlowStatementNodeType {
 
 class ControlFlowStatementNode : public IDocumentNode,
                                  public IDocumentNodeRenderer {
-    DOCUMENT_NODE_INTERFACE_ACCESS(IDocumentNodeRenderer)
-
 public:
     ControlFlowStatementNode(ControlFlowStatementNodeType, NodeExtension nodeExtension);
     std::string renderingCode() const override;

src/iconvertible_to_procedure.h

@@ -1,12 +1,13 @@
 #pragma once
 #include <sfun/interface.h>
+#include <optional>
 #include <string_view>
 
-namespace htcpp{
+namespace htcpp {
 
 class IConvertibleToProcedure : private sfun::interface<IConvertibleToProcedure> {
 public:
-    virtual std::string_view procedureName() const = 0;
+    virtual std::optional<std::string_view> procedureName() const = 0;
 };
 
-}
+} //namespace htcpp

src/idocumentnode.h

@@ -1,12 +1,6 @@
 #pragma once
-#include "document_node_interface_access.h"
 #include <sfun/interface.h>
 #include <sfun/optional_ref.h>
-#include <gsl/assert>
-#include <string>
-#include <typeinfo>
-#include <memory>
-#include <vector>
 
 namespace htcpp {
 class INodeCollection;
@@ -22,39 +16,24 @@ class IDocumentNode : private sfun::interface<IDocumentNode>
 {
 public:
     template<typename TInterface>
-    auto getInterface() const
+    sfun::optional_ref<const TInterface> as() const
     {
-        return (this->*InterfaceGetterMapping<TInterface>::getterPtr())();
+        auto obj = dynamic_cast<const TInterface*>(this);
+        return obj ? sfun::optional_ref<const TInterface>{*obj} : sfun::optional_ref<const TInterface>{};
     }
 
     template<typename TInterface>
-    auto getInterface()
+    sfun::optional_ref<TInterface> as()
     {
-        return (this->*InterfaceGetterMapping<TInterface>::getterPtr())();
+        auto obj = dynamic_cast<TInterface*>(this);
+        return obj ? sfun::optional_ref<TInterface>{*obj} : sfun::optional_ref<TInterface>{};
     }
 
     template<typename T>
-    bool is()
+    bool is() const
     {
-        return typeid(*this) == typeid(T);
+        return as<T>().has_value();
     }
-
-private:
-    DOCUMENT_NODE_ADD_INTERFACE_GETTER(INodeCollection);
-    DOCUMENT_NODE_ADD_INTERFACE_GETTER(IDocumentNodeRenderer);
-    DOCUMENT_NODE_ADD_INTERFACE_GETTER(IRenderedAsStringPart);
-    DOCUMENT_NODE_ADD_INTERFACE_GETTER(IConvertibleToProcedure);
-    DOCUMENT_NODE_ADD_INTERFACE_GETTER(IAttribute);
-
-    template<typename TInterface>
-    friend struct InterfaceGetterMapping;
 };
 
-DOCUMENT_NODE_REGISTER_INTERFACE(INodeCollection);
-DOCUMENT_NODE_REGISTER_INTERFACE(IDocumentNodeRenderer);
-DOCUMENT_NODE_REGISTER_INTERFACE(IRenderedAsStringPart);
-DOCUMENT_NODE_REGISTER_INTERFACE(IConvertibleToProcedure);
-DOCUMENT_NODE_REGISTER_INTERFACE(IAttribute);
-
-
 } // namespace htcpp

src/node_utils.cpp

@@ -8,7 +8,7 @@ std::vector<std::unique_ptr<IDocumentNode>> flattenNodes(std::vector<std::unique
 {
     auto flattenNodes = std::vector<std::unique_ptr<IDocumentNode>>{};
     for (auto& node : nodes) {
-        if (const auto nodeCollection = node->template getInterface<INodeCollection>())
+        if (const auto nodeCollection = node->template as<INodeCollection>())
             std::ranges::move(nodeCollection->flatten(), std::back_inserter(flattenNodes));
         else
             flattenNodes.emplace_back(std::move(node));
@@ -20,9 +20,9 @@ std::vector<std::unique_ptr<IDocumentNode>> optimizeNodes(std::vector<std::uniqu
 {
     auto processedNodes = std::vector<std::unique_ptr<IDocumentNode>>{};
     for (auto& node : nodes) {
-        if (auto text = node->getInterface<IRenderedAsStringPart>()) {
-            if (!processedNodes.empty() && processedNodes.back()->getInterface<IRenderedAsStringPart>()) {
-                auto prevText = processedNodes.back()->getInterface<IRenderedAsStringPart>()->content();
+        if (auto text = node->as<IRenderedAsStringPart>()) {
+            if (!processedNodes.empty() && processedNodes.back()->as<IRenderedAsStringPart>()) {
+                auto prevText = processedNodes.back()->as<IRenderedAsStringPart>()->content();
                 processedNodes.back() = std::make_unique<TextNode>(prevText + text->content());
             }
             else

src/procedurenode.cpp

@@ -1,10 +1,11 @@
 #include "procedurenode.h"
 #include "errors.h"
 #include "idocumentnoderenderer.h"
+#include "node_utils.h"
 #include "nodereader.h"
 #include "streamreader.h"
 #include "utils.h"
-#include "node_utils.h"
+#include <gsl/assert>
 
 namespace htcpp{
 
@@ -58,7 +59,7 @@ std::string ProcedureNode::renderingCode() const
 {
     auto result = std::string{};
     for (auto& node : contentNodes_)
-        result += node->getInterface<IDocumentNodeRenderer>()->renderingCode();
+        result += node->as<IDocumentNodeRenderer>()->renderingCode();
     return result;
 }
 

src/procedurenode.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "document_node_interface_access.h"
 #include "idocumentnode.h"
 #include "idocumentnoderenderer.h"
 #include <memory>
@@ -11,8 +10,6 @@ class StreamReader;
 
 class ProcedureNode : public IDocumentNode,
                       public IDocumentNodeRenderer {
-    DOCUMENT_NODE_INTERFACE_ACCESS(IDocumentNodeRenderer)
-
 public:
     ProcedureNode(std::string procedureName, StreamReader& stream);
     ProcedureNode(std::string procedureName, std::unique_ptr<IDocumentNode> contentNode);

src/sectionnode.cpp

@@ -63,10 +63,10 @@ std::vector<std::unique_ptr<IDocumentNode>> SectionNode::flatten()
         result.emplace_back(
                 std::make_unique<ControlFlowStatementNode>(ControlFlowStatementNodeType::Open, extension_.value()));
     for (auto& node : contentNodes_) {
-        if (node->getInterface<IAttribute>().has_value())
+        if (node->as<IAttribute>().has_value())
             continue;
 
-        if (auto nodeCollection = node->getInterface<INodeCollection>())
+        if (auto nodeCollection = node->as<INodeCollection>())
             std::ranges::move(nodeCollection->flatten(), std::back_inserter(result));
         else
             result.emplace_back(std::move(node));
@@ -78,46 +78,22 @@ std::vector<std::unique_ptr<IDocumentNode>> SectionNode::flatten()
     return result;
 }
 
-template<typename T>
-sfun::optional_ref<T> getIConvertibleToProcedure(auto selfPtr)
-{
-    if (std::ranges::any_of(
-                    selfPtr->contentNodes_,
-                    [](const auto& node)
-                    {
-                        return node->template getInterface<IAttribute>().has_value();
-                    }))
-        return selfPtr;
-
-    return std::nullopt;
-}
-
-sfun::optional_ref<const IConvertibleToProcedure> SectionNode::getIConvertibleToProcedure() const
-{
-    return getIConvertibleToProcedure<const IConvertibleToProcedure>(this);
-}
-
-sfun::optional_ref<IConvertibleToProcedure> SectionNode::getIConvertibleToProcedure()
-{
-    return getIConvertibleToProcedure<IConvertibleToProcedure>(this);
-}
-
-std::string_view SectionNode::procedureName() const
+std::optional<std::string_view> SectionNode::procedureName() const
 {
     auto idAttribute = std::ranges::find_if(
                 contentNodes_,
                 [](const auto& node)
                 {
-                    auto attribute = node->template getInterface<IAttribute>();
-                    if (!attribute.has_value())
-                        return false;
-                    return attribute->name() == "htcpp-id";
-                });
+                auto attribute = node->template as<IAttribute>();
+                if (!attribute.has_value())
+                    return false;
+                return attribute->name() == "htcpp-id";
+            });
 
     if (idAttribute == contentNodes_.end())
-        return {};
+        return std::nullopt;
 
-    return idAttribute->get()->template getInterface<IAttribute>()->value();
+    return idAttribute->get()->template as<IAttribute>()->value();
 }
 
 } //namespace htcpp

src/sectionnode.h

@@ -1,5 +1,4 @@
 #pragma once
-#include "document_node_interface_access.h"
 #include "idocumentnode.h"
 #include "inodecollection.h"
 #include "iconvertible_to_procedure.h"
@@ -13,21 +12,14 @@ namespace htcpp{
 class SectionNode : public IDocumentNode,
                     public INodeCollection,
                     public IConvertibleToProcedure {
-    DOCUMENT_NODE_INTERFACE_ACCESS(INodeCollection)
-
 public:
     explicit SectionNode(StreamReader& stream);
     std::vector<std::unique_ptr<IDocumentNode>>& content() override;
     std::vector<std::unique_ptr<IDocumentNode>> flatten() override;
-    std::string_view procedureName() const override;
-
-    sfun::optional_ref<const IConvertibleToProcedure> getIConvertibleToProcedure() const override;
-    sfun::optional_ref<IConvertibleToProcedure> getIConvertibleToProcedure() override;
+    std::optional<std::string_view> procedureName() const override;
 
 private:
     void load(StreamReader& stream);
-    template<typename T>
-    friend sfun::optional_ref<T> getIConvertibleToProcedure(auto selfPtr);
 
 private:
     std::vector<std::unique_ptr<IDocumentNode>> contentNodes_;