presage.h

Go to the documentation of this file.

/******************************************************
 *  Presage, an extensible predictive text entry system
 *  ---------------------------------------------------
 *
 *  Copyright (C) 2008  Matteo Vescovi <matteo.vescovi@yahoo.co.uk>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with this program; if not, write to the Free Software Foundation, Inc.,
    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
                                                                             *
                                                                **********(*)*/


#ifndef PRESAGE
#define PRESAGE

#include "presageException.h"
#include "presageCallback.h"

/********************************
 *    Presage C++ API starts here
 */

#ifdef __cplusplus
#ifndef _MSC_VER

#include <string>
#include <vector>
#include <map>

/* Forward declarations, not part of presage C++ API */
class Configuration;
class ProfileManager;
class Profile;
class ContextTracker;
class PredictorRegistry;
class PredictorActivator;
class Selector;

class Presage {
public:
    Presage(PresageCallback* callback) throw (PresageException);


    Presage(PresageCallback* callback, const std::string config) throw (PresageException);


    ~Presage();

    std::vector<std::string> predict() throw (PresageException);

    std::multimap<double, std::string> predict(std::vector<std::string> filter) throw (PresageException);

    void learn(const std::string text) const throw (PresageException);

    PresageCallback* callback(PresageCallback* callback) throw (PresageException);

    std::string completion(std::string str) throw (PresageException);

    std::string context() const throw (PresageException);

    bool context_change() const throw (PresageException);

    std::string prefix() const throw (PresageException);

    std::string config(const std::string variable) const throw (PresageException);

    void config(const std::string variable, const std::string value) const throw (PresageException);

    void save_config() const throw (PresageException);

    std::string version() const throw (PresageException);

    /*
     * Presage public API ends here
     */

private:
    ProfileManager*     profileManager;
    Configuration*      configuration;
    PredictorRegistry*  predictorRegistry;
    ContextTracker*     contextTracker;
    PredictorActivator* predictorActivator;
    Selector*           selector;

};

#endif /* _MSC_VER */
#endif /* __cplusplus */

/*
 *    Presage C++ API ends here
 *******************************/


/*******************************
 *    Presage C API starts here
 */

#ifdef __cplusplus
extern "C" {
#endif

    typedef struct _presage* presage_t;

    typedef struct {
        char*  token;
        double probability;
    } presage_suggestion_t;

    typedef presage_suggestion_t* presage_prediction_t;


    presage_error_code_t presage_new                 (_presage_callback_get_past_stream past_stream_cb,
                                                      void* past_stream_cb_arg,
                                                      _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_arg,
                                                      _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);

    void                 presage_free_string_array   (char** str);

    void                 presage_free_prediction     (presage_prediction_t prediction);

    presage_error_code_t presage_predict             (presage_t prsg,
                                                      char*** result);

    presage_error_code_t presage_predict_with_filter  (presage_t prsg,
                                                      const char** filter,
                                                      presage_prediction_t* result);
    
    presage_error_code_t presage_learn               (presage_t prsg,
                                                      const char* text);

    presage_error_code_t presage_completion          (presage_t prsg,
                                                      const char* token,
                                                      char** result);

    presage_error_code_t presage_context             (presage_t prsg, 
                                                      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);

    presage_error_code_t presage_version             (presage_t prsg,
                                                      char** result);

#ifdef __cplusplus
}
#endif

/*
 *    Presage C API ends here
 ****************************/


#endif /* PRESAGE */