dynamicpowernode.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
 
#ifndef DUNE_TYPETREE_DYNAMICPOWERNODE_HH
#define DUNE_TYPETREE_DYNAMICPOWERNODE_HH
 
#include <cassert>
#include <vector>
#include <memory>
#include <type_traits>
 
#include <dune/common/typetraits.hh>
#include <dune/common/std/type_traits.hh>
 
#include <dune/typetree/nodetags.hh>
#include <dune/typetree/utility.hh>
#include <dune/typetree/typetraits.hh>
 
namespace Dune {
  namespace TypeTree {
 
    template<typename T>
    class DynamicPowerNode
    {
 
    public:
 
      static const bool isLeaf = false;
 
      static const bool isPower = true;
 
      static const bool isComposite = false;
 
      std::size_t degree() const
      {
        return _children.size();
      }
 
      typedef DynamicPowerNodeTag NodeTag;
 
      typedef T ChildType;
 
      typedef std::shared_ptr<T> ChildStorageType;
 
      typedef std::shared_ptr<const T> ChildConstStorageType;
 
      typedef std::vector<ChildStorageType> NodeStorage;
 
 
 
 
      ChildType& child (std::size_t i)
      {
        assert(i < degree() && "child index out of range");
        return *_children[i];
      }
 
 
      const ChildType& child (std::size_t i) const
      {
        assert(i < degree() && "child index out of range");
        return *_children[i];
      }
 
 
      ChildStorageType childStorage (std::size_t i)
      {
        assert(i < degree() && "child index out of range");
        return _children[i];
      }
 
 
      ChildConstStorageType childStorage (std::size_t i) const
      {
        assert(i < degree() && "child index out of range");
        return _children[i];
      }
 
      void setChild (std::size_t i, ChildType& t)
      {
        assert(i < degree() && "child index out of range");
        _children[i] = stackobject_to_shared_ptr(t);
      }
 
      void setChild (std::size_t i, ChildType&& t)
      {
        assert(i < degree() && "child index out of range");
        _children[i] = convert_arg(std::move(t));
      }
 
      void setChild (std::size_t i, ChildStorageType st)
      {
        assert(i < degree() && "child index out of range");
        _children[i] = std::move(st);
      }
 
      const NodeStorage& nodeStorage () const
      {
        return _children;
      }
 
 
 
    protected:
 
      DynamicPowerNode () = delete;
 
 
      explicit DynamicPowerNode (std::size_t size)
        : _children(size)
      {}
 
      explicit DynamicPowerNode (NodeStorage children)
        : _children(std::move(children))
      {}
 
#ifdef DOXYGEN
 
      DynamicPowerNode (T& t1, T& t2, ...)
      {}
 
#else
 
      template<typename... Children,
        std::enable_if_t<(std::is_same_v<ChildType, std::decay_t<Children>> &&...), bool> = true>
      DynamicPowerNode (Children&&... children)
      {
        _children = NodeStorage{convert_arg(std::forward<Children>(children))...};
      }
 
      template<typename... Children,
        std::enable_if_t<(std::is_same_v<ChildType, std::decay_t<Children>> &&...), bool> = true>
      DynamicPowerNode (std::shared_ptr<Children>... children)
      {
        _children = NodeStorage{std::move(children)...};
      }
 
#endif // DOXYGEN
 
 
    private:
      NodeStorage _children;
    };
 
 
  } // namespace TypeTree
} //namespace Dune
 
#endif // DUNE_TYPETREE_DYNAMICPOWERNODE_HH