uAutoCompleter Class Reference

#include <uMenu.h>

Inheritance diagram for uAutoCompleter:

[legend]

List of all members.

Public Member Functions
	uAutoCompleter (std::deque< tString > &words)
	Constructor.
virtual int	Complete (tString &string, unsigned pos)
	Attempts the completion.
virtual	~uAutoCompleter ()
void	SetIgnorecase (bool ignorecase)
	Enable or disable case ignoring?
Protected Member Functions
virtual int	FindLengthOfLastWord (tString &string, unsigned pos)
	Finds the space to the last delimiter.
virtual void	FindPossibleWords (tString word, std::deque< tString > &results)
	Finds the possible completions for a word.
virtual tString	FindClosestMatch (tString &word, std::deque< tString > &results)
	Attempts to complete as much of the word as possible.
virtual void	ShowPossibilities (std::deque< tString > &results, tString &word)
	Prints the possible completions to the console.
virtual int	DoCompletion (tString &string, int pos, int len, tString &match)
	Replaces the word the cursor is on by the closest match.
virtual int	DoFullCompletion (tString &string, int pos, int len, tString &match)
	Replaces the word the cursor is on by the given match and a space.
virtual int	TryCompletion (tString &string, unsigned pos, unsigned len)
	Attempt completion with a certain word length.
virtual tString	Simplify (tString const &str)
	Simplifies a string, by default converts it to lowercase.
Protected Attributes
std::deque< tString > &	m_PossibleWords
	The words that can be used for completion.
int	m_LastCompletion
bool	m_ignorecase

---

Detailed Description

A class that can provide auto- completion and supports overwriting of parts for special cases.

The default implementation implements the typical bash- like auto- completion, if you need more than that derive your own class.

Definition at line 412 of file uMenu.h.

---

Constructor & Destructor Documentation

uAutoCompleter::uAutoCompleter

(

std::deque< tString > &

words

)

Constructor.

Parameters:

words

a deque containing the possible words that can be used for completion

Definition at line 868 of file uMenu.cpp.

00870                                                        :
00871         m_PossibleWords(words),
00872         m_LastCompletion(-1),
        m_ignorecase(true)

virtual uAutoCompleter::~uAutoCompleter

(

)

[inline, virtual]

Definition at line 431 of file uMenu.h.

{}

---

Member Function Documentation

int uAutoCompleter::FindLengthOfLastWord	(	tString &	string,
		unsigned	pos
	)			[protected, virtual]

Finds the space to the last delimiter.

Parameters:

	string	the string that should be tested
	pos	the cursor position within the string

Returns:

-1 if the cursor isn't at the end of a word, the number of characters to the previous space if it is

Definition at line 877 of file uMenu.cpp.

                                                                      {
    int charright = ' ', charleft  = ' ';
    if(string.size() >= 1) {
        if (pos == string.size()) {
            charleft=string.at(pos-1);
        }
        else if (pos < string.size()) {
            charright=string.at(pos);
            if(pos>1) {
                charleft=string.at(pos-1);
            }
        }
    }
    if(charright != ' ' && charleft != ' ')
        return -1; //no completion possible
    if(charleft == ' ')
        return 0;
    else

void uAutoCompleter::FindPossibleWords	(	tString	word,
		std::deque< tString > &	results
	)			[protected, virtual]

Finds the possible completions for a word.

Parameters:

	word	the part of the word that is searched for
	results	the list where the possible completions will be saved

Definition at line 900 of file uMenu.cpp.

                                                                               {
    if(m_ignorecase)
        word = Simplify(word);
    for(std::deque<tString>::iterator i=m_PossibleWords.begin(); i!=m_PossibleWords.end(); ++i) {
        size_t pos;
        if((pos = (m_ignorecase ? Simplify(*i) : *i).find(word)) != tString::npos) {
            if(isalpha((*i)[pos]) && pos != 0 && isalpha((*i)[pos-1]))
                continue; //both the char we're at and the one before is alphanumeric; we're in the middle of a word
            results.push_back(*i);
        }

tString uAutoCompleter::FindClosestMatch	(	tString &	word,
		std::deque< tString > &	results
	)			[protected, virtual]

Attempts to complete as much of the word as possible.

Parameters:

	word	the part of the word that is searched for
	results	the list of possible completions

Returns:

the match, if any

Definition at line 916 of file uMenu.cpp.

                                                                                  {
    tString ret(m_ignorecase?Simplify(word):word);
    unsigned int len = ret.size();
    while(true) { // complete right side
        std::deque<tString>::iterator i;
        i = results.begin();
        bool found=true;
        tString::size_type pos=(m_ignorecase?Simplify(*i):*i).find(ret);
        if(pos!=tString::npos && pos+len < i->size()) {
            found=false;
            ret+=(m_ignorecase ? tolower(i->at(pos+len)) : i->at(pos+len));
            ++i;
            for(; i!=results.end(); ++i) {
                if((m_ignorecase?Simplify(*i):*i).find(ret) == tString::npos) {
                    found=true;
                    ret.erase(ret.length()-1);
                    break;
                }
            }
        }
        if (found) //we found a mismatch
            break;
        else
            len++;
    }
    while(true) { // something similar, but now for the left side of the word
        std::deque<tString>::iterator i;
        i = results.begin();
        bool found=true;
        tString::size_type pos=(m_ignorecase?Simplify(*i):*i).find(ret);
        if(pos!=tString::npos && pos > 0) {
            found=false;
            ret.insert(ret.begin(),(m_ignorecase ? tolower(i->at(pos-1)) : i->at(pos-1)));
            ++i;
            for(; i!=results.end(); ++i) {
                if((m_ignorecase?Simplify(*i):*i).find(ret) == tString::npos) {
                    found=true;
                    ret.erase(0,1);
                    break;
                }
            }
        }
        if (found)  //we found a mismatch
            break;
        else
            len++;
    }

void uAutoCompleter::ShowPossibilities	(	std::deque< tString > &	results,
		tString &	word
	)			[protected, virtual]

Prints the possible completions to the console.

Parameters:

	results	the list of possible completions
	word	the word that was already typed, it will be highlighted

Definition at line 968 of file uMenu.cpp.

                                                                                {
    if(results.size() > 10) {
        con << tOutput("$tab_completion_toomanyresults");
    }
    else {
        con << tOutput("$tab_completion_results");
        tString::size_type len=word.length();
        for(std::deque<tString>::iterator i=results.begin(); i!=results.end(); ++i) {
            tString::size_type pos=(m_ignorecase?Simplify(*i):*i).find(word);
            con << i->SubStr(0,pos)
            << "0xff8888"
            << i->SubStr(pos, len)
            << "0xffffff"
            << i->SubStr(pos+len)
            << "\n";
        }

int uAutoCompleter::DoCompletion	(	tString &	string,
		int	pos,
		int	len,
		tString &	match
	)			[protected, virtual]

Replaces the word the cursor is on by the closest match.

Parameters:

	string	the string in which the completion should take place
	pos	the position in strind where the replaced word ends
	len	the length of the word that is already there
	match	the string that will be inserted into the other one

Returns:

the new cursor position

Definition at line 992 of file uMenu.cpp.

                                                                                  {
    string.erase(pos-len, len);
    string.insert(pos-len, match);

int uAutoCompleter::DoFullCompletion	(	tString &	string,
		int	pos,
		int	len,
		tString &	match
	)			[protected, virtual]

Replaces the word the cursor is on by the given match and a space.

Parameters:

	string	the string in which the completion should take place
	pos	the position in string where the replaced word ends
	len	the length of the word that is already there
	match	the string that will be inserted into the other one

Returns:

the new cursor position

Reimplemented in eAutoCompleterChat.

Definition at line 1003 of file uMenu.cpp.

                                                                                      {
    tString actualString = match + " ";

int uAutoCompleter::TryCompletion	(	tString &	string,
		unsigned	pos,
		unsigned	len
	)			[protected, virtual]

Attempt completion with a certain word length.

Parameters:

	string	the string in which the completion should take place
	pos	the cursor position
	len	the length of the word

Returns:

the new position on success (something was found), -1 on failure

Definition at line 1012 of file uMenu.cpp.

                                                                             {
    tString word(string.SubStr(pos-len, len));
    std::deque<tString> results;
    FindPossibleWords(word, results);
    if(results.size() > 1){
        tString match(FindClosestMatch(word, results));
        if(match == word) { //no completion took place
            ShowPossibilities(results, word);
            return pos;
        }
        else { //do the completion
            return DoCompletion(string, pos, len, match);
        }
    }
    else if(!results.empty()){
        return DoFullCompletion(string, pos, len, results.front());
    }

tString uAutoCompleter::Simplify

(

tString const &

str

)

[protected, virtual]

Simplifies a string, by default converts it to lowercase.

Parameters:

str

the string to simplify

Returns:

the simplified string(in this case everything converted to lowercase)

Reimplemented in eAutoCompleterChat.

Definition at line 1057 of file uMenu.cpp.

                                                   {

int uAutoCompleter::Complete	(	tString &	string,
		unsigned	pos
	)			[virtual]

Attempts the completion.

Parameters:

	string	the string in which the completion should take place
	pos	the cursor position

Returns:

the new cursor position

Reimplemented in gAutoCompleterConsole.

Definition at line 1035 of file uMenu.cpp.

Referenced by gAutoCompleterConsole::Complete().

                                                          {
    if(m_LastCompletion != -1 && (unsigned)m_LastCompletion < pos) {
        int res = TryCompletion(string, pos, pos - m_LastCompletion);
        if(res != -1) return res;
    }
    int len = FindLengthOfLastWord(string, pos);
    if(len == -1) return pos; //in the middle of a word...
    int res = TryCompletion(string, pos, len);
    if(res != -1) {
        m_LastCompletion = pos - len;
        return res;
    }

Here is the caller graph for this function:

void uAutoCompleter::SetIgnorecase

(

bool

ignorecase

)

Enable or disable case ignoring?

Parameters:

ignorecase

ignore upper and lower case?

Definition at line 1051 of file uMenu.cpp.

References m_ignorecase.

                                                  {

---

Member Data Documentation

std::deque<tString>& uAutoCompleter::m_PossibleWords [protected]

The words that can be used for completion.

Definition at line 414 of file uMenu.h.

int uAutoCompleter::m_LastCompletion [protected]

Definition at line 415 of file uMenu.h.

bool uAutoCompleter::m_ignorecase [protected]

Definition at line 416 of file uMenu.h.

Referenced by SetIgnorecase().

---

The documentation for this class was generated from the following files:

• src/ui/uMenu.h
• src/ui/uMenu.cpp

---