DesignCommandManager.h

#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignCommand.h>
#include <NDEVR/TranslatedString.h>
#include <NDEVR/Dictionary.h>
namespace NDEVR
{
    class Thread;
    class RLock;
    class WLock;
    class NDEVR_DESIGN_API DesignCommandManager
    {
    public:
        DesignCommandManager(DesignObjectLookup* lookup, InfoPipe* log);

        virtual ~DesignCommandManager();

        void clear();

        RLock commandReadLock();

        WLock commandLock();

        WLock tryCommandLock();

        void executePendingCommands();
 

        virtual void executeCommand(DynamicPointer<DesignCommand> command);
        //const Buffer<UUID>& finishedCommands() const { return m_undo_commands; };

        const Buffer<UUID>& undoneCommands() const { return m_undone_commands; };

        template<class t_type>
        void postCommand(const DynamicPointer<t_type>& command)
        {
            postCommand(command.template as<DesignCommand>());
        }

        virtual void postCommand(const DynamicPointer<DesignCommand>& command);

        template<class t_type>
        void runCommand(const DynamicPointer<t_type>& command)
        {
            runCommand(command.template as<DesignCommand>());
        }

        virtual void runCommand(const DynamicPointer<DesignCommand>& command);

        virtual void finishCommand(const DynamicPointer<DesignCommand>& command);

        bool hasCommand(UUID id);

        bool canUndo() const { return m_undo_commands.size() > 0; }

        bool canRedo() const { return m_undone_commands.size() > 0; }

        bool hasPendingCommands() const;

        Buffer<UUID> undo();

        Buffer<UUID> redo();

        virtual void undoCommand(UUID command);

        const DynamicPointer<DesignCommand>& lastPendingCommand() const;

        const DynamicPointer<DesignCommand>& getCommand(UUID command_id) const;
 
        Resource<UUID> command_id;              
        Resource<TranslatedString> command_name;
        Resource<TranslatedString> command_hint;
    public:
        Resource<bool> command_lock;            
    protected:
        Dictionary<UUID, DynamicPointer<DesignCommand>> m_commands; 
        Buffer<UUID> m_undo_commands;           
        Buffer<UUID> m_undone_commands;         
        Buffer<UUID> m_pending_commands;            
#if NDEVR_SUPPORTS_THREADING
        Buffer<UUID> m_thread_pending_commands; 
        Thread* m_command_thread;               
#endif
        LogPtr m_log;                           
        DesignObjectLookup* m_lookup;           
    };
}