//系统工具 -- 体现为函数
void DirectionList(const string& path, vector<string>& sub_dir, vector<string>& sub_file)
{
	struct _finddata_t file;

	//"C:\\Users\\86188\\Desktop\\项目1\\项目—文档快速搜索工具\\TestDoc"
	string _path = path;

	//"C:\\Users\\86188\\Desktop\\项目1\\项目—文档快速搜索工具\\TestDoc"
	_path += "\\*.*";

	long handle = _findfirst(_path.c_str(), &file);
	if (handle == -1)
	{
		//printf("扫描目录失败.\n");
		ERROR_LOG("扫描目录失败");
		return;
	}

	do
	{
		if (file.name[0] == '.')
			continue;
		//cout<<file.name<<endl;

		if (file.attrib & _A_SUBDIR)
			sub_dir.push_back(file.name);
		else
			sub_file.push_back(file.name);

		if (file.attrib & _A_SUBDIR)
		{
			//文件为目录(文件夹)

			//"C:\\Users\\86188\\Desktop\\项目1\\项目—文档快速搜索工具\\TestDoc"
			string tmp_path = path;
			//"C:\\Users\\86188\\Desktop\\项目1\\项目—文档快速搜索工具\\TestDoc"
			tmp_path += "\\";
			//"C:\\Users\\86188\\Desktop\\项目1\\项目—文档快速搜索工具\\TestDoc"
			tmp_path += file.name;

			//目录递归遍历
			DirectionList(tmp_path, sub_dir, sub_file);
		}

	} while (_findnext(handle, &file) == 0);

	_findclose(handle);
}

七、增加数据管理模块

​
​//打开数据库
int sqlite3_open(const char *filename, sqlite3 **ppDb);
//关闭
int sqlite3_close(sqlite3*);
//执行操作  后面的创建表，插入数据其实就是把sql的内容换了而已
int sqlite3_exec(sqlite3*, const char *sql, sqlite_callback,
void *data, char **errmsg);

int sqlite3_get_table(
sqlite3 *db, /* An open database */
const char *zSql, /* SQL to be evaluated */
char ***pazResult, /* Results of the query */
int *pnRow, /* Number of result rows written here */
int *pnColumn, /* Number of result columns written here */
char **pzErrmsg /* Error msg written here */
);
void sqlite3_free_table(char **result);

​

​

7.2  封装sqlite数据库管理类

//封装数据库sqlite
class SqliteManager
{
public:
	SqliteManager();
	~SqliteManager();

public:
	void Open(const string& database);  //打开或者创建一个数据库 
	void Close();					//关闭数据库
	void ExecuteSq1(const string& sql);//执行SQL  创建表，插入，删除都是通过执行sql语句
	void GetResultTable(const string& sql, char**& ppRet, int& row, int& col);

private:
	sqlite3* m_db;
};

SqliteManager::SqliteManager() :m_db(nullptr)
{}
SqliteManager::~SqliteManager()
{
	Close();//关闭数据库
}

void SqliteManager::Open(const string& database)
{
	int rc = sqlite3_open(database.c_str(), &m_db);

	if (rc != SQLITE_OK)
	{
		//fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(m_db));
		ERROR_LOG("Can't open database: %s\n", sqlite3_errmsg(m_db));
		exit(1);
	}
	else
	{
		//fprintf(stderr, "Opened database successfully\n");
		TRACE_LOG("Opened database successfully\n");
	}
}
void  SqliteManager::Close()
{
	int rc = sqlite3_close(m_db);

	if (rc != SQLITE_OK)
	{
		//fprintf(stderr, "Can't close database: %s\n", sqlite3_errmsg(m_db));
		ERROR_LOG("Can't close database: %s\n", sqlite3_errmsg(m_db));
		exit(1);
	}
	else
	{
		//fprintf(stderr, "Close database successfully\n");
		TRACE_LOG("Close database successfully\n");
	}
}

void SqliteManager::ExecuteSq1(const string& sql)
{
	char* zErrMsg = 0;
	int rc = sqlite3_exec(m_db, sql.c_str(), 0, 0, &zErrMsg);
	if (rc != SQLITE_OK)
	{
		//fprintf(stderr, "SQL error: %s\n", zErrMsg);
		ERROR_LOG("SQL error: %s\n", zErrMsg);
		sqlite3_free(zErrMsg);
	}
	else
	{
		//fprintf(stdout, "Operation sql successfully\n");
		TRACE_LOG("Operation sql successfully\n");
	}

}

void SqliteManager::GetResultTable(const string& sql, char**& ppRet, int& row, int& col)
{
	char* zErrMsg = 0;
	int rc = sqlite3_get_table(m_db, sql.c_str(), &ppRet, &row, &col, &zErrMsg);
	if (rc != SQLITE_OK)
	{
		//fprintf(stderr, "SQL Error: %s\n", zErrMsg);
		ERROR_LOG("SQL Error: %s\n", zErrMsg);
		sqlite3_free(zErrMsg);
	}
	else
	{
		//fprintf(stdout, "Get Result table successfully\n");
		TRACE_LOG("Get Result table successfully\n");
	}


}

//封装数据管理类
class DataManager
{
public:
DataManager();
~DataManager();
public:
void InitSqlite(); //初始化数据库
void InsertDoc(const string &path, const string &doc);
void DeleteDoc(const string &path, const string &doc);
void GetDoc(const string &path, multiset<string> &docs);
private:
SqliteManager m_dbmgr;
};

DataManager::DataManager()
{
m_dbmgr.Open(DOC_DB);
InitSqlite(); //创建表
}
DataManager::~DataManager()
{}
void DataManager::InitSqlite()
{
char sql[SQL_BUFFER_SIZE] = {0};
sprintf(sql, "CREATE TABLE if not exists %s(\
id integer primary key autoincrement,\
doc_name text,\
doc_path text)", DOC_TB);
m_dbmgr.ExecuteSql(sql);
}
void DataManager::InsertDoc(const string &path, const string &doc)
{
char sql[SQL_BUFFER_SIZE] = {0};
sprintf(sql, "INSERT INTO %s values(null, '%s', '%s')",
DOC_TB, doc.c_str(), path.c_str());
m_dbmgr.ExecuteSql(sql);
}
void DataManager::DeleteDoc(const string &path, const string &doc)
{
char sql[SQL_BUFFER_SIZE] = {0};
sprintf(sql, "DELETE FROM %s where doc_path='%s' and doc_name='%s'",
DOC_TB, path.c_str(), doc.c_str());
m_dbmgr.ExecuteSql(sql);
}
void DataManager::GetDoc(const string &path, multiset<string> &docs)
{
char sql[SQL_BUFFER_SIZE] = {0};
sprintf(sql, "SELECT doc_name from %s where doc_path='%s'",
DOC_TB, path.c_str());
char **ppRet = 0;
int row = 0, col = 0;
m_dbmgr.GetResultTable(sql, ppRet, row, col);
for(int i=1; i<=row; ++i)
docs.insert(ppRet[i]);
//释放表结果
sqlite3_free_table(ppRet);
}

7.3.1增加搜索功能

这里的搜索是用到了like模糊匹配

void DataManager::Search(const string &key, vector<pair<string,string>>
&doc_path)
{
char sql[SQL_BUFFER_SIZE] = {0};
sprintf(sql, "SELECT doc_name, doc_path from %s where doc_name like
'%%%s%%'",
DOC_TB, key.c_str());
char **ppRet;
int row, col;
m_dbmgr.GetResultTable(sql, ppRet, row, col);
for(int i=1; i<=row; ++i)
{
doc_path.push_back(make_pair(ppRet[i*col], ppRet[i*col+1]));
}
sqlite3_free_table(ppRet);
}

7.3.2  利用RAII机制解决表结果的自动释放

增加一个AutoGetResultTable类

我们会发现，在管理数据的时候，只要获取了表，就需要在最后面进行一步释放表结果的操作

我们万一忘记释放表结果就会导致内存泄漏，也就是说搜一次就会泄漏一次，如果搜的次数多的话，势必会导致内存资源被耗光

手动释放表结果还是有点麻烦的，而且我们也不能保证每次都记得去释放

所以我们就想着能不能让他自动的去释放呢？

这时候就想到了智能指针的思想 

class AutoGetResultTable
{
public:
	AutoGetResultTable(SqliteManager& db, const string& sql, char**& ppRet, int& row, int& col);
	~AutoGetResultTable();
private:
	SqliteManager& m_db;
	char** m_ppRet;
};
AutoGetResultTable::AutoGetResultTable(SqliteManager& db, const string& sql,
										char**& ppRet, int& row, int& col)
										:m_db(db), m_ppRet(nullptr)
{
	//获取数据库表的函数在数据库类中，所以必须要有一个数据库类对象才能去调
	m_db.GetResultTable(sql, ppRet, row, col);
	m_ppRet = ppRet;
}
AutoGetResultTable::~AutoGetResultTable()
{
	if (m_ppRet)//如果这个指针不空的话，说明就需要进行释放
		sqlite3_free_table(m_ppRet);
}

小小问题：我们在写这个类的时候怎么知道要传哪些参数呢？我们怎么知道要有哪些成员呢？

本身这个类就是要解决的释放空间，那么我们要是不把空间保存下来，拿什么去释放呢？所以在类中就把ppRet给保留了。

有了智能指针以后，获取表实现起来就简单了点

八、新增扫描模块

ScanManager.h  和  ScanManager.cpp

//同步本地数据和数据库数据
void ScanManger::ScanDirectory(const string& path)
{
	//1 扫描本地文件
	vector<string> local_dir;
	vector<string> local_file;
	DirectionList(path, local_dir, local_file);
	multiset<string> local_set;
	local_set.insert(local_file.begin(), local_file.end());
	local_set.insert(local_dir.begin(), local_dir.end());


	//2 扫描数据库文件
	multiset<string> db_set;
	DataManager& m_dbmgr = DataManager::GetInstance();//注意一定使用引用接收

	m_dbmgr.GetDoc(path, db_set);


	//3 同步数据
	auto local_it = local_set.begin();
	auto db_it = db_set.begin();
	while (local_it != local_set.end() && db_it != db_set.end())
	{
		if (*local_it < *db_it)
		{
			//本地有，数据库没有，数据库插入文件
			m_dbmgr.InsertDoc(path, *local_it);
			++local_it;
		}
		else if (*local_it > *db_it)
		{
			//本地没有，数据库有，数据库删除文件
			m_dbmgr.DeleteDoc(path, *db_it);
			++db_it;
		}
		else
		{
			//两者都有
			++local_it;
			++db_it;
		}
	}

	while (local_it != local_set.end())
	{
		//本地有，数据库没有，数据库插入文件
		m_dbmgr.InsertDoc(path, *local_it);
		++local_it;
	}

	while (db_it != db_set.end())
	{
		//本地没有，数据库有，数据库删除文件
		m_dbmgr.DeleteDoc(path, *db_it);
		++db_it;
	}
}

8.2、新增实时扫描功能

之前写的扫描是在搜索之前先进行了扫描，当程序跑起来之后，就无法再去同步数据库了，比如我们运行程序以后，这时候我们删除了一个文件，数据库是同步不了数据的，这就是个问题。我们要想同步就必须要把程序重启一下，这显然是不妥当的。

那有什么办法能实时的进行同步呢？

我们想要实时的进行一直扫描，就需要多线程的思想，让一个线程去专门扫描

在ScanManger的构造函数当中新增创建扫描线程

ScanManger::ScanManger(const string &path)
{
	//扫描对象 
	thread ScanObj(&ScanManger::ScanThread,this,path);
	ScanObj.detach();

}

线程的函数就是一直在做着扫描的工作，当然一直在while（1）效率肯定不高，后面会使用条件变量来让扫描不那么盲目

void ScanManger::ScanThread(const string& path)
{
	//这个线程就是一直在扫描
	while (1)
	{
		ScanDirectory(path);
	}
}

8.3 扫描管理类的单例化

为什么要单例化？

因为我们的扫描是的时候是需要先去实例化一个对象，那么要是别人也实例化一个对象的话会怎么样呢？

比如：

 那就可能再去创建线程去接着扫描，在这个程序之下，整个系统只需要产生一个对象就行了，多个对象进行扫描肯定是不好的，

而一个类只产生一个对象就是叫做单例化

 我们这里使用的是懒汉模式：

class ScanManager
{
public:
static ScanManager& GetInstance(const string &path);
protected:
ScanManager(const string &path);
ScanManager(ScanManager &);
ScanManager& operator=(const ScanManager&);
private:
//DataManager m_dbmgr;
};

ScanManager& ScanManager::GetInstance(const string &path)
{
static ScanManager _inst(path);
return _inst;
}

九、对sqlite进行静态链接库的使用

#include<mutex>
#include<condition_variable>
class ScanManager
{
//...............
mutex m_mutex;
condition_variable m_cond;
};

unique_lock<mutex> lock(m_mutex);  这个锁对象是构造函数加锁，析构函数解锁

void ScanManger::ScanThread(const string& path)
{
	//初始化扫描
	ScanDirectory(path);//防止第一次扫描的时候数据库里没有东西

	while (1)
	{
		unique_lock<mutex> lock(m_mutex);
		m_cond.wait(lock);  //条件阻塞等待，阻塞的时候不占CPU资源
		ScanDirectory(path);
	}
}

void ScanManger::WatchThread(const string& path)
{
	                                                   //true表示的是监控子目录
	HANDLE hd = FindFirstChangeNotification(path.c_str(), true,
						FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME);
	if (hd == INVALID_HANDLE_VALUE)
	{
		//cout<<"监控目录失败."<<endl;
		ERROR_LOG("监控目录失败.");
		return;
	}

	while (1)//监控成功，监控到了就要通知别人
	{
		WaitForSingleObject(hd, INFINITE); //永不超时等待
		m_cond.notify_one();//通知扫描线程去干活
		FindNextChangeNotification(hd);//接下来继续监控 
	}
}

十一、中间逻辑层实现

1、实现拼音全拼和首字母的搜索

//汉字转拼音
string ChineseConvertPinYinAllSpell(const string &dest_chinese);
//汉字转拼音首字母
string ChineseConvertPinYinInitials(const string &name);

void DataManager::InitSqlite()
{
char sql[SQL_BUFFER_SIZE] = {0};
sprintf(sql, "CREATE TABLE if not exists %s(\
id integer primary key autoincrement,\
doc_name text,\
doc_name_py text,\
doc_name_initials text,\
doc_path text)", DOC_TB);
m_dbmgr.ExecuteSql(sql);
}

void DataManager::InsertDoc(const string &path, const string &doc)
{
//汉字转拼音
string doc_py = ChineseConvertPinYinAllSpell(doc);
//汉字转首字母
string doc_initials = ChineseConvertPinYinInitials(doc);
char sql[SQL_BUFFER_SIZE] = {0};
sprintf(sql, "INSERT INTO %s values(null, '%s', '%s','%s', '%s')",
DOC_TB, doc.c_str(), doc_py.c_str(), doc_initials.c_str(),
path.c_str());
m_dbmgr.ExecuteSql(sql);
}

2、实现高亮搜索

// 颜色高亮显示一段字符串
void ColourPrintf(const char* str)
{
	// 0-黑 1-蓝 2-绿 3-浅绿 4-红 5-紫 6-黄 7-白 8-灰 9-淡蓝 10-淡绿
	// 11-淡浅绿 12-淡红 13-淡紫 14-淡黄 15-亮白
	//颜色：前景色 + 背景色*0x10
	//例如：字是红色，背景色是白色，即 红色 + 亮白 = 4 + 15*0x10
	WORD color = 9 + 0 * 0x10;

	WORD colorOld;
	HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);

	CONSOLE_SCREEN_BUFFER_INFO csbi;
	GetConsoleScreenBufferInfo(handle, &csbi);
	colorOld = csbi.wAttributes;

	SetConsoleTextAttribute(handle, color);
	printf("%s", str);
	SetConsoleTextAttribute(handle, colorOld);
}

十二、客户端的实现