lingucomponent/source/languageguessing/simpleguesser.cxx

   1 /***************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: simpleguesser.cxx,v $
  10  * $Revision: 1.6 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31  /**
  32   *
  33   *
  34   *
  35   *
  36   * TODO
  37   * - Add exception throwing when h == NULL
  38   * - Not init h when implicit constructor is launched
  39   */
  40
  41 // MARKER(update_precomp.py): autogen include statement, do not remove
  42 #include "precompiled_lingucomponent.hxx"
  43
  44 #include <string.h>
  45 #include <sstream>
  46 #include <iostream>
  47
  48 #include <libtextcat/textcat.h>
  49 #include <libtextcat/common.h>
  50 #include <libtextcat/constants.h>
  51 #include <libtextcat/fingerprint.h>
  52 #include <libtextcat/utf8misc.h>
  53
  54 #include <sal/types.h>
  55
  56 #include "altstrfunc.hxx"
  57 #include "simpleguesser.hxx"
  58
  59 #ifndef _UTF8_
  60 #define _UTF8_
  61 #endif
  62
  63
  64 using namespace std;
  65
  66
  67 /**
  68  * This 3 following structures are from fingerprint.c and textcat.c
  69  */
  70
  71 typedef struct ngram_t {
  72
  73     sint2 rank;
  74     char str[MAXNGRAMSIZE+1];
  75
  76 } ngram_t;
  77
  78 typedef struct fp_t {
  79
  80     const char *name;
  81     ngram_t *fprint;
  82     uint4 size;
  83
  84 } fp_t;
  85
  86 typedef struct textcat_t{
  87
  88     void **fprint;
  89     char *fprint_disable;
  90     uint4 size;
  91     uint4 maxsize;
  92
  93     char output[MAXOUTPUTSIZE];
  94
  95 } textcat_t;
  96 /** end of the 3 structs */
  97
  98 SimpleGuesser::SimpleGuesser()
  99 {
 100     h = NULL;
 101 }
 102
 103 void SimpleGuesser::operator=(SimpleGuesser& sg){
 104     if(h){textcat_Done(h);}
 105     h = sg.h;
 106 }
 107
 108 SimpleGuesser::~SimpleGuesser()
 109 {
 110     if(h){textcat_Done(h);}
 111 }
 112
 113
 114 /*!
 115     \fn SimpleGuesser::GuessLanguage(char* text)
 116  */
 117 vector<Guess> SimpleGuesser::GuessLanguage(char* text)
 118 {
 119         vector<Guess> guesses;
 120
 121         if(!h){return guesses;}
 122
 123         //calculate le number of unicode charcters (symbols)
 124         int len = utfstrlen(text);
 125
 126     if( len > MAX_STRING_LENGTH_TO_ANALYSE ){len = MAX_STRING_LENGTH_TO_ANALYSE ;}
 127
 128         char *guess_list = textcat_Classify(h, text, len);
 129
 130         if(strcmp(guess_list, _TEXTCAT_RESULT_SHORT) == 0){
 131             return guesses;
 132         }
 133
 134         int current_pointer = 0;
 135
 136         for(int i = 0; guess_list[current_pointer] != '\0'; i++)
 137         {
 138             while(guess_list[current_pointer] != GUESS_SEPARATOR_OPEN && guess_list[current_pointer] != '\0'){
 139                 current_pointer++;
 140             }
 141             if(guess_list[current_pointer] != '\0')
 142             {
 143                 Guess g((char*)(guess_list + current_pointer));
 144
 145                 guesses.push_back(g);
 146
 147                 current_pointer++;
 148             }
 149         }
 150
 151     return guesses;
 152 }
 153
 154 /*!
 155     \fn SimpleGuesser::GuessPrimaryLanguage(char* text)
 156  */
 157 Guess SimpleGuesser::GuessPrimaryLanguage(char* text)
 158 {
 159     vector<Guess> ret = GuessLanguage(text);
 160     if(ret.size() > 0){
 161         return GuessLanguage(text)[0];
 162     }
 163     else{
 164         return Guess();
 165     }
 166 }
 167 /**
 168  * Is used to know wich language is available, unavailable or both
 169  * when mask = 0xF0, return only Available
 170  * when mask = 0x0F, return only Unavailable
 171  * when mask = 0xFF, return both Available and Unavailable
 172  */
 173 vector<Guess> SimpleGuesser::GetManagedLanguages(const char mask)
 174 {
 175     size_t i;
 176     textcat_t *tables = (textcat_t*)h;
 177
 178     vector<Guess> lang;
 179     if(!h){return lang;}
 180
 181     for (i=0; i<tables->size; i++) {
 182         if(tables->fprint_disable[i] & mask){
 183             string langStr = "[";
 184             langStr += (char*)fp_Name(tables->fprint[i]);
 185             Guess g( (char *)langStr.c_str());
 186             lang.push_back(g);
 187         }
 188     }
 189
 190     return lang;
 191 }
 192
 193 vector<Guess> SimpleGuesser::GetAvailableLanguages(){
 194     return GetManagedLanguages( sal::static_int_cast< char >( 0xF0 ) );
 195 }
 196
 197 vector<Guess> SimpleGuesser::GetUnavailableLanguages(){
 198     return GetManagedLanguages( sal::static_int_cast< char >( 0x0F ));
 199 }
 200
 201 vector<Guess> SimpleGuesser::GetAllManagedLanguages(){
 202     return GetManagedLanguages( sal::static_int_cast< char >( 0xFF ));
 203 }
 204
 205 void SimpleGuesser::XableLanguage(string lang, char mask){
 206     size_t i;
 207     textcat_t *tables = (textcat_t*)h;
 208
 209     if(!h){return;}
 210
 211     for (i=0; i<tables->size; i++) {
 212         string language(fp_Name(tables->fprint[i]));
 213         if(start(language,lang) == 0){
 214             //cout << language << endl;
 215             tables->fprint_disable[i] = mask;
 216             //continue;
 217         }
 218     }
 219 }
 220
 221 void SimpleGuesser::EnableLanguage(string lang){
 222     XableLanguage(lang,  sal::static_int_cast< char >( 0xF0 ));
 223 }
 224
 225 void SimpleGuesser::DisableLanguage(string lang){
 226     XableLanguage(lang,  sal::static_int_cast< char >( 0x0F ));
 227 }
 228
 229 /**
 230 *
 231 */
 232 void SimpleGuesser::SetDBPath(const char* path, const char* prefix){
 233     if(h){
 234         textcat_Done(h);
 235     }
 236     h = special_textcat_Init(path, prefix);
 237 }