Changeset 1441 for code

Timestamp:

May 27, 2008, 6:29:08 PM (17 years ago)

Author:

landauf

Message:

you'll love this: separated displayed strings in autocompletion from actually inserted strings, to make fancy things like a really good autocompletion for files and directories.

@bensch: this is the "better system" I was talking about

Location:

code/branches/console/src/core

Files:

• ArgumentCompleter.h (modified) (4 diffs)
• ArgumentCompletionFunctions.cc (modified) (10 diffs)
• ArgumentCompletionFunctions.h (modified) (2 diffs)
• ArgumentCompletionListElement.h (added)
• CommandEvaluation.cc (modified) (1 diff)
• CommandEvaluation.h (modified) (3 diffs)
• CommandExecutor.cc (modified) (9 diffs)
• CommandExecutor.h (modified) (2 diffs)
• ConsoleCommand.h (modified) (3 diffs)
• CorePrereqs.h (modified) (1 diff)
• TclThreadManager.cc (modified) (1 diff)
• TclThreadManager.h (modified) (1 diff)

code/branches/console/src/core/ArgumentCompleter.h

@@ -30 +30 @@
 #define _ArgumentCompleter_H__
 
-#include <list>
-#include <string>
-
 #include "CorePrereqs.h"
+#include "ArgumentCompletionListElement.h"
 
 namespace orxonox
@@ -40 +38 @@
     {
         public:
-            ArgumentCompleter(std::list<std::pair<std::string, std::string> > (*function) (void)) : paramCount_(0), function_0_(function) {}
-            ArgumentCompleter(std::list<std::pair<std::string, std::string> > (*function) (const std::string& param1)) : paramCount_(1), function_1_(function) {}
-            ArgumentCompleter(std::list<std::pair<std::string, std::string> > (*function) (const std::string& param1, const std::string& param2)) : paramCount_(2), function_2_(function) {}
-            ArgumentCompleter(std::list<std::pair<std::string, std::string> > (*function) (const std::string& param1, const std::string& param2, const std::string& param3)) : paramCount_(3), function_3_(function) {}
-            ArgumentCompleter(std::list<std::pair<std::string, std::string> > (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4)) : paramCount_(4), function_4_(function) {}
-            ArgumentCompleter(std::list<std::pair<std::string, std::string> > (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5)) : paramCount_(5), function_5_(function) {}
+            ArgumentCompleter(ArgumentCompletionList (*function) (void)) : paramCount_(0), function_0_(function) {}
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1)) : paramCount_(1), function_1_(function) {}
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2)) : paramCount_(2), function_2_(function) {}
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3)) : paramCount_(3), function_3_(function) {}
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4)) : paramCount_(4), function_4_(function) {}
+            ArgumentCompleter(ArgumentCompletionList (*function) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5)) : paramCount_(5), function_5_(function) {}
 
-            std::list<std::pair<std::string, std::string> > operator()(const std::string& param1 = "", const std::string& param2 = "", const std::string& param3 = "", const std::string& param4 = "", const std::string& param5 = "")
+            ArgumentCompletionList operator()(const std::string& param1 = "", const std::string& param2 = "", const std::string& param3 = "", const std::string& param4 = "", const std::string& param5 = "")
             {
                 switch (this->paramCount_)
@@ -64 +62 @@
                         return (*this->function_5_)(param1, param2, param3, param4, param5);
                     default:
-                        return std::list<std::pair<std::string, std::string> >();
+                        return ArgumentCompletionList();
                 }
             }
@@ -70 +68 @@
         private:
             unsigned char paramCount_;
-            std::list<std::pair<std::string, std::string> > (*function_0_) (void);
-            std::list<std::pair<std::string, std::string> > (*function_1_) (const std::string& param1);
-            std::list<std::pair<std::string, std::string> > (*function_2_) (const std::string& param1, const std::string& param2);
-            std::list<std::pair<std::string, std::string> > (*function_3_) (const std::string& param1, const std::string& param2, const std::string& param3);
-            std::list<std::pair<std::string, std::string> > (*function_4_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4);
-            std::list<std::pair<std::string, std::string> > (*function_5_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5);
+            ArgumentCompletionList (*function_0_) (void);
+            ArgumentCompletionList (*function_1_) (const std::string& param1);
+            ArgumentCompletionList (*function_2_) (const std::string& param1, const std::string& param2);
+            ArgumentCompletionList (*function_3_) (const std::string& param1, const std::string& param2, const std::string& param3);
+            ArgumentCompletionList (*function_4_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4);
+            ArgumentCompletionList (*function_5_) (const std::string& param1, const std::string& param2, const std::string& param3, const std::string& param4, const std::string& param5);
     };
 }

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

@@ -30 +30 @@
 #include <map>
 
-//#include <stdio.h>
-//#include <stdlib.h>
-//#include <errno.h>
-//#include <sys/types.h>
-//#include <sys/stat.h>
 #include <dirent.h>
 
@@ -42 +37 @@
 #include "ConfigValueContainer.h"
 #include "TclThreadManager.h"
+#include "util/Convert.h"
 #include "util/String.h"
 #include "util/SubString.h"
@@ -51 +47 @@
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(fallback)()
         {
-            return std::list<std::pair<std::string, std::string> >();
+            return ArgumentCompletionList();
         }
 
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(files)(const std::string& fragment)
         {
-            std::list<std::pair<std::string, std::string> > dirlist;
-            std::list<std::pair<std::string, std::string> > filelist;
+            ArgumentCompletionList dirlist;
+            ArgumentCompletionList filelist;
 
             SubString tokens(fragment, "/", "", false, '\0', false, '\0', false, '\0', '\0', false, '\0');
@@ -86 +82 @@
 
                         if (S_ISREG(fileInfo.st_mode)) // normal file
-                            filelist.push_back(std::pair<std::string, std::string>(getLowercase(path), path));
+                            filelist.push_back(ArgumentCompletionListElement(path, getLowercase(path), currentFile->d_name));
                         else if (S_ISDIR(fileInfo.st_mode)) // directory
-                            dirlist.push_back(std::pair<std::string, std::string>(getLowercase(path) + "/", path + "/"));
+                            dirlist.push_back(ArgumentCompletionListElement(path + "/", getLowercase(path) + "/", std::string(currentFile->d_name) + "/"));
                         else // special file
-                            filelist.push_back(std::pair<std::string, std::string>(getLowercase(path), path));
+                            filelist.push_back(ArgumentCompletionListElement(path, getLowercase(path), currentFile->d_name));
                     }
                 }
@@ -103 +99 @@
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(configvalueclasses)()
         {
-            std::list<std::pair<std::string, std::string> > classlist;
+            ArgumentCompletionList classlist;
 
             for (std::map<std::string, Identifier*>::const_iterator it = Identifier::getIdentifierMapBegin(); it != Identifier::getIdentifierMapEnd(); ++it)
                 if ((*it).second->hasConfigValues())
-                    classlist.push_back(std::pair<std::string, std::string>(getLowercase((*it).first), (*it).second->getName()));
+                    classlist.push_back(ArgumentCompletionListElement((*it).second->getName(), getLowercase((*it).first)));
 
             return classlist;
@@ -114 +110 @@
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(configvalues)(const std::string& fragment, const std::string& classname)
         {
-            std::list<std::pair<std::string, std::string> > configvalues;
+            ArgumentCompletionList configvalues;
             std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getIdentifierMap().find(classname);
 
@@ -120 +116 @@
             {
                 for (std::map<std::string, ConfigValueContainer*>::const_iterator it = (*identifier).second->getConfigValueMapBegin(); it != (*identifier).second->getConfigValueMapEnd(); ++it)
-                    configvalues.push_back(std::pair<std::string, std::string>(getLowercase((*it).first), (*it).second->getName()));
+                    configvalues.push_back(ArgumentCompletionListElement((*it).second->getName(), getLowercase((*it).first)));
             }
 
@@ -128 +124 @@
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(configvalue)(const std::string& fragment, const std::string& varname, const std::string& classname)
         {
-            std::list<std::pair<std::string, std::string> > oldvalue;
+            ArgumentCompletionList oldvalue;
             std::map<std::string, Identifier*>::const_iterator identifier = Identifier::getLowercaseIdentifierMap().find(getLowercase(classname));
             if (identifier != Identifier::getLowercaseIdentifierMapEnd())
@@ -136 +132 @@
                 {
                     std::string valuestring = (*variable).second->toString();
-                    oldvalue.push_back(std::pair<std::string, std::string>(valuestring, valuestring));
+                    oldvalue.push_back(ArgumentCompletionListElement(valuestring, getLowercase(valuestring), "Old value: " + valuestring));
                 }
             }
@@ -144 +140 @@
         ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(tclthreads)()
         {
-            return TclThreadManager::getInstance().getThreadList();
+            std::list<unsigned int> threadnumbers = TclThreadManager::getInstance().getThreadList();
+            ArgumentCompletionList threads;
+
+            for (std::list<unsigned int>::const_iterator it = threadnumbers.begin(); it != threadnumbers.end(); ++it)
+                threads.push_back(ArgumentCompletionListElement(getConvertedValue<unsigned int, std::string>(*it)));
+
+            return threads;
         }
     }

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

@@ -30 +30 @@
 #define _ArgumentCompletionFunctions_H__
 
-#include <list>
-#include <string>
-
+#include "CorePrereqs.h"
 #include "ArgumentCompleter.h"
-#include "CorePrereqs.h"
 
 
 #define ARGUMENT_COMPLETION_FUNCTION_DECLARATION(functionname) \
     ArgumentCompleter* functionname(); \
-    _CoreExport std::list<std::pair<std::string, std::string> > acf_##functionname
+    _CoreExport ArgumentCompletionList acf_##functionname
 
 #define ARGUMENT_COMPLETION_FUNCTION_IMPLEMENTATION(functionname) \
@@ -48 +45 @@
     } \
     \
-    std::list<std::pair<std::string, std::string> > acf_##functionname
+    ArgumentCompletionList acf_##functionname
 
 

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

@@ -271 +271 @@
     }
 
-    std::string CommandEvaluation::dump(const std::list<std::pair<std::string, std::string> >& list)
+    std::string CommandEvaluation::dump(const ArgumentCompletionList& list)
     {
         std::string output = "";
-        for (std::list<std::pair<std::string, std::string> >::const_iterator it = list.begin(); it != list.end(); ++it)
+        for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
         {
             if (it != list.begin())
                 output += " ";
 
-            output += (*it).second;
+            output += (*it).getDisplay();
         }
         return output;

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

@@ -35 +35 @@
 #include <list>
 
+#include "ArgumentCompletionListElement.h"
 #include "util/SubString.h"
 #include "util/MultiTypeMath.h"
@@ -82 +83 @@
             unsigned int getStartindex() const;
             static std::string dump(const std::list<std::pair<const std::string*, const std::string*> >& list);
-            static std::string dump(const std::list<std::pair<std::string, std::string> >& list);
+            static std::string dump(const ArgumentCompletionList& list);
             static std::string dump(const ConsoleCommand* command);
 
@@ -96 +97 @@
             std::list<std::pair<const std::string*, const std::string*> > listOfPossibleIdentifiers_;
             std::list<std::pair<const std::string*, const std::string*> > listOfPossibleFunctions_;
-            std::list<std::pair<std::string, std::string> > listOfPossibleArguments_;
+            ArgumentCompletionList listOfPossibleArguments_;
 
             Identifier* functionclass_;

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

@@ -371 +371 @@
                 {
                     // There is exactly one possible argument
-                    CommandExecutor::getEvaluation().argument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).second;
-                    CommandExecutor::getEvaluation().possibleArgument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).second;
+                    CommandExecutor::getEvaluation().argument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).getString();
+                    CommandExecutor::getEvaluation().possibleArgument_ = (*CommandExecutor::getEvaluation().listOfPossibleArguments_.begin()).getString();
                     CommandExecutor::getEvaluation().state_ = CS_ParamPreparation;
                     return;
@@ -457 +457 @@
                 if ((*it).first.find(lowercase) == 0 || fragment == "")
                     CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.push_back(std::pair<const std::string*, const std::string*>(&(*it).first, &(*it).second->getName()));
-
-        CommandExecutor::getEvaluation().listOfPossibleIdentifiers_.sort(CommandExecutor::compareStringsInList);
     }
 
@@ -477 +475 @@
                     CommandExecutor::getEvaluation().listOfPossibleFunctions_.push_back(std::pair<const std::string*, const std::string*>(&(*it).first, &(*it).second->getName()));
         }
-
-        CommandExecutor::getEvaluation().listOfPossibleFunctions_.sort(CommandExecutor::compareStringsInList);
     }
 
@@ -487 +483 @@
         CommandExecutor::getEvaluation().listOfPossibleArguments_.clear();
         std::string lowercase = getLowercase(fragment);
-        for (std::list<std::pair<std::string, std::string> >::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
-            if ((*it).first.find(lowercase) == 0 || fragment == "")
-                CommandExecutor::getEvaluation().listOfPossibleArguments_.push_back(std::pair<std::string, std::string>((*it).first, (*it).second));
-
-        CommandExecutor::getEvaluation().listOfPossibleArguments_.sort(CommandExecutor::compareStringsInList2);
+        for (ArgumentCompletionList::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
+        {
+            if ((*it).lowercaseComparison())
+            {
+                if ((*it).getComparable().find(lowercase) == 0 || fragment == "")
+                    CommandExecutor::getEvaluation().listOfPossibleArguments_.push_back(*it);
+            }
+            else
+            {
+                if ((*it).getComparable().find(fragment) == 0 || fragment == "")
+                    CommandExecutor::getEvaluation().listOfPossibleArguments_.push_back(*it);
+            }
+        }
     }
 
@@ -527 +531 @@
 
         std::string lowercase = getLowercase(name);
-        for (std::list<std::pair<std::string, std::string> >::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
-        {
-            if ((*it).first == lowercase)
-                return (*it).second;
+        for (ArgumentCompletionList::const_iterator it = command->getArgumentCompletionListBegin(); it != command->getArgumentCompletionListEnd(); ++it)
+        {
+            if ((*it).lowercaseComparison())
+            {
+                if ((*it).getComparable() == lowercase)
+                    return (*it).getString();
+            }
+            else
+            {
+                if ((*it).getComparable() == name)
+                    return (*it).getString();
+            }
         }
 
@@ -595 +607 @@
     }
 
-    std::string CommandExecutor::getCommonBegin(const std::list<std::pair<std::string, std::string> >& list)
+    std::string CommandExecutor::getCommonBegin(const ArgumentCompletionList& list)
     {
         if (list.size() == 0)
@@ -603 +615 @@
         else if (list.size() == 1)
         {
-            return ((*list.begin()).first + " ");
+            return ((*list.begin()).getComparable() + " ");
         }
         else
@@ -611 +623 @@
             {
                 char temp = 0;
-                for (std::list<std::pair<std::string, std::string> >::const_iterator it = list.begin(); it != list.end(); ++it)
-                {
-                    if ((*it).first.size() > i)
+                for (ArgumentCompletionList::const_iterator it = list.begin(); it != list.end(); ++it)
+                {
+                    std::string argument = (*it).getComparable();
+                    if (argument.size() > i)
                     {
                         if (it == list.begin())
                         {
-                            temp = (*it).first[i];
+                            temp = argument[i];
                         }
                         else
                         {
-                            if (temp != (*it).first[i])
+                            if (temp != argument[i])
                                 return output;
                         }
@@ -635 +648 @@
         }
     }
-
-    bool CommandExecutor::compareStringsInList(const std::pair<const std::string*, const std::string*>& first, const std::pair<const std::string*, const std::string*>& second)
-    {
-        return ((*first.first) < (*second.first));
-    }
-
-    bool CommandExecutor::compareStringsInList2(const std::pair<std::string, std::string>& first, const std::pair<std::string, std::string>& second)
-    {
-        return (first.first < second.first);
-    }
 }

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

@@ -35 +35 @@
 
 #include "CommandEvaluation.h"
-
-#define COMMAND_EXECUTOR_CURSOR "$"
 
 namespace orxonox
@@ -95 +93 @@
             static void createArgumentCompletionList(ConsoleCommand* command, unsigned int param);
             static std::string getCommonBegin(const std::list<std::pair<const std::string*, const std::string*> >& list);
-            static std::string getCommonBegin(const std::list<std::pair<std::string, std::string> >& list);
-            static bool compareStringsInList(const std::pair<const std::string*, const std::string*>& first, const std::pair<const std::string*, const std::string*>& second);
-            static bool compareStringsInList2(const std::pair<std::string, std::string>& first, const std::pair<std::string, std::string>& second);
-
+            static std::string getCommonBegin(const ArgumentCompletionList& list);
 
             CommandEvaluation evaluation_;

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

@@ -34 +34 @@
 #include "Executor.h"
 #include "ClassManager.h"
-#include "Identifier.h"
 #include "CommandExecutor.h"
 #include "ArgumentCompletionFunctions.h"
@@ -104 +103 @@
 
             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 = "");
-            const std::list<std::pair<std::string, std::string> >& getArgumentCompletionList() const
+            const ArgumentCompletionList& getArgumentCompletionList() const
                 { return this->argumentList_; }
-            std::list<std::pair<std::string, std::string> >::const_iterator getArgumentCompletionListBegin() const
+            ArgumentCompletionList::const_iterator getArgumentCompletionListBegin() const
                 { return this->argumentList_.begin(); }
-            std::list<std::pair<std::string, std::string> >::const_iterator getArgumentCompletionListEnd() const
+            ArgumentCompletionList::const_iterator getArgumentCompletionListEnd() const
                 { return this->argumentList_.end(); }
 
@@ -114 +113 @@
             AccessLevel::Level accessLevel_;
             ArgumentCompleter* argumentCompleter_[5];
-            std::list<std::pair<std::string, std::string> > argumentList_;
+            ArgumentCompletionList argumentList_;
     };
 

code/branches/console/src/core/CorePrereqs.h

@@ -78 +78 @@
 
   class ArgumentCompleter;
+  class ArgumentCompletionListElement;
   class BaseFactory;
   class BaseMetaObjectListElement;

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

@@ -632 +632 @@
     }
 
-    std::list<std::pair<std::string, std::string> > TclThreadManager::getThreadList() const
+    std::list<unsigned int> TclThreadManager::getThreadList() const
     {
         boost::mutex::scoped_lock bundles_lock(TclThreadManager::getInstance().bundlesMutex_);
-        std::list<std::pair<std::string, std::string> > threads;
+        std::list<unsigned int> threads;
         for (std::map<unsigned int, TclInterpreterBundle*>::const_iterator it = this->interpreterBundles_.begin(); it != this->interpreterBundles_.end(); ++it)
-        {
-            std::string number = getConvertedValue<unsigned int, std::string>((*it).first);
-            threads.push_back(std::pair<std::string, std::string>(number, number));
-        }
+            threads.push_back((*it).first);
         return threads;
     }

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

@@ -109 +109 @@
             virtual void tick(float dt);
 
-            std::list<std::pair<std::string, std::string> > getThreadList() const;
+            std::list<unsigned int> getThreadList() const;
 
         private: