codac2_ExprBase.h

Go to the documentation of this file.

 
#pragma once
 
#include <map>
#include <memory>
#include <cassert>
#include <utility>
#include <atomic>
#include "codac2_Domain.h"
#include "codac2_Index.h"
 
namespace codac2
{
  class ExprBase;
  class VarBase;

  class ExprID
  {
    public:

      ExprID();

      Index id() const;

      bool operator==(const ExprID& i) const;

      bool operator<(const ExprID& i) const;
 
    protected:
 
      const Index _id; 
      static std::atomic<Index> _id_counter; 
  };

  class ExprBase : public std::enable_shared_from_this<ExprBase>
  {
    public:

      ExprBase();

      virtual std::shared_ptr<ExprBase> copy() const = 0;

      virtual void replace_arg(const ExprID& old_arg_id, const std::shared_ptr<ExprBase>& new_expr) = 0;

      const ExprID& unique_id() const;

      bool operator==(const ExprBase& e) const;

      virtual ~ExprBase() = default;

      virtual std::vector<std::shared_ptr<ExprBase>> children_expr_base() const
      {
        return {};
      }
 
    protected:
 
      const ExprID _unique_id; 
  };

  template<typename... X>
  class OperationExprBase
  {
    public:

      OperationExprBase(std::shared_ptr<X>... x)
        : _x(std::make_tuple((x)...))
      { }

      OperationExprBase(const OperationExprBase<X...>& e)
        : _x(e._x)
      {
        std::apply(
          [](auto &&... x)
          {
            ((x = __copy(x)), ...);
          }, _x);
      }

      void replace_arg(const ExprID& old_arg_id, const std::shared_ptr<ExprBase>& new_expr)
      {
        std::apply(
          [old_arg_id,new_expr](auto &&... x)
          {
            (__replace_arg(x,old_arg_id,new_expr), ...);
          }, _x);
      }

      std::vector<std::shared_ptr<ExprBase>> children_expr_base() const
      {
        std::vector<std::shared_ptr<ExprBase>> children;
        children.reserve(sizeof...(X));
        std::apply(
          [&children](const auto&... x)
          {
            (children.push_back(std::static_pointer_cast<ExprBase>(x)), ...);
          }, _x);
        return children;
      }
 
    protected:

      template<typename X_>
      static std::shared_ptr<X_> __copy(const std::shared_ptr<X_>& x)
      {
        return std::dynamic_pointer_cast<X_>(x->copy());
      }

      template<typename D>
      static void __replace_arg(std::shared_ptr<D>& x, const ExprID& old_arg_id, const std::shared_ptr<ExprBase>& new_expr)
      {
        if(x->unique_id() == old_arg_id)
        {
          assert(std::dynamic_pointer_cast<VarBase>(x) && "this subexpr should be some variable");
          x = std::dynamic_pointer_cast<D>(new_expr);
        }
        else
          x->replace_arg(old_arg_id, new_expr);
      }
 
      std::tuple<std::shared_ptr<X>...> _x; 
  };
}