command.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2000-2022 Inria
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *  this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *  this list of conditions and the following disclaimer in the documentation
 *  and/or other materials provided with the distribution.
 *  * Neither the name of the ALICE Project-Team nor the names of its
 *  contributors may be used to endorse or promote products derived from this
 *  software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 *
 *  Contact: Bruno Levy
 *
 *     https://www.inria.fr/fr/bruno-levy
 *
 *     Inria,
 *     Domaine de Voluceau,
 *     78150 Le Chesnay - Rocquencourt
 *     FRANCE
 *
 */
 
#ifndef GEOGRAM_GFX_GUI_COMMAND
#define GEOGRAM_GFX_GUI_COMMAND
 
#include <geogram_gfx/basic/common.h>
#include <geogram/basic/logger.h>
#include <geogram/basic/string.h>
 
namespace GEO {
 
    class GEOGRAM_GFX_API CommandInvoker : public Counted {
    public:
        CommandInvoker();
 
        ~CommandInvoker() override;
 
        virtual void invoke() = 0;
 
        virtual void auto_create_args() = 0;
    };
 
    typedef SmartPointer<CommandInvoker> CommandInvoker_var;
 
    /*****************************************************************/
 
    class GEOGRAM_GFX_API Command : public Counted {
    public:
 
        template<class FPTR> static void set_current(
            const std::string& prototype, FPTR tfun
        );
 
        template<class T, class TFPTR> static void set_current(
            const std::string& prototype, T* target, TFPTR tfun
        );
 
        static void flush_queue();
 
 
        static void replay_latest();
 
        Command(const std::string& prototype);
 
 
        const std::string& name() const {
            return name_;
        }
 
        void set_invoker(CommandInvoker* invoker) {
            invoker_ = invoker;
            if(auto_create_args_) {
                invoker_->auto_create_args();
                auto_create_args_ = false;
            }
        }
 
        ~Command() override;
 
        bool is_visible() const {
            return visible_;
        }
 
        bool* is_visible_ptr() {
            return &visible_;
        }
 
        virtual void draw();
 
        virtual void reset_factory_settings();
 
        virtual void apply() ;
 
        static Command* current() {
            return current_;
        }
 
 
        static Command* latest() {
            return latest_;
        }
 
        static Command* queued() {
            return queued_;
        }
 
 
        static void reset_current() {
            current_.reset();
        }
 
        static void set_current(Command* command) {
            current_ = command;
            command->visible_ = true;
        }
 
        bool bool_arg_by_index(index_t i) const {
            const Arg& arg = find_arg_by_index(i);
            geo_assert(arg.type == Arg::ARG_BOOL);
            return arg.val.bool_val;
        }
 
        int int_arg_by_index(index_t i) const;
 
        unsigned int uint_arg_by_index(index_t i) const;
 
        float float_arg_by_index(index_t i) const {
            const Arg& arg = find_arg_by_index(i);
            geo_assert(arg.type == Arg::ARG_FLOAT);
            return arg.val.float_val;
        }
 
        double double_arg_by_index(index_t i) const {
            return double(float_arg_by_index(i));
        }
 
        std::string string_arg_by_index(index_t i) const {
            const Arg& arg = find_arg_by_index(i);
            geo_assert(arg.type == Arg::ARG_STRING);
            return std::string(arg.val.string_val);
        }
 
        template<class T> void get_arg_by_index(index_t i, T& val) {
            geo_argused(val);
            Logger::err("Cmd") << "Attempted to read argument #"
                               << i
                               << " to variable of unknown type"
                               << std::endl;
            geo_assert_not_reached;
        }
 
        /***************************************************************/
 
        template <class T> void invoke(
            T* target, void (T::*fptr)(void)
        ) {
            this->assert_nb_args_matches(0);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)();
            }
        }
 
        template <
            class T,
            class ARG0
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0)
            ) {
            this->assert_nb_args_matches(1);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0);
            }
        }
 
        template <
            class T,
            class ARG0, class ARG1
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0,ARG1)
            ) {
            this->assert_nb_args_matches(2);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0,a1);
            }
        }
 
        template <
            class T,
            class ARG0, class ARG1, class ARG2
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0,ARG1,ARG2)
            ) {
            this->assert_nb_args_matches(3);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0,a1,a2);
            }
        }
 
        template <
            class T,
            class ARG0, class ARG1, class ARG2, class ARG3
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0,ARG1,ARG2,ARG3)
            ) {
            this->assert_nb_args_matches(4);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0,a1,a2,a3);
            }
        }
 
        template <
            class T,
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4)
            ) {
            this->assert_nb_args_matches(5);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0,a1,a2,a3,a4);
            }
        }
 
        template <
            class T,
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4, class ARG5
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4,ARG5)
            ) {
            this->assert_nb_args_matches(6);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            ARG5 a5;
            this->get_arg_by_index(5,a5);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0,a1,a2,a3,a4,a5);
            }
        }
 
        template <
            class T,
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4, class ARG5, class ARG6
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6)
            ) {
            this->assert_nb_args_matches(7);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            ARG5 a5;
            this->get_arg_by_index(5,a5);
            ARG6 a6;
            this->get_arg_by_index(6,a6);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0,a1,a2,a3,a4,a5,a6);
            }
        }
 
        template <
            class T,
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4, class ARG5, class ARG6, class ARG7
            > void invoke(
                T* target,
                void (T::*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7)
            ) {
            this->assert_nb_args_matches(8);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            ARG5 a5;
            this->get_arg_by_index(5,a5);
            ARG6 a6;
            this->get_arg_by_index(6,a6);
            ARG7 a7;
            this->get_arg_by_index(7,a7);
            if(target != nullptr && fptr != nullptr) {
                (*target.*fptr)(a0,a1,a2,a3,a4,a5,a6,a7);
            }
        }
 
        /**************************************************************/
 
        void invoke(
            void (*fptr)(void)
        ) {
            this->assert_nb_args_matches(0);
            if(fptr != nullptr) {
                (*fptr)();
            }
        }
 
        template <
            class ARG0
            > void invoke(
                void (*fptr)(ARG0)
            ) {
            this->assert_nb_args_matches(1);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            if(fptr != nullptr) {
                (*fptr)(a0);
            }
        }
 
        template <
            class ARG0, class ARG1
            > void invoke(
                void (*fptr)(ARG0,ARG1)
            ) {
            this->assert_nb_args_matches(2);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            if(fptr != nullptr) {
                (*fptr)(a0,a1);
            }
        }
 
        template <
            class ARG0, class ARG1, class ARG2
            > void invoke(
                void (*fptr)(ARG0,ARG1,ARG2)
            ) {
            this->assert_nb_args_matches(3);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            if(fptr != nullptr) {
                (*fptr)(a0,a1,a2);
            }
        }
 
        template <
            class ARG0, class ARG1, class ARG2, class ARG3
            > void invoke(
                void (*fptr)(ARG0,ARG1,ARG2,ARG3)
            ) {
            this->assert_nb_args_matches(4);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            if(fptr != nullptr) {
                (*fptr)(a0,a1,a2,a3);
            }
        }
 
        template <
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4
            > void invoke(
                void (*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4)
            ) {
            this->assert_nb_args_matches(5);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            if(fptr != nullptr) {
                (*fptr)(a0,a1,a2,a3,a4);
            }
        }
 
        template <
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4, class ARG5
            > void invoke(
                void (*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4,ARG5)
            ) {
            this->assert_nb_args_matches(6);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            ARG5 a5;
            this->get_arg_by_index(5,a5);
            if(fptr != nullptr) {
                (*fptr)(a0,a1,a2,a3,a4,a5);
            }
        }
 
        template <
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4, class ARG5, class ARG6
            > void invoke(
                void (*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6)
            ) {
            this->assert_nb_args_matches(7);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            ARG5 a5;
            this->get_arg_by_index(5,a5);
            ARG6 a6;
            this->get_arg_by_index(6,a6);
            if(fptr != nullptr) {
                (*fptr)(a0,a1,a2,a3,a4,a5,a6);
            }
        }
 
        template <
            class ARG0, class ARG1, class ARG2, class ARG3,
            class ARG4, class ARG5, class ARG6, class ARG7
            > void invoke(
                void (*fptr)(ARG0,ARG1,ARG2,ARG3,ARG4,ARG5,ARG6,ARG7)
            ) {
            this->assert_nb_args_matches(8);
            ARG0 a0;
            this->get_arg_by_index(0,a0);
            ARG1 a1;
            this->get_arg_by_index(1,a1);
            ARG2 a2;
            this->get_arg_by_index(2,a2);
            ARG3 a3;
            this->get_arg_by_index(3,a3);
            ARG4 a4;
            this->get_arg_by_index(4,a4);
            ARG5 a5;
            this->get_arg_by_index(5,a5);
            ARG6 a6;
            this->get_arg_by_index(6,a6);
            ARG7 a7;
            this->get_arg_by_index(7,a7);
            if(fptr != nullptr) {
                (*fptr)(a0,a1,a2,a3,a4,a5,a6,a7);
            }
        }
 
        /**************************************************************/
 
    protected:
 
        void assert_nb_args_matches(index_t nb) {
            geo_assert(
                (auto_create_args_ && args_.size() == 0) ||
                (args_.size() == nb)
            );
        }
 
 
        template<class T> void add_arg(
            const std::string& name, const T& default_val,
            const std::string& help = ""
        ) {
            args_.push_back(Arg(name, default_val, help));
        }
 
        template<class T> void create_arg(
            index_t i, const T& default_val
        ) {
            if(i >= args_.size()) {
                args_.resize(i+1);
            }
            args_[i] = Arg("arg " + String::to_string(i), default_val);
        }
 
    private:
 
        struct GEOGRAM_GFX_API ArgVal {
            void clear();
 
            ArgVal() {
                clear();
            }
 
            ArgVal(const ArgVal& rhs);
 
            ArgVal& operator=(const ArgVal& rhs);
 
            bool bool_val;
            int int_val;
            float float_val;
            char string_val[64];
        };
 
        struct GEOGRAM_GFX_API Arg {
 
            Arg();
 
            Arg(
                const std::string& name_in, bool x,
                const std::string& help_in=""
            );
 
            Arg(
                const std::string& name_in, int x,
                const std::string& help_in=""
            );
 
            Arg(
                const std::string& name_in, unsigned int x,
                const std::string& help_in=""
            );
 
            Arg(
                const std::string& name_in, float x,
                const std::string& help_in=""
            );
 
            Arg(
                const std::string& name_in, double x,
                const std::string& help_in=""
            );
 
            Arg(
                const std::string& name_in, const std::string& x,
                const std::string& help_in=""
            );
 
            void draw();
 
            enum { ARG_BOOL, ARG_INT, ARG_UINT, ARG_FLOAT, ARG_STRING } type;
            std::string name;
            std::string help;
            ArgVal val;
            ArgVal default_val;
        };
 
        const Arg& find_arg(const std::string& name) const {
            for(index_t i=0; i<args_.size(); ++i) {
                if(args_[i].name == name) {
                    return args_[i];
                }
            }
            geo_assert_not_reached;
        }
 
        const Arg& find_arg_by_index(index_t i) const {
            geo_assert(i < args_.size());
            return args_[i];
        }
 
 
    private:
        std::string name_;
        std::string help_;
        vector<Arg> args_;
        CommandInvoker_var invoker_;
        bool visible_;
        bool auto_create_args_;
        static SmartPointer<Command> current_;
        static SmartPointer<Command> queued_;
        static SmartPointer<Command> latest_;
    };
 
/***********************************************************************/
 
    template<> inline void Command::get_arg_by_index(
        index_t i, bool& val
    ) {
        if(auto_create_args_) {
            val = false;
            this->create_arg(i, val);
        } else {
            val = this->bool_arg_by_index(i);
        }
    }
 
    template<> inline void Command::get_arg_by_index(
        index_t i, int& val
    ) {
        if(auto_create_args_) {
            val = 0;
            this->create_arg(i, val);
        } else {
            val = this->int_arg_by_index(i);
        }
    }
 
    template<> inline void Command::get_arg_by_index(
        index_t i, unsigned int& val
    ) {
        if(auto_create_args_) {
            val = 0;
            this->create_arg(i, val);
        } else {
            val = this->uint_arg_by_index(i);
        }
    }
 
    template<> inline void Command::get_arg_by_index(
        index_t i, float& val
    ) {
        if(auto_create_args_) {
            val = 0.0f;
            this->create_arg(i, val);
        } else {
            val = this->float_arg_by_index(i);
        }
    }
 
    template<> inline void Command::get_arg_by_index(
        index_t i, double& val
    ) {
        if(auto_create_args_) {
            val = 0.0;
            this->create_arg(i, val);
        } else {
            val = this->double_arg_by_index(i);
        }
    }
 
    template<> inline void Command::get_arg_by_index(
        index_t i, std::string& val
    ) {
        if(auto_create_args_) {
            val = "";
            this->create_arg(i, val);
        } else {
            val = this->string_arg_by_index(i);
        }
    }
 
    /*****************************************************************/
 
    template <class FPTR>
    class FunctionCommandInvoker : public CommandInvoker {
    public:
 
        FunctionCommandInvoker(
            Command* command,
            FPTR fun
        ) :
            command_(command),
            fun_(fun) {
        }
 
        void invoke() override {
            command_->invoke(fun_);
        }
 
        void auto_create_args() override {
            command_->invoke(FPTR(nullptr));
        }
 
    private:
        Command* command_;
        FPTR fun_;
    };
 
    /*****************************************************************/
 
    template <class T, class TFPTR>
    class MemberFunctionCommandInvoker : public CommandInvoker {
    public:
 
        MemberFunctionCommandInvoker(
            Command* command,
            T* target,
            TFPTR target_fun
        ) :
            command_(command),
            target_(target),
            target_fun_(target_fun) {
        }
 
        void invoke() override {
            command_->invoke(target_, target_fun_);
        }
 
        void auto_create_args() override {
            command_->invoke((T*)(nullptr), (TFPTR)(nullptr));
        }
 
 
    private:
        Command* command_;
        T* target_;
        TFPTR target_fun_;
    };
 
    /*****************************************************************/
 
    template<class FPTR> inline void Command::set_current(
        const std::string& prototype,
        FPTR fun
    ) {
        set_current(new Command(prototype));
        current()->set_invoker(
            new FunctionCommandInvoker<FPTR>(current(), fun)
        );
    }
 
    /*****************************************************************/
 
    template<class T, class TFPTR> inline void Command::set_current(
        const std::string& prototype,
        T* target,
        TFPTR tfun
    ) {
        set_current(new Command(prototype));
        current()->set_invoker(
            new MemberFunctionCommandInvoker<T, TFPTR>(current(), target, tfun)
        );
    }
 
    /*****************************************************************/
 
}
 
#endif