////
//// Created by ps on 8/6/18.
////
//
//#ifndef UNTITLED_ERLANGTOOL_HPP
//#define UNTITLED_ERLANGTOOL_HPP
//
//#include <iostream>
//#include <cstring>
//#include <unistd.h>
//
//#include <map>
//#include <vector>
//#include <mutex>
//
//#include <stdio.h>
//#include <stdarg.h>
//#include <jsoncpp/json/json.h>
//#include <arpa/inet.h>
//
//#include "erl_interface.h"
//#include "ei.h"
//
//#include "SyncDB.hpp"
//
//#define TIMEOUT (5000)
//
////#TODO 多线程优化
//namespace ErlangTool {
//
//    static int m_loop = 0;
//    //map<uuid，人脸特征信息>
//    typedef std::map<std::string, SyncDB::Feature_Info> map_FaceDataCache;
//    //map<uuid，设备信息>
//    typedef std::map<std::string, SyncDB::Device_Info> map_DevDataCache;
//    //map<表名，底库表信息>
//    typedef std::map<std::string, SyncDB::Table_Info> map_TabDataCache;
//    //map<表名，黑白名单类型>
//    typedef std::map<std::string, SyncDB::Bw_Info> map_BwDataCache;
//
//    //c++11 互斥锁
//    // LockG(Parma);
//    typedef std::lock_guard<std::mutex> LockG;
//
//    /***
//     * 判断文件夹路径是否存在，不存在则创建
//     * @param dir 文件路径
//     * @param mkdir_flag 是否创建创建文件夹
//     * @return 是否成功
//     */
//    static bool dir_file_exists(std::string dir, bool mkdir_flag = true) {
//        int state = access(dir.c_str(), R_OK | W_OK); // 头文件 #include <unistd.h>
//        if (state == 0) {
//            //#todo
//            INFO("file exist");
//            return true;
//        } else if (mkdir_flag) {
//            dir = "mkdir -p " + dir;
//            system(dir.c_str()); // 调用linux系统命令创建文件
//            //#todo
//            return true;
//        } else {
//            return false;
//        }
//    }
//
//    /***
//     * 测试节点是否启动
//     * @param nodeName 节点名称
//     * @param cookie   节点cookie
//     * @return 启动状态
//     */
//    static bool pingNode(const std::string &nodeName, const std::string &cookie) {
//        int fd = -1;
//        int ret = -1;
//        erl_init(NULL, 0);
//        struct in_addr addr;
//        addr.s_addr = inet_addr("127.0.0.1");
//        if (erl_connect_xinit("idril", "cnode", "cnode@127.0.0.1", &addr, cookie.c_str(), 0) == -1) {
//            ERR("");
//            erl_err_quit("erl_connect_xinit");
//            return false;
//        }
//
//        fd = erl_connect(const_cast<char *>(nodeName.c_str()));
//        if (0 > fd) {
////            erl_err_quit("erl_connect");
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " error " << fd << std::endl;
//            return false;
//        }
////        std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << fd << std::endl;
//        erl_close_connection(fd);
//        return true;
//    }
//
//    /***
//     * 检查ETERM的数据类型
//     * @param elemen
//     * @return 返回数据类型
//     */
//    static int checkETERMType(ETERM *elemen) {
//        if (elemen == NULL) {
//            return -1;
//        }
//        switch (ERL_TYPE(elemen)) {
//            case ERL_UNDEF:
//                return ERL_UNDEF;
//            case ERL_INTEGER:
//                INFO("value is a int: " << ERL_INT_VALUE(elemen));
//                return ERL_INTEGER;
//            case ERL_U_INTEGER:
//                break;
//            case ERL_ATOM: {
////                int atomSize = ERL_ATOM_SIZE(elemen);
////                char *atomValue = ERL_ATOM_PTR(elemen);
////                printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                return ERL_ATOM;
//            }
//            case ERL_PID:
//                break;
//            case ERL_PORT:
//                break;
//            case ERL_REF:
//                break;
//            case ERL_LIST:
////                printf("value is a list:%s\n", erl_iolist_to_string(elemen));
//                return ERL_LIST;
//            case ERL_NIL:
//                return ERL_EMPTY_LIST;
//            case ERL_TUPLE:
//                INFO("value is a tupe: " << ERL_ATOM_PTR(erl_element(1, elemen)));
//                return ERL_TUPLE;
//            case ERL_BINARY:
//                break;
//            case ERL_FLOAT:
//                break;
//            case ERL_VARIABLE:
//                break;
//            case ERL_SMALL_BIG:
//                break;
//            case ERL_U_SMALL_BIG:
//                break;
//            case ERL_FUNCTION:
//                break;
//            case ERL_BIG:
//                break;
//            case ERL_LONGLONG:
//                break;
//            case ERL_U_LONGLONG:
//                break;
//            default:
//                ERR("[Client] got a value but now checked\n\r");
//                //#todo morechuli
//        }
//        return -1;
//    }
//
//    static void erlangFreeEterm(int count, ...) {
//        va_list args;
//        va_start(args, count);
//        for (int i = 0; i < count; ++i) {
//            auto test = va_arg(args, ETERM*);
//            erl_free_compound(test);
////            if (test != NULL)
////                erl_free_compound(test);
////            else{
////
////            }
//        }
//    }
//
//
//    /***
//     * Erlang交互工具
//     * #todo map保存到内存？
//     */
//    class ErlangDbTool {
//    public:
//        ErlangDbTool() : m_fd(-1) {
//
//        }
//
//        /***
//         * 初始化节点(zhizuo chaxun shiyong)
//         * @param nodeName 节点名称
//         * @param cookie 集群cookie
//         */
//        ErlangDbTool(const std::string &nodeName, const std::string &cookie, const std::string &pName) :
//            m_fd(-1), m_path(""), m_nodeName(nodeName), m_cookie(cookie), m_pName(pName) {
//            initCNode();
//        }
//
//        /***
//         * 初始化节点
//         * @param path 节点数据库保存路径
//         * @param nodeName 节点名称
//         * @param cookie 集群cookie
//         */
//        ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
//                     const std::string &pName) : m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie),
//                                                 m_pName(pName) {
//            initCNode();
//        }
//
//        //clusterID clusterName
//        /***
//         * 初始化节点
//         * @param path 节点数据库保存路径
//         * @param nodeName 节点名称
//         * @param cookie 集群cookie
//         * @param clusterID 集群id
//         * @param clusterName 集群名称
//         */
//        ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
//                     const std::string &clusterID, const std::string &clusterName) :
//            m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_clusterID(clusterID),
//            m_clusterName(clusterName) {
//
//        }
//
//        //clusterID clusterName
//        /***
//         * 初始化节点
//         * @param path 节点数据库保存路径
//         * @param nodeName 节点名称
//         * @param cookie 集群cookie
//         * @param clusterID 集群id
//         * @param clusterName 集群名称
//         * @param pName c节点标识名
//         */
//        ErlangDbTool(const std::string &path, const std::string &nodeName, const std::string &cookie,
//                     const std::string &clusterID, const std::string &clusterName, const std::string &pName) :
//            m_fd(-1), m_path(path), m_nodeName(nodeName), m_cookie(cookie), m_clusterID(clusterID),
//            m_clusterName(clusterName), m_pName(pName) {
//            initCNode();
//        }
//
//    private:
//
//        void initCNode() {
//            erl_init(NULL, 0);
//            struct in_addr addr;
//            //#todo
//            addr.s_addr = inet_addr("127.0.0.1");
//            std::string t_cNodeName(m_pName);
//            t_cNodeName.append("@127.0.0.1");
//            //m_pName
//            if (erl_connect_xinit("idril", const_cast<char *>(m_pName.c_str()), const_cast<char *>(t_cNodeName.c_str()),
//                                  &addr, const_cast<char *>(m_cookie.c_str()), 0) == -1) {
//                ERR("erl_connect_xinit error" << m_pName << " " << t_cNodeName << " " << m_cookie);
//                erl_err_quit("erl_connect_xinit");
//            } else {
//                ERR("erl_connect_xinit ok" << m_pName << " " << t_cNodeName << " " << m_cookie);
//            }
//        }
//
//    public:
//
//        virtual ~ErlangDbTool() {
//            erl_close_connection(m_fd);
//        }
//
//        //#todo setCNodeName
//
//        //#todo sendMessage
//
//        /***
//         * 启动erlang节点
//         * @return 启动状态
//         */
//        int initErlang() {
//            if (m_nodeName == "") {
//                ERR("m_nodeName is null ");
//                return 3;
//            }
//            m_ret = pingNode(m_nodeName, m_cookie);
//            if (!m_ret) {
//                if (dir_file_exists(m_path, true)) {
//                    std::string cmd = std::string("cd " + m_path + " && erl -name " + m_nodeName + " -setcookie  "
//                                                  + m_cookie + " -mnesia dir '\"" + m_path +
//                                                  "\"' -detached -noshell");// >>log
//                    std::cout << cmd << std::endl;
//                    system(cmd.c_str());
//                    std::cout << m_ret << std::endl;
//                    m_ret = waitNode();
//                    return m_ret;
//                } else {
//                    ERR("create file faile ");
//                    return 0;
//                }
//            } else {
//                INFO("node is running");
//                return 2;
//            }
//        }
//
//        std::string getConfigJsonString() {
//            Json::Value t_json;
//            Json::FastWriter writer;
//
//            t_json["\"path\""] = "\"" + m_path + "\"";
//            t_json["\"nodeName\""] = "\"" + m_nodeName + "\"";
//            t_json["\"cookie\""] = "\"" + m_cookie + "\"";
//            t_json["\"clusterID\""] = "\"" + m_clusterID + "\"";
//            t_json["\"clusterName\""] = "\"" + m_clusterName + "\"";
//
//            std::string str_json = writer.write(t_json);
//
//            return str_json.substr(0, str_json.length() - 1);
//        }
//
//        /***
//         * 启动节点数据库
//         * 新节点自动创建数据库
//         * @param FatherNodeName 第一个节点无需传入此参数，其他节点需要传入引导节点的名称
//         * @param DeviceName 设备名称
//         * @param DevAdd 设备地址
//         * @return
//         */
//        bool startNodeDb(std::string FatherNodeName, std::string DeviceId = "", std::string DevAdd = "DevAddress") {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (m_ret) {
////                DeviceName = DeviceName.empty() ? m_nodeName : DeviceName;
//            } else {
//                //#todo error message
//                ERR(" error " << m_ret << "  " << m_fd);
//                return false;
//            }
//
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
//            ETERM *arrlist[5];
//            arrlist[0] = erl_mk_atom(m_nodeName.c_str());
//            arrlist[1] = erl_mk_atom(FatherNodeName.c_str());
//            arrlist[2] = erl_mk_atom(DeviceId.c_str());
//            arrlist[3] = erl_mk_atom(m_clusterID.c_str());
//            arrlist[4] = erl_mk_atom(m_clusterName.c_str());
//            ETERM *list = erl_mk_list(arrlist, 5);
//
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
////            erl_rpc(m_fd, "syncDB", "startNode", list);
//            int ret = -1;
//            ret = erl_rpc_to(m_fd, "syncDB", "startNode", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, 9000000000, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    std::map<std::string, std::string> t_results;
//                    ETERM *key, *value;
//                    ETERM *tuplep[6];
//
//                    tuplep[0] = erl_element(2, emsg.msg);
//                    key = erl_element(1, tuplep[0]);
//                    value = erl_element(2, tuplep[0]);
////                printf("key:%s\n", ERL_ATOM_PTR(key));
//                    switch (checkETERMType(value)) {
//                        case ERL_ATOM: {
//                            int atomSize = ERL_ATOM_SIZE(value);
//                            char *atomValue = ERL_ATOM_PTR(value);
//                            t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
////                        printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                            break;
//                        }
//                        default:
//                            ERR("error add case todo \n\r");
//                    }
//                    auto it = t_results.find("atomic");
//                    if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
////                        erlangFreeEterm(7, emsg.to, emsg.msg, emsg.from, list, key, value, tuplep[0]);
////                        erl_eterm_release();
//                        return true;
//                    } //if end
//                    else {
//                        INFO(" t_results size is " << t_results.size());
//                        for (auto &item : t_results) {
//                            INFO("item is " << item.first << "  " << item.second);
//                        }
//                    }
//                }//ret == ERL_MSG end
//                else {
//                    ERR(" ret is " << ret);
//
//                }
//            } //ret == ERL_TICK
//
////            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            return false;
//        }
//
//        /***
//         * 删除节点数据库，同时删除本地文件
//         * @return 返回状态
//         */
//        bool removeNode() {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return false;
//            }
//            int ret = -1;
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
////            ETERM *arrlist[1];
////            arrlist[0] = erl_mk_atom(m_nodeName.c_str());
//            ETERM *list = erl_mk_empty_list();// (arrlist, 0);
//
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
//            ret = erl_rpc_to(m_fd, "syncDB", "removeNode", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    std::map<std::string, std::string> t_results;
//                    ETERM *key, *value;
//                    ETERM *tuplep[6];
//
//                    tuplep[0] = erl_element(2, emsg.msg);
//                    key = erl_element(1, tuplep[0]);
//                    value = erl_element(2, tuplep[0]);
////                printf("key:%s\n", ERL_ATOM_PTR(key));
//                    switch (checkETERMType(value)) {
//                        case ERL_ATOM: {
//                            int atomSize = ERL_ATOM_SIZE(value);
//                            char *atomValue = ERL_ATOM_PTR(value);
//                            t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
////                        printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                            break;
//                        }
//                        default:
//                            printf("error add case todo \n\r");
//                    }
//                    auto it = t_results.find("atomic");
//                    if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
//                        //删除本地文件
//                        std::string cmd = std::string("rm -rf ").append(m_path);
//                        //#todo
//                        system(cmd.c_str());
//                        erlangFreeEterm(7, emsg.to, emsg.msg, emsg.from, list, key, value, tuplep[0]);
//                        erl_eterm_release();
//                        return true;
//                    } //if end
//                } //ret == ERL_MSG end
//            } //ret == ERL_TICK
//
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            return false;
//        }
//
//
//        bool modifyCluName(std::string CluId, std::string CluName) {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return false;
//            }
//            ErlMessage emsg;             /* Incoming message */
//            int ret = -1;
//            ETERM *arrlist[2];
//            arrlist[0] = erl_mk_atom(CluId.c_str());
//            arrlist[1] = erl_mk_atom(CluName.c_str());
//            ETERM *list = erl_mk_list(arrlist, 2);
//
//            ret = erl_rpc_to(m_fd, "syncDB", "modifyCluName", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    std::map<std::string, std::string> t_results;
//
//                    ETERM *tail_list;
//                    ETERM *list_ret[1000], *arr_ret[2];
//                    ETERM *key, *value;
//                    ETERM *tuplep[6];
//
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    int erlLength = erl_length(arr_ret[0]);
//                    printf("arr_ret[0]:%d\n", erlLength);
//                    list_ret[0] = erl_hd(arr_ret[0]);
//                    tail_list = erl_tl(arr_ret[0]);
//                    for (int i = 0; i < erlLength; i++) {
//                        if (i > 0) {
//                            list_ret[i] = erl_hd(tail_list);
//                            tail_list = erl_tl(tail_list);
//                        }
////                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        key = erl_element(1, list_ret[i]);
//                        value = erl_element(2, list_ret[i]);
////                    printf("key:%s\n", ERL_ATOM_PTR(key));
//
//                        switch (checkETERMType(value)) {
//                            case ERL_ATOM: {
//                                int atomSize = ERL_ATOM_SIZE(value);
//                                char *atomValue = ERL_ATOM_PTR(value);
//                                printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                                t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
//                                break;
//                            }
//                            default:
//                                printf("error add case todo \n\r");
//                        }
//                        erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
//
//                    }
//                    erlangFreeEterm(2, tail_list, arr_ret[0]);
//                    erl_eterm_release();
//                    auto it = t_results.find("atomic");
//                    if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
//                        return true;
//                    }
//                }
//            }
//            erl_free_array(arrlist, 2);
////            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            erl_eterm_release();
//            return false;
//        }
//
//
//        /***
//         * 查找在线节点信息
//         * #TODO 有一个小bug
//         * device_info.create_by会被重置
//         * @return 节点集合信息
//         */
//        map_DevDataCache findAllNode() {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//
//                return map_DevDataCache();
//            }
//            map_DevDataCache devDataCache;
//            int ret = -1;
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
////            ETERM *arrlist[0];
////            arrlist[0] = erl_mk_atom(m_nodeName.c_str());
//            ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);
//
//            ret = erl_rpc_to(m_fd, "syncDB", "findAllNode", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    ETERM *key, *value;
//                    ETERM *tuplep[20];
//                    ETERM *arr_ret[2], *list_ret[1000];
//                    ETERM *tail_list, *tail_tuple;
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                        int erlLength = erl_length(arr_ret[0]);
////                    printf("arr_ret[0]:%d\n", erlLength);
//                        list_ret[0] = erl_hd(arr_ret[0]);
//                        tail_list = erl_tl(arr_ret[0]);
//                        for (int i = 0; i < erlLength; i++) {
//                            if (i > 0) {
//                                list_ret[i] = erl_hd(tail_list);
//                                tail_list = erl_tl(tail_list);
//                            }
//                            if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                                SyncDB::Device_Info device_info;
//                                int erlLength1 = erl_length(list_ret[i]);
////                            printf("list_ret[%d]:%d\n", i, erlLength1);
//                                tuplep[0] = erl_hd(list_ret[i]);
//                                tail_tuple = erl_tl(list_ret[i]);
//
//                                for (int j = 0; j < erlLength1; j++) {
//                                    if (j > 0) {
//                                        tuplep[j] = erl_hd(tail_tuple);
//                                        tail_tuple = erl_tl(tail_tuple);
//                                    }
//                                    key = erl_element(1, tuplep[j]);
//                                    value = erl_element(2, tuplep[j]);
////                                printf("key:%s\n", erl_iolist_to_string(key));
//                                    switch (checkETERMType(value)) {
//                                        case ERL_ATOM: {
//                                            device_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                            break;
//                                        }
//                                        case ERL_INTEGER: {
//                                            device_info.setValue(erl_iolist_to_string(key),
//                                                                 std::to_string(ERL_INT_VALUE(value)));
//                                            break;
//                                        }
//                                        case ERL_LIST: {
//                                            device_info.setValue(erl_iolist_to_string(key),
//                                                                 erl_iolist_to_string(value));
//                                            break;
//                                        }
//                                        default:
//                                            printf("error add case todo %d\n\r", checkETERMType(value));
//                                    }
//                                    erlangFreeEterm(3, key, value, tuplep[j]);
//                                }
////                            printf("\none list end\n\n\n\n");
//                                // #todo this is have a bug
////                                device_info.create_by = "";
//                                devDataCache.insert(std::make_pair(device_info.uuid, device_info));
//                                erlangFreeEterm(1, tail_tuple);
//                            } else {
//                                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
//                                          << checkETERMType(arr_ret[0])
//                                          << "  "
//                                          << std::endl;
//                            }
//                            erlangFreeEterm(1, list_ret[i]);
//                        }
//
//                        erlangFreeEterm(6, emsg.to, emsg.msg, emsg.from, list, tail_list, arr_ret[0]);
//                        erl_eterm_release();
//                        return devDataCache;
//                    } else {
//                        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
//                                  << "  "
//                                  << std::endl;
//                    }
//                }
//            } //ret == ERL_TICK end
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            erl_eterm_release();
//            return map_DevDataCache();
//        }
//
//        /***
//         * 创建底库表
//         * @param TableType car||person
//         * @param TableName
//         * @param SyncType true 1||false 0
//         * @param BwType   "Black"1||"White"0
//         * @return 创建状态
//         */
//        bool createDatabase(std::string TableType, std::string TableName, bool SyncType, std::string BwType,
//                            std::string StartTime = "", std::string EndTime = "") {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return false;
//            }
//            std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
//                                                                              : TableName;
//
//            ErlMessage emsg;             /* Incoming message */
//            int ret = -1;
//            ETERM *arrlist[6];
//            arrlist[0] = erl_mk_atom(TableType.c_str());
//            arrlist[1] = erl_mk_atom(NewTableName.c_str());
//            auto str = std::to_string(SyncType);
//            arrlist[2] = erl_mk_atom(str.c_str());
//            arrlist[3] = erl_mk_atom(BwType.c_str());
//            arrlist[4] = erl_mk_atom(StartTime.c_str());
//            arrlist[5] = erl_mk_atom(EndTime.c_str());
//            ETERM *list = erl_mk_list(arrlist, 6);
//
//            ret = erl_rpc_to(m_fd, "syncDB", "createDatabase", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    std::map<std::string, std::string> t_results;
//
//                    ETERM *tail_list;
//                    ETERM *list_ret[1000], *arr_ret[2];
//                    ETERM *key, *value;
//                    ETERM *tuplep[6];
//
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    int erlLength = erl_length(arr_ret[0]);
//                    printf("arr_ret[0]:%d\n", erlLength);
//                    list_ret[0] = erl_hd(arr_ret[0]);
//                    tail_list = erl_tl(arr_ret[0]);
//                    for (int i = 0; i < erlLength; i++) {
//                        if (i > 0) {
//                            list_ret[i] = erl_hd(tail_list);
//                            tail_list = erl_tl(tail_list);
//                        }
////                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        key = erl_element(1, list_ret[i]);
//                        value = erl_element(2, list_ret[i]);
////                    printf("key:%s\n", ERL_ATOM_PTR(key));
//
//                        switch (checkETERMType(value)) {
//                            case ERL_ATOM: {
////                            int atomSize = ERL_ATOM_SIZE(value);
//                                char *atomValue = ERL_ATOM_PTR(value);
////                            printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                                t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
//                                break;
//                            }
//                            default:
//                                printf("error add case todo \n\r");
//                        }
//                        erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
//
//                    }
//                    erlangFreeEterm(2, tail_list, arr_ret[0]);
//                    erl_eterm_release();
//                    auto it = t_results.find("atomic");
//                    if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
//                        return true;
//                    }
//                }
//            }
//            erl_free_array(arrlist, 6);
////            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            erl_eterm_release();
//            return false;
//        }
//
//        /***
//         * 更新底库表
//         * @param TableType car||person
//         * @param TableName
//         * @param SyncType true 1||false 0
//         * @param BwType   "white"0||"black"1
//         * @return 创建状态
//         */
//        bool updateDatabase(std::string UUID, std::string TableType, std::string TableName, bool SyncType,
//                            std::string BwType, std::string StartTime = "", std::string EndTime = "") {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return false;
//            }
//            std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
//                                                                              : TableName;
//
//            ErlMessage emsg;             /* Incoming message */
//            int ret = -1;
//            ETERM *arrlist[7];
//            arrlist[0] = erl_mk_atom(UUID.c_str());
//            arrlist[1] = erl_mk_atom(TableType.c_str());
//            arrlist[2] = erl_mk_atom(NewTableName.c_str());
//            auto str = std::to_string(SyncType);
//            arrlist[3] = erl_mk_atom(str.c_str());
//            arrlist[4] = erl_mk_atom(BwType.c_str());
//            arrlist[5] = erl_mk_atom(StartTime.c_str());
//            arrlist[6] = erl_mk_atom(EndTime.c_str());
//            ETERM *list = erl_mk_list(arrlist, 7);
//
//            ret = erl_rpc_to(m_fd, "syncDB", "updateDatabase", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    std::map<std::string, std::string> t_results;
//
//                    ETERM *tail_list;
//                    ETERM *list_ret[1000], *arr_ret[2];
//                    ETERM *key, *value;
//                    ETERM *tuplep[6];
//
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    int erlLength = erl_length(arr_ret[0]);
//                    printf("arr_ret[0]:%d\n", erlLength);
//                    list_ret[0] = erl_hd(arr_ret[0]);
//                    tail_list = erl_tl(arr_ret[0]);
//                    for (int i = 0; i < erlLength; i++) {
//                        if (i > 0) {
//                            list_ret[i] = erl_hd(tail_list);
//                            tail_list = erl_tl(tail_list);
//                        }
////                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        key = erl_element(1, list_ret[i]);
//                        value = erl_element(2, list_ret[i]);
////                    printf("key:%s\n", ERL_ATOM_PTR(key));
//
//                        switch (checkETERMType(value)) {
//                            case ERL_ATOM: {
////                            int atomSize = ERL_ATOM_SIZE(value);
//                                char *atomValue = ERL_ATOM_PTR(value);
////                            printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                                t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
//                                break;
//                            }
//                            default:
//                                printf("error add case todo \n\r");
//                        }
//                        erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
//                    }
//                    erlangFreeEterm(2, tail_list, arr_ret[0]);
//                    erl_eterm_release();
//                    auto it = t_results.find("atomic");
//                    if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
//                        return true;
//                    }
//                }
//            }
//            erl_free_array(arrlist, 7);
////            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            erl_eterm_release();
//            return false;
//        }
//
//        /***
//         * 删除数据表
//         * @param TableType car||person
//         * @param TableName biaoming
//         * @param SyncType true 1||false 0
//         * @return
//         */
//        bool deleteDatabase(std::string TableType, std::string TableName, bool SyncType) {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                ERR(" error " << m_ret << "  " << m_fd);
//                return false;
//            }
//            std::string NewTableName = ((!SyncType) && TableName.find("lt_")) ? std::string("lt_").append(TableName)
//                                                                              : TableName;
//
//            ErlMessage emsg;             /* Incoming message */
//            int ret = -1;
//
//            ETERM *arrlist[2];
//            arrlist[0] = erl_mk_atom(TableType.c_str());
//            arrlist[1] = erl_mk_atom(NewTableName.c_str());
//            ETERM *list = erl_mk_list(arrlist, 2);
//
//            ret = erl_rpc_to(m_fd, "syncDB", "deleteDatabase", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    std::map<std::string, std::string> t_results;
//                    ETERM *tail_list;
//                    ETERM *list_ret[10], *arr_ret[2];
//                    ETERM *key, *value;
//                    ETERM *tuplep[6];
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    int erlLength = erl_length(arr_ret[0]);
//                    printf("arr_ret[0]:%d\n", erlLength);
//                    list_ret[0] = erl_hd(arr_ret[0]);
//                    tail_list = erl_tl(arr_ret[0]);
//                    for (int i = 0; i < erlLength; i++) {
//                        if (i > 0) {
//                            list_ret[i] = erl_hd(tail_list);
//                            tail_list = erl_tl(tail_list);
//                        }
////                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        key = erl_element(1, list_ret[i]);
//                        value = erl_element(2, list_ret[i]);
////                    printf("key:%s\n", ERL_ATOM_PTR(key));
//                        switch (checkETERMType(value)) {
//                            case ERL_ATOM: {
//                                int atomSize = ERL_ATOM_SIZE(value);
//                                char *atomValue = ERL_ATOM_PTR(value);
//                                t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
//                                printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                                break;
//                            }
//                            default:
//                                printf("error add case todo \n\r");
//                        }
//                        erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
//                    }
//                    erlangFreeEterm(2, tail_list, arr_ret[0]);
//                    auto it = t_results.find("atomic");
//                    if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
//                        return true;
//                    }
//                }
//            }
//            erl_free_array(arrlist, 2);
//            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            return false;
//        }
//
//        /***
//         * 查询所有数据表
//         * @return
//         */
//        map_TabDataCache findAllDatabase() {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            map_TabDataCache tabDataCache;
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return tabDataCache;
//            }
//            int ret = -1;
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
////            ETERM *arrlist[0];
////            arrlist[0] = erl_mk_atom(m_nodeName.c_str());
//            ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);
//
//            std::cout << __FILE__ << __FUNCTION__ << __LINE__ << "  " << m_fd << std::endl;
//            ret = erl_rpc_to(m_fd, "syncDB", "findAllDatabase", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    ETERM *key, *value;
//                    ETERM *tuplep[20];
//                    ETERM *arr_ret[2], *list_ret[1000];
//                    ETERM *tail_list, *tail_tuple;
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                        int erlLength = erl_length(arr_ret[0]);
//                        list_ret[0] = erl_hd(arr_ret[0]);
//                        tail_list = erl_tl(arr_ret[0]);
//                        for (int i = 0; i < erlLength; i++) {
//                            if (i > 0) {
//                                list_ret[i] = erl_hd(tail_list);
//                                tail_list = erl_tl(tail_list);
//                            }
//                            if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                                SyncDB::Table_Info table_info;
//                                int erlLength1 = erl_length(list_ret[i]);
//                                tuplep[0] = erl_hd(list_ret[i]);
//                                tail_tuple = erl_tl(list_ret[i]);
//
//                                for (int j = 0; j < erlLength1; j++) {
//                                    if (j > 0) {
//                                        tuplep[j] = erl_hd(tail_tuple);
//                                        tail_tuple = erl_tl(tail_tuple);
//                                    }
//                                    key = erl_element(1, tuplep[j]);
//                                    value = erl_element(2, tuplep[j]);
//                                    switch (checkETERMType(value)) {
//                                        case ERL_ATOM: {
//                                            table_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                            break;
//                                        }
//                                        case ERL_INTEGER: {
//                                            table_info.setValue(erl_iolist_to_string(key),
//                                                                std::to_string(ERL_INT_VALUE(value)));
//                                            break;
//                                        }
//                                        case ERL_LIST: {
//                                            table_info.setValue(erl_iolist_to_string(key),
//                                                                erl_iolist_to_string(value));
//                                            break;
//                                        }
//                                        default:
//                                            printf("error add case todo %d\n\r", checkETERMType(value));
//                                    }
////                                    erlangFreeEterm(3, key, value, tuplep[j]);
//                                }
////                                erlangFreeEterm(2, tail_tuple, list_ret[i]);
//
//                                // #todo this is have a bug
////                                table_info.create_by = "";
//                                tabDataCache.insert(std::make_pair(table_info.tableName, table_info));
//                            } else {
//                                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
//                                          << checkETERMType(arr_ret[0])
//                                          << "  "
//                                          << std::endl;
//                            }
//                        }
////                        erlangFreeEterm(2, tail_list, arr_ret[0]);
//                        return tabDataCache; //ok
//                    } else {
//                        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
//                                  << "  "
//                                  << std::endl;
//                    }
//                }
//            }
////            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            return tabDataCache; //not ok
//        }
//
//        /***
//         * 查询所有表的黑白名单类型
//         * @return
//         */
//        map_BwDataCache findAllTypeInfo() {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return map_BwDataCache();
//            }
//            map_BwDataCache bwDataCache;
//            int ret = -1;
//            ErlMessage emsg;    /* Incoming message */
//            ETERM *list = erl_mk_empty_list();//erl_mk_list(arrlist, 0);
//
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
//            ret = erl_rpc_to(m_fd, "syncDB", "findAllTypeInfo", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    ETERM *key, *value;
//                    ETERM *tuplep[20];
//                    ETERM *arr_ret[2], *list_ret[1000];
//                    ETERM *tail_list, *tail_tuple;
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                        int erlLength = erl_length(arr_ret[0]);
////                    printf("arr_ret[0]:%d\n", erlLength);
//                        list_ret[0] = erl_hd(arr_ret[0]);
//                        tail_list = erl_tl(arr_ret[0]);
//                        for (int i = 0; i < erlLength; i++) {
//                            if (i > 0) {
//                                list_ret[i] = erl_hd(tail_list);
//                                tail_list = erl_tl(tail_list);
//                            }
//                            if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                                SyncDB::Bw_Info bw_info;
//                                int erlLength1 = erl_length(list_ret[i]);
////                            printf("list_ret[%d]:%d\n", i, erlLength1);
//                                tuplep[0] = erl_hd(list_ret[i]);
//                                tail_tuple = erl_tl(list_ret[i]);
//
//                                for (int j = 0; j < erlLength1; j++) {
//                                    if (j > 0) {
//                                        tuplep[j] = erl_hd(tail_tuple);
//                                        tail_tuple = erl_tl(tail_tuple);
//                                    }
//                                    key = erl_element(1, tuplep[j]);
//                                    value = erl_element(2, tuplep[j]);
////                                printf("key:%s\n", erl_iolist_to_string(key));
//                                    switch (checkETERMType(value)) {
//                                        case ERL_ATOM: {
//                                            bw_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                            break;
//                                        }
//                                        case ERL_INTEGER: {
//                                            bw_info.setValue(erl_iolist_to_string(key),
//                                                             std::to_string(ERL_INT_VALUE(value)));
//                                            break;
//                                        }
//                                        case ERL_LIST: {
//                                            bw_info.setValue(erl_iolist_to_string(key),
//                                                             erl_iolist_to_string(value));
//                                            break;
//                                        }
//                                        default:
//                                            printf("error add case todo %d\n\r", checkETERMType(value));
//                                    }
////                                    erlangFreeEterm(3, key, value, tuplep[j]);
//                                }
////                                erlangFreeEterm(2, tail_tuple, list_ret[i]);
////                            printf("\none list end\n\n\n\n");
//                                // #todo this is have a bug
////                            bw_info.create_by = "";
//                                bwDataCache.insert(std::make_pair(bw_info.tableName, bw_info));
//                            } else {
//                                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
//                                          << checkETERMType(arr_ret[0])
//                                          << "  "
//                                          << std::endl;
//                            }
//                        }
////                        erlangFreeEterm(2, tail_list, arr_ret[0]);
//                        return bwDataCache;//ok
//                    } else {
//                        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
//                                  << "  "
//                                  << std::endl;
//                    }
//                }
//            }
////            erlangFreeEterm(4, emsg.to, emsg.msg, emsg.from, list);
//            return map_BwDataCache();
//        }
//
//        /***
//         * 增加人员
//         * @param UUID  out
//         * @param TableName
//         * @param Feature
//         * @param PersonName
//         * @param Age
//         * @param Sex
//         * @param IdCard
//         * @param PhoneNum
//         * @return
//         */
//        bool addPerson(std::string &UUID, std::string TableName, std::string Feature, std::string ImgUrl = " ",
//                       std::string IdCard = " ", std::string PersonName = " ", std::string Age = " ",
//                       std::string Sex = " ", std::string PhoneNum = " ") {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << " "
//                          << Feature << std::endl;
//                return false;
//            }
//            int ret;
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
//            ETERM *arrlist[9];
//            arrlist[0] = erl_mk_atom(TableName.c_str());
//            arrlist[1] = erl_mk_atom(PersonName.c_str());
//            arrlist[2] = erl_mk_atom(Age.c_str());
//            arrlist[3] = erl_mk_atom(Sex.c_str());
//            arrlist[4] = erl_mk_atom(IdCard.c_str());
//            arrlist[5] = erl_mk_atom(PhoneNum.c_str());
//            arrlist[6] = erl_mk_atom(ImgUrl.c_str());
//            arrlist[7] = erl_mk_atom(UUID.c_str());
//            arrlist[8] = erl_mk_string(Feature.c_str());
//
//            ETERM *list = erl_mk_list(arrlist, 9);
//            ret = erl_rpc_to(m_fd, "syncDB", "addPersonData", list);
//            if (ret == ERL_TICK) {
//
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    ETERM *value;
//                    value = erl_element(2, emsg.msg);
//                    switch (checkETERMType(value)) {
//                        case ERL_LIST: {
//                            UUID = std::string(erl_iolist_to_string(value));
//                            break;
//                        }
//                        case ERL_ATOM: {
//                            UUID = std::string(ERL_ATOM_PTR(value));
//                            break;
//                        }
//                        default:
//                            printf("error add case todo \n\r");
//                    }
//                    erl_free_term(value);
//                    if (UUID.size() > 0) {
//                        erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[8]);
//                        erl_free_array(arrlist, 8);
//                        erl_eterm_release();
//                        return true;
//                    }
//                }
//            }
//            erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[8]);
//            erl_free_array(arrlist, 8);
//            erl_eterm_release();
//            return false;
//        }
//
//        /***
//         * 删除人员
//         * @param UUID
//         * @param TableName
//         * @return
//         */
//        bool delPerson(std::string UUID, std::string TableName) {
//            LockG lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << " "
//                          << std::endl;
//                return false;
//            }
//            int ret;
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
//            ETERM *arrlist[2];
//            arrlist[0] = erl_mk_atom(TableName.c_str());
//            arrlist[1] = erl_mk_atom(UUID.c_str());
//
//            ETERM *list = erl_mk_list(arrlist, 2);
//            ret = erl_rpc_to(m_fd, "syncDB", "deletePersonData", list);
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    std::map<std::string, std::string> t_results;
//                    ETERM *tail_list;
//                    ETERM *list_ret[10], *arr_ret[2];
//                    ETERM *key, *value;
//                    ETERM *tuplep[6];
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    int erlLength = erl_length(arr_ret[0]);
//                    printf("arr_ret[0]:%d\n", erlLength);
//                    list_ret[0] = erl_hd(arr_ret[0]);
//                    tail_list = erl_tl(arr_ret[0]);
//                    for (int i = 0; i < erlLength; i++) {
//                        if (i > 0) {
//                            list_ret[i] = erl_hd(tail_list);
//                            tail_list = erl_tl(tail_list);
//                        }
////                    printf("list_ret[%d]:%d\n", i, erl_length(list_ret[i]));
//                        tuplep[0] = erl_hd(list_ret[i]);
//                        key = erl_element(1, list_ret[i]);
//                        value = erl_element(2, list_ret[i]);
////                    printf("key:%s\n", ERL_ATOM_PTR(key));
//                        switch (checkETERMType(value)) {
//                            case ERL_ATOM: {
//                                int atomSize = ERL_ATOM_SIZE(value);
//                                char *atomValue = ERL_ATOM_PTR(value);
//                                t_results.insert(std::make_pair(ERL_ATOM_PTR(key), atomValue));
////                                printf("value is a atom: atomSize:%d, atomValue:%s \n\r", atomSize, atomValue);
//                                break;
//                            }
//                            default:
//                                printf("error add case todo \n\r");
//                        }
//                        erlangFreeEterm(4, key, value, tuplep[0], list_ret[i]);
//                    }
//                    erlangFreeEterm(2, tail_list, arr_ret[0]);
//                    auto it = t_results.find("atomic");
//                    if (t_results.size() > 0 && t_results.end() != it && it->second == "ok") {
//                        return true;
//                    }
//                }
//            }
//            erlangFreeEterm(4, emsg.msg, emsg.from, emsg.to, list);
//            erl_free_array(arrlist, 2);
//            erl_eterm_release();
//            return false;
//        }
//
//
//        /***
//         * 根据表名加载人脸特征
//         * @param TableName
//         * @return
//         */
//        map_FaceDataCache loadFaceFeaData(std::string TableName) {
//            std::lock_guard<std::mutex> lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return map_FaceDataCache();
//            }
//            map_FaceDataCache dataCache;
//            int ret;
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
//            ETERM *arrlist[1];
//            arrlist[0] = erl_mk_atom(TableName.c_str());
//
//            ETERM *list = erl_mk_list(arrlist, 1);
//            ret = erl_rpc_to(m_fd, "syncDB", "loadFaceFeaData", list);
//
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    ETERM *key, *value;
//                    ETERM *tuplep[20];
//                    ETERM *arr_ret[2], *list_ret[5000];
//                    ETERM *tail_list, *tail_tuple;
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                        int erlLength = erl_length(arr_ret[0]);
////                        printf("arr_ret[0]:%d\n", erlLength);
//                        list_ret[0] = erl_hd(arr_ret[0]);
//                        tail_list = erl_tl(arr_ret[0]);
//                        for (int i = 0; i < erlLength; i++) {
////                            DBG(i);
//                            if (i > 0) {
//                                list_ret[i] = erl_hd(tail_list);
//                                tail_list = erl_tl(tail_list);
//                            }
//                            if (tail_list == NULL)
//                                break;
//                            if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                                SyncDB::Feature_Info feature_info;
////                                feature_info.id = "test";
////                                feature_info.create_by = "";
////                                feature_info.feature ="";
////                                feature_info.update_time = "";
////                                feature_info.create_time = "";
//
//                                int erlLength1 = erl_length(list_ret[i]);
////                                printf("list_ret[%d]:%d\n", i, erlLength1);
//                                tuplep[0] = erl_hd(list_ret[i]);
//                                tail_tuple = erl_tl(list_ret[i]);
//
//                                for (int j = 0; j < erlLength1; j++) {
//                                    if (j > 0) {
//                                        tuplep[j] = erl_hd(tail_tuple);
//                                        tail_tuple = erl_tl(tail_tuple);
//                                    }
//                                    key = erl_element(1, tuplep[j]);
//                                    value = erl_element(2, tuplep[j]);
////                                    printf("key:%s\n", erl_iolist_to_string(key));
//
//                                    switch (checkETERMType(value)) {
//                                        case ERL_ATOM: {
//                                            feature_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                            break;
//                                        }
//                                        case ERL_LIST: {
//                                            feature_info.setValue(erl_iolist_to_string(key),
//                                                                  erl_iolist_to_string(value));
//                                            break;
//                                        }
//                                        default:
//                                            printf("error add case todo %d\n\r", checkETERMType(value));
//                                    }
//
////                                    erlangFreeEterm(2, key, value);
//                                }
////                                printf("\none list end\n\n\n\n");
//                                dataCache.insert(std::move(std::make_pair(feature_info.id, feature_info)));
////                                break;
////                                erlangFreeEterm(1, list_ret[i]);
//                            } else {
//                                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
//                                          << checkETERMType(list_ret[i])
//                                          << "  "
//                                          << std::endl;
//                            }
//                        }
//                        erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
//                        erl_eterm_release();
////                        sleep()
//                        return dataCache;
//                    } else {
//                        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
//                                  << "  "
//                                  << std::endl;
//                    }
//                } else {
//                    std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << ret << "  " << std::endl;
//                }
//
//            }
//            erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
//            erl_eterm_release();
//            return map_FaceDataCache();
//        };
//
//
//        /***
//         * 根据表名加载人脸特征2
//         * @param TableName
//         * @return
//         */
//        map_FaceDataCache loadFaceFeaData2(std::string TableName) {
//            std::lock_guard<std::mutex> lock(m_mutex);
////            m_mutex.lock();
//            m_ret = resetConn();
//            if (!m_ret) {
//                //#todo error message
//                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << m_ret << "  " << m_fd << std::endl;
//                return map_FaceDataCache();
//            }
//            map_FaceDataCache dataCache;
//            int ret;
//            ErlMessage emsg;    /* Incoming message */
//            //hanshu canshu
//            ETERM *arrlist[1];
//            arrlist[0] = erl_mk_atom(TableName.c_str());
//
//            ETERM *list = erl_mk_list(arrlist, 1);
//            ret = erl_rpc_to(m_fd, "syncDB", "loadFaceFeaData2", list);
//
//            if (ret == ERL_TICK) {
//                ret = erl_rpc_from(m_fd, TIMEOUT * 100000, &emsg);
////                m_mutex.unlock();
//                if (ret == ERL_MSG) {
//                    ETERM *key, *value;
//                    ETERM *tuplep[20];
//                    ETERM *arr_ret[2], *list_ret[5000];
//                    ETERM *tail_list, *tail_tuple;
//                    arr_ret[0] = erl_element(2, emsg.msg);
//                    if (checkETERMType(arr_ret[0]) == ERL_LIST) {
//                        int erlLength = erl_length(arr_ret[0]);
////                        printf("arr_ret[0]:%d\n", erlLength);
//                        list_ret[0] = erl_hd(arr_ret[0]);
//                        tail_list = erl_tl(arr_ret[0]);
//                        for (int i = 0; i < erlLength; i++) {
////                            DBG(i);
//                            if (i > 0) {
//                                list_ret[i] = erl_hd(tail_list);
//                                tail_list = erl_tl(tail_list);
//                            }
//                            if (tail_list == NULL)
//                                break;
//                            if (checkETERMType(list_ret[i]) == ERL_LIST) {
//                                SyncDB::Feature_Info feature_info;
////                                feature_info.id = "test";
////                                feature_info.create_by = "";
////                                feature_info.feature ="";
////                                feature_info.update_time = "";
////                                feature_info.create_time = "";
//
//                                int erlLength1 = erl_length(list_ret[i]);
////                                printf("list_ret[%d]:%d\n", i, erlLength1);
//                                tuplep[0] = erl_hd(list_ret[i]);
//                                tail_tuple = erl_tl(list_ret[i]);
//
//                                for (int j = 0; j < erlLength1; j++) {
//                                    if (j > 0) {
//                                        tuplep[j] = erl_hd(tail_tuple);
//                                        tail_tuple = erl_tl(tail_tuple);
//                                    }
//                                    key = erl_element(1, tuplep[j]);
//                                    value = erl_element(2, tuplep[j]);
////                                    printf("key:%s\n", erl_iolist_to_string(key));
//
//                                    switch (checkETERMType(value)) {
//                                        case ERL_ATOM: {
//                                            feature_info.setValue(erl_iolist_to_string(key), ERL_ATOM_PTR(value));
//                                            break;
//                                        }
//                                        case ERL_LIST: {
//                                            feature_info.setValue(erl_iolist_to_string(key),
//                                                                  erl_iolist_to_string(value));
//                                            break;
//                                        }
//                                        default:
//                                            printf("error add case todo %d\n\r", checkETERMType(value));
//                                    }
//
////                                    erlangFreeEterm(2, key, value);
//                                }
////                                printf("\none list end\n\n\n\n");
//                                dataCache.insert(std::move(std::make_pair(feature_info.id, feature_info)));
////                                break;
////                                erlangFreeEterm(1, list_ret[i]);
//                            } else {
//                                std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " type error "
//                                          << checkETERMType(list_ret[i])
//                                          << "  "
//                                          << std::endl;
//                            }
//                        }
//                        erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
//                        erl_eterm_release();
////                        sleep()
//                        return dataCache;
//                    } else {
//                        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << checkETERMType(arr_ret[0])
//                                  << "  "
//                                  << std::endl;
//                    }
//                } else {
//                    std::cout << __FILE__ << __FUNCTION__ << __LINE__ << " error " << ret << "  " << std::endl;
//                }
//
//            }
//            erlangFreeEterm(5, emsg.msg, emsg.from, emsg.to, list, arrlist[0]);
//            erl_eterm_release();
//            return map_FaceDataCache();
//        };
//
////    private:
//        /***
//         * 重新连接节点
//         * @return 连接状态
//         */
//        bool resetConn() {
//            //#todo
//            if (m_pName.size() <= 0) {
//                srand(time(0));
//                m_loop = rand() % 1000;
//
//                int ret = -1;
//                erl_init(NULL, 0);
////            m_loop %= 10;
////            m_loop++;
//                ret = erl_connect_init(m_loop, const_cast<char *>(m_cookie.c_str()), 0);
//                DBG("node name is   " << m_loop);
//                if (-1 == ret) {
////            erl_err_quit("erl_connect_init");
//                    return false;
//                }
//
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
//                erl_close_connection(m_fd);
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
//                m_fd = erl_connect(const_cast<char *>(m_nodeName.c_str()));
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << m_fd << std::endl;
//                if (0 > m_fd) {
////            erl_err_quit("erl_connect");
//                    return false;
//                }
//                return true;
//            } else {
//                erl_close_connection(m_fd);
//                m_fd = erl_connect(const_cast<char *>(m_nodeName.c_str()));
//                if (0 > m_fd) {
////            erl_err_quit("erl_connect");
////            std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << " error " << fd << std::endl;
////                    ERR("node name is   " << m_loop);
//                    return false;
//                }
////        std::cout << __FILE__ << __FUNCTION__ <<__LINE__ << "  " << fd << std::endl;
//                return true;
//            }
//        }
//
//        /***
//         * 等待节点启动，阻塞
//         * @return
//         */
//        bool waitNode() {
//            std::cout << "start waitNode" << std::endl;
//            int loop = 0;
//            while (!m_ret && loop <= 4000) {
//                m_ret = ErlangTool::pingNode(m_nodeName, m_cookie);
//                if (m_ret) {
////                    std::cout << "startNodeDb" << std::endl;
//                } else {
////                    std::cout << "init failer" << std::endl;
//                    usleep(1000);
//                    loop++;
//                }
//            }
//            std::cout << "start waitNode" << std::endl;
//            return m_ret;
//        }
//
//    public:
//
//    private:
//        //存储路径
//        std::string m_path;
//        std::string m_nodeName;
//        std::string m_pName;
//        std::string m_cookie;
//
//        std::string m_clusterID;
//        std::string m_clusterName;
//
//        bool m_ret;
//        int m_fd;
//
//        std::mutex m_mutex;
//    };
//
//}
//
//#endif //UNTITLED_ERLANGTOOL_HPP