TreeNodePrivateAttorney.hpp

// <TreeNode> -*- C++ -*-
 
 
#pragma once
 
#include "sparta/simulation/TreeNode.hpp"
 
namespace sparta {
 
    class TreeNodePrivateAttorney
    {
    public:
        static const TreeNode::ChildrenVector& getAllChildren(const TreeNode& node)
        {
            return node.getAllChildren_();
        }
 
        static const TreeNode::ChildrenVector& getAllChildren(const TreeNode* node)
        {
            sparta_assert(node);
            return getAllChildren(*node);
        }
 
        static TreeNode* getChild(TreeNode* node, const std::string& path,
                                  const bool must_exist = false)
        {
            return node->getChild_(path, must_exist, true /* private also */);
        }
 
        static uint32_t findChildren(TreeNode* node, const std::string& pattern,
                                     std::vector<TreeNode*>& results)
        {
            return node->findChildren_(pattern, results, true /* allow private */);
        }
 
        static bool hasChild(const TreeNode* node, const std::string& path)
        {
            return node->hasChild_(path, true /* private also */);
        }
 
        template <typename DataT, typename T, void (T::*TMethod)(const DataT&)>
        static void registerForNotification(TreeNode* node, T* obj,
                                            const std::string& name, bool ensure_possible=true)
        {
            sparta_assert(node != nullptr);
            node->registerForNotification_<DataT, T, TMethod>(obj, name,
                                                              ensure_possible,
                                                              true /*allow_private*/);
        }
        template <typename DataT, typename T, void (T::*TMethod)(const TreeNode&, const TreeNode&, const DataT&)>
        static void registerForNotification(TreeNode* node, T* obj,
                                            const std::string& name,
                                            bool ensure_possible=true)
        {
            sparta_assert(node != nullptr);
            node->registerForNotification_<DataT, T, TMethod>(obj, name,
                                                              ensure_possible,
                                                              true /*allow_private*/);
        }
 
        template <typename DataT, typename T, void (T::*TMethod)(const DataT&)>
        static void deregisterForNotification(TreeNode* node,
                                              T* obj, const std::string& name)
        {
            sparta_assert(node != nullptr);
            node->deregisterForNotification_<DataT, T, TMethod>(obj,
                                                                name,
                                                                true /* allow_private */);
        }
 
        template <typename DataT, typename T, void (T::*TMethod)(const TreeNode&, const TreeNode&, const DataT&)>
        static void deregisterForNotification(TreeNode* node,
                                              T* obj, const std::string& name)
        {
            sparta_assert(node != nullptr);
            node->deregisterForNotification_<DataT, T, TMethod>(obj,
                                                                name,
                                                                true /* allow_private */);
        }
    };
 
} // namespace sparta