Add simple target iterface

include/rtg/program.hpp

@@ -7,6 +7,7 @@
 #include <rtg/literal.hpp>
 #include <rtg/builtin.hpp>
 #include <rtg/instruction_ref.hpp>
+#include <rtg/target.hpp>
 #include <algorithm>
 #include <iostream>
 
@@ -68,6 +69,8 @@ struct program
 
     instruction_ref validate() const;
 
+    void compile(const target& t);
+
     private:
     std::unique_ptr<program_impl> impl;
 };

include/rtg/target.hpp

+#ifndef RTG_GUARD_RTGLIB_TARGET_HPP
+#define RTG_GUARD_RTGLIB_TARGET_HPP
+
+#include <string>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace rtg {
+
+struct program;
+
+/*
+ * Type-erased interface for:
+ *
+ * struct target
+ * {
+ *     std::string name() const;
+ *     void apply(program & p) const;
+ * };
+ *
+ */
+
+struct target
+{
+    // Constructors
+    target() = default;
+
+    template <typename PrivateDetailTypeErasedT>
+    target(PrivateDetailTypeErasedT value)
+        : private_detail_te_handle_mem_var(
+              std::make_shared<private_detail_te_handle_type<
+                  typename std::remove_reference<PrivateDetailTypeErasedT>::type>>(
+                  std::forward<PrivateDetailTypeErasedT>(value)))
+    {
+    }
+
+    // Assignment
+    template <typename PrivateDetailTypeErasedT>
+    target& operator=(PrivateDetailTypeErasedT value)
+    {
+        if(private_detail_te_handle_mem_var.unique())
+            *private_detail_te_handle_mem_var = std::forward<PrivateDetailTypeErasedT>(value);
+        else if(!private_detail_te_handle_mem_var)
+            private_detail_te_handle_mem_var = std::make_shared<PrivateDetailTypeErasedT>(
+                std::forward<PrivateDetailTypeErasedT>(value));
+        return *this;
+    }
+
+    // Cast
+    template <typename PrivateDetailTypeErasedT>
+    PrivateDetailTypeErasedT* any_cast()
+    {
+        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT)
+                   ? std::addressof(static_cast<private_detail_te_handle_type<
+                                        typename std::remove_cv<PrivateDetailTypeErasedT>::type>&>(
+                                        private_detail_te_get_handle())
+                                        .private_detail_te_value)
+                   : nullptr;
+    }
+
+    template <typename PrivateDetailTypeErasedT>
+    const typename std::remove_cv<PrivateDetailTypeErasedT>::type* any_cast() const
+    {
+        return private_detail_te_get_handle().type() == typeid(PrivateDetailTypeErasedT)
+                   ? std::addressof(static_cast<const private_detail_te_handle_type<
+                                        typename std::remove_cv<PrivateDetailTypeErasedT>::type>&>(
+                                        private_detail_te_get_handle())
+                                        .private_detail_te_value)
+                   : nullptr;
+    }
+
+    std::string name() const
+    {
+        assert(private_detail_te_handle_mem_var);
+        return private_detail_te_get_handle().name();
+    }
+
+    void apply(program& p) const
+    {
+        assert(private_detail_te_handle_mem_var);
+        return private_detail_te_get_handle().apply(p);
+    }
+
+    private:
+    struct private_detail_te_handle_base_type
+    {
+        virtual ~private_detail_te_handle_base_type() {}
+        virtual std::shared_ptr<private_detail_te_handle_base_type> clone() const = 0;
+        virtual const std::type_info& type() const                                = 0;
+
+        virtual std::string name() const     = 0;
+        virtual void apply(program& p) const = 0;
+    };
+
+    template <typename PrivateDetailTypeErasedT>
+    struct private_detail_te_handle_type : private_detail_te_handle_base_type
+    {
+        template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
+        private_detail_te_handle_type(
+            PrivateDetailTypeErasedT value,
+            typename std::enable_if<std::is_reference<PrivateDetailTypeErasedU>::value>::type* =
+                nullptr)
+            : private_detail_te_value(value)
+        {
+        }
+
+        template <typename PrivateDetailTypeErasedU = PrivateDetailTypeErasedT>
+        private_detail_te_handle_type(
+            PrivateDetailTypeErasedT value,
+            typename std::enable_if<!std::is_reference<PrivateDetailTypeErasedU>::value,
+                                    int>::type* = nullptr) noexcept
+            : private_detail_te_value(std::move(value))
+        {
+        }
+
+        std::shared_ptr<private_detail_te_handle_base_type> clone() const override
+        {
+            return std::make_shared<private_detail_te_handle_type>(private_detail_te_value);
+        }
+
+        const std::type_info& type() const override { return typeid(private_detail_te_value); }
+
+        std::string name() const override { return private_detail_te_value.name(); }
+
+        void apply(program& p) const override { return private_detail_te_value.apply(p); }
+
+        PrivateDetailTypeErasedT private_detail_te_value;
+    };
+
+    template <typename PrivateDetailTypeErasedT>
+    struct private_detail_te_handle_type<std::reference_wrapper<PrivateDetailTypeErasedT>>
+        : private_detail_te_handle_type<PrivateDetailTypeErasedT&>
+    {
+        private_detail_te_handle_type(std::reference_wrapper<PrivateDetailTypeErasedT> ref)
+            : private_detail_te_handle_type<PrivateDetailTypeErasedT&>(ref.get())
+        {
+        }
+    };
+
+    const private_detail_te_handle_base_type& private_detail_te_get_handle() const
+    {
+        return *private_detail_te_handle_mem_var;
+    }
+
+    private_detail_te_handle_base_type& private_detail_te_get_handle()
+    {
+        if(!private_detail_te_handle_mem_var.unique())
+            private_detail_te_handle_mem_var = private_detail_te_handle_mem_var->clone();
+        return *private_detail_te_handle_mem_var;
+    }
+
+    std::shared_ptr<private_detail_te_handle_base_type> private_detail_te_handle_mem_var;
+};
+
+template <typename ValueType>
+inline const ValueType* any_cast(const target* x)
+{
+    return x->any_cast<ValueType>();
+}
+
+template <typename ValueType>
+inline ValueType* any_cast(target* x)
+{
+    return x->any_cast<ValueType>();
+}
+
+template <typename ValueType>
+inline ValueType& any_cast(target& x)
+{
+    auto* y = x.any_cast<typename std::remove_reference<ValueType>::type>();
+    if(y == nullptr)
+        throw std::bad_cast();
+    return *y;
+}
+
+template <typename ValueType>
+inline const ValueType& any_cast(const target& x)
+{
+    const auto* y = x.any_cast<typename std::remove_reference<ValueType>::type>();
+    if(y == nullptr)
+        throw std::bad_cast();
+    return *y;
+}
+
+} // namespace rtg
+
+#endif

src/program.cpp

@@ -79,6 +79,14 @@ instruction_ref program::validate() const
                         [](const instruction& i) { return i.valid(); });
 }
 
+void program::compile(const target& t)
+{
+    assert(this->validate() != impl->instructions.end());
+    t.apply(*this);
+    if(this->validate() == impl->instructions.end())
+        RTG_THROW("Invalid program from compilation");
+}
+
 literal program::eval(std::unordered_map<std::string, argument> params) const
 {
     assert(this->validate() != impl->instructions.end());

test/eval_test.cpp

@@ -62,6 +62,16 @@ struct minus_op
     }
 };
 
+struct id_target
+{
+    std::string name() const
+    {
+        return "id";
+    }
+    void apply(rtg::program&) const
+    {}
+};
+
 void literal_test1()
 {
     rtg::program p;
@@ -133,6 +143,19 @@ void insert_replace_test()
     EXPECT(result != rtg::literal{5});
 }
 
+void target_test()
+{
+    rtg::program p;
+
+    auto one = p.add_literal(1);
+    auto two = p.add_literal(2);
+    p.add_instruction(sum_op{}, one, two);
+    p.compile(id_target{});
+    auto result = p.eval({});
+    EXPECT(result == rtg::literal{3});
+    EXPECT(result != rtg::literal{4});
+}
+
 int main()
 {
     literal_test1();
@@ -140,4 +163,5 @@ int main()
     param_test();
     replace_test();
     insert_replace_test();
+    target_test();
 }

tools/include/target.hpp

+#ifndef RTG_GUARD_RTGLIB_TARGET_HPP
+#define RTG_GUARD_RTGLIB_TARGET_HPP
+
+#include <string>
+#include <functional>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace rtg {
+
+struct program;
+
+<%
+interface('target',
+    virtual('name', returns='std::string', const=True),
+    virtual('apply', returns='void', p='program &', const=True)
+)
+%>
+
+} // namespace rtg
+
+#endif