SystemNode.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
#pragma once
#include <agxSensor/export.h>
 
#include <agx/Referenced.h>
#include <agx/BitState.h>
 
#include <agxStream/Serializable.h>
 
#include <queue>
#include <stack>
 
namespace agxRender
{
  class RenderManager;
}
 
namespace agxSensor
{
  class Environment;
 
  AGX_DECLARE_POINTER_TYPES( SystemNode );
  AGX_DECLARE_VECTOR_TYPES( SystemNode );
 
  class AGXSENSOR_EXPORT SystemNode : public agx::Referenced, public agxStream::Serializable
  {
    public:
      struct CallbackData
      {
        agx::Real dt = 1.0 / 60.0;
      };
 
    public:
      void setName( const agx::Name& name );
 
      const agx::Name& getName() const;
 
      void setEnable( bool enable );
 
      bool getEnable() const;
 
      bool addChild( SystemNode* child );
 
      bool appendChild( SystemNode* child );
 
      bool removeChild( SystemNode* child );
 
      bool detachChild( SystemNode* child );
 
      virtual bool insertParent( SystemNode& parent );
 
      virtual bool eraseAndConnect();
 
      bool hasChild( const SystemNode* child, bool recurse = true ) const;
 
      size_t getNumChildren() const;
 
      SystemNode* getChild( size_t index ) const;
 
      template<typename VisitorT>
      SystemNode* visitBf( VisitorT visitor ) const;
 
      template<typename VisitorT>
      SystemNode* visitChildrenBf( VisitorT visitor ) const;
 
      template<typename VisitorT>
      SystemNode* visitDf( VisitorT visitor ) const;
 
      template<typename VisitorT>
      SystemNode* visitChildrenDf( VisitorT visitor ) const;
 
      template<typename T>
      T* getChild() const;
 
      template<typename PredicateT>
      SystemNode* findChild( PredicateT pred, bool recurse = true ) const;
 
      template<typename T>
      T* findChild( bool recurse = true ) const;
 
      SystemNode* getParent() const;
 
      template<typename PredicateT>
      SystemNode* findParent( PredicateT pred ) const;
 
      template<typename T>
      T* findParent() const;
 
      template<typename VisitorT>
      void visitChildren( VisitorT visitor, bool recurse = true ) const;
 
      template<typename T, typename VisitorT>
      void visitChildrenOfType( VisitorT visitor, bool recurse = true) const;
 
      SystemNode* getRoot() const;
 
      Environment* getEnvironment() const;
 
    public:
      SystemNode( const SystemNode& ) = delete;
 
      virtual ~SystemNode() = default;
 
      virtual bool addNotification();
 
      virtual void removeNotification();
 
      virtual void onChildAdded( SystemNode& child );
 
      virtual void onChildRemoved( SystemNode& child );
 
      virtual bool onAdd( agx::Referenced& instance );
 
      virtual bool onRemove( agx::Referenced& instance );
 
      virtual void synchronize( const CallbackData& data );
 
      virtual void execute( const CallbackData& data );
      
      virtual void complete();
 
      virtual void result( const CallbackData& data );
 
      virtual void synchronizeGraphics( const agxRender::RenderManager& renderManager );
 
      virtual void cleanup() = 0;
 
      DOXYGEN_START_INTERNAL_BLOCK()
 
    public:
      void printTree(std::ostream& out) const;
 
      void printTree(std::ostream& out, size_t& depth) const;
 
      AGXSTREAM_DECLARE_ABSTRACT_SERIALIZABLE( agxSensor::SystemNode );
 
      virtual void store( agxStream::OutputArchive& out ) const override;
      virtual void restore( agxStream::InputArchive& in ) override;
 
    protected:
      SystemNode();
 
    protected:
      SystemNode* m_parent;
      SystemNodeRefVector m_children;
 
      struct CallbackEvent
      {
        enum CallbackType
        {
          SYNC,
          EXECUTE,
          COMPLETE,
          RESULT,
          CLEANUP
        };
 
        CallbackType type;
        CallbackData data;
      };
 
      virtual void invoke( const CallbackEvent& callbackEvent );
 
    private:
      friend Environment;
 
      struct InternalState
      {
        enum Flag : agx::UInt32
        {
          ENABLED = 1 << 0,
        };
        using Flags = agx::BitState<Flag, std::underlying_type_t<Flag>>;
        Flags flags;
 
        InternalState()
          : flags( ENABLED )
        {
        }
      };
 
      DOXYGEN_END_INTERNAL_BLOCK()
 
    private:
      bool setEnvironment( Environment* environment );
 
    private:
      Environment* m_environment;
      agx::Name m_name;
      InternalState m_state;
  };
 
  template<typename VisitorT>
  SystemNode* SystemNode::visitBf( VisitorT visitor ) const
  {
    auto self = const_cast<SystemNode*>( this );
    if ( visitor( *self ) )
      return self;
 
    return this->visitChildrenBf( visitor );
  }
 
  template<typename VisitorT>
  SystemNode* SystemNode::visitChildrenBf( VisitorT visitor ) const
  {
    using SystemNodeQueue = std::queue<SystemNode*>;
 
    SystemNodeQueue queue;
 
    for ( auto& child : m_children )
      queue.push( child );
 
    while ( !queue.empty() ) {
      auto node = queue.front();
      queue.pop();
 
      if ( visitor( *node ) )
        return node;
 
      for ( auto& child : node->m_children )
        queue.push( child );
    }
 
    return nullptr;
  }
 
  template<typename VisitorT>
  SystemNode* SystemNode::visitDf( VisitorT visitor ) const
  {
    auto self = const_cast<SystemNode*>( this );
    if ( visitor( *self ) )
      return self;
 
    return this->visitChildrenDf( visitor );
  }
 
  template<typename VisitorT>
  SystemNode* SystemNode::visitChildrenDf( VisitorT visitor ) const
  {
    using SystemNodeStack = std::stack<SystemNode*>;
 
    SystemNodeStack stack;
 
    for ( auto& myChild : m_children ) {
      stack.push( myChild );
 
      while ( !stack.empty() ) {
        auto node = stack.top();
        stack.pop();
 
        if ( visitor( *node ) )
          return node;
 
        for ( auto it = node->m_children.rbegin(); it != node->m_children.rend(); ++it )
          stack.push( *it );
      }
    }
 
    return nullptr;
  }
 
  template<typename T>
  T* SystemNode::getChild() const
  {
    return this->template findChild<T>( false );
  }
 
  template<typename PredicateT>
  SystemNode* SystemNode::findChild( PredicateT pred, bool recurse /*= true*/ ) const
  {
    if ( recurse ) {
      return this->visitChildrenDf( [&pred]( const SystemNode& node )
                                    {
                                      return pred( node );
                                    } );
    }
    else {
      auto it = std::find_if( m_children.begin(),
                              m_children.end(),
                              [&pred]( const SystemNodeRef& child )
                              {
                                return child != nullptr && pred( *child.get() );
                              } );
      return it != m_children.end() ?
               (SystemNode*)it->get() :
               nullptr;
    }
  }
 
  template<typename T>
  T* SystemNode::findChild( bool recurse /*= true*/ ) const
  {
    auto child = this->findChild( []( const SystemNode& child )
                                  {
                                    return child.template asSafe<T>() != nullptr;
                                  },
                                  recurse );
    return child != nullptr ? child->template as<T>() : nullptr;
  }
 
  template<typename VisitorT>
  void SystemNode::visitChildren( VisitorT visitor, bool recurse /*= true*/ ) const
  {
    if ( recurse ) {
      this->visitChildrenBf( [&visitor]( SystemNode& child )
                             {
                               visitor( child );
                               return false;
                             } );
    }
    else {
      for ( auto& child : m_children )
        visitor( *child );
    }
  }
 
  template<typename PredicateT>
  SystemNode* SystemNode::findParent( PredicateT pred ) const
  {
    auto parent = const_cast<SystemNode*>( this );
    while ( ( parent = parent->getParent() ) != nullptr && !pred( *parent ) )
      ;
 
    return parent;
  }
 
  template<typename T>
  T* SystemNode::findParent() const
  {
    auto parent = this->findParent( []( const SystemNode& parent )
                                    {
                                      return parent.template asSafe<T>() != nullptr;
                                    } );
    return parent != nullptr ? parent->template asSafe<T>() : nullptr;
  }
 
  template<typename T, typename VisitorT>
  void SystemNode::visitChildrenOfType( VisitorT visitor, bool recurse /*= true*/ ) const
  {
    this->visitChildren( [&visitor]( SystemNode& child )
                         {
                           if ( auto childT = child.template asSafe<T>() )
                             visitor( *childT );
                         },
                         recurse );
  }
}