helper.hpp

浏览该文件的文档.

 
#pragma once
#include <iostream>
#include <string>
#include <vector>
#include <sqlite3.h>
#include <functional>
#include <random>
#include <sstream>
#include <iomanip>
#include <atomic>
#include <sys/stat.h>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cerrno>
#include "logger.hpp"
 
namespace XuMQ
{
    class SqliteHelper
    {
    public:
        typedef int (*SqliteCallback)(void *, int, char **, char **);
        SqliteHelper(const std::string &dbfile)
            : _dbfile(dbfile), _handler(nullptr)
        {
        }
        bool open(int safe_level = SQLITE_OPEN_FULLMUTEX)
        {
            int ret = sqlite3_open_v2(_dbfile.c_str(), &_handler, SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | safe_level, nullptr);
            if (ret != SQLITE_OK)
            {
                error(logger, "打开SQLite数据库失败: %s", sqlite3_errmsg(_handler));
                return false;
            }
            return true;
        }
        bool exec(const std::string &sql, SqliteCallback cb, void *arg)
        {
            int ret = sqlite3_exec(_handler, sql.c_str(), cb, arg, nullptr);
            if (ret != SQLITE_OK)
            {
                error(logger, "%s--执行语句失败: %s", sql.c_str(), sqlite3_errmsg(_handler));
                return false;
            }
            return true;
        }
        void close()
        {
            sqlite3_close_v2(_handler);
        }
 
    private:
        std::string _dbfile; 
        sqlite3 *_handler;   
    };
 
    class StrHelper
    {
        public:
        static size_t split(const std::string &str, const std::string &sep, std::vector<std::string> &result)
        {
            // 从0位置查找指定字符的位置
            // 从上次查找的位置向后继续查找指定位置
            size_t pos, idx = 0;
            while (idx < str.size())
            {
                pos = str.find(sep, idx);
                if (pos == std::string::npos) // 没找到
                {
                    result.push_back(str.substr(idx));
                    return result.size();
                }
                if (pos == idx) // 位置相同则数据无效
                {
                    idx += sep.size();
                    continue;
                }
                result.push_back(str.substr(idx, pos - idx));
                idx = pos + sep.size();
            }
            return result.size();
        }
    };
    class UUIDHelper
    {
    public:
        static std::string uuid()
        {
            std::random_device rd;
            std::mt19937_64 generator(rd());                         // 生成机器随机数作为种子 使用梅森旋转算法生成伪随机数
            std::uniform_int_distribution<int> distribution(0, 255); // 范围取到0~255
            std::stringstream ss;
            for (int i = 0; i < 8; i++)
            {
                ss << std::setw(2) << std::setfill('0') << std::hex << distribution(generator); // 转为16进制字符串 不满两位自动补0
                if (i == 3 || i == 5 || i == 7)
                    ss << '-';
            }
            static std::atomic<size_t> seq(1); // 定义原子类型整数
            size_t num = seq.fetch_add(1);
            for (int i = 7; i >= 0; i--)
            {
                ss << std::setw(2) << std::setfill('0') << std::hex << ((num >> i * 8) & 0xff);
                if (i == 6)
                    ss << '-';
            }
            return ss.str();
        }
    };
    class FileHelper
    {
    public:
        FileHelper(const std::string &filename)
            : _filename(filename)
        {
        }
        bool exists()
        {
            struct stat st;
            return (stat(_filename.c_str(), &st) == 0);
        }
        size_t size()
        {
            struct stat st;
            int ret = stat(_filename.c_str(), &st);
            if (ret < 0)
                return 0;
            return st.st_size;
        }
        bool read(std::string &body)
        {
            size_t fsize = size();
            body.resize(fsize);
            return read(&body[0], 0, fsize);
        }
        bool read(char *body, size_t offset, size_t len)
        {
            // 打开文件
            std::ifstream ifs(_filename, std::ios::binary | std::ios::in); // 二进制形式打开
            if (ifs.is_open() == false)
            {
                error(logger, "%s:文件打开失败!", _filename.c_str());
                return false;
            }
            // 跳转文件读写位置
            ifs.seekg(offset, std::ios::beg);
            // 读取文件数据
            ifs.read(body, len);
            if (ifs.good() == false)
            {
                error(logger, "%s:文件读取数据失败!", _filename.c_str());
                ifs.close();
                return false;
            }
            // 关闭文件
            ifs.close();
            return true;
        }
        bool write(const std::string &body)
        {
            return write(body.c_str(), 0, body.size());
        }
        bool write(const char *body, size_t offset, size_t len)
        {
            // 打开文件
            std::fstream fs(_filename, std::ios::binary | std::ios::in | std::ios::out); // 二进制形式打开
            if (fs.is_open() == false)
            {
                error(logger, "%s:文件打开失败!", _filename.c_str());
                return false;
            }
            // 跳转文件指定位置
            fs.seekp(offset, std::ios::beg);
            // 写入数据
            fs.write(body, len);
            if (fs.good() == false)
            {
                error(logger, "%s:文件读取数据失败!", _filename.c_str());
                fs.close();
                return false;
            }
            // 关闭文件
            return true;
        }
        static std::string parentDirectory(const std::string &filename)
        {
            size_t pos = filename.find_last_of("/\\");
            if (pos == std::string::npos)
            {
                return ".";
            }
            std::string path = filename.substr(0, pos);
            return path;
        }
        bool rename(const std::string &nname)
        {
            return (::rename(_filename.c_str(), nname.c_str()) == 0);
        }
        static bool createFile(const std::string filename)
        {
            std::fstream ofs(filename, std::ios::binary | std::ios::out);
            if (ofs.is_open() == false)
            {
                error(logger, "%s:文件创建失败!", filename.c_str());
                return false;
            }
            ofs.close();
            return true;
        }
        static bool removeFile(const std::string filename)
        {
            return (::remove(filename.c_str()) == 0);
        }
        static bool createDirectory(const std::string &pathname)
        {
            size_t pos = 0, idx = 0; // pos表示'/'的位置，idx表示起始位置
            while (idx < pathname.size())
            {
                pos = pathname.find_first_of("/\\", idx); // 找第一个'/'
                if (pos == std::string::npos)             // 如果没有任何目录，直接创建
                {
                    return (mkdir(pathname.c_str(), 0775) == 0);
                }
                std::string parent_dir = pathname.substr(0, pos + 1); // 找到父级目录
                if (FileHelper(parent_dir).exists() == true)          // 如果存在则直接找下一个
                {
                    idx = pos + 1;
                    continue;
                }
                mkdir(parent_dir.c_str(), 0775);
                idx = pos + 1;
            }
            return true;
        }
        static bool removeDirectory(const std::string &pathname)
        {
 
#ifdef _WIN32
            std::string cmd = "rmdir /s /q \"" + pathname + "\"";
#else
            std::string cmd = "rm -rf " + pathname;
#endif
            return (system(cmd.c_str()) != -1);
        }
 
    private:
        std::string _filename; 
    };
}