TreeNode.hpp

Go to the documentation of this file.

// <TreeNode> -*- C++ -*-
 
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <fstream>
#include <string>
#include <ostream>
#include <vector>
#include <sstream>
#include <set>
#include <map>
#include <unordered_map>
#include <regex>
#include <functional>
#include <memory>
#include <type_traits>
#include <typeinfo>
#include <utility>
 
#include "sparta/utils/StaticInit.hpp"
#include "sparta/simulation/ResourceContainer.hpp"
#include "sparta/functional/ArchDataContainer.hpp"
#include "sparta/utils/Utils.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/Printing.hpp"
#include "sparta/utils/StringManager.hpp"
#include "sparta/kernel/PhasedObject.hpp"
 
namespace sparta {
class PostRunValidationInfo;
}  // namespace sparta
 
#ifndef TREENODE_LIFETIME_TRACE
//#define TREENODE_LIFETIME_TRACE 1
#endif // #ifndef TREENODE_LIFETIME_TRACE
 
 
#define ALPHANUM_CHARS \
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890_"
 
#define DIGIT_CHARS "0123456789"
 
#define RESERVED_WORDS {"and",     "del",       "from",        "not",       \
                        "while",   "as",        "elif",        "global",    \
                        "or",      "with",      "assert",      "else",      \
                        "if",      "pass",      "yield",       "break",     \
                        "except",  "import",    "print",       "class",     \
                        "exec",    "in",        "raise",       "continue",  \
                        "finally", "is",        "return",      "def",       \
                        "for",     "lambda",    "try",         "__init__",  \
                        "__del__", "__cinit__", "__dealloc__",              \
                        /* End of Python reserved names */                  \
                        "name",    "author",    "report",      "content",   \
                        "include",                                          \
                        /* End of SPARTA Report definition reserved nodes */  \
                        "extension"                                         \
                        /* End of SPARTA extensions reserved words */         \
                        }
 
#define REGISTER_FOR_NOTIFICATION(func, datat, name)                    \
    registerForNotification<datat,                                      \
                            typename std::remove_reference<decltype(*this)>::type, \
                            &std::remove_reference<decltype(*this)>::type::func>(this, name);
 
#define DEREGISTER_FOR_NOTIFICATION(func, datat, name)                  \
    deregisterForNotification<datat,                                    \
                              typename std::remove_reference<decltype(*this)>::type, \
                              &std::remove_reference<decltype(*this)>::type::func>(this, name);
 
#define NOTIFY(func, datat, name) \
 
 
namespace sparta
{
    namespace app {
        class Simulation;
    }
 
    class Clock;
    class VirtualGlobalTreeNode;
    class ClockManager;
    class TreeNodePrivateAttorney;
    class ParameterSet;
    class Scheduler;
    class ExtensionDescriptor;
 
    typedef std::vector<std::unique_ptr<ExtensionDescriptor>> ExtensionDescriptorVec;
 
    class TreeNode : public ResourceContainer, public ArchDataContainer
    {
    public:
        friend class VirtualGlobalTreeNode;
 
        friend class ClockManager;
 
        friend class SpartaStaticInitializer;
 
        friend class TreeNodePrivateAttorney;
 
 
        typedef uint64_t node_uid_type;
 
        typedef std::vector<TreeNode*> ChildrenVector;
 
        typedef std::vector<std::string> AliasVector;
 
        typedef std::multimap<std::string, TreeNode*> ChildNameMapping;
 
        typedef uint32_t group_idx_type;
 
        typedef std::weak_ptr<TreeNode> WeakPtr;
 
        typedef std::weak_ptr<const TreeNode> ConstWeakPtr;
 
        typedef std::shared_ptr<TreeNode> SharedPtr;
 
        typedef std::map<const std::string*, std::vector<TreeNode*>> TagsMap;
 
        struct ANY_TYPE {};
 
 
 
        static const group_idx_type GROUP_IDX_NONE = (group_idx_type)-1;
 
        static const node_uid_type MAX_NODE_UID;
 
        static constexpr char GROUP_NAME_NONE[] = "";
 
        static constexpr char NODE_NAME_NONE[] = "";
 
        static const std::string DEBUG_DUMP_SECTION_DIVIDER;
 
        static constexpr char NODE_NAME_VIRTUAL_GLOBAL[] = "_SPARTA_virtual_global_";
 
        static constexpr char LOCATION_NODE_SEPARATOR_ATTACHED = '.';
 
        static constexpr char LOCATION_NODE_SEPARATOR_EXPECTING = ',';
 
        static constexpr char LOCATION_NODE_SEPARATOR_UNATTACHED = '~';
 
        static const uint32_t RENDER_SUBTREE_INDENT = 2;
 
        static constexpr char GROUP_NAME_BUILTIN[] = "_SPARTA_builtin_group_";
 
        static const uint64_t CHILD_FIND_THRESHOLD = 100000;
 
        static const uint64_t CHILD_GET_THRESHOLD = 100000;
 
        static const uint32_t TEARDOWN_ERROR_LIMIT = 5;
 
        static const std::vector<std::pair<const char*, std::function<void (std::string&)>>> TREE_NODE_PATTERN_SUBS;
 
 
 
        void lockdownParameters(){
            if(getRoot()->getPhase() != sparta::PhasedObject::TreePhase::TREE_BUILDING and
               getRoot()->getPhase() != sparta::PhasedObject::TreePhase::TREE_CONFIGURING){
                throw SpartaException("Device tree with root \"")
                    << getRoot()->getLocation() << "\" not currently in the TREE_BUILDING phase or "
                    << "TREE_CONFIGURING phase, so it cannot enter TREE_LOCKDOWN";
            }
            lockdownParametersUtil_();
        }
 
        static const std::map<const TreeNode*, WeakPtr>& getParentlessNodes();
 
        static const std::map<const TreeNode*, WeakPtr>& getAllNodes();
 
        static std::string formatAllNodes();
 
        static bool isNodeConstructed(const TreeNode*);
 
 
 
        TreeNode() = delete;
 
        TreeNode(const TreeNode&) = delete;
 
        TreeNode(TreeNode&& rhp);
 
        TreeNode& operator=(const TreeNode&) = delete;
 
        TreeNode(TreeNode* parent,
                 const std::string& name,
                 const std::string& group,
                 group_idx_type group_idx,
                 const std::string& desc,
                 bool is_indexable);
 
        TreeNode(TreeNode* parent,
                 const std::string& name,
                 const std::string& group,
                 group_idx_type group_idx,
                 const std::string& desc);
 
        TreeNode(const std::string& name,
                 const std::string& group,
                 group_idx_type group_idx,
                 const std::string& desc);
 
        TreeNode(TreeNode* parent,
                 const std::string& name,
                 const std::string& desc);
 
        TreeNode(TreeNode* parent,
                 const std::string& group,
                 group_idx_type group_idx,
                 const std::string& desc);
 
        TreeNode(const std::string& name,
                 const std::string& desc);
 
        virtual ~TreeNode();
 
 
 
        void addAlias(const std::string& alias);
 
        void addAliases(const AliasVector& v);
 
        void addTag(const std::string& tag);
 
        void addTags(const std::vector<std::string>& v);
 
 
 
        virtual std::string stringize(bool pretty=false) const {
            (void) pretty;
            std::stringstream ss;
            ss << "<" << getLocation();
            if(is_expired_){
                ss << " EXPIRED";
            }
            stringizeTags(ss);
            ss << ">";
            return ss.str();
        }
 
        void stringizeTags(std::stringstream& ss) const {
            if(tags_.size() > 0){
                ss << " tags:[";
                uint32_t i = 0;
                for(auto & tag : tags_){
                    if(i != 0){
                        ss << ", ";
                    }
                    ss << *tag;
                    ++i;
                }
                ss << "]";
            }
 
        }
 
 
 
        node_uid_type getNodeUID() const;
 
        const std::string& getName() const override;
 
        const std::string* getNamePtr() const;
 
        bool isAnonymous() const;
 
        bool isExpired() const;
 
        bool isIndexableByGroup() const;
 
        const std::string& getGroup() const;
 
        const std::string* getGroupNamePtr() const;
 
        group_idx_type getGroupIdx() const;
 
        const std::vector<const std::string*>& getTags() const;
 
        bool hasTag(const std::string& tag) const;
 
        bool hasTag(const std::string* interned_tag_name) const;
 
        const std::string& getDesc() const;
 
        bool isBuiltin() const;
 
        void markHidden(bool hidden=true);
 
        bool isHidden() const;
 
 
 
        void validateName(const std::string& nm);
 
        void validateGroup(const std::string& name,
                           const std::string& group,
                           group_idx_type idx);
 
        void validateDesc(const std::string& desc);
 
 
 
        virtual bool isAttached() const {
            return is_attached_;
        }
 
        virtual TreeNode* getParent() {
            return parent_;
        }
 
        virtual const TreeNode* getParent() const {
            return parent_;
        }
 
        template <class T, typename = typename std::enable_if<std::is_pointer<T>::value>::type>
        const T getParentAs(bool must_exist=true) const {
            const T result = dynamic_cast<const T>(getParent());
            if(result == nullptr){
                if(must_exist){
                    throw SpartaException("Could not get parent of ")
                        << getLocation() << " with type: const " << demangle(typeid(T*).name());
                }
                return nullptr;
            }
            return result;
        }
 
        // Overload of getParentAs for const access with a non-pointer T type
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        const T* getParentAs(bool must_exist=true) const {
            return getParentAs<const T*>(must_exist);
        }
 
        // Overload of getParentAs for non-const access with a pointer T type
        template <class T, typename = typename std::enable_if<std::is_pointer<T>::value>::type>
        T getParentAs(bool must_exist=true) {
            T result = dynamic_cast<T>(getParent());
            if(result == nullptr){
                if(must_exist){
                    throw SpartaException("Could not get parent of ")
                        << getLocation() << " with type: const " << demangle(typeid(T*).name());
                }
                return nullptr;
            }
            return result;
        }
 
        // Overload of getParentAs for non-const access with a non-pointer T type
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        T* getParentAs(bool must_exist=true) {
            return getParentAs<T*>(must_exist);
        }
 
        virtual TreeNode* getRoot();
 
        virtual const TreeNode* getRoot() const;
 
        TreeNode *getScopeRoot();
 
        const TreeNode *getScopeRoot() const;
 
        const TreeNode* getExpectedRoot() const;
 
        app::Simulation* getSimulation() const;
 
        uint32_t getNumChildren() const;
 
        TreeNode* getChildAt(uint32_t idx) const;
 
        const ChildrenVector getChildren() const;
 
        uint32_t getChildren(std::vector<TreeNode*>& results,
                             bool ignore_builtin_group=true,
                             bool ignore_anonymous_nodes=true);
 
        template <class T>
        uint32_t getChildrenOfType(std::vector<T*>& results) const
        {
            uint32_t orig_size = results.size();
            for (auto child : getChildren())
            {
                if (dynamic_cast<T*>(child))
                {
                    results.emplace_back(static_cast<T*>(child));
                }
            }
            return results.size() - orig_size;
        }
 
        sparta::TreeNode *findAncestorByName(const std::string &name) {
            sparta::TreeNode *parent = getParent();
            while (parent != getRoot()) {
                if (parent->locationMatchesPattern(name, parent->getParent())) {
                    return parent;
                }
                parent = parent->getParent();
            }
            return nullptr;
        }
 
        template <typename T>
        sparta::TreeNode *findAncestorByType() {
            sparta::TreeNode *parent = getParent();
            while (parent != getRoot()) {
                if (parent->getResourceTypeRaw() == typeid(T).name()) {
                    return parent;
                }
                parent = parent->getParent();
            }
            return nullptr;
        }
 
        sparta::TreeNode *findAncestorByTag(const std::string& tag)
        {
            sparta::TreeNode *parent = getParent();
            while (parent != getRoot()) {
                if (parent->hasTag(tag))
                {
                    return parent;
                }
                parent = parent->getParent();
            }
            return nullptr;
        }
 
        template<typename T>
        T* findAncestorResourceByType()
        {
            static_assert(!std::is_pointer<T>::value && !std::is_reference<T>::value,
                          "Expected a non-pointer/non-reference T template argument");
            sparta::TreeNode* node = findAncestorByType<T>();
            if (node)
            {
                return node->getResourceAs<T*>();
            }
            return nullptr;
        }
 
        const AliasVector& getAliases() const;
 
        uint32_t getChildrenIdentifiers(std::vector<std::string>& idents,
                                        bool ignore_builtin_group=true) const;
 
        std::vector<const std::string*> getIdentifiers() const;
 
        uint32_t getGroupSize(const std::string& group);
 
        group_idx_type getGroupIndexMax(const std::string& group);
 
        uint32_t getGroup(const std::string& group,
                          std::vector<TreeNode*>& results);
 
        uint32_t findChildren(const std::string& pattern,
                              std::vector<TreeNode*>& results,
                              std::vector<std::vector<std::string>>& replacements)
        {
            return findChildren_(pattern, results, replacements, false /*allow_private*/);
        }
 
        uint32_t findChildren(const std::string& pattern,
                              std::vector<TreeNode*>& results)
        {
            return findChildren_(pattern, results, false /*allow_private*/);
        }
 
        virtual uint32_t findImmediateChildren_(std::regex& expr,
                                                std::vector<TreeNode*>& found,
                                                std::vector<std::vector<std::string>>& replacements,
                                                bool allow_private=false);
 
        uint32_t findImmediateChildren_(std::regex& expr,
                                        std::vector<TreeNode*>& found,
                                        bool allow_private=false);
 
        virtual uint32_t findImmediateChildren_(std::regex& expr,
                                                std::vector<const TreeNode*>& found,
                                                std::vector<std::vector<std::string>>& replacements,
                                                bool allow_private=false) const;
 
        uint32_t findImmediateChildren_(std::regex& expr,
                                        std::vector<const TreeNode*>& found,
                                        bool allow_private=false) const;
 
        bool locationMatchesPattern(const std::string& pattern,
                                    const TreeNode* pat_loc) const;
 
        TreeNode* getChild(const std::string& name,
                           bool must_exist=true)
        {
            return getChild_(name, must_exist, false /*private_also*/);
        }
 
        const TreeNode* getChild(const std::string& name,
                                 bool must_exist=true) const
        {
            return getChild_(name, must_exist, false /*private also */);
        }
 
 
        std::string getDeepestMatchingPath(const std::string& path) const;
 
        bool hasChild(const std::string& name) const noexcept
        {
            return hasChild_(name, false /*private also */);
        }
 
        bool hasImmediateChild(const TreeNode* n) const noexcept;
 
        template <class T,
                  typename = typename std::enable_if<std::is_pointer<T>::value>::type,
                  class ConstT = typename ptr_to_const_obj_ptr<T>::type>
        const ConstT getChildAs(const std::string& name, bool must_exist=true) const {
            static_assert(std::is_base_of<TreeNode, typename std::remove_pointer<T>::type>::value == true,
                          "Cannot use getChildAs with a type argument that is not a subclass of " \
                          "TreeNode. If the caller is looking for a resource, use " \
                          "getChild(name)->getResource instead.");
            const TreeNode* child = TreeNode::getChild(name, must_exist);
            const ConstT result = dynamic_cast<ConstT>(child);
            if(result == nullptr){
                if(must_exist){
                    throw SpartaException("Could not find child of \"")
                        << getLocation() << "\" with the relative path \""
                        << name << "\" that was of type: const "
                        << demangle(typeid(T*).name()) << ". Found node of type "
                        << demangle(typeid(*child).name());
                }
                return nullptr;
            }
            return result;
        }
 
        // Overload of getChildAs for const access with a non-pointer T typeid
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        const T* getChildAs(const std::string& name, bool must_exist=true) const {
            return getChildAs<const T*>(name, must_exist);
        }
 
        // Overload of getChildAs for non-const access with a non-pointer T type
        template <class T, typename = typename std::enable_if<std::is_pointer<T>::value>::type>
        T getChildAs(const std::string& name, bool must_exist=true) {
            static_assert(std::is_base_of<TreeNode, typename std::remove_pointer<T>::type>::value == true,
                          "Cannot use getChildAs with a type argument that is not a subclass of " \
                          "TreeNode. If the caller is looking for a resource, use " \
                          "getChild(name)->getResource instead.");
            TreeNode* child = TreeNode::getChild(name, must_exist);
            T result = dynamic_cast<T>(child);
            if(result == nullptr){
                if(must_exist){
                    throw SpartaException("Could not find child of \"")
                        << getLocation() << "\" with the relative path \""
                        << name << "\" that was of type: " << demangle(typeid(T).name())
                        << ". Found node of type "<< demangle(typeid(*child).name());
                }
                return nullptr;
            }
            return result;
        }
 
        // Overload of getChildAs for non-const access with a non-pointer T type
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        T* getChildAs(const std::string& name, bool must_exist=true) {
            return getChildAs<T*>(name, must_exist);
        }
 
 
        template <class T,
                  typename = typename std::enable_if<std::is_pointer<T>::value>::type,
                  class ConstT = typename ptr_to_const_obj_ptr<T>::type>
        ConstT getAs() const {
            static_assert(std::is_base_of<TreeNode, typename std::remove_pointer<T>::type>::value == true,
                          "Cannot use getAs with a type argument that is not a subclass of " \
                          "TreeNode.");
            ConstT result = dynamic_cast<typename ptr_to_const_obj_ptr<T>::type>(this);
            if(result == nullptr){
                throw SpartaException("Could not get TreeNode \"")
                    << getLocation() << "\" as type: const " << demangle(typeid(T).name());
            }
            return result;
        }
 
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        const T* getAs() const {
            return getAs<const T*>();
        }
 
        template <class T, typename = typename std::enable_if<std::is_pointer<T>::value>::type>
        T getAs() {
            static_assert(std::is_base_of<TreeNode, typename std::remove_pointer<T>::type>::value == true,
                          "Cannot use getAs with a type argument that is not a subclass of " \
                          "TreeNode.");
            T result = dynamic_cast<T>(this);
            if(result == nullptr){
                throw SpartaException("Could not get TreeNode \"")
                    << getLocation() << "\" as type: " << demangle(typeid(T).name());
            }
            return result;
        }
 
        template <class T, typename = typename std::enable_if<!std::is_pointer<T>::value>::type>
        T* getAs() {
            return getAs<T*>();
        }
 
        uint32_t findChildrenByTag(const std::string& tag,
                                   std::vector<TreeNode*>& results,
                                   int32_t max_depth=-1);
 
        bool isDescendantOf(const TreeNode* ancestor,
                            int32_t max_depth=-1) const;
 
        std::string getLocation() const override final;
 
        std::string getDisplayLocation() const;
 
        std::string getExpectedLocation() const;
 
        std::string renderSubtree(int32_t max_depth=-1,
                                  bool show_builtins=false,
                                  bool names_only=false,
                                  bool hide_hidden=false,
                                  bool(*leaf_filt_fxn)(const TreeNode*) = nullptr) const;
 
        uint32_t getLevel() const;
 
        template <typename T>
        uint32_t getRecursiveNodeCount() const {
            uint32_t count = dynamic_cast<const typename std::remove_const<typename std::remove_pointer<T>::type>::type*>(this) != nullptr;
            for(auto& child : children_){
                count += child->getRecursiveNodeCount<T>();
            }
            return count;
        }
 
        static TreeNode* getVirtualGlobalNode();
 
 
 
        class ExtensionsBase
        {
        public:
            ExtensionsBase();
            virtual ~ExtensionsBase();
            virtual void setParameters(std::unique_ptr<ParameterSet> params) = 0;
            virtual ParameterSet * getParameters() = 0;
            virtual ParameterSet * getYamlOnlyParameters() = 0;
            virtual void postCreate() {}
        };
 
        void addExtensionParameters(const std::string & extension_name,
                                    std::unique_ptr<ParameterSet> extension_params);
 
        void addExtensionFactory(const std::string & extension_name,
                                 std::function<ExtensionsBase*()> factory);
 
        ExtensionsBase * getExtension(const std::string & extension_name);
 
        ExtensionsBase * getExtension();
 
        const std::set<std::string> & getAllExtensionNames();
 
        size_t getNumExtensions() const {
            return extensions_.size();
        }
 
 
 
        void addChild(TreeNode* child, bool inherit_phase=true);
 
        void addChild(TreeNode& child);
 
        void makeSubtreePrivate()
        {
            incrementPrivacyLevel_(1);
        }
 
        void setScopeRoot()
        {
            is_scope_root_ = true;
        }
 
 
        bool isScopeRoot() const
        {
            return is_scope_root_;
        }
 
 
        const Clock* getClock() override{
            if(isFinalized()){
                return working_clock_;
            }else{
                // Search for clock
                TreeNode* n = this;
                while(n){
                    const Clock* c = n->getLocalClock();
                    if(c){
                        return c;
                    }
                    n = n->getParent();
                }
                return nullptr;
            }
        }
 
        const Clock* getClock() const {
            if(isFinalized()){
                return working_clock_;
            }else{
                // Search for clock
                const TreeNode* n = this;
                while(n){
                    const Clock* c = n->getLocalClock();
                    if(c){
                        return c;
                    }
                    n = n->getParent();
                }
                return nullptr;
            }
        }
 
        const Clock* getLocalClock() {
            return clock_;
        }
 
        const Clock* getLocalClock() const {
            return clock_;
        }
 
        virtual void setClock(const Clock * clk);
 
        Scheduler * getScheduler(const bool must_exist = false);
        const Scheduler * getScheduler(const bool must_exist = false) const;
 
        WeakPtr getWeakPtr();
 
        ConstWeakPtr getWeakPtr() const;
 
        virtual void addLink(TreeNode *node, const std::string &label);
 
        virtual void activateLink(const std::string &label);
 
        static std::string createSearchRegexPattern(const std::string& pat);
 
        static bool hasWildcardCharacters(const std::string& name);
 
        static std::string getNextName(const std::string& name, size_t& pos);
 
        static bool matchesGlobLike(const std::string& pattern, const std::string& other);
 
 
    private:
        void lockdownParametersUtil_(){
            for(auto child : children_){
                child->lockdownParametersUtil_();
            }
            special_params_lockdown_ = true;
        }
 
         static node_uid_type getNextNodeUID_();
 
        static void trackParentlessNode_(TreeNode* node);
 
        static void untrackParentlessNode_(TreeNode* node);
 
        static void trackNode_(TreeNode* node);
 
        static void untrackNode_(TreeNode* node) noexcept;
 
        void informAddedChildSubtree_();
 
        void informAddedChildAncestors_(TreeNode* des);
 
        void incrementGetChildCount_(const std::string& name) const;
 
 
        virtual void setParent_(TreeNode* parent, bool inherit_phase);
        void addChild_(TreeNode* child, bool inherit_phase);
        void recursSetPhase_(TreePhase phase);
 
 
 
        void getLocation_(std::stringstream& ss, bool anticipate_parent=false) const;
 
        void getDisplayLocation_(std::stringstream& ss) const;
 
        uint32_t renderSubtree_(std::stringstream& ss,
                                uint32_t indent,
                                int32_t max_depth,
                                bool show_builtins,
                                bool names_only,
                                bool hide_hidden,
                                bool(*leaf_filt_fxn)(const TreeNode*)) const;
 
        virtual TreeNode*
        getImmediateChildByIdentity_(const std::string& name,
                                     bool must_exist=true)
                                       ;
 
        // Overload of getImmediateChildByIdentity_
        virtual const TreeNode*
        getImmediateChildByIdentity_(const std::string& name,
                                     bool must_exist=true)
                                        const;
        void ensureNoParent_(const char* action);
 
        OneWayBool<false> special_params_lockdown_; 
 
 
    protected:
 
        static bool identityMatchesPattern_(const std::string& ident,
                                            std::regex& expr,
                                            std::vector<std::string>& replacements);
 
 
        static bool identityMatchesPattern_(const std::string& ident,
                                            std::regex& expr);
 
        static std::string getPreviousName_(const std::string& name,
                                            size_t& pos);
 
        std::pair<uint32_t, std::string> recursGetDeepestMatchingPath_(const std::string& path,
                                                                       size_t name_pos) const;
 
        void setExpectedParent_(const TreeNode* parent);
 
        void enterFinalizing_();
 
        void finalizeTree_();
 
        void validateTree_();
 
        void enterFinalized_();
 
        void enterConfig_() noexcept;
 
        void bindTreeEarly_();
 
        void bindTreeLate_();
 
        void simulationTerminating_();
 
        void validatePostRun_(const PostRunValidationInfo& info) const;
 
        void dumpDebugContent_(std::ostream& out) const noexcept;
 
 
        void enterTeardown_() noexcept;
 
        void verifyUniqueChildIdentifier_(const std::string& ident,
                                          bool ignore_group_collision=false);
 
        void removeChildForTeardown_(TreeNode* child);
 
        void removeFromParentForTeardown_(TreeNode* parent);
 
        void detachFromParent_();
 
        void detachFromChildren_();
 
        bool areParametersLocked_() const{
            return special_params_lockdown_;
        }
 
 
        class delegate
        {
        public:
 
            typedef void (*stub_type)(void* obj,
                                      const TreeNode& origin,
                                      const TreeNode* obs_pt,
                                      const void* data); //, const std::type_info& tinfo);
 
            delegate() :
                object_ptr(0),
                obs_point(0),
                name_ptr(0),
                stub_ptr(0),
                reveals_origin(true)
            { }
 
            delegate(const delegate&& d) :
                object_ptr(d.object_ptr),
                obs_point(d.obs_point),
                name_ptr(d.name_ptr),
                stub_ptr(d.stub_ptr),
                reveals_origin(d.reveals_origin)
            { }
 
            delegate& operator=(const delegate& d) {
                object_ptr = d.object_ptr;
                obs_point = d.obs_point;
                name_ptr = d.name_ptr;
                stub_ptr = d.stub_ptr;
                reveals_origin = d.reveals_origin;
 
                return *this;
            }
 
            delegate(const delegate& d) :
                object_ptr(d.object_ptr),
                obs_point(d.obs_point),
                name_ptr(d.name_ptr),
                stub_ptr(d.stub_ptr),
                reveals_origin(d.reveals_origin)
            { }
 
 
            template <class DataT, class T, void (T::*TMethod)(const TreeNode&,
                                                               const TreeNode&,
                                                               const DataT&)>
            constexpr bool equals(T* obj,
                                  const TreeNode& obs_pt,
                                  const std::string& name) const
            {
                return (stub_ptr == &method_stub<DataT, T, TMethod>)
                    && (obj == object_ptr)
                    && (&obs_pt == obs_point)
                    && (name == *name_ptr);
            }
 
            template <class DataT, class T, void (T::*TMethod)(const DataT&)>
            constexpr bool equals(T* obj,
                                  const TreeNode& obs_pt,
                                  const std::string& name) const
            {
                return (stub_ptr == &method_stub<DataT, T, TMethod>)
                    && (obj == object_ptr)
                    && (&obs_pt == obs_point)
                    && (name == *name_ptr);
            }
 
 
            bool operator==(const delegate& d) const {
                return (stub_ptr == d.stub_ptr)
                    && (object_ptr == d.object_ptr)
                    && (obs_point == d.obs_point)
                    && (name_ptr == d.name_ptr);
            }
 
            bool observes(const TreeNode& obs_pt, const std::string* name) const
            {
                return (&obs_pt == obs_point)
                       && TreeNode::notificationCategoryMatch(name_ptr, name);
            }
 
            template <class DataT, class T, void (T::*TMethod)(const TreeNode&,
                                                               const TreeNode&,
                                                               const DataT&)>
            static delegate from_method(T* obj,
                                        const TreeNode& obs_pt,
                                        const std::string& name)
            {
                delegate d;
                d.object_ptr = obj;
                d.obs_point = &obs_pt;
                d.name_ptr = StringManager::getStringManager().internString(name);
                d.stub_ptr = &method_stub<DataT, T, TMethod>;
                return d;
            }
 
            template <class DataT, class T, void (T::*TMethod)(const DataT&)>
            static delegate from_method(T* obj,
                                        const TreeNode& obs_pt,
                                        const std::string& name)
            {
                delegate d;
                d.object_ptr = obj;
                d.obs_point = &obs_pt;
                d.name_ptr = StringManager::getStringManager().internString(name);
                d.stub_ptr = &method_stub<DataT, T, TMethod>;
                d.reveals_origin = false;
                return d;
            }
 
            template <typename DataT>
            void operator()(const TreeNode& origin,
                            const DataT& data) const
            {
                (*stub_ptr)(object_ptr, origin, obs_point, &data); //, typeid(DataT));
            }
 
            const std::string* getNameID() const {
                return name_ptr;
            }
 
            const TreeNode* getObservationPoint() const {
                return obs_point;
            }
 
            bool revealsOrigin() const { return reveals_origin; }
 
        private:
 
            template <class DataT, class T, void (T::*TMethod)(const TreeNode&,
                                                               const TreeNode&,
                                                               const DataT&)>
            static void method_stub(void* obj,
                                    const TreeNode& origin,
                                    const TreeNode* obs_pt,
                                    const void* data)
            {
                // Check type
                //sparta_assert(tinfo == typeid(DataT),
                //                  "Expected to invoke method delegate for data type \"" << typeid(DataT).name()
                //                  << "\" with incorrect data type \"" << typeid(tinfo).name() << "\"")
 
                T* p = static_cast<T*>(obj);
                const DataT& d = *static_cast<const DataT*>(data);
                return (p->*TMethod)(origin, *obs_pt, d);
            }
 
            template <class DataT, class T, void (T::*TMethod)(const DataT&)>
            static void method_stub(void* obj,
                                    const TreeNode& origin,
                                    const TreeNode* obs_pt,
                                    const void* data)
            {
                (void) origin;
                (void) obs_pt;
                T* p = static_cast<T*>(obj);
                const DataT& d = *static_cast<const DataT*>(data);
                return (p->*TMethod)(d);
            }
 
            template <class DataT, void (*TMethod)(const TreeNode&,
                                                   const TreeNode&,
                                                   const DataT&)>
            static void method_stub(void* obj,
                                    const TreeNode& origin,
                                    const TreeNode* obs_pt,
                                    const void* data)
            {
                (void) obj;
                const DataT& d = *static_cast<const DataT*>(data);
                return (*TMethod)(origin, *obs_pt, d);
            }
 
            template <class DataT, void (*TMethod)(const DataT&)>
            static void method_stub(void* obj,
                                    const TreeNode& origin,
                                    const TreeNode* obs_pt,
                                    const void* data)
            {
                (void) obj;
                (void) origin;
                (void) obs_pt;
                const DataT& d = *static_cast<const DataT*>(data);
                return (*TMethod)(d);
            }
 
            void* object_ptr;
 
            const TreeNode* obs_point;
 
            const std::string* name_ptr;
 
            stub_type stub_ptr;
 
            bool reveals_origin = true;
        };
 
        class type_info_container {
 
            const std::type_info* tinfo_;
            size_t hash_code_;
 
        public:
 
            type_info_container() = delete;
 
            type_info_container(const type_info_container& rhp) :
                tinfo_(rhp.tinfo_),
                hash_code_(rhp.hash_code_)
            { }
 
            type_info_container(const std::type_info& tinfo) :
                tinfo_(&tinfo),
                hash_code_(tinfo.hash_code())
            { }
 
            bool operator==(const type_info_container& rhp) const {
                return hash_code_ == rhp.hash_code_;
            }
 
            bool operator<(const type_info_container& rhp) const {
                return hash_code_ < rhp.hash_code_;
            }
 
            const std::type_info& operator*() const {
                return *tinfo_;
            }
 
            const std::type_info* get() const {
                return tinfo_;
            }
        };
 
        typedef std::vector<delegate> DelegateVector;
 
        typedef std::map<type_info_container, DelegateVector> NotificationObserverMap;
 
 
        template <typename DataT>
        void postPropagatingNotification_(const TreeNode* origin,
                                          const DataT& data,
                                          const std::string* name_id) {
            // Assure that this notification passes canGenerateNotification. It
            // is of no use to us if nodes are generating Notifications that no
            // observer can possible expect by examining the tree.
            // Skip this in production builds for performance
#ifndef NDEBUG
            sparta_assert(origin);
            sparta_assert(name_id);
            NotificationInfo info(origin, &typeid(DataT), name_id);
            if(!canGenerateNotification(info)){
                throw SpartaException("TreeNode ")
                    << getLocation() << " posted a notification <"
                    << origin->getLocation() << ", \"" << demangle(typeid(DataT).name())
                    << "\", \"" << *name_id
                    << "\"> which it did not properly announce through canGenerateNotification";
            }
#endif
            propagateNotification_(origin, data, name_id);
 
            // Post to the global virtual node
            getVirtualGlobalNode()->propagateNotification_(origin, data, name_id);
        }
 
        template <typename DataT, typename T, void (T::*TMethod)(const TreeNode&,
                                                                 const TreeNode&,
                                                                 const DataT&)>
        DelegateVector::iterator findDelegate_(DelegateVector& dvec,
                                               T* obj,
                                               const std::string& target_name) {
            const DelegateVector::const_iterator dend = dvec.end();
            DelegateVector::iterator d;
            for(d=dvec.begin(); d!=dend; ++d){
                if(d->equals<DataT, T, TMethod>(obj, *this, target_name)){
                    break;
                }
            }
            return d;
        }
 
        // Overload of findDelegate_ with one TMethod signature having a sole DataT parameter
        template <typename DataT, typename T, void (T::*TMethod)(const DataT&)>
        DelegateVector::iterator findDelegate_(DelegateVector& dvec,
                                               T* obj,
                                               const std::string& target_name) {
            const DelegateVector::const_iterator dend = dvec.end();
            DelegateVector::iterator d;
            for(d=dvec.begin(); d!=dend; ++d){
                if(d->equals<DataT, T, TMethod>(obj, *this, target_name)){
                    break;
                }
            }
            return d;
        }
 
        virtual void
        broadcastRegistrationForNotificationToChildren_(const std::type_info& tinfo,
                                                        const std::vector<const std::string*>& name_ids,
                                                        TreeNode* obs_node,
                                                        const delegate* del,
                                                        const bool allow_private);
 
        virtual void
        broadcastDeregistrationForNotificationToChildren_(const std::type_info& tinfo,
                                                          const std::vector<const std::string*>& name_ids,
                                                          TreeNode* obs_node,
                                                          const delegate* del,
                                                          const bool allow_private);
 
        void
        broadcastRegistrationForNotificationListStringToChildren_(const std::type_info& tinfo,
                                                                  const std::string& name,
                                                                  TreeNode* obs_node,
                                                                  const delegate* del,
                                                                  const bool private_only)
        {
            auto names = parseNotificationNameString(name);
            broadcastRegistrationForNotificationToChildren_(tinfo, names, obs_node, del,
                                                            private_only);
        }
 
        void
        broadcastDeregistrationForNotificationListStringToChildren_(const std::type_info& tinfo,
                                                                    const std::string& name,
                                                                    TreeNode* obs_node,
                                                                    const delegate* del,
                                                                    const bool private_only)
        {
            auto names = parseNotificationNameString(name);
            broadcastDeregistrationForNotificationToChildren_(tinfo, names, obs_node, del,
                                                              private_only);
        }
 
        template <typename DataT>
        void invokeDelegatesOn_(TreeNode* to_invoke,
                                const DataT& data,
                                const std::string* name_id) {
            to_invoke->invokeDelegates_(this, data, name_id);
        }
 
    private:
 
        template <typename DataT>
        void invokeDelegates_(const TreeNode* origin,
                              const DataT& data,
                              const std::string* name_id) {
            auto itr = obs_local_.find(typeid(DataT));
            if(itr != obs_local_.end()){
                DelegateVector& observers = itr->second;
                for(delegate& d : observers) {
                    // Invoke delegate if matched
                    if(d.getNameID() == name_id
                       || d.getNameID() == StringManager::getStringManager().EMPTY){
                        d(*origin, data); // invoke
                    }
                }
            }
        }
 
        template <typename DataT>
        void propagateNotification_(const TreeNode* origin,
                                    const DataT& data,
                                    const std::string* name_id) {
 
            invokeDelegates_<DataT>(origin, data, name_id);
 
            if(getParent() != nullptr){
                getParent()->propagateNotification_(origin, data, name_id);
            }
        }
 
        // Internal Notification System
 
    public:
 
 
        struct NotificationInfo {
 
            NotificationInfo(const TreeNode* _origin,
                             const std::type_info* _tinfo,
                             const std::string* _name) :
                origin(_origin),
                tinfo(_tinfo),
                name(_name)
            {
                checkValid();
            }
 
            NotificationInfo(const NotificationInfo&& rhp) :
                origin(rhp.origin),
                tinfo(rhp.tinfo),
                name(rhp.name)
            {
                checkValid();
            }
 
            NotificationInfo(const NotificationInfo& rhp) :
                origin(rhp.origin),
                tinfo(rhp.tinfo),
                name(rhp.name)
            {
                checkValid();
            }
 
            NotificationInfo& operator=(const NotificationInfo& rhp) {
                rhp.checkValid();
                origin = rhp.origin;
                tinfo = rhp.tinfo;
                name = rhp.name;
                return *this;
            }
 
            void checkValid() const {
                sparta_assert(origin);
                sparta_assert(tinfo);
                sparta_assert(name);
            }
 
            const TreeNode* origin;
 
            const std::type_info* tinfo;
 
            const std::string* name;
        };
 
        uint32_t getPossibleNotifications(std::vector<NotificationInfo>& infos) const;
 
        void dumpPossibleNotifications(std::ostream& o) const noexcept;
 
        template <typename DataT=ANY_TYPE>
        uint32_t locateNotificationSources(std::vector<TreeNode*>& nodes,
                                           const std::string& name="") {
            static_assert(std::is_same<
                              typename std::remove_cv<
                                  typename std::remove_reference<
                                      typename std::remove_pointer<DataT>::type
                                  >::type
                              >::type,
                              DataT
                          >::value,
                          "DataT must NOT be a const, volatile, pointer, or reference"
                          "type. It violates at least one of these restrictions");
 
            auto& strmgr = StringManager::getStringManager();
            const std::string* name_id = strmgr.internString(name);
            return locateNotificationSources_<DataT>(nodes, name_id);
        }
 
        template <typename DataT=ANY_TYPE>
        void dumpLocatedNotificationSources(std::ostream& o, const std::string& name=""){
            std::vector<TreeNode*> nodes;
            locateNotificationSources<DataT>(nodes, name);
            for(const TreeNode* n : nodes){
                o << n->stringize() << std::endl;
            }
        }
 
        uint32_t getPossibleSubtreeNotifications(std::vector<NotificationInfo>& infos) const noexcept;
        void dumpPossibleSubtreeNotifications(std::ostream& o) const noexcept;
 
        bool canGenerateNotification(const std::type_info& tinfo,
                                     const std::string* name) const;
 
        bool canGenerateNotification(const std::type_info& tinfo,
                                     const std::string& name) const;
 
        bool canGenerateNotification(const NotificationInfo& info) const;
 
        bool canSubtreeGenerateNotification(const std::type_info& tinfo,
                                            const std::string* name) const;
 
        bool canSubtreeGenerateNotification(const std::type_info& tinfo,
                                            const std::string& name) const;
 
        bool canSubtreeGenerateNotifications(const std::type_info& tinfo,
                                            const std::vector<const std::string*>& names) const;
 
        static std::vector<const std::string*> parseNotificationNameString(const std::string& csl);
 
        template <typename DataT, typename T, void (T::*TMethod)(const TreeNode&, const TreeNode&, const DataT&)>
        void registerForNotification(T* obj, const std::string& name, bool ensure_possible=true)
        {
            registerForNotification_<DataT, T, TMethod>(obj, name, ensure_possible, false /*allow_private*/);
        }
 
        // Overload which allows registration with a class member function accepting only a data argument
        template <typename DataT, typename T, void (T::*TMethod)(const DataT&)>
        void registerForNotification(T* obj, const std::string& name, bool ensure_possible=true)
        {
            registerForNotification_<DataT, T, TMethod>(obj, name, ensure_possible, false /*allow_private*/);
        }
 
        template <typename DataT, typename T, void (T::*TMethod)(const TreeNode&, const TreeNode&, const DataT&)>
        void deregisterForNotification(T* obj, const std::string& name)
        {
            deregisterForNotification_<DataT, T, TMethod>(obj, name, false /* allow_private */);
        }
 
        // Overload which allows deregistration with a class member function accepting only a data argument
        template <typename DataT, typename T, void (T::*TMethod)(const DataT&)>
        void deregisterForNotification(T* obj, const std::string& name)
        {
            deregisterForNotification_<DataT, T, TMethod>(obj, name, false /* allow_private */);
        }
 
        bool hasObserversRegisteredForNotification(const std::type_info& tinfo,
                                                   const std::string* name) const noexcept;
 
        void getDelegatesRegisteredForNotification(const std::type_info& tinfo,
                                                   const std::string* name,
                                                   std::vector<delegate>& dels) noexcept;
 
        static bool notificationCategoryMatch(const std::string* query_id,
                                              const std::string* node_id);
 
        // Public Notification System
 
    private:
 
        void incrementPrivacyLevel_(uint32_t privacy_increment)
        {
            privacy_level_ += privacy_increment;
            for (auto n : children_)
            {
                n->incrementPrivacyLevel_(privacy_increment);
            }
        }
 
        virtual void onAddingChild_(TreeNode* child) {
            (void) child;
            // No actions by default
            // Could throw to reject child
        }
 
        virtual void onSettingParent_(const TreeNode* parent) const {
            (void) parent;
            // No actions by default
            // Could throw to reject parent
        }
 
        virtual void onAddedAsChild_() noexcept {
        }
 
        virtual void onDescendentSubtreeAdded_(TreeNode* des) noexcept {
            (void) des;
        }
 
        virtual void onDestroyingParent_() noexcept {
        }
 
        virtual void onDestroyingChild_(TreeNode* child) noexcept {
            (void) child;
        }
 
        virtual void onConfiguring_() {;}
 
        virtual void onBindTreeEarly_() {;}
 
        virtual void onBindTreeLate_() {;}
 
        virtual void onEnteringTeardown_() noexcept {
        }
 
        void addChildNameMapping_(const std::string& name,
                                  TreeNode* child);
 
        template <typename DataT>
        uint32_t locateNotificationSources_(std::vector<TreeNode*>& nodes, const std::string* name_id){
            uint32_t additions = 0;
 
            const std::string* dummy;
            if(canGenerateNotification_(typeid(DataT), name_id, dummy)){
                nodes.push_back(this);
                ++additions;
            }
 
            for(TreeNode* child : children_){
                additions += child->template locateNotificationSources_<DataT>(nodes, name_id);
            }
            return additions;
        }
 
        virtual void notificationObserverAdded_(const std::type_info& tinfo,
                                                const std::string* name_id,
                                                TreeNode* obs_node,
                                                const delegate* del) {
            (void) tinfo;
            (void) name_id;
            (void) obs_node;
            (void) del;
        }
 
 
        virtual void notificationObserverRemoved_(const std::type_info& tinfo,
                                                  const std::string* name_id,
                                                  TreeNode* obs_node,
                                                  const delegate* del) {
            (void) tinfo;
            (void) name_id;
            (void) obs_node;
            (void) del;
        }
 
        virtual bool canGenerateNotification_(const std::type_info& tinfo,
                                              const std::string* name,
                                              const std::string*& match) const {
            (void) tinfo;
            (void) name;
            (void) match;
            return false;
        }
 
        virtual void getPossibleNotifications_(std::vector<NotificationInfo>& infos) const {
            (void) infos;
        }
 
        virtual void createResource_() {
            sparta_assert(isFinalizing()); // Must be in the finalizing phase
        }
 
        virtual void validateNode_() const {
        }
 
        bool canSeeChild_(const TreeNode* node) const
        {
            sparta_assert(node != nullptr);
            // If the node is not on the same privacy level then we can't see it.
            return (privacy_level_ == node->privacy_level_);
        }
        uint32_t findChildren_(const std::string& pattern,
                               std::vector<TreeNode*>& results,
                               std::vector<std::vector<std::string>>& replacements,
                               bool allow_private);
 
        uint32_t findChildren_(const std::string& pattern,
                               std::vector<TreeNode*>& results,
                               bool allow_private);
        template <typename DataT, typename T, void (T::*TMethod)(const TreeNode&, const TreeNode&, const DataT&)>
        void registerForNotification_(T* obj, const std::string& name, bool ensure_possible=true, bool allow_private=false)
        {
            (void)allow_private;
            const std::type_info& data_type = typeid(DataT);
            if(true == ensure_possible && false == canSubtreeGenerateNotification(data_type, name)){
                throw SpartaException("Cannot registerForNotification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" and name=\"" << name << "\" on node " << getLocation()
                    << " with callback on \"" << demangle(typeid(T).name()) << "\""
                    << "\" because this notification cannot possibly be generated by any descendant of this "
                    << "node. Set ensure_possible=false to prevent this check if additional notification "
                    << "source descendants are expected to be added. "
                    << "It is possible the node generating the desired notification is in a private sub tree.";
            }
 
            DelegateVector& observers = obs_local_[data_type]; // Create notification map
            if(findDelegate_<DataT, T, TMethod>(observers, obj, name) != observers.end()){
                throw SpartaException("Already observing a notification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" Name \"" << name << "\" on node " << getLocation()
                    << " with callback on \"" << demangle(typeid(T).name()) << "\""
                    << "\". Cannot register";
            }
 
            delegate d = delegate::from_method<DataT, T, TMethod>(obj, *this, name);
            observers.push_back(std::move(d));
 
            // Let children know
            broadcastRegistrationForNotificationListStringToChildren_(typeid(DataT), name, this, &observers.back(), allow_private);
        }
 
        // Overload which allows registration with a class member function accepting only a data argument
        template <typename DataT, typename T, void (T::*TMethod)(const DataT&)>
        void registerForNotification_(T* obj, const std::string& name, bool ensure_possible=true, const bool allow_private=false)
        {
            (void)allow_private;
            const std::type_info& data_type = typeid(DataT);
            if(true == ensure_possible && false == canSubtreeGenerateNotification(data_type, name)){
                throw SpartaException("Cannot registerForNotification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" and name=\"" << name << "\" on node " << getLocation()
                    << " with callback on \"" << demangle(typeid(T).name()) << "\""
                    << "\" because this notification cannot possibly be generated by any descendant of this "
                    << "node. Set ensure_possible=false to prevent this check if additional notification "
                    << "source descendants are expected to be added. "
                    << "It is possible the node generating the desired notification is in a private sub tree.";
            }
 
            DelegateVector& observers = obs_local_[data_type]; // Create notification map
            if(findDelegate_<DataT, T, TMethod>(observers, obj, name) != observers.end()){
                throw SpartaException("Already observing a notification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" Name \"" << name << "\" on node " << getLocation()
                    << " with callback on \"" << demangle(typeid(T).name()) << "\""
                    << "\". Cannot register";
            }
 
            delegate d = delegate::from_method<DataT, T, TMethod>(obj, *this, name);
            observers.push_back(std::move(d));
 
            // Let children know
            broadcastRegistrationForNotificationListStringToChildren_(typeid(DataT), name, this, &observers.back(), allow_private);
        }
 
        template <typename DataT, typename T, void (T::*TMethod)(const TreeNode&, const TreeNode&, const DataT&)>
        void deregisterForNotification_(T* obj, const std::string& name, const bool allow_private)
        {
            (void)allow_private;
            const std::type_info& data_type = typeid(DataT);
            auto itr = obs_local_.find(data_type);
            if(itr == obs_local_.end()){
                throw SpartaException("Not currently observing any notification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" Name \"" << name << "\" on node " << getLocation()
                    << " with callback on \"" << demangle(typeid(T).name()) << "\" function \"" << TMethod
                    << "\". Cannot deregister";
            }
            DelegateVector& observers = itr->second;
            DelegateVector::iterator d = findDelegate_<DataT, T, TMethod>(observers, obj, name);
            if(observers.end() == d){
                throw SpartaException("Not currently observing a notification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" Name \"" << name << "\" on node " << getLocation()
                    << " . Attempted to deregister \"" << demangle(typeid(T).name()) << "\" function \"" << TMethod
                    << "\". Cannot deregister";
            }
 
            // Let children know that a delegate has been deregistered
            broadcastDeregistrationForNotificationListStringToChildren_(data_type, name, this, &(*d), allow_private);
 
            observers.erase(d);
        }
        // Overload which allows deregistration with a class member function accepting only a data argument
        template <typename DataT, typename T, void (T::*TMethod)(const DataT&)>
        void deregisterForNotification_(T* obj, const std::string& name, const bool allow_private)
        {
            (void)allow_private;
            const std::type_info& data_type = typeid(DataT);
            auto itr = obs_local_.find(data_type);
            if(itr == obs_local_.end()){
                throw SpartaException("Not currently observing any notification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" Name \"" << name << "\" on node " << getLocation()
                    << " with callback on \"" << demangle(typeid(T).name()) << "\" function \"" << TMethod
                    << "\". Cannot deregister";
            }
            DelegateVector& observers = itr->second;
            DelegateVector::iterator d = findDelegate_<DataT, T, TMethod>(observers, obj, name);
            if(observers.end() == d){
                throw SpartaException("Not currently observing a notification for data type \"")
                    << demangle(typeid(DataT).name()) << "\" Name \"" << name << "\" on node " << getLocation()
                    << " . Attempted to deregister \"" << demangle(typeid(T).name()) << "\" function \"" << TMethod
                    << "\". Cannot deregister";
            }
 
            // Let children know that a delegate has been deregistered
            broadcastDeregistrationForNotificationListStringToChildren_(data_type, name, this, &(*d), allow_private);
 
            observers.erase(d);
        }
        const TreeNode::ChildrenVector& getAllChildren_() const
        {
            return children_;
        }
 
        template <typename T> T *getScopeRootImpl_(T *node) const;
 
        TreeNode* getChild_(const std::string& name,
                            bool must_exist,
                            bool private_also);
 
        const TreeNode* getChild_(const std::string& name,
                                 bool must_exist,
                                 bool private_also) const;
 
        bool hasChild_(const std::string& name, bool private_also) const noexcept;
 
    private:
 
        const node_uid_type node_uid_;
 
        const std::string* name_;
 
        const bool anon_;
 
        const bool is_indexable_;
 
        const std::string * const group_ptr_;
 
        const group_idx_type group_idx_;
 
        std::vector<const std::string*> tags_;
 
        const std::string * const desc_ptr_;
 
        const std::string* parent_loc_;
 
        TreeNode* parent_;
 
        bool is_attached_;
 
        const Clock* clock_;
 
        const Clock* working_clock_;
 
        std::unordered_map<std::string, std::unique_ptr<ExtensionsBase>> extensions_;
        std::unordered_map<std::string, std::unique_ptr<ParameterSet>> extension_parameters_;
        std::unordered_map<std::string, std::function<ExtensionsBase*()>> extension_factories_;
        std::set<std::string> extension_names_;
        ExtensionDescriptorVec extension_descs_;
 
 
        mutable uint32_t num_children_finds_;
 
        mutable uint32_t num_children_gets_;
 
 
        const TreeNode* expected_parent_;
 
        bool is_builtin_;
 
        bool is_hidden_;
 
        AliasVector aliases_;
 
        SharedPtr self_ptr_;
 
        ChildrenVector children_;
 
        ChildNameMapping names_;
 
        NotificationObserverMap obs_local_;
 
        bool is_expired_;
 
        uint32_t privacy_level_ = 0;
 
        bool is_scope_root_ = false;
 
        class TreeNodeStatics {
        public:
            std::map<const TreeNode*, WeakPtr> parentless_map_;
 
            std::map<const TreeNode*, WeakPtr> node_map_;
        };
        static TreeNodeStatics *statics_;
 
        static node_uid_type next_node_uid_;
 
        static TagsMap global_tags_map_;
 
        static uint32_t teardown_errors_;
    };
 
    template<class Ch,class Tr>
    inline std::basic_ostream<Ch,Tr>&
    operator<< (std::basic_ostream<Ch,Tr>& out, sparta::TreeNode const & tn) {
        out << tn.stringize();
        return out;
    }
 
    inline std::ostream& operator<< (std::ostream& out, sparta::TreeNode const * tn) {
        if(nullptr == tn){
            out << "null";
        }else{
            out << tn->stringize();
        }
        return out;
    }
} // namespace sparta