Node.h

Go to the documentation of this file.

/*

             *
            ***
           *****
   *********************       Mercenaries Engineering SARL
     *****************              Copyright (C) 2018
       *************
         *********        http://www.mercenaries-engineering.com
        ***********
       ****     ****
      **           **

*/
#pragma once

#include <optional>

#include "Impl.h"
#include "Plug.h"

  namespace maquina
  {

    class MAQUINA_EXPORT Node
    {
    public:

      Node(const char* type,    
        const char* name,       
        Node* parent = nullptr, 
        bool undo_stack=false   
      );

      Node duplicate(
        Node* parent = nullptr, 
        bool undo_stack = false   
       ) const;


      void delete_node(
        bool undo_stack=false 
      );

      void rename(
        const char* new_name,    
        bool undo_stack = false  
      );

      const char* name() const;

      std::string full_name() const;

      std::string full_document_name() const;

      std::shared_ptr<AttributeDescriptor> description() const;

      void set_description(const std::string& description, bool undo_stack = false);

      const char* type_name() const;

      bool is_deleted() const;

      bool is_instance( const char* node_type_name ) const;


      bool is_referenced() const;


      bool is_mutable() const;


      bool is_reference_root() const;

      bool is_reference_loaded() const;

      bool is_serializable() const;

      bool is_singleton() const;
      void set_singleton(bool singleton);


      bool is_document_node() const;

      void set_serializable( bool serialize );


      std::wstring reference_filename() const;


      void unload_reference();


      void load_reference();


      void replace_reference(const std::wstring& new_reference);


      void flatten_reference();


      void write(const std::wstring& filename) const;


      class MAQUINA_EXPORT Children
      {
      public:
        class MAQUINA_EXPORT Iterator
        {
        public:
          using iterator_category = std::forward_iterator_tag;
          using value_type = Node;
          using difference_type = std::ptrdiff_t;
          using pointer = Node;
          using reference = Node;

          reference operator*() const;
          bool operator==(const Iterator &other) const;
          bool operator!=(const Iterator &other) const;
          Iterator& operator++();
          Iterator(void *iterator);
          Iterator( const Iterator &other );
          ~Iterator();
       private:
          void *_internal;
        };

        Children( void *node )
          : _node{ node }
        {}
        Iterator begin() const;
        Iterator end() const;

        size_t size() const;
      private:
        void* _node;
      };

      Children children() const;

      bool has_parent() const;


      Node parent() const;


      void set_parent(Node& parent, bool undo_stack);


      std::optional<Node> document() const;

      bool has_child(const char* child_name) const;


      Node child(const char* name) const;

      bool is_child_of(const Node& parent) const;


      Node find_first(const char* name) const;
    

      class MAQUINA_EXPORT Plugs
      {
      public:
        class MAQUINA_EXPORT Iterator
        {
        public:
          using iterator_category = std::forward_iterator_tag;
          using value_type = Plug;
          using difference_type = std::ptrdiff_t;
          using pointer = Plug;
          using reference = Plug;

          reference operator*() const;
          bool operator==(const Iterator &other) const;
          bool operator!=(const Iterator &other) const;
          Iterator& operator++();
          Iterator( const std::shared_ptr< Impl > &node, void *iterator );
          Iterator( const Iterator &other );
          ~Iterator();
        private:
          std::shared_ptr< Impl > _node;
          void *_internal;
        };

        Plugs( void *node )
          : _node{ node }
        {}
        Iterator begin();
        Iterator end();
      private:
        void* _node;
      };

      Plugs plugs() const;

      bool has_plug(const char* plug_name) const;

      using Flags = Plug::Flags;
      
      Plug add_plug( const char* name, const Value& default_value, int flags = Flags::serial, bool undo_stack = false, const std::string & description = "" );

      void rename_plug( const Plug& plug, const char* new_name, bool undo_stack = false );

      void remove_plug( const char* name, bool undo_stack = false );

      void remove_plug( const Plug& plug, bool undo_stack = false );


      Plug plug(const char* plug_name) const;

      [[deprecated]]
      std::vector<Plug> channel_plugs() const;

      std::vector<Channel> channels() const;

      std::shared_ptr<Channel> channel(ChannelType channel_type) const;


      std::vector<Node> relationship();

      const std::vector<std::string>& bases() const;

      Node random_child();

      std::shared_ptr<NodePlugin> plugin() const;


      std::vector<Node> search(
        const std::string& key 
      ) const;


      std::shared_ptr<class NodeDelegate> node_delegate();


      void notify_first_init(bool undo_stack);


      void set_graph_properties(const class GraphProperties& gp);

      bool is_selected() const;

      std::optional<Plug> channel_switch_sub_channel(const std::string_view& sub_channel) const;

      bool operator==(const Node& o) const { return _impl == o._impl; }
      bool operator!=(const Node& o) const { return _impl != o._impl; }

      std::shared_ptr<Impl> _impl;

      Node(const std::shared_ptr<Impl>& impl)
        : _impl{ impl }
      {}
    };

    // This is can't be done in Plug:: because of a cyclic class definition issue
    MAQUINA_EXPORT Node plug_node(const Plug& plug);
  }