Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 1434


Ignore:
Timestamp:
May 27, 2008, 12:27:13 AM (17 years ago)
Author:
landauf
Message:

autocompletion is almost done

Location:
code/branches/console/src/core
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • code/branches/console/src/core/ArgumentCompletionFunctions.cc

    r1430 r1434  
    2828
    2929#include <iostream>
     30#include <map>
    3031
    3132#include "ArgumentCompletionFunctions.h"
     33#include "CoreIncludes.h"
     34#include "Identifier.h"
     35#include "ConfigValueContainer.h"
     36#include "TclThreadManager.h"
     37#include "util/String.h"
    3238
    3339namespace orxonox
    … …  
    3945            return std::list<std::pair<std::string, std::string> >();
    4046        }
     47
     48        ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(configvalueclasses)()
     49        {
     50            std::list<std::pair<std::string, std::string> > classlist;
     51
     52            for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
     53                if ((*it).second->hasConfigValues())
     54                    classlist.push_back(std::pair<std::string, std::string>(getLowercase((*it).first), (*it).second->getName()));
     55
     56            return classlist;
     57        }
     58
     59        ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(configvalues)(const std::string& classname)
     60        {
     61            std::list<std::pair<std::string, std::string> > configvalues;
     62            std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getIdentifierMap().find(classname);
     63
     64            if (identifier != Identifier::getIdentifierMapEnd() && (*identifier).second->hasConfigValues())
     65            {
     66                for (std::map<std::string, ConfigValueContainer*>::const_iterator it = (*identifier).second->getConfigValueMapBegin(); it != (*identifier).second->getConfigValueMapEnd(); ++it)
     67                    configvalues.push_back(std::pair<std::string, std::string>(getLowercase((*it).first), (*it).second->getName()));
     68            }
     69
     70            return configvalues;
     71        }
     72
     73        ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(configvalue)(const std::string& varname, const std::string& classname)
     74        {
     75            std::list<std::pair<std::string, std::string> > oldvalue;
     76            std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
     77            if (identifier != Identifier::getLowercaseIdentifierMapEnd())
     78            {
     79                std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
     80                if (variable != (*identifier).second->getLowercaseConfigValueMapEnd())
     81                {
     82                    std::string valuestring = (*variable).second->toString();
     83                    oldvalue.push_back(std::pair<std::string, std::string>(valuestring, valuestring));
     84                }
     85            }
     86            return oldvalue;
     87        }
     88
     89        ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(tclthreads)()
     90        {
     91            return TclThreadManager::getInstance().getThreadList();
     92        }
    4193    }
    4294}

  • code/branches/console/src/core/ArgumentCompletionFunctions.h

    r1430 r1434  
    5050    std::list<std::pair<std::string, std::string> > acf_##functionname
    5151
     52
    5253namespace orxonox
    5354{
    … …  
    5556    {
    5657        ARGUMENT_COMPLETION_FUNCTION_DECLARATION(fallback)();
     58        ARGUMENT_COMPLETION_FUNCTION_DECLARATION(configvalueclasses)();
     59        ARGUMENT_COMPLETION_FUNCTION_DECLARATION(configvalues)(const std::string& classname);
     60        ARGUMENT_COMPLETION_FUNCTION_DECLARATION(configvalue)(const std::string& varname, const std::string& classname);
     61        ARGUMENT_COMPLETION_FUNCTION_DECLARATION(tclthreads)();
    5762    }
    5863}

  • code/branches/console/src/core/CommandEvaluation.cc

    r1430 r1434  
    3030#include "ConsoleCommand.h"
    3131#include "Debug.h"
     32#include "util/String.h"
    3233
    3334namespace orxonox
    … …  
    8182        }
    8283
    83         if (!this->bCommandChanged_)
     84        if (!this->bCommandChanged_ || removeTrailingWhitespaces(this->command_) == removeTrailingWhitespaces(this->originalCommand_))
    8485        {
    8586            COUT(4) << "CE_execute: " << this->command_ << "\n";
    … …  
    136137                        maxIndex -= 1;
    137138                    std::string whitespace = "";
    138                     if (this->function_->getParamCount() > (maxIndex + 1 - this->getStartindex()))
    139                         whitespace = " ";
    140139
    141140                    if (this->possibleArgument_ != "")
    142141                    {
    143                         maxIndex -= 1;
    144142                        this->argument_ = this->possibleArgument_;
     143                        if (this->function_->getParamCount() > (maxIndex + 1 - this->getStartindex()))
     144                            whitespace = " ";
    145145                    }
    146146
    … …  
    163163        {
    164164            case CS_Uninitialized:
     165std::cout << "hint: CS_Uninitialized" << std::endl;
    165166                break;
    166167            case CS_Empty:
     168std::cout << "hint: CS_Empty" << std::endl;
    167169            case CS_ShortcutOrIdentifier:
     170std::cout << "hint: CS_ShortcutOrIdentifier" << std::endl;
    168171                if (this->listOfPossibleFunctions_.size() == 0)
    169172                    return CommandEvaluation::dump(this->listOfPossibleIdentifiers_);
    … …  
    174177                break;
    175178            case CS_Function:
     179std::cout << "hint: CS_Function" << std::endl;
    176180                return CommandEvaluation::dump(this->listOfPossibleFunctions_);
    177181                break;
    178182            case CS_ParamPreparation:
     183std::cout << "hint: CS_ParamPreparation" << std::endl;
    179184            case CS_Params:
     185std::cout << "hint: CS_Params" << std::endl;
    180186                if (this->listOfPossibleArguments_.size() > 0)
    181187                    return CommandEvaluation::dump(this->listOfPossibleArguments_);
    … …  
    183189                    return CommandEvaluation::dump(this->function_);
    184190            case CS_Finished:
     191std::cout << "hint: CS_Finished" << std::endl;
    185192                if (this->function_)
    186193                    return CommandEvaluation::dump(this->function_);
    187194                break;
    188195            case CS_Error:
     196std::cout << "hint: CS_Error" << std::endl;
    189197                return this->errorMessage_;
    190198                break;
    … …  
    272280    }
    273281
     282    std::string CommandEvaluation::dump(const std::list<std::pair<std::string, std::string> >& list)
     283    {
     284        std::string output = "";
     285        for (std::list<std::pair<std::string, std::string> >::const_iterator it = list.begin(); it != list.end(); ++it)
     286        {
     287            if (it != list.begin())
     288                output += " ";
     289
     290            output += (*it).second;
     291        }
     292        return output;
     293    }
     294
    274295    std::string CommandEvaluation::dump(const ConsoleCommand* command)
    275296    {

  • code/branches/console/src/core/CommandEvaluation.h

    r1427 r1434  
    8282            unsigned int getStartindex() const;
    8383            static std::string dump(const std::list<std::pair<const std::string*, const std::string*> >& list);
     84            static std::string dump(const std::list<std::pair<std::string, std::string> >& list);
    8485            static std::string dump(const ConsoleCommand* command);
    8586
    … …  
    9596            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleIdentifiers_;
    9697            std::list<std::pair<const std::string*, const std::string*> > listOfPossibleFunctions_;
    97             std::list<std::pair<const std::string*, const std::string*> > listOfPossibleArguments_;
     98            std::list<std::pair<std::string, std::string> > listOfPossibleArguments_;
    9899
    99100            Identifier* functionclass_;

  • code/branches/console/src/core/CommandExecutor.cc

    r1430 r1434  
    126126    void CommandExecutor::parseIfNeeded(const std::string& command)
    127127    {
     128std::cout << "parse if needed: command:      >" << command << "<" << std::endl;
     129std::cout << "                 old original: >" << CommandExecutor::getEvaluation().originalCommand_ << "<" << std::endl;
     130std::cout << "                 old modified: >" << CommandExecutor::getEvaluation().command_ << "<" << std::endl;
    128131        if (CommandExecutor::getEvaluation().state_ == CS_Uninitialized)
    129132        {
     133std::cout << "parse if needed: parse!" << std::endl;
    130134            CommandExecutor::parse(command);
    131135        }
    132         else if (CommandExecutor::getEvaluation().originalCommand_ != command)
     136        else if (/*removeTrailingWhitespaces*/(CommandExecutor::getEvaluation().originalCommand_) != /*removeTrailingWhitespaces*/(command))
    133137        {
    134138            if (CommandExecutor::getEvaluation().command_ == command)
    135139            {
     140std::cout << "parse if needed: parse and set bNewCommand_ to false" << std::endl;
    136141                CommandExecutor::parse(command);
    137142                CommandExecutor::getEvaluation().bNewCommand_ = false;
    … …  
    139144            else
    140145            {
     146std::cout << "parse if needed: parse!" << std::endl;
    141147                CommandExecutor::parse(command);
    142148            }
    143149        }
     150std::cout << "parse if needed: don't parse" << std::endl;
    144151    }
    145152
    … …  
    156163        {
    157164            case CS_Uninitialized:
     165std::cout << "0: Uninitialized\n";
    158166            {
    159167                // Impossible
    … …  
    161169            }
    162170            case CS_Empty:
     171std::cout << "0: Empty\n";
    163172            {
    164173                if (CommandExecutor::argumentsGiven() == 0)
    … …  
    175184            }
    176185            case CS_ShortcutOrIdentifier:
     186std::cout << "0: ShortcutOrIdentifier\n";
    177187            {
    178188                if (CommandExecutor::argumentsGiven() > 1)
    … …  
    191201                    else if (CommandExecutor::getEvaluation().functionclass_)
    192202                    {
     203std::cout << "MEP" << std::endl;
    193204                        // It's a functionname
    194205                        CommandExecutor::getEvaluation().state_ = CS_Function;
    … …  
    272283            }
    273284            case CS_Function:
     285std::cout << "0: Function\n";
    274286            {
    275287                if (CommandExecutor::getEvaluation().functionclass_)
    … …  
    283295                        if (CommandExecutor::getEvaluation().function_)
    284296                        {
     297std::cout << "MEP2" << std::endl;
    285298                            // It's a function
    286299                            CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
    … …  
    377390std::cout << "3_1\n";
    378391                    // There is exactly one possible argument
    379                     CommandExecutor::getEvaluation().argument_ = *(*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).second;
     392                    CommandExecutor::getEvaluation().argument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).second;
     393                    CommandExecutor::getEvaluation().possibleArgument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).second;
    380394                    CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
    381395                    return;
    … …  
    393407std::cout << "3_3\n";
    394408                    // There are several possibilities
    395                     unsigned int argumentNumber = CommandExecutor::argumentsGiven() - 1;
    396                     if (CommandExecutor::getEvaluation().functionclass_)
    397                         argumentNumber -= 1;
    398 
     409                    unsigned int argumentNumber = CommandExecutor::argumentsGiven();
     410                    if (argumentNumber > 0)
     411                        --argumentNumber;
     412std::cout << "3_3_1\n";
     413                    if (CommandExecutor::getEvaluation().functionclass_ && argumentNumber > 0)
     414                        --argumentNumber;
     415
     416std::cout << "3_3_2\n";
    399417                    CommandExecutor::getEvaluation().argument_ = CommandExecutor::getCommonBegin(CommandExecutor::getEvaluation().listOfPossibleArguments_);
     418std::cout << "3_3_3\n";
    400419                    CommandExecutor::getEvaluation().possibleArgument_ = CommandExecutor::getPossibleArgument(CommandExecutor::getLastArgument(), CommandExecutor::getEvaluation().function_, argumentNumber);
     420std::cout << "3_3_4\n";
    401421                    CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
     422std::cout << "3_3_5\n";
    402423                    return;
    403424                }
    … …  
    495516        for (std::list<std::pair<std::string, std::string> >::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
    496517            if ((*it).first.find(lowercase) == 0 || fragment == "")
    497                 CommandExecutor::getEvaluation().listOfPossibleArguments_.push_back(std::pair<const std::string*, const std::string*>(&(*it).first, &(*it).second));
    498 
    499         CommandExecutor::getEvaluation().listOfPossibleArguments_.sort(CommandExecutor::compareStringsInList);
     518                CommandExecutor::getEvaluation().listOfPossibleArguments_.push_back(std::pair<std::string, std::string>((*it).first, (*it).second));
     519
     520        CommandExecutor::getEvaluation().listOfPossibleArguments_.sort(CommandExecutor::compareStringsInList2);
    500521    }
    501522
    … …  
    530551    std::string CommandExecutor::getPossibleArgument(const std::string& name, ConsoleCommand* command, unsigned int param)
    531552    {
     553std::cout << "4_1\n";
    532554        CommandExecutor::createArgumentCompletionList(command, param);
    533555
     556std::cout << "4_2\n";
    534557        std::string lowercase = getLowercase(name);
     558std::cout << "4_3\n";
    535559        for (std::list<std::pair<std::string, std::string> >::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
     560        {
     561std::cout << "4_4\n";
    536562            if ((*it).first == lowercase)
    537563                return (*it).second;
    538 
    539         return 0;
     564        }
     565
     566std::cout << "4_5\n";
     567        return "";
    540568    }
    541569
    … …  
    599627    }
    600628
     629    std::string CommandExecutor::getCommonBegin(const std::list<std::pair<std::string, std::string> >& list)
     630    {
     631        if (list.size() == 0)
     632        {
     633            return "";
     634        }
     635        else if (list.size() == 1)
     636        {
     637            return ((*list.begin()).first + " ");
     638        }
     639        else
     640        {
     641            std::string output = "";
     642            for (unsigned int i = 0; true; i++)
     643            {
     644                char temp = 0;
     645                for (std::list<std::pair<std::string, std::string> >::const_iterator it = list.begin(); it != list.end(); ++it)
     646                {
     647                    if ((*it).first.size() > i)
     648                    {
     649                        if (it == list.begin())
     650                        {
     651                            temp = (*it).first[i];
     652                        }
     653                        else
     654                        {
     655                            if (temp != (*it).first[i])
     656                                return output;
     657                        }
     658                    }
     659                    else
     660                    {
     661                        return output;
     662                    }
     663                }
     664                output += temp;
     665            }
     666            return output;
     667        }
     668    }
     669
    601670    bool CommandExecutor::compareStringsInList(const std::pair<const std::string*, const std::string*>& first, const std::pair<const std::string*, const std::string*>& second)
    602671    {
    603672        return ((*first.first) < (*second.first));
    604673    }
     674
     675    bool CommandExecutor::compareStringsInList2(const std::pair<std::string, std::string>& first, const std::pair<std::string, std::string>& second)
     676    {
     677        return (first.first < second.first);
     678    }
    605679}

  • code/branches/console/src/core/CommandExecutor.h

    r1430 r1434  
    9595            static void createArgumentCompletionList(ConsoleCommand* command, unsigned int param);
    9696            static std::string getCommonBegin(const std::list<std::pair<const std::string*, const std::string*> >& list);
     97            static std::string getCommonBegin(const std::list<std::pair<std::string, std::string> >& list);
    9798            static bool compareStringsInList(const std::pair<const std::string*, const std::string*>& first, const std::pair<const std::string*, const std::string*>& second);
     99            static bool compareStringsInList2(const std::pair<std::string, std::string>& first, const std::pair<std::string, std::string>& second);
    98100
    99101

  • code/branches/console/src/core/ConfigFileManager.cc

    r1341 r1434  
    3838namespace orxonox
    3939{
     40    SetConsoleCommandShortcutExtern(config).setArgumentCompleter(0, autocompletion::configvalueclasses()).setArgumentCompleter(1, autocompletion::configvalues()).setArgumentCompleter(2, autocompletion::configvalue());
     41    SetConsoleCommandShortcutExtern(tconfig);
    4042    SetConsoleCommandShortcutExtern(reloadConfig);
    4143    SetConsoleCommandShortcutExtern(cleanConfig);
    4244    SetConsoleCommandShortcutExtern(loadSettings);
    4345    SetConsoleCommandShortcutExtern(loadKeybindings);
     46
     47    bool config(const std::string& classname, const std::string& varname, const std::string& value)
     48    {
     49std::cout << "10a_1\n";
     50        std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
     51        if (identifier != Identifier::getLowercaseIdentifierMapEnd())
     52        {
     53std::cout << "10a_2\n";
     54            std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
     55            if (variable != (*identifier).second->getLowercaseConfigValueMapEnd())
     56            {
     57std::cout << "10a_3\n";
     58                return (*variable).second->tset(value);
     59            }
     60        }
     61        return false;
     62    }
     63
     64    bool tconfig(const std::string& classname, const std::string& varname, const std::string& value)
     65    {
     66std::cout << "10b_1\n";
     67        std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
     68        if (identifier != Identifier::getLowercaseIdentifierMapEnd())
     69        {
     70std::cout << "10b_2\n";
     71            std::map<std::string, ConfigValueContainer*>::const_iterator variable = (*identifier).second->getLowercaseConfigValueMap().find(getLowercase(varname));
     72            if (variable != (*identifier).second->getLowercaseConfigValueMapEnd())
     73            {
     74std::cout << "10b_3\n";
     75                return (*variable).second->tset(value);
     76            }
     77        }
     78        return false;
     79    }
    4480
    4581    void reloadConfig()

  • code/branches/console/src/core/ConfigFileManager.h

    r1116 r1434  
    5050
    5151
     52    bool config(const std::string& classname, const std::string& varname, const std::string& value);
     53    bool tconfig(const std::string& classname, const std::string& varname, const std::string& value);
    5254    void reloadConfig();
    5355    void saveConfig();

  • code/branches/console/src/core/ConsoleCommand.cc

    r1430 r1434  
    4141    }
    4242
    43     ConsoleCommand& ConsoleCommand::setArgumentCompletionList(unsigned int param, ArgumentCompleter* completer)
     43    ConsoleCommand& ConsoleCommand::setArgumentCompleter(unsigned int param, ArgumentCompleter* completer)
    4444    {
    4545        if (param < 5)
    … …  
    5252    }
    5353
     54    ArgumentCompleter* ConsoleCommand::getArgumentCompleter(unsigned int param) const
     55    {
     56        if (param < 5)
     57            return this->argumentCompleter_[param];
     58        else
     59            return 0;
     60    }
     61
    5462    void ConsoleCommand::createArgumentCompletionList(unsigned int param, const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5)
    5563    {

  • code/branches/console/src/core/ConsoleCommand.h

    r1430 r1434  
    100100                { return this->accessLevel_; }
    101101
    102             ConsoleCommand& setArgumentCompletionList(unsigned int param, ArgumentCompleter* completer);
     102            ConsoleCommand& setArgumentCompleter(unsigned int param, ArgumentCompleter* completer);
     103            ArgumentCompleter* getArgumentCompleter(unsigned int param) const;
     104
    103105            void createArgumentCompletionList(unsigned int param, const std::string& param1 = "", const std::string& param2 = "", const std::string& param3 = "", const std::string& param4 = "", const std::string& param5 = "");
    104106            const std::list<std::pair<std::string, std::string> >& getArgumentCompletionList() const

  • code/branches/console/src/core/TclThreadManager.cc

    r1424 r1434  
    4848namespace orxonox
    4949{
    50     SetConsoleCommandShortcutGeneric(tclexecute, createConsoleCommand(createFunctor(&TclThreadManager::execute), "tclexecute"));
    51     SetConsoleCommandShortcutGeneric(tclquery,   createConsoleCommand(createFunctor(&TclThreadManager::query),   "tclquery"  ));
     50    SetConsoleCommandShortcutGeneric(tclexecute, createConsoleCommand(createFunctor(&TclThreadManager::execute), "tclexecute")).setArgumentCompleter(0, autocompletion::tclthreads());
     51    SetConsoleCommandShortcutGeneric(tclquery,   createConsoleCommand(createFunctor(&TclThreadManager::query),   "tclquery"  )).setArgumentCompleter(0, autocompletion::tclthreads());
    5252    SetConsoleCommand(TclThreadManager, create,  false);
    53     SetConsoleCommand(TclThreadManager, destroy, false);
    54     SetConsoleCommand(TclThreadManager, execute, false);
    55     SetConsoleCommand(TclThreadManager, query,   false);
     53    SetConsoleCommand(TclThreadManager, destroy, false).setArgumentCompleter(0, autocompletion::tclthreads());
     54    SetConsoleCommand(TclThreadManager, execute, false).setArgumentCompleter(0, autocompletion::tclthreads());
     55    SetConsoleCommand(TclThreadManager, query,   false).setArgumentCompleter(0, autocompletion::tclthreads());
    5656    SetConsoleCommand(TclThreadManager, status,  false);
    57     SetConsoleCommand(TclThreadManager, dump,    false);
    58     SetConsoleCommand(TclThreadManager, flush,   false);
     57    SetConsoleCommand(TclThreadManager, dump,    false).setArgumentCompleter(0, autocompletion::tclthreads());
     58    SetConsoleCommand(TclThreadManager, flush,   false).setArgumentCompleter(0, autocompletion::tclthreads());
    5959
    6060    TclThreadManager* instance_tclthreadmanager = &TclThreadManager::getInstance();
    … …  
    632632    }
    633633
     634    std::list<std::pair<std::string, std::string> > TclThreadManager::getThreadList() const
     635    {
     636        boost::mutex::scoped_lock bundles_lock(TclThreadManager::getInstance().bundlesMutex_);
     637        std::list<std::pair<std::string, std::string> > threads;
     638        for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
     639        {
     640            std::string number = getConvertedValue<unsigned int, std::string>((*it).first);
     641            threads.push_back(std::pair<std::string, std::string>(number, number));
     642        }
     643        return threads;
     644    }
     645
    634646    void tclThread(TclInterpreterBundle* interpreterBundle, std::string command)
    635647    {

  • code/branches/console/src/core/TclThreadManager.h

    r1337 r1434  
    109109            virtual void tick(float dt);
    110110
     111            std::list<std::pair<std::string, std::string> > getThreadList() const;
     112
    111113        private:
    112114            TclThreadManager();
Note: See TracChangeset for help on using the changeset viewer.