third_codes/cppjieba
1
0
Fork 0
mirror of https://github.com/yanyiwu/cppjieba.git synced 2025-07-18 00:00:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

统一私有函数的命名风格

Browse Source
This commit is contained in:
yanyiwu 2015-08-28 11:17:38 +08:00
parent 0e0318f6ad
commit fae951a95d
7 changed files with 58 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
src/DictTrie.hpp
View File

@ -41,21 +41,21 @@ class DictTrie {
if(trie_ != NULL) { if(trie_ != NULL) {
LogFatal("trie already initted"); LogFatal("trie already initted");
} }
loadDict_(dictPath); LoadDict(dictPath);
calculateWeight_(staticNodeInfos_); CalculateWeight(staticNodeInfos_);
minWeight_ = findMinWeight_(staticNodeInfos_); minWeight_ = FindMinWeight(staticNodeInfos_);
maxWeight_ = findMaxWeight_(staticNodeInfos_); maxWeight_ = FindMaxWeight(staticNodeInfos_);
if(userDictPath.size()) { if(userDictPath.size()) {
loadUserDict_(userDictPath); LoadUserDict(userDictPath);
} }
shrink_(staticNodeInfos_); Shrink(staticNodeInfos_);
createTrie_(staticNodeInfos_); CreateTrie(staticNodeInfos_);
} }
bool insertUserWord(const string& word, const string& tag = UNKNOWN_TAG) { bool insertUserWord(const string& word, const string& tag = UNKNOWN_TAG) {
DictUnit nodeInfo; DictUnit nodeInfo;
if(!makeUserNodeInfo_(nodeInfo, word, tag)) { if(!MakeUserNodeInfo(nodeInfo, word, tag)) {
return false; return false;
} }
activeNodeInfos_.push_back(nodeInfo); activeNodeInfos_.push_back(nodeInfo);
@ -83,7 +83,7 @@ class DictTrie {
} }
private: private:
void createTrie_(const vector<DictUnit>& dictUnits) { void CreateTrie(const vector<DictUnit>& dictUnits) {
assert(dictUnits.size()); assert(dictUnits.size());
vector<Unicode> words; vector<Unicode> words;
vector<const DictUnit*> valuePointers; vector<const DictUnit*> valuePointers;
@ -94,7 +94,7 @@ class DictTrie {
trie_ = new Trie(words, valuePointers); trie_ = new Trie(words, valuePointers);
} }
void loadUserDict_(const string& filePath) { void LoadUserDict(const string& filePath) {
ifstream ifs(filePath.c_str()); ifstream ifs(filePath.c_str());
if(!ifs.is_open()) { if(!ifs.is_open()) {
LogFatal("file %s open failed.", filePath.c_str()); LogFatal("file %s open failed.", filePath.c_str());
@ -110,13 +110,13 @@ class DictTrie {
LogFatal("split [%s] result illegal", line.c_str()); LogFatal("split [%s] result illegal", line.c_str());
} }
DictUnit nodeInfo; DictUnit nodeInfo;
makeUserNodeInfo_(nodeInfo, buf[0], MakeUserNodeInfo(nodeInfo, buf[0],
(buf.size() == 2 ? buf[1] : UNKNOWN_TAG)); (buf.size() == 2 ? buf[1] : UNKNOWN_TAG));
staticNodeInfos_.push_back(nodeInfo); staticNodeInfos_.push_back(nodeInfo);
} }
LogInfo("load userdict[%s] ok. lines[%u]", filePath.c_str(), lineno); LogInfo("load userdict[%s] ok. lines[%u]", filePath.c_str(), lineno);
} }
bool makeNodeInfo(DictUnit& nodeInfo, bool MakeNodeInfo(DictUnit& nodeInfo,
const string& word, const string& word,
double weight, double weight,
const string& tag) { const string& tag) {
@ -128,7 +128,7 @@ class DictTrie {
nodeInfo.tag = tag; nodeInfo.tag = tag;
return true; return true;
} }
bool makeUserNodeInfo_(DictUnit& nodeInfo, bool MakeUserNodeInfo(DictUnit& nodeInfo,
const string& word, const string& word,
const string& tag = UNKNOWN_TAG) { const string& tag = UNKNOWN_TAG) {
if(!TransCode::decode(word, nodeInfo.word)) { if(!TransCode::decode(word, nodeInfo.word)) {
@ -142,7 +142,7 @@ class DictTrie {
nodeInfo.tag = tag; nodeInfo.tag = tag;
return true; return true;
} }
void loadDict_(const string& filePath) { void LoadDict(const string& filePath) {
ifstream ifs(filePath.c_str()); ifstream ifs(filePath.c_str());
if(!ifs.is_open()) { if(!ifs.is_open()) {
LogFatal("file %s open failed.", filePath.c_str()); LogFatal("file %s open failed.", filePath.c_str());
@ -156,21 +156,21 @@ class DictTrie {
if(buf.size() != DICT_COLUMN_NUM) { if(buf.size() != DICT_COLUMN_NUM) {
LogFatal("split result illegal, line: %s, result size: %u", line.c_str(), buf.size()); LogFatal("split result illegal, line: %s, result size: %u", line.c_str(), buf.size());
} }
makeNodeInfo(nodeInfo, MakeNodeInfo(nodeInfo,
buf[0], buf[0],
atof(buf[1].c_str()), atof(buf[1].c_str()),
buf[2]); buf[2]);
staticNodeInfos_.push_back(nodeInfo); staticNodeInfos_.push_back(nodeInfo);
} }
} }
double findMinWeight_(const vector<DictUnit>& nodeInfos) const { double FindMinWeight(const vector<DictUnit>& nodeInfos) const {
double ret = MAX_DOUBLE; double ret = MAX_DOUBLE;
for(size_t i = 0; i < nodeInfos.size(); i++) { for(size_t i = 0; i < nodeInfos.size(); i++) {
ret = min(nodeInfos[i].weight, ret); ret = min(nodeInfos[i].weight, ret);
} }
return ret; return ret;
} }
double findMaxWeight_(const vector<DictUnit>& nodeInfos) const { double FindMaxWeight(const vector<DictUnit>& nodeInfos) const {
double ret = MIN_DOUBLE; double ret = MIN_DOUBLE;
for(size_t i = 0; i < nodeInfos.size(); i++) { for(size_t i = 0; i < nodeInfos.size(); i++) {
ret = max(nodeInfos[i].weight, ret); ret = max(nodeInfos[i].weight, ret);
@ -178,7 +178,7 @@ class DictTrie {
return ret; return ret;
} }
void calculateWeight_(vector<DictUnit>& nodeInfos) const { void CalculateWeight(vector<DictUnit>& nodeInfos) const {
double sum = 0.0; double sum = 0.0;
for(size_t i = 0; i < nodeInfos.size(); i++) { for(size_t i = 0; i < nodeInfos.size(); i++) {
sum += nodeInfos[i].weight; sum += nodeInfos[i].weight;
@ -191,11 +191,10 @@ class DictTrie {
} }
} }
void shrink_(vector<DictUnit>& units) const { void Shrink(vector<DictUnit>& units) const {
vector<DictUnit>(units.begin(), units.end()).swap(units); vector<DictUnit>(units.begin(), units.end()).swap(units);
} }
private:
vector<DictUnit> staticNodeInfos_; vector<DictUnit> staticNodeInfos_;
deque<DictUnit> activeNodeInfos_; // must not be vector deque<DictUnit> activeNodeInfos_; // must not be vector
Trie * trie_; Trie * trie_;

19
src/HMMSegment.hpp
View File

@ -30,15 +30,15 @@ class HMMSegment: public SegmentBase {
while(right != end) { while(right != end) {
if(*right < 0x80) { if(*right < 0x80) {
if(left != right) { if(left != right) {
cut_(left, right, res); Cut(left, right, res);
} }
left = right; left = right;
do { do {
right = sequentialLetterRule_(left, end); right = SequentialLetterRule(left, end);
if(right != left) { if(right != left) {
break; break;
} }
right = numbersRule_(left, end); right = NumbersRule(left, end);
if(right != left) { if(right != left) {
break; break;
} }
@ -51,12 +51,12 @@ class HMMSegment: public SegmentBase {
} }
} }
if(left != right) { if(left != right) {
cut_(left, right, res); Cut(left, right, res);
} }
} }
private: private:
// sequential letters rule // sequential letters rule
Unicode::const_iterator sequentialLetterRule_(Unicode::const_iterator begin, Unicode::const_iterator end) const { Unicode::const_iterator SequentialLetterRule(Unicode::const_iterator begin, Unicode::const_iterator end) const {
Rune x = *begin; Rune x = *begin;
if (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z')) { if (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z')) {
begin ++; begin ++;
@ -74,7 +74,7 @@ class HMMSegment: public SegmentBase {
return begin; return begin;
} }
// //
Unicode::const_iterator numbersRule_(Unicode::const_iterator begin, Unicode::const_iterator end) const { Unicode::const_iterator NumbersRule(Unicode::const_iterator begin, Unicode::const_iterator end) const {
Rune x = *begin; Rune x = *begin;
if('0' <= x && x <= '9') { if('0' <= x && x <= '9') {
begin ++; begin ++;
@ -91,9 +91,9 @@ class HMMSegment: public SegmentBase {
} }
return begin; return begin;
} }
void cut_(Unicode::const_iterator begin, Unicode::const_iterator end, vector<Unicode>& res) const { void Cut(Unicode::const_iterator begin, Unicode::const_iterator end, vector<Unicode>& res) const {
vector<size_t> status; vector<size_t> status;
viterbi_(begin, end, status); Viterbi(begin, end, status);
Unicode::const_iterator left = begin; Unicode::const_iterator left = begin;
Unicode::const_iterator right; Unicode::const_iterator right;
@ -106,7 +106,7 @@ class HMMSegment: public SegmentBase {
} }
} }
void viterbi_(Unicode::const_iterator begin, void Viterbi(Unicode::const_iterator begin,
Unicode::const_iterator end, Unicode::const_iterator end,
vector<size_t>& status) const { vector<size_t>& status) const {
size_t Y = HMMModel::STATUS_SUM; size_t Y = HMMModel::STATUS_SUM;
@ -160,7 +160,6 @@ class HMMSegment: public SegmentBase {
} }
} }
private:
const HMMModel* model_; const HMMModel* model_;
bool isNeedDestroy_; bool isNeedDestroy_;
}; // class HMMSegment }; // class HMMSegment

21
src/KeywordExtractor.hpp
View File

@ -17,16 +17,16 @@ class KeywordExtractor {
const string& stopWordPath, const string& stopWordPath,
const string& userDict = "") const string& userDict = "")
: segment_(dictPath, hmmFilePath, userDict) { : segment_(dictPath, hmmFilePath, userDict) {
loadIdfDict_(idfPath); LoadIdfDict(idfPath);
loadStopWordDict_(stopWordPath); LoadStopWordDict(stopWordPath);
} }
KeywordExtractor(const DictTrie* dictTrie, KeywordExtractor(const DictTrie* dictTrie,
const HMMModel* model, const HMMModel* model,
const string& idfPath, const string& idfPath,
const string& stopWordPath) const string& stopWordPath)
: segment_(dictTrie, model){ : segment_(dictTrie, model){
loadIdfDict_(idfPath); LoadIdfDict(idfPath);
loadStopWordDict_(stopWordPath); LoadStopWordDict(stopWordPath);
} }
~KeywordExtractor() { ~KeywordExtractor() {
} }
@ -51,7 +51,7 @@ class KeywordExtractor {
map<string, double> wordmap; map<string, double> wordmap;
for(vector<string>::iterator iter = words.begin(); iter != words.end(); iter++) { for(vector<string>::iterator iter = words.begin(); iter != words.end(); iter++) {
if(isSingleWord_(*iter)) { if(IsSingleWord(*iter)) {
continue; continue;
} }
wordmap[*iter] += 1.0; wordmap[*iter] += 1.0;
@ -75,12 +75,12 @@ class KeywordExtractor {
keywords.clear(); keywords.clear();
std::copy(wordmap.begin(), wordmap.end(), std::inserter(keywords, keywords.begin())); std::copy(wordmap.begin(), wordmap.end(), std::inserter(keywords, keywords.begin()));
topN = min(topN, keywords.size()); topN = min(topN, keywords.size());
partial_sort(keywords.begin(), keywords.begin() + topN, keywords.end(), cmp_); partial_sort(keywords.begin(), keywords.begin() + topN, keywords.end(), Compare);
keywords.resize(topN); keywords.resize(topN);
return true; return true;
} }
private: private:
void loadIdfDict_(const string& idfPath) { void LoadIdfDict(const string& idfPath) {
ifstream ifs(idfPath.c_str()); ifstream ifs(idfPath.c_str());
if(!ifs.is_open()) { if(!ifs.is_open()) {
LogFatal("open %s failed.", idfPath.c_str()); LogFatal("open %s failed.", idfPath.c_str());
@ -111,7 +111,7 @@ class KeywordExtractor {
idfAverage_ = idfSum / lineno; idfAverage_ = idfSum / lineno;
assert(idfAverage_ > 0.0); assert(idfAverage_ > 0.0);
} }
void loadStopWordDict_(const string& filePath) { void LoadStopWordDict(const string& filePath) {
ifstream ifs(filePath.c_str()); ifstream ifs(filePath.c_str());
if(!ifs.is_open()) { if(!ifs.is_open()) {
LogFatal("open %s failed.", filePath.c_str()); LogFatal("open %s failed.", filePath.c_str());
@ -123,7 +123,7 @@ class KeywordExtractor {
assert(stopWords_.size()); assert(stopWords_.size());
} }
bool isSingleWord_(const string& str) const { bool IsSingleWord(const string& str) const {
Unicode unicode; Unicode unicode;
TransCode::decode(str, unicode); TransCode::decode(str, unicode);
if(unicode.size() == 1) if(unicode.size() == 1)
@ -131,11 +131,10 @@ class KeywordExtractor {
return false; return false;
} }
static bool cmp_(const pair<string, double>& lhs, const pair<string, double>& rhs) { static bool Compare(const pair<string, double>& lhs, const pair<string, double>& rhs) {
return lhs.second > rhs.second; return lhs.second > rhs.second;
} }
private:
MixSegment segment_; MixSegment segment_;
unordered_map<string, double> idfMap_; unordered_map<string, double> idfMap_;
double idfAverage_; double idfAverage_;

13
src/MPSegment.hpp
View File

@ -38,9 +38,9 @@ class MPSegment: public SegmentBase {
dictTrie_->find(begin, end, dags); dictTrie_->find(begin, end, dags);
calcDP_(dags); CalcDP(dags);
cut_(dags, res); Cut(dags, res);
} }
void cut(Unicode::const_iterator begin, void cut(Unicode::const_iterator begin,
Unicode::const_iterator end, Unicode::const_iterator end,
@ -51,15 +51,15 @@ class MPSegment: public SegmentBase {
end, end,
dags, dags,
max_word_len); max_word_len);
calcDP_(dags); CalcDP(dags);
cut_(dags, res); Cut(dags, res);
} }
const DictTrie* getDictTrie() const { const DictTrie* getDictTrie() const {
return dictTrie_; return dictTrie_;
} }
private: private:
void calcDP_(vector<Dag>& dags) const { void CalcDP(vector<Dag>& dags) const {
size_t nextPos; size_t nextPos;
const DictUnit* p; const DictUnit* p;
double val; double val;
@ -88,7 +88,7 @@ class MPSegment: public SegmentBase {
} }
} }
} }
void cut_(const vector<Dag>& dags, void Cut(const vector<Dag>& dags,
vector<Unicode>& res) const { vector<Unicode>& res) const {
size_t i = 0; size_t i = 0;
while(i < dags.size()) { while(i < dags.size()) {
@ -103,7 +103,6 @@ class MPSegment: public SegmentBase {
} }
} }
private:
const DictTrie* dictTrie_; const DictTrie* dictTrie_;
bool isNeedDestroy_; bool isNeedDestroy_;
}; // class MPSegment }; // class MPSegment

6
src/PosTagger.hpp
View File

@ -43,7 +43,7 @@ class PosTagger {
} }
tmp = dict->find(unico.begin(), unico.end()); tmp = dict->find(unico.begin(), unico.end());
if(tmp == NULL || tmp->tag.empty()) { if(tmp == NULL || tmp->tag.empty()) {
res.push_back(make_pair(*itr, specialRule_(unico))); res.push_back(make_pair(*itr, SpecialRule(unico)));
} else { } else {
res.push_back(make_pair(*itr, tmp->tag)); res.push_back(make_pair(*itr, tmp->tag));
} }
@ -51,7 +51,7 @@ class PosTagger {
return !res.empty(); return !res.empty();
} }
private: private:
const char* specialRule_(const Unicode& unicode) const { const char* SpecialRule(const Unicode& unicode) const {
size_t m = 0; size_t m = 0;
size_t eng = 0; size_t eng = 0;
for(size_t i = 0; i < unicode.size() && eng < unicode.size() / 2; i++) { for(size_t i = 0; i < unicode.size() && eng < unicode.size() / 2; i++) {
@ -73,7 +73,7 @@ class PosTagger {
// the ascii chars contain english letter // the ascii chars contain english letter
return POS_ENG; return POS_ENG;
} }
private:
MixSegment segment_; MixSegment segment_;
}; // class PosTagger }; // class PosTagger

11
src/SegmentBase.hpp
View File

@ -22,7 +22,7 @@ const Rune SPECIAL_SYMBOL[] = {32u, 9u, 10u};
class SegmentBase: public ISegment, public NonCopyable { class SegmentBase: public ISegment, public NonCopyable {
public: public:
SegmentBase() { SegmentBase() {
loadSpecialSymbols_(); LoadSpecialSymbols();
}; };
virtual ~SegmentBase() { virtual ~SegmentBase() {
}; };
@ -69,17 +69,18 @@ class SegmentBase: public ISegment, public NonCopyable {
} }
} }
private: private:
void loadSpecialSymbols_() { void LoadSpecialSymbols() {
size_t size = sizeof(SPECIAL_SYMBOL)/sizeof(*SPECIAL_SYMBOL); size_t size = sizeof(SPECIAL_SYMBOL)/sizeof(*SPECIAL_SYMBOL);
for(size_t i = 0; i < size; i ++) { for(size_t i = 0; i < size; i ++) {
specialSymbols_.insert(SPECIAL_SYMBOL[i]); specialSymbols_.insert(SPECIAL_SYMBOL[i]);
} }
assert(specialSymbols_.size()); assert(specialSymbols_.size());
} }
private:
unordered_set<Rune> specialSymbols_; unordered_set<Rune> specialSymbols_;
}; }; // class SegmentBase
}
} // CppJieba
#endif #endif

10
src/Trie.hpp
View File

@ -49,7 +49,7 @@ class Trie {
public: public:
static const size_t BASE_SIZE = (1 << (8 * (sizeof(TrieKey)))); static const size_t BASE_SIZE = (1 << (8 * (sizeof(TrieKey))));
Trie(const vector<Unicode>& keys, const vector<const DictUnit*>& valuePointers) { Trie(const vector<Unicode>& keys, const vector<const DictUnit*>& valuePointers) {
_createTrie(keys, valuePointers); CreateTrie(keys, valuePointers);
} }
~Trie() { ~Trie() {
for (size_t i = 0; i < BASE_SIZE; i++) { for (size_t i = 0; i < BASE_SIZE; i++) {
@ -57,7 +57,7 @@ class Trie {
continue; continue;
} }
for (TrieNode::NextMap::iterator it = _base[i].next->begin(); it != _base[i].next->end(); it++) { for (TrieNode::NextMap::iterator it = _base[i].next->begin(); it != _base[i].next->end(); it++) {
_deleteNode(it->second); DeleteNode(it->second);
it->second = NULL; it->second = NULL;
} }
delete _base[i].next; delete _base[i].next;
@ -143,7 +143,7 @@ class Trie {
} }
private: private:
void _createTrie(const vector<Unicode>& keys, const vector<const DictUnit*>& valuePointers) { void CreateTrie(const vector<Unicode>& keys, const vector<const DictUnit*>& valuePointers) {
if (valuePointers.empty() || keys.empty()) { if (valuePointers.empty() || keys.empty()) {
return; return;
} }
@ -154,14 +154,14 @@ class Trie {
} }
} }
void _deleteNode(TrieNode* node) { void DeleteNode(TrieNode* node) {
if (NULL == node) { if (NULL == node) {
return; return;
} }
if (NULL != node->next) { if (NULL != node->next) {
TrieNode::NextMap::iterator it; TrieNode::NextMap::iterator it;
for (it = node->next->begin(); it != node->next->end(); it++) { for (it = node->next->begin(); it != node->next->end(); it++) {
_deleteNode(it->second); DeleteNode(it->second);
} }
delete node->next; delete node->next;
node->next = NULL; node->next = NULL;