presage.h   presage.h 
skipping to change at line 30 skipping to change at line 30
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
* *
**********( *)*/ **********( *)*/
#ifndef PRESAGE #ifndef PRESAGE
#define PRESAGE #define PRESAGE
#include "presageException.h" #include "presageException.h"
#include "presageCallback.h" #include "presageCallback.h"
#ifdef __cplusplus /** \mainpage
extern "C" {
#endif
/*
* Presage C API starts here
*/
typedef struct _presage* presage_t;
presage_error_code_t presage_new (_presage_callback_get
_past_stream past_stream_cb,
void* past_stream_cb_a
rg,
_presage_callback_get_
future_stream future_stream_cb,
void* future_stream_cb
_arg,
presage_t* result);
presage_error_code_t presage_new_with_config (_presage_callback_get
_past_stream past,
void* past_stream_cb_a
rg,
_presage_callback_get_
future_stream future_stream_cb,
void* future_stream_cb
_arg,
const char* config,
presage_t* result);
void presage_free (presage_t prsg);
void presage_free_string (char* str); \section intro_section Introduction
void presage_free_string_array (char** str);
presage_error_code_t presage_predict (presage_t prsg, Presage is an intelligent predictive text entry
char*** result); platform. Presage exploits <a
href="http://en.wikipedia.org/wiki/Redundancy_%28information_theory%29"
>redundant
information</a> embedded in natural languages to generate
predictions. Presage's modular and pluggable <a
href="?q=node/14">architecture</a> allows its <a
href="http://en.wikipedia.org/wiki/Language_modeling">language
model</a> to be extended and customized to utilize statistical,
syntactic, and semantic information sources.
presage_error_code_t presage_completion (presage_t prsg, A predictive text entry system attempts to improve ease and speed of
const char* token, textual input. Word prediction consists in computing which word tokens
char** result); or word completions are most likely to be entered next. The system
analyses the text already entered and combines the information thus
extracted with other information sources to calculate a set of most
probable tokens.
presage_error_code_t presage_context (presage_t prsg, A typical presage-based application would display the set of most
char** result); probable tokens (i.e. a list of suggestions) to the user and
automatically enter the desired token after the user selects it. If
the list of suggestions does not contain the desired word, the user
continues entering text until the correct suggestion is offered or
until the user is done entering text.
presage_error_code_t presage_context_change (presage_t prsg, Presage is fundamentally different from predictive <a
int* result); href="http://en.wikipedia.org/wiki/T9_%28predictive_text%29">input
technologies commonly found on mobile phones</a>, which might more
accurately be described as 'disambiguating text entry' rather than
'predictive text entry' systems. Such systems do not try to guess
what the user intends to write in the future, only to determine what
they most-likely intend to write in the present, given their past
input. Presage, on the other hand, actively predicts the what the
user intends to write, and only reverts to <a
href="http://en.wikipedia.org/wiki/Word_completion">word
completion</a> mode if the prediction did not contain the desired
token.
presage_error_code_t presage_prefix (presage_t prsg, Presage is <a
char** result); href="http://www.gnu.org/philosophy/free-sw.html">free
software</a>. It is distributed under the term of the <a
href="http://www.gnu.org/copyleft/gpl.html">General Public
License</a>.
presage_error_code_t presage_config (presage_t prsg, \author Matteo Vescovi
const char* variable,
char** result);
presage_error_code_t presage_config_set (presage_t prsg, \section getting_started_section Getting started
const char* variable, \include getting_started.txt
const char* value);
presage_error_code_t presage_save_config (presage_t prsg); */
/* /********************************
* Presage C API ends here * Presage C++ API starts here
*/ */
#ifdef __cplusplus
}
#endif
#ifdef __cplusplus #ifdef __cplusplus
#ifndef _MSC_VER #ifndef _MSC_VER
/*
* Presage C++ API starts here
*/
#include <string> #include <string>
#include <vector> #include <vector>
#include <map> #include <map>
/* Forward declarations, not part of presage C++ API */ /* Forward declarations, not part of presage C++ API */
class Configuration; class Configuration;
class ProfileManager; class ProfileManager;
class Profile; class Profile;
class ContextTracker; class ContextTracker;
skipping to change at line 244 skipping to change at line 238
private: private:
ProfileManager* profileManager; ProfileManager* profileManager;
Configuration* configuration; Configuration* configuration;
PredictorRegistry* predictorRegistry; PredictorRegistry* predictorRegistry;
ContextTracker* contextTracker; ContextTracker* contextTracker;
PredictorActivator* predictorActivator; PredictorActivator* predictorActivator;
Selector* selector; Selector* selector;
}; };
#endif /* _MSC_VER */
#endif /* __cplusplus */
/* /*
* Presage C++ API ends here * Presage C++ API ends here
*******************************/
/*******************************
* Presage C API starts here
*/ */
#endif /* _MSC_VER */
#endif /* __cplusplus */
/** \mainpage #ifdef __cplusplus
extern "C" {
#endif
\section intro_section Introduction typedef struct _presage* presage_t;
Presage is an intelligent predictive text entry presage_error_code_t presage_new (_presage_callback_get
platform. Presage exploits <a _past_stream past_stream_cb,
href="http://en.wikipedia.org/wiki/Redundancy_%28information_theory%29" void* past_stream_cb_
>redundant arg,
information</a> embedded in natural languages to generate _presage_callback_get
predictions. Presage's modular and pluggable <a _future_stream future_stream_cb,
href="?q=node/14">architecture</a> allows its <a void* future_stream_c
href="http://en.wikipedia.org/wiki/Language_modeling">language b_arg,
model</a> to be extended and customized to utilize statistical, presage_t* result);
syntactic, and semantic information sources.
A predictive text entry system attempts to improve ease and speed of presage_error_code_t presage_new_with_config (_presage_callback_get
textual input. Word prediction consists in computing which word tokens _past_stream past,
or word completions are most likely to be entered next. The system void* past_stream_cb_
analyses the text already entered and combines the information thus arg,
extracted with other information sources to calculate a set of most _presage_callback_get
probable tokens. _future_stream future_stream_cb,
void* future_stream_c
b_arg,
const char* config,
presage_t* result);
A typical presage-based application would display the set of most void presage_free (presage_t prsg);
probable tokens (i.e. a list of suggestions) to the user and
automatically enter the desired token after the user selects it. If
the list of suggestions does not contain the desired word, the user
continues entering text until the correct suggestion is offered or
until the user is done entering text.
Presage is fundamentally different from predictive <a void presage_free_string (char* str);
href="http://en.wikipedia.org/wiki/T9_%28predictive_text%29">input void presage_free_string_array (char** str);
technologies commonly found on mobile phones</a>, which might more
accurately be described as 'disambiguating text entry' rather than
'predictive text entry' systems. Such systems do not try to guess
what the user intends to write in the future, only to determine what
they most-likely intend to write in the present, given their past
input. Presage, on the other hand, actively predicts the what the
user intends to write, and only reverts to <a
href="http://en.wikipedia.org/wiki/Word_completion">word
completion</a> mode if the prediction did not contain the desired
token.
Presage is <a presage_error_code_t presage_predict (presage_t prsg,
href="http://www.gnu.org/philosophy/free-sw.html">free char*** result);
software</a>. It is distributed under the term of the <a
href="http://www.gnu.org/copyleft/gpl.html">General Public
License</a>.
\author Matteo Vescovi presage_error_code_t presage_completion (presage_t prsg,
const char* token,
char** result);
\section getting_started_section Getting started presage_error_code_t presage_context (presage_t prsg,
\include getting_started.txt char** result);
*/ presage_error_code_t presage_context_change (presage_t prsg,
int* result);
presage_error_code_t presage_prefix (presage_t prsg,
char** result);
presage_error_code_t presage_config (presage_t prsg,
const char* variable,
char** result);
presage_error_code_t presage_config_set (presage_t prsg,
const char* variable,
const char* value);
presage_error_code_t presage_save_config (presage_t prsg);
#ifdef __cplusplus
}
#endif
/*
* Presage C API ends here
****************************/
#endif /* PRESAGE */ #endif /* PRESAGE */
 End of changes. 26 change blocks. 
107 lines changed or deleted 110 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/