Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/SuperOrxoBros_HS18/src/libraries/core/command/Executor.cc @ 12177

Last change on this file since 12177 was 12177, checked in by siramesh, 5 years ago

Super Orxo Bros Final (Sidharth Ramesh, Nisa Balta, Jeff Ren)

File size: 9.5 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 *   Inspiration: Executor by Benjamin Grauer
28 */
29
30/**
31    @file
32    @brief Implementation of orxonox::Executor
33*/
34
35#include "Executor.h"
36
37#include <algorithm>
38
39#include "util/Convert.h"
40#include "util/Output.h"
41#include "util/StringUtils.h"
42#include "util/SubString.h"
43#include "CommandExecutor.h"
44
45namespace orxonox
46{
47    /**
48        @brief Constructor: Creates an executor.
49        @param functor The wrapped functor
50        @param name The name of the executor (optional, used mostly for debug output)
51    */
52    Executor::Executor(const FunctorPtr& functor, const std::string& name)
53    {
54        this->functor_ = functor;
55        this->name_ = name;
56    }
57
58    /**
59        @brief Copy-constructor: Creates a new executor with the same values and a clone of the wrapped Functor.
60    */
61    Executor::Executor(const Executor& other) : name_(other.name_)
62    {
63        for (size_t i = 0; i < MAX_FUNCTOR_ARGUMENTS; ++i)
64            defaultValue_[i] = other.defaultValue_[i];
65        this->functor_ = other.functor_->clone();
66    }
67
68    /**
69        @brief Calls the wrapped function with arguments that are passed in a string.
70        @param arguments The arguments that should be passed to the function, separated by @a delimiter
71        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
72        @param delimiter The delimiter that is used to separate the arguments in the string @a arguments
73        @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
74        @return Returns the return value of the function (or MultiType::Null if there is no return value)
75    */
76    MultiType Executor::parse(const std::string& arguments, int* error, const std::string& delimiter, bool bPrintError) const
77    {
78        return this->parse(SubString(arguments, delimiter, SubString::WhiteSpaces, false, '\\', true, '"', true, '{', '}', true, '\0'), error, delimiter, bPrintError);
79    }
80
81    /**
82        @brief Calls the wrapped function with arguments that are passed as tokens in a SubString
83        @param arguments The arguments that should be passed to the function
84        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
85        @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
86        @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
87        @return Returns the return value of the function (or MultiType::Null if there is no return value)
88    */
89    MultiType Executor::parse(const SubString& arguments, int* error, const std::string& delimiter, bool bPrintError) const
90    {
91        // evaluate the arguments
92        MultiType arg[MAX_FUNCTOR_ARGUMENTS];
93        unsigned int argCount = this->evaluateArguments(arguments, arg, error, delimiter);
94
95        // check if an error occurred
96        if (error && *error)
97        {
98            if (bPrintError)
99                orxout(internal_warning) << "Can't call executor " << this->name_ << " through parser: Not enough arguments or default values given (input: " << arguments.join() << ")." << endl;
100            return MultiType::Null;
101        }
102
103        orxout(verbose, context::misc::executor) << "Executor::parse: \"" << arguments.join(delimiter) << "\" -> " << argCount << " arguments: " << arg[0] << " / " << arg[1] << " / " << arg[2] << " / " << arg[3] << " / " << arg[4] << endl;
104
105        // execute the function with the evaluated arguments (the default values of the executor are also included in these arguments)
106        switch (argCount)
107        {
108            case 0:  return (*this->functor_)();
109            case 1:  return (*this->functor_)(arg[0]);
110            case 2:  return (*this->functor_)(arg[0], arg[1]);
111            case 3:  return (*this->functor_)(arg[0], arg[1], arg[2]);
112            case 4:  return (*this->functor_)(arg[0], arg[1], arg[2], arg[3]);
113            case 5:
114            default: return (*this->functor_)(arg[0], arg[1], arg[2], arg[3], arg[4]);
115        }
116    }
117
118    /**
119        @brief Converts the arguments in a SubString to the right type, so they can be used to execute the function without further conversions.
120        @param arguments The arguments that should be converted
121        @param arg An array of MultiType where the converted arguments will be stored
122        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
123        @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
124        @return Returns the number of evaluated arguments
125    */
126    int Executor::evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error, const std::string& delimiter) const
127    {
128        unsigned int paramCount = this->functor_->getParamCount();
129        unsigned int argumentCount = arguments.size();
130
131        // if there are not enough params given, check if there are default values
132        for (unsigned int i = argumentCount; i < paramCount; i++)
133        {
134            if (this->defaultValue_[i].null())
135            {
136                if (error)
137                    *error = CommandExecutor::Incomplete;
138                return 0;
139            }
140        }
141
142        // assign all given arguments to the multitypes
143        for (unsigned int i = 0; i < std::min(std::min(argumentCount, paramCount), MAX_FUNCTOR_ARGUMENTS); i++)
144            arg[i] = arguments[i];
145
146        // fill the remaining multitypes with default values
147        for (unsigned int i = argumentCount; i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
148            arg[i] = this->defaultValue_[i];
149
150        // assign the remaining arguments all to the last parameter if it is a string
151        if ((paramCount <= MAX_FUNCTOR_ARGUMENTS) &&(argumentCount > paramCount) && (paramCount == 1 || this->functor_->getTypenameParam(paramCount - 1) == "string"))
152            arg[paramCount - 1] = arguments.subSet(paramCount - 1).join(delimiter);
153
154        // evaluate the parameter types through the functor
155        for (unsigned int i = 0; i < std::min(paramCount, MAX_FUNCTOR_ARGUMENTS); i++)
156            this->functor_->evaluateArgument(i, arg[i]);
157
158        if (error)
159            *error = CommandExecutor::Success;
160        return paramCount;
161    }
162
163    /// Defines the default value for the first parameter.
164    void Executor::setDefaultValues(const MultiType& arg1)
165    {
166        this->defaultValue_[0] = arg1;
167    }
168
169    /// Defines the default value for the first two parameters.
170    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2)
171    {
172        this->defaultValue_[0] = arg1;
173        this->defaultValue_[1] = arg2;
174    }
175
176    /// Defines the default value for the first three parameters.
177    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3)
178    {
179        this->defaultValue_[0] = arg1;
180        this->defaultValue_[1] = arg2;
181        this->defaultValue_[2] = arg3;
182    }
183
184    /// Defines the default value for the first four parameters.
185    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4)
186    {
187        this->defaultValue_[0] = arg1;
188        this->defaultValue_[1] = arg2;
189        this->defaultValue_[2] = arg3;
190        this->defaultValue_[3] = arg4;
191    }
192
193    /// Defines the default value for the first five parameters.
194    void Executor::setDefaultValues(const MultiType& arg1, const MultiType& arg2, const MultiType& arg3, const MultiType& arg4, const MultiType& arg5)
195    {
196        this->defaultValue_[0] = arg1;
197        this->defaultValue_[1] = arg2;
198        this->defaultValue_[2] = arg3;
199        this->defaultValue_[3] = arg4;
200        this->defaultValue_[4] = arg5;
201    }
202
203    /// Defines the default value for a parameter with given index (the first parameter has index 0).
204    void Executor::setDefaultValue(unsigned int index, const MultiType& arg)
205    {
206        if (index < MAX_FUNCTOR_ARGUMENTS)
207            this->defaultValue_[index] = arg;
208    }
209
210    /// Returns true if the executor has a default value for each parameter of the wrapped function, so it can be called without passing additional arguments.
211    bool Executor::allDefaultValuesSet() const
212    {
213        for (unsigned int i = 0; i < this->functor_->getParamCount(); i++)
214            if (this->defaultValue_[i].null())
215                return false;
216
217        return true;
218    }
219}
Note: See TracBrowser for help on using the repository browser.