#include <EditLineReader.hh>

Inheritance diagram for EditLineReader:

Collaboration diagram for EditLineReader:

Public Member Functions
	EditLineReader (std::string program="")

virtual	~EditLineReader ()

virtual void	initialize (std::string defPrompt="", FILE in=stdin, FILE out=stdout, FILE *err=stderr)

virtual std::string	readLine (std::string prompt="")

virtual char	charQuestion (std::string question, std::string allowedChars, bool caseSensitive=false, char defaultAnswer='\0')

Public Member Functions inherited from LineReader
	LineReader (std::istream &iStream=std::cin, std::ostream &oStream=std::cout)

virtual	~LineReader ()

virtual std::ostream &	outputStream ()

bool	confirmation (std::string question, char defaultAnswer='n', char yesChar='y', char noChar='n')

virtual void	setSaveInputHistoryToFile (bool flag)

virtual bool	saveInputHistoryToFile () const

virtual void	setInputHistoryLog (const std::string &historyFilename)

virtual void	setInputHistoryLength (std::size_t length)

virtual size_t	inputHistoryMaxLength () const

virtual std::size_t	inputsInHistory () const

virtual std::string	inputHistoryEntry (std::size_t age) const

Private Types
typedef std::map< EditLine , EditLineReader >::value_type	ValType
	value_type for map.

typedef std::map< EditLine , EditLineReader >::iterator	MapIt
	Iterator for map.

Private Member Functions
	EditLineReader (const EditLineReader &)
	Copying not allowed.

EditLineReader &	operator= (const EditLineReader &)
	Assignment not allowed.

char *	prompt ()

void	updateHistory (const char *c)

Static Private Member Functions
static char *	wrapperToCallPrompt (EditLine *edit)

Private Attributes
char *	prompt_
	Line reader prompt.

std::string	program_
	The name of the invocating program.

EditLine *	editLine_
	EditLine instance.

History *	history_
	History instance.

FILE *	in_
	Input stream is saved for end-of-file checking.

Static Private Attributes
static std::map< EditLine , EditLineReader >	lineReaders_
	Map containing all (EditLine, EditLineReader) pairs to make prompt printing possible. This map offers to callback function 'wrapperToCallPrompt' a right instance of EditLineReader. This instance then returns the right prompt.

Additional Inherited Members
Protected Member Functions inherited from LineReader
void	setInitialized ()

bool	initialized () const

void	putInInputHistory (const std::string &inputLine)

Detailed Description

LineReader implementation using libedit library.

libedit offers functionality to edit a line as well as command history browsing functionality. In other words, user can edit the line he is writing as well as browse history of commands.

Definition at line 53 of file EditLineReader.hh.

Member Typedef Documentation

◆ MapIt

typedef std::map<EditLine*,EditLineReader*>::iterator EditLineReader::MapIt

private

Iterator for map.

Definition at line 72 of file EditLineReader.hh.

◆ ValType

typedef std::map<EditLine*,EditLineReader*>::value_type EditLineReader::ValType

private

value_type for map.

Definition at line 70 of file EditLineReader.hh.

Constructor & Destructor Documentation

◆ EditLineReader() [1/2]

EditLineReader::EditLineReader ( std::string program = "" )

explicit

Constructor.

Parameters

program The name of the invocating program.

Definition at line 56 of file EditLineReader.cc.

                                                : 
    LineReader(), prompt_(NULL), program_(program), editLine_(NULL), 
    history_(NULL) {
}

◆ ~EditLineReader()

EditLineReader::~EditLineReader ( )

virtual

Destructor.

Definition at line 64 of file EditLineReader.cc.

                                {
    
    lineReaders_.erase(editLine_);
    
    if (history_ != NULL) {
        history_end(history_);
    }
    
    if (editLine_ != NULL) {
        el_end(editLine_);
    }
    
    if (prompt_ != NULL) {
        delete[] prompt_;
    }
}

References editLine_, history_, lineReaders_, and prompt_.

◆ EditLineReader() [2/2]

EditLineReader::EditLineReader ( const EditLineReader & )

private

Copying not allowed.

Member Function Documentation

◆ charQuestion()

char EditLineReader::charQuestion	(	std::string	question,
		std::string	allowedChars,
		bool	caseSensitive = `false`,
		char	defaultAnswer = `'\0'`
	)

virtual

Asks user a question and expects that answer is given as char.

Prompt is temporarily changed to 'question' during the execution of this function.

Parameters

question	The asked question.
allowedChars	The chars that are legal answers.
caseSensitive	Flag indicating whether answer is read case sensitive or not.
defaultAnswer	The default answer.

Returns: User given answer.

Exceptions

ObjectNotInitialized If LineReader is not initialized.

Implements LineReader.

Definition at line 180 of file EditLineReader.cc.

                        {
    if (!initialized()) {
        string method = "EditLineReader::charQuestion()";
        string message = "LineReader not initialized";
        throw ObjectNotInitialized(__FILE__, __LINE__, method, message);
    }
 
    char* oldPrompt = prompt_;
    prompt_ = StringTools::stringToCharPtr(question);
 
    if (defaultAnswer == '\0') {
        const char* answer = nullptr;
        do {
            int count;
            answer = el_gets(editLine_, &count);
        } while (strlen(answer) != 1 && 
                 !StringTools::
                 containsChar(allowedChars, answer[0], caseSensitive));
        
        updateHistory(answer);
        delete[] prompt_;
        prompt_ = oldPrompt;
        return answer[0];
    } else {
        const char* answer = nullptr;
        int count;
        assert(editLine_ != nullptr);
        answer = el_gets(editLine_, &count);
        if (answer == nullptr) {
            updateHistory("");
            delete[] prompt_;
            prompt_ = oldPrompt;
            return defaultAnswer;
        }
        if (strlen(answer) != 1 && 
            !StringTools::
            containsChar(allowedChars, answer[0], caseSensitive)) {
            
            updateHistory(&defaultAnswer);
            delete[] prompt_;
            prompt_ = oldPrompt;
            return defaultAnswer;
        } else {
            updateHistory(answer);
            delete[] prompt_;
            prompt_ = oldPrompt;
            return answer[0];
        }
    }
}

References assert, editLine_, LineReader::initialized(), prompt_, StringTools::stringToCharPtr(), and updateHistory().

Here is the call graph for this function:

◆ initialize()

void EditLineReader::initialize	(	std::string	defPrompt = `""`,
		FILE *	in = `stdin`,
		FILE *	out = `stdout`,
		FILE *	err = `stderr`
	)

virtual

Initializes LineReader.

Sets the prompt printing function and initializes history.

Parameters

defPrompt	The prompt for the program.
in	Input file stream.
out	Output file stream.
err	Error file stream.

Implements LineReader.

Definition at line 92 of file EditLineReader.cc.

               {
 
    prompt_ = StringTools::stringToCharPtr(defPrompt);
    // initialize EditLine
    editLine_ = el_init(program_.c_str(), in, out, err);
    assert(editLine_!=NULL);
    // define prompt printing function
    el_set(editLine_, EL_PROMPT, wrapperToCallPrompt);
    // bind all keys to the standard GNU emacs-like bindings.
    //el_set(editLine_, EL_BIND, "-e");
    el_set(editLine_, EL_EDITOR, "emacs");
    if (in != stdin) {
        // when reading from file, editing is set off
        el_set(editLine_, EL_EDITMODE, 0);
    }
    // initialize History
    HistEvent ev;    
    history_ = history_init();
    if (history_!=NULL) {
        // size of the history is set to 100
        history(history_, &ev, H_SETSIZE, 100);
        el_set(editLine_, EL_HIST, history, history_);
    }
    lineReaders_.insert(ValType(editLine_, this));
    in_ = in;
    setInitialized();
}

References assert, editLine_, history_, in_, lineReaders_, program_, prompt_, LineReader::setInitialized(), StringTools::stringToCharPtr(), and wrapperToCallPrompt().

Here is the call graph for this function:

◆ operator=()

EditLineReader & EditLineReader::operator= ( const EditLineReader & )

private

Assignment not allowed.

◆ prompt()

char * EditLineReader::prompt ( )

private

Returns the used prompt.

Returns: The prompt.

Definition at line 259 of file EditLineReader.cc.

                       {
    return prompt_;
}

References prompt_.

Referenced by readLine(), and wrapperToCallPrompt().

◆ readLine()

string EditLineReader::readLine ( std::string prompt = "" )

virtual

Reads line from input stream.

If prompt is given, it is used as a prompt only for reading this one line.

Parameters

prompt The prompt.

Returns: The string that is read.

Exceptions

ObjectNotInitialized	If LineReader is not initialized.
EndOfFile	When end of file mark (ctrl-d) is received.

Implements LineReader.

Definition at line 135 of file EditLineReader.cc.

                                         {
    if (!initialized()) {
        string message = "LineReader not initialized";
        throw ObjectNotInitialized(__FILE__, __LINE__, __func__, message);
    }
    
    char* oldPrompt = NULL;
    if (prompt != "") {
        oldPrompt = prompt_;
        prompt_ = StringTools::stringToCharPtr(prompt);
    }
 
    int count;
    const char* c = el_gets(editLine_, &count);
 
    bool endOfFile = (c == NULL || strlen(c) == 0 || feof(in_));
    if (endOfFile) {
        string message = "End of file.";
        throw EndOfFile(__FILE__, __LINE__, __func__, message);
    }
  
    // add command to history
    updateHistory(c);
    if (oldPrompt != NULL) {
        delete[] prompt_;
        prompt_ = oldPrompt;
    }
    return c;
}

References __func__, editLine_, in_, LineReader::initialized(), prompt(), prompt_, StringTools::stringToCharPtr(), and updateHistory().

Here is the call graph for this function:

◆ updateHistory()

void EditLineReader::updateHistory ( const char * newEntry )

private

Inserts a new entry to history.

Only non-empty strings are saved to history.

Parameters

newEntry A new entry to be added.

Definition at line 271 of file EditLineReader.cc.

                                                  {
    string entry(newEntry);
    entry = StringTools::trim(entry);
    if (entry != "") {
        HistEvent ev;
        history(history_, &ev, H_ENTER, newEntry);
        putInInputHistory(newEntry);
    }
}

References history_, LineReader::putInInputHistory(), and StringTools::trim().

Referenced by charQuestion(), and readLine().

Here is the call graph for this function:

◆ wrapperToCallPrompt()

char * EditLineReader::wrapperToCallPrompt ( EditLine * edit )

staticprivate

Static wrapper function that calls function that returns the prompt.

If correct EditLine* instance is not found in the map, an empty string (null char*) is returned.

Parameters

edit	EditLine which prompt is needed.

Returns: The prompt.

Definition at line 243 of file EditLineReader.cc.

                                                  {
    
    MapIt mi = lineReaders_.find(edit);
    if (mi == lineReaders_.end()) {
        return NULL;
    }
    EditLineReader* reader = (*mi).second;
    return reader->prompt();
}

References lineReaders_, and prompt().

Referenced by initialize().

Here is the call graph for this function:

Member Data Documentation

◆ editLine_

EditLine* EditLineReader::editLine_

private

EditLine instance.

Definition at line 88 of file EditLineReader.hh.

Referenced by charQuestion(), initialize(), readLine(), and ~EditLineReader().

◆ history_

History* EditLineReader::history_

private

History instance.

Definition at line 90 of file EditLineReader.hh.

Referenced by initialize(), updateHistory(), and ~EditLineReader().

◆ in_

FILE* EditLineReader::in_

private

Input stream is saved for end-of-file checking.

Definition at line 98 of file EditLineReader.hh.

Referenced by initialize(), and readLine().

◆ lineReaders_

map< EditLine *, EditLineReader * > EditLineReader::lineReaders_

staticprivate

Map containing all (EditLine*, EditLineReader*) pairs to make prompt printing possible. This map offers to callback function 'wrapperToCallPrompt' a right instance of EditLineReader. This instance then returns the right prompt.

Definition at line 95 of file EditLineReader.hh.

Referenced by initialize(), wrapperToCallPrompt(), and ~EditLineReader().

◆ program_

std::string EditLineReader::program_

private

The name of the invocating program.

Definition at line 86 of file EditLineReader.hh.

Referenced by initialize().

◆ prompt_

char* EditLineReader::prompt_

private

Line reader prompt.

Definition at line 84 of file EditLineReader.hh.

Referenced by charQuestion(), initialize(), prompt(), readLine(), and ~EditLineReader().

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

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ MapIt

◆ ValType

Constructor & Destructor Documentation

◆ EditLineReader() [1/2]

◆ ~EditLineReader()

◆ EditLineReader() [2/2]

Member Function Documentation

◆ charQuestion()

◆ initialize()

◆ operator=()

◆ prompt()

◆ readLine()

◆ updateHistory()

◆ wrapperToCallPrompt()

Member Data Documentation

◆ editLine_

◆ history_

◆ in_

◆ lineReaders_

◆ program_

◆ prompt_