BoostSeacher

//src_path="data/input" --存放html文件的路径
//files_list --用于保存文件路径的容器
bool enumfile(const std::string &src_path, std::vector<std::string> *files_list)
{
    // 引入boost开发库 因为c++对文件系统的支持不是很好
 
    // 展开boost的命名空间
    namespace fs = boost::filesystem;
    //path是一个用于处理文件操作的类
    fs::path root_path(src_path);
    //  判断路径是否存在
    if (!fs::exists(root_path))
    {
        std::cerr << "file not exists" <<  std::endl;
        return false;
    }
    // 存在 递归遍历 recursive_directory_iterator end == nullptr
    fs::recursive_directory_iterator end;
    // 筛选文件
    for (fs::recursive_directory_iterator iter(root_path); iter != end; iter++)
    {
        // is_regular_file是否为普通文件 eg:png false
        if (!fs::is_regular_file(*iter))
            continue;//跳过本次循环，筛选下一个文件
        // 是否为html文件 path.extension()
        if (iter->path().extension() != ".html")
            continue;//跳过本次循环，筛选下一个文件
        // html文件，将文件路径导入到容器中
        files_list->push_back(iter->path().string());
    }
    return true;
}

//file --文件内容
//title --提取的标题存放进的容器
static bool parsertitle(const  std::string &file,  std::string *title)
{
    size_t begin = file.find("<title>");//寻找title出现的位置
    if (begin ==  std::string::npos)
    {
        return false;
    }
    size_t end = file.find("</title>");//寻找</title>出现的位置
    if (end ==  std::string::npos)
    {
        return false;
    }
    if (begin > end)
    {
        return false;
    }
    begin +=  std::string("<title>").size();
    *title = file.substr(begin, end - begin);//截取标题内容
    return true;
}

<a name="xpressive.legal"></a><p>

//results --存放结构体数据的容器
//output --写入磁盘的文件路径
bool savehtml(const  std::vector<docinfo_t> &results, const  std::string &output)
{
#define sep '\3'    // title\3content\3url\n
    // 按照二进制方式写入
     std::ofstream out(output,  std::ios::out |  std::ios::binary);
    if (!out.is_open())
    {
         std::cerr << "open " << output << "failed!" <<  std::endl;
        return false;
    }
 
    for (const docinfo_t &item : results)//读取每一个结构体信息
    {
         std::string out_string;
        out_string = item.title;
        out_string += sep;    //title\3
        out_string += item.content;    //title\3content
        out_string += sep;    //title\3content\3
        out_string += item.url;    //title\3content\3url
        out_string += '\n';    //title\3content\3url\n
        out.write(out_string.c_str(), out_string.size());
    }
    out.close();
    return true;
}

//line --存放文件内容的容器
//out --存放切分结果的容器
//forwardindex --正排索引  类型vector<docinfo>
  struct docinfo
    {
        std::string title;
        std::string content;
        std::string url;
        uint64_t docid;
    };
//...文件读取操作
docinfo *bulidforwardindex(const std::string &line)
        {
            // 对line进行 title content url 的分词 
            std::vector<std::string> out;
            const std::string sep = "\3";    //以'\3'为分割标志
            ns_util::stringutil::split(line, &out, sep);    //调用切分字符的接口
            if(out.size()!=3){
                return nullptr;
            }
            docinfo doc;
            doc.title = out[0];
            doc.content = out[1];
            doc.url = out[2];
            doc.docid = forwardindex.size();
            forwardindex.push_back(std::move(doc));
            //std::cout<<(forwardindex[forwardindex.size()-1].url)<<std::endl;//表明正派建立成功
            return &forwardindex.back();    //返回构建好的一组数据，供建立倒排索引使用
        }

//wordmap --unordered_map<string,wordcnt>类型 用于存储被划分词在标题与内容中出现的次数 
//invertedindex --unordered_map<string，invertedlist>类型 用于表示关键词与网页间的对应关系 
//ilist --invertedlist类型，typedef vector<invertedelem> invertedlist 
//item --invertedelem类型
  struct invertedelem
    {
        uint64_t docid;
        std::string word;
        int weight;
        invertedelem() : weight(0)
        {
        }
    };
bool buildinvertedindex(const docinfo &doc)
 
        {
            struct wordcnt    //用于计算被划分的词在标题/内容出现的次数
            {
                int titlecnt;    //用于计算被划分的标题词在标题中出现的次数    
                int contentcnt;    //用于计算被划分的内容词在内容中出现的次数
                wordcnt() : titlecnt(0), contentcnt(0)
                {
                }
            };
            std::string title = doc.title;    //取出完整的标题
            std::string content = doc.content;    //取出完整的内容
 
            // jieba分词--title
            std::vector<std::string> titlecut;
            ns_util::jiebautil::cutstring(title, &titlecut);
            // 拿到了jieba为我们分好的词 --title
            std::unordered_map<std::string, wordcnt> wordmap; 
            for (auto &s : titlecut)    //遍历被划分的标题词
            {
                boost::to_lower(s);    //不区分大小写
                wordmap[s].titlecnt++;    //记录标题词在标题出现次数
            }
 
            // jieba分词--content
            std::vector<std::string> contentcut;
            ns_util::jiebautil::cutstring(content, &contentcut);
            for (auto &s : contentcut)    //遍历被划分的内容词
            {
                boost::to_lower(s);
                wordmap[s].contentcnt++;    //记录内容词在内容出现次数
            }
 
            // word -> id word weight
#define X 10
#define Y 1
            //构建倒排索引    被划分的词才是主角
            for (auto &wmap : wordmap)
            {
                invertedelem item;
                item.docid = doc.docid;
                item.word = wmap.first;
                //构建各个词在此"网页"中的权重 --标题:10/次 内容:1/次
                item.weight = X * wmap.second.titlecnt + Y * wmap.second.contentcnt; 
                //构建被划分的词与"网页"的关系
                invertedlist &ilist = invertedindex[wmap.first];
                // std::cout<<"invert success"<<std::endl;//表明创建倒排成功
                ilist.push_back(std::move(item));
            }
            return true;
        }

//正排索引的调用接口  
//docid --想要查找的内容对应的id  
docinfo *getforwardindex(uint64_t docid)
        {
            if (docid >= forwardindex.size())
            {
                std::cerr << "no expected doc" << std::endl;
                return nullptr;
            }
            return &forwardindex[docid];
        }
 
//倒排索引的调用接口
//word: 以word关键字为key值对相应内容做检索
invertedlist *getinvertedlist(const std::string &word)
        {
            auto iter = invertedindex.find(word);
            if (invertedindex.end() == iter)
            {
                return nullptr;
            }
            return &(iter->second);
        }

    //Index --Index对象
    void initsearcher()
    {
        Index = ns_index::index::getinstance();    //获取单例
        if(Index==nullptr)
        {
            std::cerr<<"getinstance fail"<<std::endl;
            exit(1);
        }
        std::cout<<"get instance success"<<std::endl;    
        Index->buildindex(input);    //创建索引
    }