mega_venik/sdcv
1
0
Fork 0
mirror of https://github.com/Dushistov/sdcv.git synced 2025-12-15 17:31:56 +00:00
Code Issues Projects Releases Wiki Activity

lib: c++11

Browse Source
This commit is contained in:
Evgeniy Dushistov
2013-07-06 23:04:28 +00:00
parent 482feda09e
commit 24f1688809
2 changed files with 570 additions and 637 deletions
Download Patch File Download Diff File Expand all files Collapse all files

454
src/lib/lib.cpp
View File

@@ -14,20 +14,25 @@
#include "file.hpp"
#include "mapfile.hpp"
#include "lib.h"
#include "lib.hpp"
// Notice: read src/tools/DICTFILE_FORMAT for the dictionary
// file's format information!
namespace {
struct Fuzzystruct {
char * pMatchWord;
int iMatchWordDistance;
};
static inline bool bIsVowel(gchar inputchar)
{
static inline bool bIsVowel(gchar inputchar)
{
gchar ch = g_ascii_toupper(inputchar);
return( ch=='A' || ch=='E' || ch=='I' || ch=='O' || ch=='U' );
}
}
static bool bIsPureEnglish(const gchar *str)
{
static bool bIsPureEnglish(const gchar *str)
{
// i think this should work even when it is UTF8 string :).
for (int i=0; str[i]!=0; i++)
//if(str[i]<0)
@@ -36,40 +41,51 @@ static bool bIsPureEnglish(const gchar *str)
if (!isascii(str[i]))
return false;
return true;
}
}
static inline guint32 get_uint32(const gchar *addr)
{
static inline guint32 get_uint32(const gchar *addr)
{
guint32 result;
memcpy(&result, addr, sizeof(guint32));
return result;
}
}
static inline void set_uint32(gchar *addr, guint32 val)
{
static inline void set_uint32(gchar *addr, guint32 val)
{
memcpy(addr, &val, sizeof(guint32));
}
}
static inline gint stardict_strcmp(const gchar *s1, const gchar *s2)
{
static inline gint stardict_strcmp(const gchar *s1, const gchar *s2)
{
gint a=g_ascii_strcasecmp(s1, s2);
if (a == 0)
return strcmp(s1, s2);
else
return a;
}
static void unicode_strdown(gunichar *str)
{
while (*str) {
*str=g_unichar_tolower(*str);
++str;
}
}
}
bool DictInfo::load_from_ifo_file(const std::string& ifofilename,
bool istreedict)
{
ifo_file_name=ifofilename;
ifo_file_name = ifofilename;
gchar *buffer;
if (!g_file_get_contents(ifofilename.c_str(), &buffer, NULL, NULL))
if (!g_file_get_contents(ifofilename.c_str(), &buffer, nullptr, nullptr))
return false;
#define TREEDICT_MAGIC_DATA "StarDict's treedict ifo file\nversion=2.4.2\n"
#define DICT_MAGIC_DATA "StarDict's dict ifo file\nversion=2.4.2\n"
const gchar *magic_data=istreedict ? TREEDICT_MAGIC_DATA : DICT_MAGIC_DATA;
const gchar *magic_data = istreedict ? TREEDICT_MAGIC_DATA : DICT_MAGIC_DATA;
if (!g_str_has_prefix(buffer, magic_data)) {
g_free(buffer);
return false;
@@ -174,18 +190,6 @@ bool DictInfo::load_from_ifo_file(const std::string& ifofilename,
return true;
}
//===================================================================
DictBase::DictBase()
{
dictfile = NULL;
cache_cur =0;
}
DictBase::~DictBase()
{
if (dictfile)
fclose(dictfile);
}
gchar* DictBase::GetWordData(guint32 idxitem_offset, guint32 idxitem_size)
{
@@ -326,14 +330,6 @@ gchar* DictBase::GetWordData(guint32 idxitem_offset, guint32 idxitem_size)
return data;
}
inline bool DictBase::containSearchData()
{
if (sametypesequence.empty())
return true;
return sametypesequence.find_first_of("mlgxty")!=std::string::npos;
}
bool DictBase::SearchData(std::vector<std::string> &SearchWords, guint32 idxitem_offset, guint32 idxitem_size, gchar *origin_data)
{
int nWord = SearchWords.size();
@@ -435,17 +431,23 @@ bool DictBase::SearchData(std::vector<std::string> &SearchWords, guint32 idxitem
return false;
}
class offset_index : public index_file {
public:
offset_index() : idxfile(NULL) {}
~offset_index();
bool load(const std::string& url, gulong wc, gulong fsize);
const gchar *get_key(glong idx);
void get_data(glong idx);
const gchar *get_key_and_data(glong idx);
bool lookup(const char *str, glong &idx);
private:
static const gint ENTR_PER_PAGE=32;
namespace {
class OffsetIndex : public IIndexFile {
public:
OffsetIndex() : idxfile(nullptr) {}
~OffsetIndex() {
if (idxfile)
fclose(idxfile);
}
bool load(const std::string& url, gulong wc, gulong fsize) override;
const gchar *get_key(glong idx) override;
void get_data(glong idx) override { get_key(idx); }
const gchar *get_key_and_data(glong idx) override {
return get_key(idx);
}
bool lookup(const char *str, glong &idx) override;
private:
static const gint ENTR_PER_PAGE = 32;
static const char *CACHE_MAGIC;
std::vector<guint32> wordoffset;
@@ -457,7 +459,7 @@ private:
glong idx;
std::string keystr;
void assign(glong i, const std::string& str) {
idx=i;
idx = i;
keystr.assign(str);
}
};
@@ -469,10 +471,10 @@ private:
};
std::vector<gchar> page_data;
struct page_t {
glong idx;
glong idx = -1;
page_entry entries[ENTR_PER_PAGE];
page_t(): idx(-1) {}
page_t() {}
void fill(gchar *data, gint nent, glong idx_);
} page;
gulong load_page(glong page_idx);
@@ -481,26 +483,30 @@ private:
bool load_cache(const std::string& url);
bool save_cache(const std::string& url);
static strlist_t get_cache_variant(const std::string& url);
};
};
const char *offset_index::CACHE_MAGIC="StarDict's Cache, Version: 0.1";
const char *OffsetIndex::CACHE_MAGIC = "StarDict's Cache, Version: 0.1";
class wordlist_index : public index_file {
public:
wordlist_index() : idxdatabuf(NULL) {}
~wordlist_index();
bool load(const std::string& url, gulong wc, gulong fsize);
const gchar *get_key(glong idx);
void get_data(glong idx);
const gchar *get_key_and_data(glong idx);
bool lookup(const char *str, glong &idx);
private:
class WordListIndex : public IIndexFile {
public:
WordListIndex() : idxdatabuf(nullptr) {}
~WordListIndex() { g_free(idxdatabuf); }
bool load(const std::string& url, gulong wc, gulong fsize) override;
const gchar *get_key(glong idx) override { return wordlist[idx]; }
void get_data(glong idx) override;
const gchar *get_key_and_data(glong idx) override {
get_data(idx);
return get_key(idx);
}
bool lookup(const char *str, glong &idx) override;
private:
gchar *idxdatabuf;
std::vector<gchar *> wordlist;
};
};
void offset_index::page_t::fill(gchar *data, gint nent, glong idx_)
{
void OffsetIndex::page_t::fill(gchar *data, gint nent, glong idx_)
{
idx=idx_;
gchar *p=data;
glong len;
@@ -513,16 +519,10 @@ void offset_index::page_t::fill(gchar *data, gint nent, glong idx_)
entries[i].size=g_ntohl(get_uint32(p));
p+=sizeof(guint32);
}
}
}
offset_index::~offset_index()
{
if (idxfile)
fclose(idxfile);
}
inline const gchar *offset_index::read_first_on_page_key(glong page_idx)
{
inline const gchar *OffsetIndex::read_first_on_page_key(glong page_idx)
{
fseek(idxfile, wordoffset[page_idx], SEEK_SET);
guint32 page_size=wordoffset[page_idx+1]-wordoffset[page_idx];
fread(wordentry_buf,
@@ -530,10 +530,10 @@ inline const gchar *offset_index::read_first_on_page_key(glong page_idx)
1, idxfile);
//TODO: check returned values, deal with word entry that strlen>255.
return wordentry_buf;
}
}
inline const gchar *offset_index::get_first_on_page_key(glong page_idx)
{
inline const gchar *OffsetIndex::get_first_on_page_key(glong page_idx)
{
if (page_idx<middle.idx) {
if (page_idx==first.idx)
return first.keystr.c_str();
@@ -544,21 +544,21 @@ inline const gchar *offset_index::get_first_on_page_key(glong page_idx)
return read_first_on_page_key(page_idx);
} else
return middle.keystr.c_str();
}
}
bool offset_index::load_cache(const std::string& url)
{
strlist_t vars=get_cache_variant(url);
bool OffsetIndex::load_cache(const std::string& url)
{
const strlist_t vars = get_cache_variant(url);
for (strlist_t::const_iterator it=vars.begin(); it!=vars.end(); ++it) {
struct stat idxstat, cachestat;
for (const std::string& item : vars) {
struct ::stat idxstat, cachestat;
if (g_stat(url.c_str(), &idxstat)!=0 ||
g_stat(it->c_str(), &cachestat)!=0)
g_stat(item.c_str(), &cachestat)!=0)
continue;
if (cachestat.st_mtime<idxstat.st_mtime)
continue;
MapFile mf;
if (!mf.open(it->c_str(), cachestat.st_size))
if (!mf.open(item.c_str(), cachestat.st_size))
continue;
if (strncmp(mf.begin(), CACHE_MAGIC, strlen(CACHE_MAGIC))!=0)
continue;
@@ -568,17 +568,16 @@ bool offset_index::load_cache(const std::string& url)
}
return false;
}
}
strlist_t offset_index::get_cache_variant(const std::string& url)
{
strlist_t res;
res.push_back(url+".oft");
strlist_t OffsetIndex::get_cache_variant(const std::string& url)
{
strlist_t res = {url + ".oft"};
if (!g_file_test(g_get_user_cache_dir(), G_FILE_TEST_EXISTS) &&
g_mkdir(g_get_user_cache_dir(), 0700)==-1)
return res;
std::string cache_dir=std::string(g_get_user_cache_dir())+G_DIR_SEPARATOR_S+"sdcv";
const std::string cache_dir = std::string(g_get_user_cache_dir())+G_DIR_SEPARATOR_S+"sdcv";
if (!g_file_test(cache_dir.c_str(), G_FILE_TEST_EXISTS)) {
if (g_mkdir(cache_dir.c_str(), 0700)==-1)
@@ -586,17 +585,17 @@ strlist_t offset_index::get_cache_variant(const std::string& url)
} else if (!g_file_test(cache_dir.c_str(), G_FILE_TEST_IS_DIR))
return res;
gchar *base=g_path_get_basename(url.c_str());
gchar *base = g_path_get_basename(url.c_str());
res.push_back(cache_dir+G_DIR_SEPARATOR_S+base+".oft");
g_free(base);
return res;
}
}
bool offset_index::save_cache(const std::string& url)
{
strlist_t vars=get_cache_variant(url);
for (strlist_t::const_iterator it=vars.begin(); it!=vars.end(); ++it) {
FILE *out=fopen(it->c_str(), "wb");
bool OffsetIndex::save_cache(const std::string& url)
{
const strlist_t vars = get_cache_variant(url);
for (const std::string& item : vars) {
FILE *out=fopen(item.c_str(), "wb");
if (!out)
continue;
if (fwrite(CACHE_MAGIC, 1, strlen(CACHE_MAGIC), out)!=strlen(CACHE_MAGIC))
@@ -608,10 +607,10 @@ bool offset_index::save_cache(const std::string& url)
return true;
}
return false;
}
}
bool offset_index::load(const std::string& url, gulong wc, gulong fsize)
{
bool OffsetIndex::load(const std::string& url, gulong wc, gulong fsize)
{
wordcount=wc;
gulong npages=(wc-1)/ENTR_PER_PAGE+2;
wordoffset.resize(npages);
@@ -648,10 +647,10 @@ bool offset_index::load(const std::string& url, gulong wc, gulong fsize)
real_last.assign(wc-1, get_key(wc-1));
return true;
}
}
inline gulong offset_index::load_page(glong page_idx)
{
inline gulong OffsetIndex::load_page(glong page_idx)
{
gulong nentr=ENTR_PER_PAGE;
if (page_idx==glong(wordoffset.size()-2))
if ((nentr=wordcount%ENTR_PER_PAGE)==0)
@@ -666,30 +665,20 @@ inline gulong offset_index::load_page(glong page_idx)
}
return nentr;
}
}
const gchar *offset_index::get_key(glong idx)
{
const gchar *OffsetIndex::get_key(glong idx)
{
load_page(idx/ENTR_PER_PAGE);
glong idx_in_page=idx%ENTR_PER_PAGE;
wordentry_offset=page.entries[idx_in_page].off;
wordentry_size=page.entries[idx_in_page].size;
return page.entries[idx_in_page].keystr;
}
}
void offset_index::get_data(glong idx)
{
get_key(idx);
}
const gchar *offset_index::get_key_and_data(glong idx)
{
return get_key(idx);
}
bool offset_index::lookup(const char *str, glong &idx)
{
bool OffsetIndex::lookup(const char *str, glong &idx)
{
bool bFound=false;
glong iFrom;
glong iTo=wordoffset.size()-2;
@@ -747,17 +736,12 @@ bool offset_index::lookup(const char *str, glong &idx)
idx*=ENTR_PER_PAGE;
}
return bFound;
}
}
wordlist_index::~wordlist_index()
{
g_free(idxdatabuf);
}
bool wordlist_index::load(const std::string& url, gulong wc, gulong fsize)
{
bool WordListIndex::load(const std::string& url, gulong wc, gulong fsize)
{
gzFile in = gzopen(url.c_str(), "rb");
if (in == NULL)
if (in == nullptr)
return false;
idxdatabuf = (gchar *)g_malloc(fsize);
@@ -780,29 +764,18 @@ bool wordlist_index::load(const std::string& url, gulong wc, gulong fsize)
wordlist[wc] = p1;
return true;
}
}
const gchar *wordlist_index::get_key(glong idx)
{
return wordlist[idx];
}
void wordlist_index::get_data(glong idx)
{
void WordListIndex::get_data(glong idx)
{
gchar *p1 = wordlist[idx]+strlen(wordlist[idx])+sizeof(gchar);
wordentry_offset = g_ntohl(get_uint32(p1));
p1 += sizeof(guint32);
wordentry_size = g_ntohl(get_uint32(p1));
}
}
const gchar *wordlist_index::get_key_and_data(glong idx)
{
get_data(idx);
return get_key(idx);
}
bool wordlist_index::lookup(const char *str, glong &idx)
{
bool WordListIndex::lookup(const char *str, glong &idx)
{
bool bFound=false;
glong iTo=wordlist.size()-2;
@@ -832,6 +805,7 @@ bool wordlist_index::lookup(const char *str, glong &idx)
idx = iThisIndex;
}
return bFound;
}
}
//===================================================================
@@ -863,10 +837,10 @@ bool Dict::load(const std::string& ifofilename)
fullfilename.replace(fullfilename.length()-sizeof("ifo")+1, sizeof("ifo")-1, "idx.gz");
if (g_file_test(fullfilename.c_str(), G_FILE_TEST_EXISTS)) {
idx_file.reset(new wordlist_index);
idx_file.reset(new WordListIndex);
} else {
fullfilename.erase(fullfilename.length()-sizeof(".gz")+1, sizeof(".gz")-1);
idx_file.reset(new offset_index);
idx_file.reset(new OffsetIndex);
}
if (!idx_file->load(fullfilename, wordcount, idxfilesize))
@@ -884,8 +858,6 @@ bool Dict::load_ifofile(const std::string& ifofilename, gulong &idxfilesize)
if (dict_info.wordcount==0)
return false;
ifo_file_name=dict_info.ifo_file_name;
wordcount=dict_info.wordcount;
bookname=dict_info.bookname;
@@ -899,28 +871,21 @@ bool Dict::load_ifofile(const std::string& ifofilename, gulong &idxfilesize)
bool Dict::LookupWithRule(GPatternSpec *pspec, glong *aIndex, int iBuffLen)
{
int iIndexCount=0;
int iIndexCount = 0;
for(guint32 i=0; i<narticles() && iIndexCount<iBuffLen-1; i++)
for (guint32 i=0; i < narticles() && iIndexCount < (iBuffLen - 1); i++)
if (g_pattern_match_string(pspec, get_key(i)))
aIndex[iIndexCount++]=i;
aIndex[iIndexCount++] = i;
aIndex[iIndexCount]= -1; // -1 is the end.
aIndex[iIndexCount] = -1; // -1 is the end.
return (iIndexCount>0);
}
//===================================================================
Libs::Libs(progress_func_t f)
{
progress_func=f;
iMaxFuzzyDistance = MAX_FUZZY_DISTANCE; //need to read from cfg.
return iIndexCount > 0;
}
Libs::~Libs()
{
for (std::vector<Dict *>::iterator p=oLib.begin(); p!=oLib.end(); ++p)
delete *p;
for (Dict *p : oLib)
delete p;
}
void Libs::load_dict(const std::string& url)
@@ -932,81 +897,54 @@ void Libs::load_dict(const std::string& url)
delete lib;
}
class DictLoader {
public:
DictLoader(Libs& lib_): lib(lib_) {}
void operator()(const std::string& url, bool disable) {
if (!disable)
lib.load_dict(url);
}
private:
Libs& lib;
};
void Libs::load(const strlist_t& dicts_dirs,
const strlist_t& order_list,
const strlist_t& disable_list)
{
for_each_file(dicts_dirs, ".ifo", order_list, disable_list,
DictLoader(*this));
[this](const std::string& url, bool disable) -> void {
if (!disable)
load_dict(url);
});
}
class DictReLoader {
public:
DictReLoader(std::vector<Dict *> &p, std::vector<Dict *> &f,
Libs& lib_) : prev(p), future(f), lib(lib_)
{
}
void operator()(const std::string& url, bool disable) {
if (!disable) {
Dict *dict=find(url);
if (dict)
future.push_back(dict);
else
lib.load_dict(url);
}
}
private:
std::vector<Dict *> &prev;
std::vector<Dict *> &future;
Libs& lib;
Dict *find(const std::string& url) {
std::vector<Dict *>::iterator it;
for (it=prev.begin(); it!=prev.end(); ++it)
if ((*it)->ifofilename()==url)
break;
if (it!=prev.end()) {
Dict *res=*it;
prev.erase(it);
return res;
}
return NULL;
}
};
void Libs::reload(const strlist_t& dicts_dirs,
const strlist_t& order_list,
const strlist_t& disable_list)
{
std::vector<Dict *> prev(oLib);
oLib.clear();
for_each_file(dicts_dirs, ".ifo", order_list, disable_list,
DictReLoader(prev, oLib, *this));
for (std::vector<Dict *>::iterator it=prev.begin(); it!=prev.end(); ++it)
delete *it;
[&prev, this](const std::string& url, bool disable) -> void {
if (!disable) {
auto it = prev.begin();
for (; it != prev.end(); ++it)
if ((*it)->ifofilename() == url)
break;
if (it != prev.end()) {
Dict *res = *it;
prev.erase(it);
oLib.push_back(res);
} else
load_dict(url);
}
});
for (Dict *p : prev)
delete p;
}
const gchar *Libs::poGetCurrentWord(glong * iCurrent)
{
const gchar *poCurrentWord = NULL;
const gchar *poCurrentWord = nullptr;
const gchar *word;
for (std::vector<Dict *>::size_type iLib=0; iLib<oLib.size(); iLib++) {
if (iCurrent[iLib]==INVALID_INDEX)
continue;
if ( iCurrent[iLib]>=narticles(iLib) || iCurrent[iLib]<0)
continue;
if ( poCurrentWord == NULL ) {
if ( poCurrentWord == nullptr ) {
poCurrentWord = poGetWord(iCurrent[iLib],iLib);
} else {
word = poGetWord(iCurrent[iLib],iLib);
@@ -1018,24 +956,23 @@ const gchar *Libs::poGetCurrentWord(glong * iCurrent)
return poCurrentWord;
}
const gchar *
Libs::poGetNextWord(const gchar *sWord, glong *iCurrent)
const gchar *Libs::poGetNextWord(const gchar *sWord, glong *iCurrent)
{
// the input can be:
// (word,iCurrent),read word,write iNext to iCurrent,and return next word. used by TopWin::NextCallback();
// (NULL,iCurrent),read iCurrent,write iNext to iCurrent,and return next word. used by AppCore::ListWords();
const gchar *poCurrentWord = NULL;
std::vector<Dict *>::size_type iCurrentLib=0;
// (nullptr,iCurrent),read iCurrent,write iNext to iCurrent,and return next word. used by AppCore::ListWords();
const gchar *poCurrentWord = nullptr;
size_t iCurrentLib = 0;
const gchar *word;
for (std::vector<Dict *>::size_type iLib=0;iLib<oLib.size();iLib++) {
for (size_t iLib = 0; iLib < oLib.size(); ++iLib) {
if (sWord)
oLib[iLib]->Lookup(sWord, iCurrent[iLib]);
if (iCurrent[iLib]==INVALID_INDEX)
continue;
if (iCurrent[iLib]>=narticles(iLib) || iCurrent[iLib]<0)
continue;
if (poCurrentWord == NULL ) {
if (poCurrentWord == nullptr ) {
poCurrentWord = poGetWord(iCurrent[iLib],iLib);
iCurrentLib = iLib;
} else {
@@ -1069,7 +1006,7 @@ const gchar *
Libs::poGetPreWord(glong * iCurrent)
{
// used by TopWin::PreviousCallback(); the iCurrent is cached by AppCore::TopWinWordChange();
const gchar *poCurrentWord = NULL;
const gchar *poCurrentWord = nullptr;
std::vector<Dict *>::size_type iCurrentLib=0;
const gchar *word;
@@ -1080,7 +1017,7 @@ Libs::poGetPreWord(glong * iCurrent)
if ( iCurrent[iLib]>narticles(iLib) || iCurrent[iLib]<=0)
continue;
}
if ( poCurrentWord == NULL ) {
if ( poCurrentWord == nullptr ) {
poCurrentWord = poGetWord(iCurrent[iLib]-1,iLib);
iCurrentLib = iLib;
} else {
@@ -1113,7 +1050,7 @@ Libs::poGetPreWord(glong * iCurrent)
bool Libs::LookupSimilarWord(const gchar* sWord, glong & iWordIndex, int iLib)
{
glong iIndex;
bool bFound=false;
bool bFound = false;
gchar *casestr;
if (!bFound) {
@@ -1449,29 +1386,6 @@ bool Libs::SimpleLookupWord(const gchar* sWord, glong & iWordIndex, int iLib)
return bFound;
}
struct Fuzzystruct {
char * pMatchWord;
int iMatchWordDistance;
};
inline bool operator<(const Fuzzystruct & lh, const Fuzzystruct & rh) {
if (lh.iMatchWordDistance!=rh.iMatchWordDistance)
return lh.iMatchWordDistance<rh.iMatchWordDistance;
if (lh.pMatchWord && rh.pMatchWord)
return stardict_strcmp(lh.pMatchWord, rh.pMatchWord)<0;
return false;
}
static inline void unicode_strdown(gunichar *str)
{
while (*str) {
*str=g_unichar_tolower(*str);
++str;
}
}
bool Libs::LookupWithFuzzy(const gchar *sWord, gchar *reslist[], gint reslist_size)
{
if (sWord[0] == '\0')
@@ -1479,8 +1393,8 @@ bool Libs::LookupWithFuzzy(const gchar *sWord, gchar *reslist[], gint reslist_si
Fuzzystruct oFuzzystruct[reslist_size];
for (int i=0; i<reslist_size; i++) {
oFuzzystruct[i].pMatchWord = NULL;
for (int i = 0; i < reslist_size; i++) {
oFuzzystruct[i].pMatchWord = nullptr;
oFuzzystruct[i].iMatchWordDistance = iMaxFuzzyDistance;
}
int iMaxDistance = iMaxFuzzyDistance;
@@ -1496,13 +1410,13 @@ bool Libs::LookupWithFuzzy(const gchar *sWord, gchar *reslist[], gint reslist_si
ucs4_str2 = g_utf8_to_ucs4_fast(sWord, -1, &ucs4_str2_len);
unicode_strdown(ucs4_str2);
for (std::vector<Dict *>::size_type iLib=0; iLib<oLib.size(); iLib++) {
for (size_t iLib = 0; iLib < oLib.size(); ++iLib) {
if (progress_func)
progress_func();
//if (stardict_strcmp(sWord, poGetWord(0,iLib))>=0 && stardict_strcmp(sWord, poGetWord(narticles(iLib)-1,iLib))<=0) {
//there are Chinese dicts and English dicts...
if (TRUE) {
const int iwords = narticles(iLib);
for (int index=0; index<iwords; index++) {
sCheck = poGetWord(index,iLib);
@@ -1511,7 +1425,7 @@ bool Libs::LookupWithFuzzy(const gchar *sWord, gchar *reslist[], gint reslist_si
if (iCheckWordLen-ucs4_str2_len>=iMaxDistance ||
ucs4_str2_len-iCheckWordLen>=iMaxDistance)
continue;
ucs4_str1 = g_utf8_to_ucs4_fast(sCheck, -1, NULL);
ucs4_str1 = g_utf8_to_ucs4_fast(sCheck, -1, nullptr);
if (iCheckWordLen > ucs4_str2_len)
ucs4_str1[ucs4_str2_len]=0;
unicode_strdown(ucs4_str1);
@@ -1548,23 +1462,27 @@ bool Libs::LookupWithFuzzy(const gchar *sWord, gchar *reslist[], gint reslist_si
} // add to list
} // find one
} // each word
} // ok for search
} // each lib
g_free(ucs4_str2);
if (Found)// sort with distance
std::sort(oFuzzystruct, oFuzzystruct+reslist_size);
std::sort(oFuzzystruct, oFuzzystruct + reslist_size, [](const Fuzzystruct& lh, const Fuzzystruct& rh) -> bool {
if (lh.iMatchWordDistance!=rh.iMatchWordDistance)
return lh.iMatchWordDistance<rh.iMatchWordDistance;
for (gint i=0; i<reslist_size; ++i)
reslist[i]=oFuzzystruct[i].pMatchWord;
if (lh.pMatchWord && rh.pMatchWord)
return stardict_strcmp(lh.pMatchWord, rh.pMatchWord)<0;
return false;
});
for (gint i = 0; i < reslist_size; ++i)
reslist[i] = oFuzzystruct[i].pMatchWord;
return Found;
}
inline bool less_for_compare(const char *lh, const char *rh) {
return stardict_strcmp(lh, rh)<0;
}
gint Libs::LookupWithRule(const gchar *word, gchar **ppMatchWord)
{
glong aiIndex[MAX_MATCH_ITEM_PER_LIB+1];
@@ -1595,7 +1513,9 @@ gint Libs::LookupWithRule(const gchar *word, gchar **ppMatchWord)
g_pattern_spec_free(pspec);
if (iMatchCount)// sort it.
std::sort(ppMatchWord, ppMatchWord+iMatchCount, less_for_compare);
std::sort(ppMatchWord, ppMatchWord+iMatchCount, [](const char *lh, const char *rh) -> bool {
return stardict_strcmp(lh, rh)<0;
});
return iMatchCount;
}
@@ -1642,7 +1562,7 @@ bool Libs::LookupData(const gchar *sWord, std::vector<gchar *> *reslist)
return false;
guint32 max_size =0;
gchar *origin_data = NULL;
gchar *origin_data = nullptr;
for (std::vector<Dict *>::size_type i=0; i<oLib.size(); ++i) {
if (!oLib[i]->containSearchData())
continue;
@@ -1664,11 +1584,11 @@ bool Libs::LookupData(const gchar *sWord, std::vector<gchar *> *reslist)
g_free(origin_data);
std::vector<Dict *>::size_type i;
for (i=0; i<oLib.size(); ++i)
for (i = 0; i < oLib.size(); ++i)
if (!reslist[i].empty())
break;
return i!=oLib.size();
return i != oLib.size();
}
/**************************************************/

91
src/lib/lib.h → src/lib/lib.hpp
View File

@@ -1,11 +1,11 @@
#ifndef __SD_LIB_H__
#define __SD_LIB_H__
#pragma once
#include <cstdio>
#include <list>
#include <memory>
#include <string>
#include <vector>
#include <functional>
#include "dictziplib.hpp"
@@ -16,8 +16,8 @@ struct cacheItem {
guint32 offset;
gchar *data;
//write code here to make it inline
cacheItem() {data= NULL;}
~cacheItem() {g_free(data);}
cacheItem() { data = nullptr;}
~cacheItem() { g_free(data); }
};
const int WORDDATA_CACHE_NUM = 10;
@@ -25,18 +25,27 @@ const int INVALID_INDEX=-100;
class DictBase {
public:
DictBase();
~DictBase();
DictBase() {}
~DictBase() {
if (dictfile)
fclose(dictfile);
}
DictBase(const DictBase&) = delete;
DictBase& operator=(const DictBase&) = delete;
gchar * GetWordData(guint32 idxitem_offset, guint32 idxitem_size);
bool containSearchData();
bool containSearchData() const {
if (sametypesequence.empty())
return true;
return sametypesequence.find_first_of("mlgxty") != std::string::npos;
}
bool SearchData(std::vector<std::string> &SearchWords, guint32 idxitem_offset, guint32 idxitem_size, gchar *origin_data);
protected:
std::string sametypesequence;
FILE *dictfile;
std::auto_ptr<dictData> dictdzfile;
FILE *dictfile = nullptr;
std::unique_ptr<dictData> dictdzfile;
private:
cacheItem cache[WORDDATA_CACHE_NUM];
gint cache_cur;
gint cache_cur = 0;
};
//this structure contain all information about dictionary
@@ -51,15 +60,16 @@ struct DictInfo {
std::string description;
guint32 index_file_size;
std::string sametypesequence;
bool load_from_ifo_file(const std::string& ifofilename, bool istreedict);
};
class index_file {
class IIndexFile {
public:
guint32 wordentry_offset;
guint32 wordentry_size;
virtual ~index_file() {}
virtual ~IIndexFile() {}
virtual bool load(const std::string& url, gulong wc, gulong fsize) = 0;
virtual const gchar *get_key(glong idx) = 0;
virtual void get_data(glong idx) = 0;
@@ -68,30 +78,22 @@ public:
};
class Dict : public DictBase {
private:
std::string ifo_file_name;
gulong wordcount;
std::string bookname;
std::auto_ptr<index_file> idx_file;
bool load_ifofile(const std::string& ifofilename, gulong &idxfilesize);
public:
Dict() {}
Dict(const Dict&) = delete;
Dict& operator=(const Dict&) = delete;
bool load(const std::string& ifofilename);
gulong narticles() { return wordcount; }
const std::string& dict_name() { return bookname; }
const std::string& ifofilename() { return ifo_file_name; }
gulong narticles() const { return wordcount; }
const std::string& dict_name() const { return bookname; }
const std::string& ifofilename() const { return ifo_file_name; }
const gchar *get_key(glong index) { return idx_file->get_key(index); }
gchar *get_data(glong index)
{
gchar *get_data(glong index) {
idx_file->get_data(index);
return DictBase::GetWordData(idx_file->wordentry_offset, idx_file->wordentry_size);
}
void get_key_and_data(glong index, const gchar **key, guint32 *offset, guint32 *size)
{
void get_key_and_data(glong index, const gchar **key, guint32 *offset, guint32 *size) {
*key = idx_file->get_key_and_data(index);
*offset = idx_file->wordentry_offset;
*size = idx_file->wordentry_size;
@@ -99,16 +101,28 @@ public:
bool Lookup(const char *str, glong &idx) { return idx_file->lookup(str, idx); }
bool LookupWithRule(GPatternSpec *pspec, glong *aIndex, int iBuffLen);
private:
std::string ifo_file_name;
gulong wordcount;
std::string bookname;
std::unique_ptr<IIndexFile> idx_file;
bool load_ifofile(const std::string& ifofilename, gulong &idxfilesize);
};
typedef std::list<std::string> strlist_t;
class Libs {
public:
typedef void (*progress_func_t)(void);
Libs(progress_func_t f=NULL);
Libs(std::function<void(void)> f = std::function<void(void)>()) {
progress_func = f;
iMaxFuzzyDistance = MAX_FUZZY_DISTANCE; //need to read from cfg.
}
~Libs();
Libs(const Libs&) = delete;
Libs& operator=(const Libs&) = delete;
void load_dict(const std::string& url);
void load(const strlist_t& dicts_dirs,
const strlist_t& order_list,
@@ -117,16 +131,16 @@ public:
const strlist_t& order_list,
const strlist_t& disable_list);
glong narticles(int idict) { return oLib[idict]->narticles(); }
const std::string& dict_name(int idict) { return oLib[idict]->dict_name(); }
glong narticles(int idict) const { return oLib[idict]->narticles(); }
const std::string& dict_name(int idict) const { return oLib[idict]->dict_name(); }
gint ndicts() const { return oLib.size(); }
const gchar * poGetWord(glong iIndex,int iLib) {
const gchar *poGetWord(glong iIndex, int iLib) {
return oLib[iLib]->get_key(iIndex);
}
gchar * poGetWordData(glong iIndex,int iLib) {
if (iIndex==INVALID_INDEX)
return NULL;
if (iIndex == INVALID_INDEX)
return nullptr;
return oLib[iLib]->get_data(iIndex);
}
const gchar *poGetCurrentWord(glong *iCurrent);
@@ -145,14 +159,13 @@ public:
private:
std::vector<Dict *> oLib; // word Libs.
int iMaxFuzzyDistance;
progress_func_t progress_func;
std::function<void(void)> progress_func;
};
typedef enum {
enum query_t {
qtSIMPLE, qtREGEXP, qtFUZZY, qtDATA
} query_t;
};
extern query_t analyze_query(const char *s, std::string& res);
#endif//!__SD_LIB_H__