Node.h

Go to the documentation of this file.

/*

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

*/
#pragma once

#include "Impl.h"
#include "Plug.h"
#include "StringView.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;

      const char* ui_descriptor() const;

      const char* type_name() const;

      StringView ui_description() 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_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 write(const std::wstring& filename) const;


      class MAQUINA_EXPORT Children
      {
      public:
        class MAQUINA_EXPORT Iterator :
            public std::iterator<
              std::forward_iterator_tag,
              Node, std::ptrdiff_t, Node, Node >
        {
        public:
          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);

      bool has_document() const;


      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 std::iterator<
              std::forward_iterator_tag,
              Plug, std::ptrdiff_t, Plug, Plug >
        {
        public:
          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 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;

      std::vector<Plug> channels() 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);

      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);
  }