Changeset 7230 for code/branches/consolecommands3/src/libraries/core/command

Timestamp:

Aug 27, 2010, 7:29:49 PM (14 years ago)

Author:

landauf

Message:

re-implemented parameter evaluation in CommandEvaluation and simplified parse() and evaluateParams() in Executor.

Location:

code/branches/consolecommands3/src/libraries/core/command

Files:

• CommandEvaluation.cc (modified) (7 diffs)
• CommandEvaluation.h (modified) (5 diffs)
• CommandExecutor.cc (modified) (1 diff)
• Executor.cc (modified) (1 diff)
• Executor.h (modified) (1 diff)

code/branches/consolecommands3/src/libraries/core/command/CommandEvaluation.cc

@@ -49 +49 @@
         this->bPossibleArgumentsRetrieved_ = false;
         this->possibleArguments_.clear();
-
-        this->tokens_.split(command, " ", SubString::WhiteSpaces, false, '\\', false, '"', false, '(', ')', false, '\0');
+        this->bEvaluatedParams_ = false;
+        this->bTriedToEvaluatedParams_ = false;
+        this->numberOfEvaluatedParams_ = 0;
+
+        this->tokens_.split(command, " ", SubString::WhiteSpaces, false, '\\', true, '"', true, '(', ')', true, '\0');
     }
 
@@ -78 +81 @@
     }
 
-    int CommandEvaluation::execute() const
+    int CommandEvaluation::execute()
     {
         int error;
@@ -85 +88 @@
     }
 
-    MultiType CommandEvaluation::query(int* error) const
+    MultiType CommandEvaluation::query(int* error)
     {
         if (error)
@@ -103 +106 @@
 
         if (this->execCommand_ && this->execCommand_->isActive() && this->execCommand_->hasAccess())
-            return this->execCommand_->getExecutor()->parse(this->tokens_.subSet(this->execArgumentsOffset_).join(), error, " ", false);
+        {
+            if (!this->bTriedToEvaluatedParams_)
+                this->evaluateParams(false);
+
+            if (this->bEvaluatedParams_)
+            {
+                COUT(0) << "call evaluated" << std::endl;
+                COUT(6) << "CE_execute (evaluation): " << this->execCommand_->getName() << " with " << this->numberOfEvaluatedParams_ << " params: " << this->param_[0] << ' ' << this->param_[1] << ' ' << this->param_[2] << ' ' << this->param_[3] << ' ' << this->param_[4] << std::endl;
+                switch (this->numberOfEvaluatedParams_)
+                {
+                    case 0:  return (*this->execCommand_->getExecutor())();
+                    case 1:  return (*this->execCommand_->getExecutor())(this->param_[0]);
+                    case 2:  return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1]);
+                    case 3:  return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1], this->param_[2]);
+                    case 4:  return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1], this->param_[2], this->param_[3]);
+                    case 5:
+                    default: return (*this->execCommand_->getExecutor())(this->param_[0], this->param_[1], this->param_[2], this->param_[3], this->param_[4]);
+                }
+            }
+            else
+            {
+                COUT(0) << "call parsed" << std::endl;
+                COUT(5) << "CE_execute: " << this->string_ << "\n";
+                return this->execCommand_->getExecutor()->parse(this->tokens_.subSet(this->execArgumentsOffset_), error, " ");
+            }
+        }
         else
             return MT_Type::Null;
     }
 
-    std::string CommandEvaluation::complete() const
+    int CommandEvaluation::evaluateParams(bool bPrintError)
+    {
+COUT(0) << "evaluate params" << std::endl;
+        this->bTriedToEvaluatedParams_ = true;
+
+        if (!this->execCommand_)
+        {
+            if (bPrintError)
+                COUT(1) << "Error: Can't evaluate params, no console command assigned." << std::endl;
+            return CommandExecutor::Error;
+        }
+
+        int error;
+        this->numberOfEvaluatedParams_ = this->execCommand_->getExecutor()->evaluateParams(this->tokens_.subSet(this->execArgumentsOffset_), this->param_, &error, " ");
+        if (!error)
+            this->bEvaluatedParams_ = true;
+        else if (bPrintError)
+            COUT(1) << "Error: Can't evaluate params, not enough arguments given." << std::endl;
+
+        return error;
+    }
+
+    void CommandEvaluation::setEvaluatedParameter(unsigned int index, const MultiType& param)
+    {
+        if (index < MAX_FUNCTOR_ARGUMENTS)
+            this->param_[index] = param;
+    }
+
+    MultiType CommandEvaluation::getEvaluatedParameter(unsigned int index) const
+    {
+        if (index < MAX_FUNCTOR_ARGUMENTS)
+            return this->param_[index];
+
+        return MT_Type::Null;
+    }
+
+    std::string CommandEvaluation::complete()
     {
         if (!this->hintCommand_ || !this->hintCommand_->isActive())
@@ -122 +186 @@
         else
         {
-            std::string output;
-            for (unsigned int i = 0; i < this->getNumberOfArguments() - 1; ++i)
-                output += this->getToken(i) + ' ';
+            std::string output = this->string_.substr(0, this->string_.find_last_of(' ') + 1);
+//            for (unsigned int i = 0; i < this->getNumberOfArguments() - 1; ++i)
+//                output += this->getToken(i) + ' ';
 
             output += CommandEvaluation::getCommonBegin(this->possibleArguments_);
@@ -131 +195 @@
     }
 
-    std::string CommandEvaluation::hint() const
+    std::string CommandEvaluation::hint()
     {
         if (!this->hintCommand_ || !this->hintCommand_->isActive())
@@ -165 +229 @@
     }
 
-    void CommandEvaluation::retrievePossibleArguments() const
+    void CommandEvaluation::retrievePossibleArguments()
     {
         this->bPossibleArgumentsRetrieved_ = true;

code/branches/consolecommands3/src/libraries/core/command/CommandEvaluation.h

@@ -34 +34 @@
 #include <string>
 
-#include "ArgumentCompletionListElement.h"
 #include "util/SubString.h"
 #include "util/MultiType.h"
+#include "ArgumentCompletionListElement.h"
+#include "Functor.h"
 
 namespace orxonox
@@ -47 +48 @@
             CommandEvaluation();
 
-            int execute() const;
-            MultiType query(int* error = 0) const;
+            int execute();
+            MultiType query(int* error = 0);
 
-            std::string complete() const;
-            std::string hint() const;
+            std::string complete();
+            std::string hint();
+
+            int evaluateParams(bool bPrintError = false);
 
             inline bool isValid() const
@@ -59 +62 @@
                 { return this->execCommand_; }
 
-//            void setEvaluatedParameter(unsigned int index, MultiType param);
-//            MultiType getEvaluatedParameter(unsigned int index) const;
+            void setEvaluatedParameter(unsigned int index, const MultiType& param);
+            MultiType getEvaluatedParameter(unsigned int index) const;
 
         private:
@@ -69 +72 @@
             const std::string& getToken(unsigned int i) const;
 
-            void retrievePossibleArguments() const;
+            void retrievePossibleArguments();
 
             static void strip(ArgumentCompletionList& list, const std::string& fragment);
@@ -84 +87 @@
             unsigned int execArgumentsOffset_;
             unsigned int hintArgumentsOffset_;
-            mutable bool bPossibleArgumentsRetrieved_;
-            mutable ArgumentCompletionList possibleArguments_;
+            bool bPossibleArgumentsRetrieved_;
+            ArgumentCompletionList possibleArguments_;
+
+            bool bEvaluatedParams_;
+            bool bTriedToEvaluatedParams_;
+            unsigned int numberOfEvaluatedParams_;
+            MultiType param_[MAX_FUNCTOR_ARGUMENTS];
     };
 }

code/branches/consolecommands3/src/libraries/core/command/CommandExecutor.cc

@@ -67 +67 @@
 COUT(0) << "evaluate" << std::endl;
                 evaluation = CommandExecutor::evaluate(command);
+                evaluation.evaluateParams();
                 CommandExecutor::getInstance().cache(command, evaluation);
             }

code/branches/consolecommands3/src/libraries/core/command/Executor.cc

@@ -50 +50 @@
     }
 
-    MultiType Executor::parse(const std::string& params, int* error, const std::string& delimiter, bool bPrintError) const
+    MultiType Executor::parse(const std::string& arguments, int* error, const std::string& delimiter, bool bPrintError) const
     {
-        if (error)
-            *error = CommandExecutor::Success;
+        return this->parse(SubString(arguments, delimiter, SubString::WhiteSpaces, false, '\\', true, '"', true, '(', ')', true, '\0'), error, delimiter, bPrintError);
+    }
 
+    MultiType Executor::parse(const SubString& arguments, int* error, const std::string& delimiter, bool bPrintError) const
+    {
+        MultiType param[MAX_FUNCTOR_ARGUMENTS];
+        unsigned int paramCount = this->evaluateParams(arguments, param, error, delimiter);
+
+        if (error && *error)
+        {
+            if (bPrintError)
+                COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough parameters or default values given (input: " << arguments.join() << ")." << std::endl;
+            return MT_Type::Null;
+        }
+
+        switch (paramCount)
+        {
+            case 0:  return (*this->functor_)();
+            case 1:  return (*this->functor_)(param[0]);
+            case 2:  return (*this->functor_)(param[0], param[1]);
+            case 3:  return (*this->functor_)(param[0], param[1], param[2]);
+            case 4:  return (*this->functor_)(param[0], param[1], param[2], param[3]);
+            case 5:
+            default: return (*this->functor_)(param[0], param[1], param[2], param[3], param[4]);
+        }
+    }
+
+    int Executor::evaluateParams(const SubString& arguments, MultiType param[MAX_FUNCTOR_ARGUMENTS], int* error, const std::string& delimiter) const
+    {
         unsigned int paramCount = this->functor_->getParamCount();
+        unsigned int argumentCount = arguments.size();
 
-        if (paramCount == 0)
+        // if there are not enough params given, check if there are default values
+        for (unsigned int i = argumentCount; i < paramCount; i++)
         {
-            COUT(5) << "Calling Executor " << this->name_ << " through parser without parameters." << std::endl;
-            return (*this->functor_)();
-        }
-        else if (paramCount == 1)
-        {
-            const std::string& temp = getStripped(params);
-            if (!temp.empty())
+            if (this->defaultValue_[i].null())
             {
-                COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using whole string: " << params << std::endl;
-                return (*this->functor_)(params);
-            }
-            else if (!this->defaultValue_[0].null())
-            {
-                COUT(5) << "Calling Executor " << this->name_ << " through parser with one parameter, using default value: " << this->defaultValue_[0] << std::endl;
-                return (*this->functor_)(this->defaultValue_[0]);
-            }
-            else
-            {
-                if (bPrintError)
-                    COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough parameters or default values given (input: " << temp << ")." << std::endl;
                 if (error)
                     *error = CommandExecutor::Incomplete;
-                return MT_Type::Null;
-            }
-        }
-        else
-        {
-            SubString tokens(params, delimiter, SubString::WhiteSpaces, false, '\\', true, '"', true, '(', ')', true, '\0');
-
-            for (unsigned int i = tokens.size(); i < this->functor_->getParamCount(); i++)
-            {
-                if (this->defaultValue_[i].null())
-                {
-                    if (bPrintError)
-                        COUT(2) << "Warning: Can't call executor " << this->name_ << " through parser: Not enough parameters or default values given (input: " << params << ")." << std::endl;
-                    if (error)
-                        *error = CommandExecutor::Incomplete;
-                    return MT_Type::Null;
-                }
-            }
-
-            MultiType param[MAX_FUNCTOR_ARGUMENTS];
-            COUT(5) << "Calling Executor " << this->name_ << " through parser with " << paramCount << " parameters, using " << tokens.size() << " tokens (";
-            for (unsigned int i = 0; i < tokens.size() && i < MAX_FUNCTOR_ARGUMENTS; i++)
-            {
-                param[i] = tokens[i];
-                if (i != 0)
-                {
-                    COUT(5) << ", ";
-                }
-                COUT(5) << tokens[i];
-            }
-            COUT(5) << ") and " << std::max((int)paramCount - (int)tokens.size(), 0) << " default values (";
-            for (unsigned int i = tokens.size(); i < paramCount; i++)
-            {
-                param[i] = this->defaultValue_[i];
-                if (i != 0)
-                {
-                    COUT(5) << ", ";
-                }
-                COUT(5) << this->defaultValue_[i];
-            }
-            COUT(5) << ")." << std::endl;
-
-            if ((tokens.size() > paramCount) && (this->functor_->getTypenameParam(paramCount - 1) == "string"))
-                param[paramCount - 1] = tokens.subSet(paramCount - 1).join();
-
-            switch(paramCount)
-            {
-                case 2:
-                    return (*this->functor_)(param[0], param[1]);
-                case 3:
-                    return (*this->functor_)(param[0], param[1], param[2]);
-                case 4:
-                    return (*this->functor_)(param[0], param[1], param[2], param[3]);
-                case 5:
-                    return (*this->functor_)(param[0], param[1], param[2], param[3], param[4]);
+                return 0;
             }
         }
 
-        return MT_Type::Null;
-    }
+        // assign all given arguments to the multitypes
+        for (unsigned int i = 0; i < std::min(argumentCount, MAX_FUNCTOR_ARGUMENTS); i++)
+            param[i] = arguments[i];
 
-    bool Executor::evaluate(const std::string& params, MultiType param[5], const std::string& delimiter) const
-    {
-        unsigned int paramCount = this->functor_->getParamCount();
+        // fill the remaining multitypes with default values
+        for (unsigned int i = argumentCount; i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
+            param[i] = this->defaultValue_[i];
 
-        if (paramCount == 1)
-        {
-            // only one param: check if there are params given, otherwise try to use default values
-            if (!getStripped(params).empty())
-            {
-                param[0] = params;
-                this->functor_->evaluateParam(0, param[0]);
-                return true;
-            }
-            else if (!this->defaultValue_[0].null())
-            {
-                param[0] = this->defaultValue_[0];
-                this->functor_->evaluateParam(0, param[0]);
-                return true;
-            }
-            return false;
-        }
-        else
-        {
-            // more than one param
-            SubString tokens(params, delimiter, SubString::WhiteSpaces, false, '\\', true, '"', true, '(', ')', true, '\0');
+        // assign the remaining arguments all to the last parameter if it is a string
+        if ((paramCount <= MAX_FUNCTOR_ARGUMENTS) &&(argumentCount > paramCount) && (paramCount == 1 || this->functor_->getTypenameParam(paramCount - 1) == "string"))
+            param[paramCount - 1] = arguments.subSet(paramCount - 1).join(delimiter);
 
-            // if there are not enough params given, check if there are default values
-            for (unsigned int i = tokens.size(); i < this->functor_->getParamCount(); i++)
-                if (this->defaultValue_[i].null())
-                    return false;
+        // evaluate the param types through the functor
+        for (unsigned int i = 0; i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
+            this->functor_->evaluateParam(i, param[i]);
 
-            // assign all given arguments to the multitypes
-            for (unsigned int i = 0; i < std::min(tokens.size(), MAX_FUNCTOR_ARGUMENTS); i++)
-                param[i] = tokens[i];
-
-            // fill the remaining multitypes with default values
-            for (unsigned int i = tokens.size(); i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
-                param[i] = this->defaultValue_[i];
-
-            // evaluate the param types through the functor
-            for (unsigned int i = 0; i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
-                this->functor_->evaluateParam(i, param[i]);
-
-            return true;
-        }
+        if (error)
+            *error = CommandExecutor::Success;
+        return paramCount;
     }
 

code/branches/consolecommands3/src/libraries/core/command/Executor.h

@@ -59 +59 @@
                 { return (*this->functor_)(param1, param2, param3, param4, param5); }
 
-            MultiType parse(const std::string& params, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
-
-            bool evaluate(const std::string& params, MultiType param[5], const std::string& delimiter = " ") const;
+            MultiType parse(const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
+            MultiType parse(const SubString& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
+
+            int evaluateParams(const SubString& arguments, MultiType param[MAX_FUNCTOR_ARGUMENTS], int* error = 0, const std::string& delimiter = " ") const;
 
             inline void setFunctor(const FunctorPtr& functor)