ROS2下编译使用libconfig

最新推荐文章于 2024-06-28 11:08:55 发布
最新推荐文章于 2024-06-28 11:08:55 发布
阅读量479 收藏 8
点赞数 5
文章标签： 算法 前端 c++ linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guoguo151/article/details/134957919
版权
  1. 库下载地址 

 libconfig下载地址：About | libconfig

  1. 解压及编译

tar xzvf libconfig-1.7.2.tar.gz

cd libconfig-1.7.2

sudo ./configure

sudo make sudo

make check

生成的库路径在 libconfig/lib/.libs

更加不同的编译环境要求生成不一样的动态库，例如X86 arm等平台

  1. 对libconfig做适配，主要是提供简单的初始化接口和配置读写接口，以及处理多任务问题和定时同步保存等。
  • 用命令创建一个空白的包 ros2 pkg create bay_config --build-type ament_cmake.
  • 在src同级创建一个lib目录，将不同平台生成的libconfig库放置在下面
  • 设置bay_config为共享库

add_library(bay_config SHARED ${LIB_CONFIG_SRC})

  • 将libconfig库和bay_config适配库一起发布
if(${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "aarch64")
  install(DIRECTORY lib/arm/ DESTINATION lib)
  target_link_libraries(bay_config ${CMAKE_CURRENT_SOURCE_DIR}/lib/arm/libconfig++.so)
elseif(${CMAKE_HOST_SYSTEM_PROCESSOR} MATCHES "x86_64")
  install(DIRECTORY lib/x86/ DESTINATION lib)
  target_link_libraries(bay_config ${CMAKE_CURRENT_SOURCE_DIR}/lib/x86/libconfig++.so)
endif()

ament_export_include_directories(include)
install(DIRECTORY include/
	DESTINATION  include/)

ament_export_libraries(${PROJECT_NAME})
install(TARGETS bay_config LIBRARY DESTINATION lib)
  • 适配库头文件代码
#ifndef BAY_CONFIG_MANAGER_H
#define BAY_CONFIG_MANAGER_H

#include <mutex>
#include <iostream>
#include <iomanip>
#include <cstdlib>
#include "libconfig.h++"
#include "libconfig.h"
#include <string>
#include <thread>
#include <boost/thread/mutex.hpp>
#include <boost/thread/lock_types.hpp>
#include <boost/thread/pthread/shared_mutex.hpp>
#include <typeinfo>
#include <unistd.h>
#include <fcntl.h>
#include <array>
#include <vector>
#include <fstream>

using std::string;
using std::vector;

class ConfigManager
{
public:
  static ConfigManager &GetInstance(void); 
  bool Init(const std::string &default_path, const std::string& user_path);
  bool ResetValue(const string &obj_directroy);
  template<class T>
  bool WriteValue(const string &obj_directroy,T write_Data);
  template<class T>
  bool ReadValue(const string &obj_directroy,T &read_data);
  template<class T>
  bool ReadDefaultValue(const string &obj_directroy,T &read_data);
  bool GetUpdateFlag(void);
  void SetForceFlagTrue(void);
  bool GetForceFlag(void);
 
private: 
  ConfigManager(/* args */);
  ~ConfigManager();
  void UpdateCfgProcess(void);
  vector<string> SplitTheString(const string &str);
  bool CopyFileStream(const char *src_path,const char *dst_path);
  bool ConfigFileInit(libconfig::Config &cfg,const char *str,bool &file_read_statu);
  bool WriteConfigToFile(libconfig::Config &cfg, bool bsync = false);
  libconfig::Setting* CheckObjectformPathFileAndReturnObj(libconfig::Config &cfg,std::vector<string> vec);
  libconfig::Setting* CheckObjectformPathFileAndReturnObjForArray(libconfig::Config &cfg,std::vector<string> vec);
  libconfig::Setting* CheckObjectformPathFileAndReturnObjForReset(libconfig::Config &cfg,std::vector<string> vec);
  libconfig::Setting* WritePathToConfigObj(libconfig::Config &cfg,std::vector<string> vec);
  libconfig::Setting* CheckPathInLoop(libconfig::Setting &root,std::vector<string> vec);
  libconfig::Setting* WritePathInLoop(libconfig::Setting &root,std::vector<string> vec); 

private:
  std::string default_file_path_;
  std::string user_file_path_;
  std::string user_backup_file_path_;
  libconfig::Config cfg_default_;
  libconfig::Config cfg_user_; 
  bool default_file_read_{true};
  bool user_file_read_{true};
  bool backup_file_read_{true};
  typedef boost::shared_lock<boost::shared_mutex> ReadConfLock;
  typedef boost::unique_lock<boost::shared_mutex> WriteConfLock;
  boost::shared_mutex ConfLock;
  std::thread * sync_config_to_file_;
  bool update_configfile_flag_{false};
  bool force_update_flag_{false};
  bool thread_exit_status{false};
};

#endif
  • 适配库实现代码（其中有一些日志输出，可以忽略）
#include "config_manager.h"
#include "log_printf.h"
#include <dlfcn.h>
#include <regex>

using namespace libconfig;
using namespace std;
ConfigManager &ConfigManager::GetInstance(void)
{   
    static ConfigManager obj;
    return obj;
}

ConfigManager::ConfigManager()
    :cfg_default_()
    ,cfg_user_()
{
    
}

bool ConfigManager::Init(const std::string &default_path, const std::string& user_path)
{
    BAY_PRINTF("Cfg",  ERROR, "%s %s ", default_path.c_str(), user_path.c_str());
    default_file_path_ = default_path;
    user_file_path_ = user_path;
    user_backup_file_path_ = user_path + std::string(".backup");
    if(!ConfigFileInit(cfg_default_, default_file_path_.c_str(), default_file_read_))
    {
        BAY_PRINTF("Cfg",  ERROR, "config init file read failed!");
        return false;
    }  
    if(ConfigFileInit(cfg_user_, user_file_path_.c_str(), user_file_read_))  //main exit
    {
        CopyFileStream(user_file_path_.c_str(),user_backup_file_path_.c_str());
        BAY_PRINTF("Cfg",  INFO, "main file read success,copy main file to backup file!");
    }
    else
    {
        if(ConfigFileInit(cfg_user_, user_backup_file_path_.c_str(), backup_file_read_)) //backup file path exit
        {
            CopyFileStream(user_backup_file_path_.c_str(), user_file_path_.c_str());
            BAY_PRINTF("Cfg",  INFO, "backup file read success,copy backup file to user file!");
        }
        else
        {
            BAY_PRINTF("Cfg",  WARN, "main file and backup file read failed!");
        }
    }
    sync_config_to_file_ = new std::thread(std::bind(&ConfigManager::UpdateCfgProcess,this));
    BAY_PRINTF("Cfg",  WARN, "started UpdateCfgProcess thread!");
    return true;
}

bool ConfigManager::ConfigFileInit(libconfig::Config &cfg,const char *str,bool &file_read_statu)
{
    cfg.setOptions( Config::OptionFsync
                  | Config::OptionSemicolonSeparators
                  | Config::OptionColonAssignmentForGroups
                  | Config::OptionOpenBraceOnSeparateLine);
    try
    {
        cfg.readFile(str);
    }
    catch(const FileIOException &fioex)
    { 
        BAY_PRINTF("Cfg",  ERROR, "load  file  failed!");
        file_read_statu=false;
    }
    catch(const ParseException &pex)
    {
        BAY_PRINTF("Cfg",  ERROR, "parse  file  failed!");
        file_read_statu=false;
    }
    return file_read_statu;
}

bool ConfigManager::CopyFileStream(const char *src_path,const char *dst_path)
{  
    ifstream  infile((const string)src_path,ios::in);
    if(!infile.is_open()) return false;
    ifstream  src((const string)src_path,ios::binary);
    ofstream  dst((const string)dst_path,ios::binary);
    dst << src.rdbuf();
    infile.close();
    src.close();
    dst.close();
    std::system("sync");
    return true;
}

ConfigManager::~ConfigManager()
{   
    BAY_PRINTF("Cfg",  INFO, "entry class config manager destroy");
    if(!thread_exit_status)
    {
        thread_exit_status = true;
        while(thread_exit_status)
        {
            usleep(10000);
        }
    }
    if(sync_config_to_file_ != nullptr)
    {
        delete sync_config_to_file_;
        sync_config_to_file_ = nullptr;
    }
    BAY_PRINTF("Cfg",  INFO, "class config manager destroy");
}

void ConfigManager::UpdateCfgProcess(void)
{
    unsigned int sum_times_us{0};
    unsigned int count = 0;
    BAY_PRINTF("Cfg",  INFO, "start UpdateCfgProcess!");
    while(!thread_exit_status)
    {
        if(update_configfile_flag_ && (force_update_flag_ || (sum_times_us >= 3000000)))
        {
            bool ret = false;
            ReadConfLock lock(ConfLock);
            ret = WriteConfigToFile(cfg_user_, true);
            if(ret || (count >= 3))
            {
                update_configfile_flag_ = false;
                force_update_flag_ = false;
                sum_times_us = 0;
                count = 0;
            }else
            {
                count += 1;
                BAY_PRINTF("Cfg",  ERROR, "update the config file fail times: %u",count);
            }
            BAY_PRINTF("Cfg",  INFO, "update the config file status: %s",ret?"true":"false");
        }else
        {
            sum_times_us += 100000;
        }
        usleep(100000);  
    }
    BAY_PRINTF("Cfg",  INFO, "exit UpdateCfgProcess!");
    thread_exit_status = false;
}

bool ConfigManager::GetUpdateFlag(void)
{
    return update_configfile_flag_;
}

bool ConfigManager::GetForceFlag(void)
{
    return force_update_flag_;
}

void ConfigManager::SetForceFlagTrue(void)
{
    force_update_flag_ = true;
}

vector<string> ConfigManager::SplitTheString(const string &str)
{
    vector<string>  resVec;
    string part=":";
    string strs=str+part;
    size_t pos=strs.find(part);
    size_t size=strs.size();
    while(pos!=string::npos)
    {
      string x=strs.substr(0,pos);
      resVec.push_back(x);
      strs=strs.substr(pos+1,size);
      pos=strs.find(part);
    }
    return resVec;
}

template<class T>
bool ConfigManager::WriteValue(const string &obj_directroy,T write_data)
{
    BAY_PRINTF("Cfg",  INFO, "The main template function()");
    return true;
}

template<>
bool ConfigManager::WriteValue<int>(const string &obj_directroy,int write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeInt)=write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write int value :%d success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<uint8_t>(const string &obj_directroy,uint8_t write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeInt)=write_data;
    update_configfile_flag_ = true;
     BAY_PRINTF("Cfg",  INFO, "write uint8_t value :%d success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<uint32_t>(const string &obj_directroy,uint32_t write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeInt)=(int)write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write uint32_t value :%d success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<uint16_t>(const string &obj_directroy,uint16_t write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeInt)=(int)write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write uint16_t value :%d success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<int16_t>(const string &obj_directroy,int16_t write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeInt)=(int)write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write int16_t value :%d success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<int64_t>(const string &obj_directroy,int64_t write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeInt64)=write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write int64_t value :%d success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<double>(const string &obj_directroy,double write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeFloat)=(float)write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write double value :%f success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<float>(const string &obj_directroy,float write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeFloat)=write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write float value :%f success to main path %s",write_data,obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<string>(const string &obj_directroy,string write_data)
{   
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeString)=write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write string value :%s success to main path %s",write_data.c_str(),obj_directroy.c_str());
    return true;
}

template<>
bool ConfigManager::WriteValue<bool>(const string &obj_directroy,bool write_data)
{
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting=WritePathToConfigObj(cfg_user_,vec);
    temp_setting->add(vec.back().c_str(),libconfig::Setting::TypeBoolean)=write_data;
    update_configfile_flag_ = true;
    BAY_PRINTF("Cfg",  INFO, "write bool value :%d success to main path %s",write_data,obj_directroy.c_str());
    return true;  
}

template<>
bool ConfigManager::WriteValue<vector<float> >(const string &obj_directroy,vector<float> write_data)
{  
    vector<string> vec;
    vec=SplitTheString(obj_directroy);
    libconfig::Setting *temp_setting_1=NULL;
    WriteConfLock lock(ConfLock);
    temp_setting_1=WritePathToConfigObj(cfg_user_,vec);
    libconfig::Setting &temp_setting_2=temp_setting_1->add(vec.back().c_str(),libconfig::Setting::TypeArray);
    for(unsigned int i=0;i<write_data.size();i++)
    {
      temp_setting_2.add(libconfig::Setting::TypeFloat)=write_data.at(i);
    }
    update_configfile_flag_ = true;
    return true;
}

template<class T>
bool ConfigManager::ReadValue(const string &obj_directroy,T &read_data)
{
    BAY_PRINTF("Cfg",  INFO, "The main template function()");
    return true;
}

template<>
bool ConfigManager::ReadValue<int>(const string &obj_directroy,int &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        //BAY_PRINTF("Cfg",  INFO, "get int value :%d success from main path %s",read_data,obj_directroy.c_str());
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        //BAY_PRINTF("Cfg",  INFO, "get int value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false; //assertion both main bk init file does not contain target configuration
}

template<>
bool ConfigManager::ReadValue<uint8_t>(const string &obj_directroy,uint8_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get uint8_t value :%d success from main path %s",read_data,obj_directroy.c_str());
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get uint8_t value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadValue<int16_t>(const string &obj_directroy,int16_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        //BAY_PRINTF("Cfg",  INFO, "get int16_t value :%d success from main path %s",read_data,obj_directroy.c_str());
        return true;
    } 
    temp_setting = CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        // BAY_PRINTF("Cfg",  INFO, "get int16_t value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadValue<uint32_t>(const string &obj_directroy,uint32_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get uint32_t value :%d success from main path %s",read_data,obj_directroy.c_str());
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get uint32_t value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadValue<uint16_t>(const string &obj_directroy,uint16_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        //BAY_PRINTF("Cfg",  INFO, "get uint16_t value :%d success from main path %s",read_data,obj_directroy.c_str());
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        //BAY_PRINTF("Cfg",  INFO, "get uint16_t value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadValue<int64_t>(const string &obj_directroy,int64_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        read_data=temp_setting->lookup(vec.back().c_str());
        //BAY_PRINTF("Cfg",  INFO, "get int64_t value :%d success from main path %s",read_data,obj_directroy.c_str());
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        read_data=temp_setting->lookup(vec.back().c_str());
        //BAY_PRINTF("Cfg",  INFO, "get int64_t value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadValue<double>(const string &obj_directroy,double &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        double a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get int value :%d success from main path",read_data);
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        double a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get int value :%d success from init path",read_data);
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadValue<bool>(const string &obj_directroy,bool &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        BAY_PRINTF("Cfg",  INFO, "get bool value :%d success from main path",read_data);
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        BAY_PRINTF("Cfg",  INFO, "get bool value :%d success from init path",read_data);
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadValue<float>(const string &obj_directroy,float &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        BAY_PRINTF("Cfg",  INFO, "get float value :%f success from main path %s",read_data,obj_directroy.c_str());
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        BAY_PRINTF("Cfg",  INFO, "get float value :%f success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false; 
}

template<>
bool ConfigManager::ReadValue<string>(const string &obj_directroy,string &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        BAY_PRINTF("Cfg",  INFO, "get string :%s success from main path",read_data.c_str(),obj_directroy.c_str());
        return true;
    } 
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        BAY_PRINTF("Cfg",  INFO, "get string :%s success from init path",read_data.c_str(),obj_directroy.c_str());
        return true;
    }
    return false; //assertion both main bk init file does not contain target configuration
}

template<>
bool ConfigManager::ReadValue<std::vector<float>>(const string &obj_directroy,std::vector<float> &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting_1=NULL;
    ReadConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting_1=CheckObjectformPathFileAndReturnObjForArray(cfg_user_,vec);
    if(temp_setting_1!=NULL)
    { 
        libconfig::Setting &tmp_setting = *temp_setting_1;
        for(int i=0;i<tmp_setting[vec.back().c_str()].getLength();i++)
        {
            float temp=tmp_setting[vec.back().c_str()][i];
            read_data.push_back(temp);    
        }   
        BAY_PRINTF("Cfg",  INFO, "get vector<float> success from main path");
        //cout<<"get vector<float> success from main path"<<endl;
        return true;
    } 
    temp_setting_1=CheckObjectformPathFileAndReturnObjForArray(cfg_default_,vec);
    if(temp_setting_1!=NULL)
    { 
        libconfig::Setting &tmp_setting = *temp_setting_1;
        for(int i=0;i<tmp_setting[vec.back().c_str()].getLength();i++)
        {
            float temp=tmp_setting[vec.back().c_str()][i];
            read_data.push_back(temp);    
            BAY_PRINTF("Cfg",  INFO, "get vector<float> %.4f", temp); 
        }  
        BAY_PRINTF("Cfg",  INFO, "get vector<float> success from init path"); 
        //cout<<"get vector<float> success from init path"<<endl;
        return true;
    } 
    return false;
}

libconfig::Setting* ConfigManager::WritePathToConfigObj(libconfig::Config &cfg,std::vector<string> vec)
{
    libconfig::Setting &root=cfg.getRoot();
    return WritePathInLoop(root,vec);
}

libconfig::Setting* ConfigManager::WritePathInLoop(libconfig::Setting &root,std::vector<string> vec)
{ 
    string temp_s=vec.begin()->c_str();
    vector<string>::iterator it=vec.begin();
    vec.erase(it);
    if(vec.empty())
    {  
        if(root.exists(temp_s.c_str())) 
        {
          root.remove(temp_s.c_str());
        }
        return &root;
    }
    else
    {
        if(!root.exists(temp_s.c_str()))
        { 
            root.add(temp_s.c_str(),libconfig::Setting::TypeGroup);
        }
        else
        {
        }
        libconfig::Setting &obj = root[temp_s.c_str()]; 
        return WritePathInLoop(obj,vec);
    }
}

libconfig::Setting* ConfigManager::CheckObjectformPathFileAndReturnObj(libconfig::Config &cfg,std::vector<string> vec)
{
    libconfig::Setting &root=cfg.getRoot();
    return CheckPathInLoop(root,vec);
}

libconfig::Setting* ConfigManager::CheckObjectformPathFileAndReturnObjForArray(libconfig::Config &cfg,std::vector<string> vec)
{
    libconfig::Setting &root=cfg.getRoot();
    return CheckPathInLoop(root,vec);
}

libconfig::Setting* ConfigManager::CheckObjectformPathFileAndReturnObjForReset(libconfig::Config &cfg,std::vector<string> vec)
{
    libconfig::Setting &root=cfg.getRoot();
    return CheckPathInLoop(root,vec);
}

libconfig::Setting* ConfigManager::CheckPathInLoop(libconfig::Setting &root,std::vector<string> vec)
{ 
    //cout<<"iter check str: "<<vec.begin()->c_str()<<endl;
    string temp_s=vec.begin()->c_str();
    //cout<<"temp str: "<<temp_s.c_str()<<endl;
    vector<string>::iterator it=vec.begin();
    vec.erase(it);
    if(root.exists(temp_s.c_str())&&vec.empty())
    {
      //cout<<"obj match!"<<endl; 
      return &root; 
    }
    else if(!root.exists(temp_s.c_str()))
    {
      //cout<<"error not obj match "<<endl;
      return NULL; 
    }
    else
    {
      libconfig::Setting &obj=root[temp_s.c_str()];
      return CheckPathInLoop(obj,vec); 
    }
}

bool ConfigManager::WriteConfigToFile(libconfig::Config &cfg, bool bsync)
{
    try
    {
        cfg.writeFile(user_file_path_);
        if(bsync)
        {
            std::system("sync");
        }
    }
    catch(const FileIOException &fioex)
    {
        BAY_PRINTF("Cfg",  INFO, "I/O error while writing file"); 
        return false;
    }
    
    if(bsync)
    {
        return CopyFileStream(user_file_path_.c_str(), user_backup_file_path_.c_str());
    }

    return true;
}

bool ConfigManager::ResetValue(const string &obj_directroy)
{
    vector<string> vec;
    WriteConfLock lock(ConfLock);
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy); 
    libconfig::Setting *temp_setting=NULL;
    temp_setting=CheckObjectformPathFileAndReturnObjForReset(cfg_user_,vec);
    if(temp_setting!=NULL)
    {
      temp_setting->remove(vec.back().c_str());
      update_configfile_flag_ = true;
      BAY_PRINTF("Cfg",  INFO, "Reset :%s success from main file",obj_directroy.c_str());
    }
    else
    {
      BAY_PRINTF("Cfg",  WARN, "%s not exsit in main file",obj_directroy.c_str());
    }
    return true;
}

template<class T>
bool ConfigManager::ReadDefaultValue(const string &obj_directroy,T &read_data)
{
    BAY_PRINTF("Cfg",  INFO, "The main template function()");
    return true;
}

template<>
bool ConfigManager::ReadDefaultValue<int>(const string &obj_directroy,int &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        temp_setting->lookupValue(vec.back().c_str(),read_data);
        BAY_PRINTF("Cfg",  INFO, "get int value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<uint8_t>(const string &obj_directroy,uint8_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get uint8_t value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<int16_t>(const string &obj_directroy,int16_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
        int a=temp_setting->lookup(vec.back().c_str());
        read_data=a;
        BAY_PRINTF("Cfg",  INFO, "get int16_t value :%d success from init path %s",read_data,obj_directroy.c_str());
        return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<uint32_t>(const string &obj_directroy,uint32_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
      int a=temp_setting->lookup(vec.back().c_str());
      read_data=a;
      BAY_PRINTF("Cfg",  INFO, "get uint32_t value :%d success from init path %s",read_data,obj_directroy.c_str());
      return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<uint16_t>(const string &obj_directroy,uint16_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
      int a=temp_setting->lookup(vec.back().c_str());
      read_data=a;
      BAY_PRINTF("Cfg",  INFO, "get uint16_t value :%d success from init path %s",read_data,obj_directroy.c_str());
      return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<int64_t>(const string &obj_directroy,int64_t &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
      read_data=temp_setting->lookup(vec.back().c_str());
      BAY_PRINTF("Cfg",  INFO, "get int64_t value :%d success from init path %s",read_data,obj_directroy.c_str());
      return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<double>(const string &obj_directroy,double &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
      double a=temp_setting->lookup(vec.back().c_str());
      read_data=a;
      BAY_PRINTF("Cfg",  INFO, "get int value :%d success from init path",read_data);
      return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<bool>(const string &obj_directroy,bool &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
      temp_setting->lookupValue(vec.back().c_str(),read_data);
      BAY_PRINTF("Cfg",  INFO, "get bool value :%d success from init path",read_data);
      return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<float>(const string &obj_directroy,float &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
      temp_setting->lookupValue(vec.back().c_str(),read_data);
      BAY_PRINTF("Cfg",  INFO, "get float value :%f success from init path %s",read_data,obj_directroy.c_str());
      return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<string>(const string &obj_directroy,string &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting=CheckObjectformPathFileAndReturnObj(cfg_default_,vec);
    if(temp_setting!=NULL)
    {
      temp_setting->lookupValue(vec.back().c_str(),read_data);
      BAY_PRINTF("Cfg",  INFO, "get string :%s success from init path",read_data.c_str(),obj_directroy.c_str());
      return true;
    }
    return false;
}

template<>
bool ConfigManager::ReadDefaultValue<std::vector<float>>(const string &obj_directroy,std::vector<float> &read_data)
{
    vector<string> vec;
    libconfig::Setting *temp_setting_1=NULL;
    if(obj_directroy.length()==0)  return false;
    vec=SplitTheString(obj_directroy);
    temp_setting_1=CheckObjectformPathFileAndReturnObjForArray(cfg_default_,vec);
    if(temp_setting_1!=NULL)
    {
        libconfig::Setting &tmp_setting = *temp_setting_1;
        for(int i=0;i<tmp_setting[vec.back().c_str()].getLength();i++)
        {
            float temp=tmp_setting[vec.back().c_str()][i];
            read_data.push_back(temp);    
        }    
        //cout<<"get vector<float> success from init path"<<endl;
        BAY_PRINTF("Cfg",  INFO, "get vector<float> success from init path");
        return true;
    } 
    return false;
}

蝈蝈的绿草地
关注
linux下libconfig的使用
ProYuan的博客
06-02 2392
一、libconfig是什么？ Libconfig是一个结构化的配置文件库，它可以定义一些配置文件，例如test.cfg . 它比xml可读性更好，而且更简洁。而且不像xml，它是type-aware类型自我感知的，因此不需要做string parsing (分词？). 而ini太弱。 2 配置文件说明（摘自手册翻译） libconfig支持结构化、层次化的配置。这些配置可以从文件中读取或写入文件，也可以在内存中操作。 一个配置由一组setting构成，setting由名字（name）关联，并有相应.
libconfig-1.4.9.tar.gz
01-02
libconfig-1.4.9.tar.gz linux下的c库文件
Ubuntu 22.04上编译安装c++ libconfig library
最新发布
Remon的专栏
06-28 449
Libconfig是一个简单的c及c++库，用于处理结构化的配置文件。libconfig++的配置的文件格式非常简洁，可读性也非常的好，而且是type-aware，普通的配置文件读取后存取的类型为字符串，而Libconfig具有类型意识，因此不需要在应用程序代码中进行字符串解析。
libconfig
how0723的博客
11-02 231
#include <libconfig.h++> #include <iostream> using namespace std; void write_test() { libconfig::Config cfg; //1.声明 Config对象 auto& root = cfg.getRoot(); root.add("name", lib...
fftw3 ndk编译移植
xhiehf的博客
08-30 753
fftw3 版本：fftw-3.3.7 下载地址：https://download.csdn.net/download/xhiehf/11644313 ndk下载地址： https://developer.android.google.cn/ndk/downloads?hl=zh-cn 版本：android-ndk-r19c-linux-x86_64.zip #!/bin/sh # Comp...
libconfig - Configuration File Library
sunlylorn的专栏
12-31 6511
配置文件很重要，INI 太弱，XML 太繁复，Linux *.conf 很酷。 找了好几种相关的类库，发觉还是 hyperrealm libconfig 最强大最好用，相关细节可参考 官方手册。 源中的版本是 1.3.2-1，也可以去官方文章下载最新版本。 $ sudo apt-get install libconfig8 libconfig8-dev 完全类脚本化的配置语
ros2_android:ros2java的Android库
05-12
这个"ros2_android:ros2java的Android库"项目是ROS2的Java版本与Android平台的集成，主要关注于提供一个Android开发者可以使用的API，以利用ROS2的功能。它通过JNI（Java Native Interface）技术将C++编写的ROS2核心...
ROS noetic MoveIt编译出错，提示缺少软件包"manipulation_msgs"
07-08
接下来，你需要使用ROS的构建工具catkin来编译新添加的软件包。在终端中，进入你的工作空间的顶层目录（即包含"src"的目录），然后执行以下命令： 1. `cd <你的工作空间目录>` 2. `catkin build manipulation_msgs`...
一个ROS下自定义消息使用案例，执行编译即可使用
09-07
在初学ROS时，一般都是使用的ROS标准库，包括激光电云laserscan、位姿posetamp等。这些库基本满足了我们的日常使用，但是在开发时，难免会遇到一些情况使用标准库不太合适，这时候使用自己的自定义消息格式就变得...
海康相机ros包，方便在ros系统下能够使用
02-23
海康相机ROS包是专为ROS（Robot Operating System，机器人操作系统）设计的，旨在帮助开发者在ROS环境下便捷地集成和使用海康相机。这个包经过实际测试，确保了其在ROS系统下的兼容性和稳定性，通过执行标准的`...
libconfig中文手册.pdf
09-30
libconfig中文手册.pdf
libconfig 配置文件使用示例程序
05-22
配置文件很重要，INI 太弱，XML 太繁复，Linux *.conf 很酷。 找了好几种相关的类库，发觉还是 hyperrealm libconfig 最强大最好用，相关细节可参考 官方手册。 源中的版本是 1.3.2-1，也可以去官方文章下载最新版本。 $ sudo apt-get install libconfig8 libconfig8-dev 源码安装　: 去　https://hyperrealm.github.io/libconfig/ 下载　 ./config make sudo make install 使用说明 c程序　　头文件libconfig.h c++程序　所需头文件libconfig.h++，编译时需要链接动态库libconfig++
libconfig-开源
07-03
libconfig 是一个可移植且灵活的 C++ 配置文件解析器，它是 KDE KConfig 类的 ISO C++ 端口。 它具有与 KDE 库中的 KConfig 几乎相同的功能。在 Linux 和 Win32（msvc、mingw32 或 Cygwin）下都可以正常工作。
ubuntu18.04+ros版本melodic下可以直接编译使用的C++版本yolo识别功能包
01-10
该功能包可以直接复制到melodic版本下的工作空间下编译使用，添加了识别 数字的权重文件，可以直接进行识别。具体使用教程，可以参考博客： ...
Linux C 开发 配置文件读写库 Libconfig
u011285208的博客
05-17 4180
一：什么是Libconfig？ 程序开发过程中往往很多参数需要放在配置文件中，因为这样可以避免更改代码重新编译的问题。通常我们可以通过自己读init文件来实现，不过已经有很多人做了这方面的东西，可以借用，Libconfig就是其中之一。 Libconfig是一个用于处理结构化配置文件的简单库。 此文件格式比XML更紧凑，更易读，更适合内存受限的设备。 与XML不同，它是类型感知的，因此不必在应...
C/C++ 读取配置（config）文件 开源库（libconfig）
phymat.nico的专栏
08-24 741
https://blog.csdn.net/abcdu1/article/details/86087549
libconfig初识
ych9527的博客
12-14 1432
文章目录一、是什么二、为什么需要三、使用说明3.1功能说明3.2配置文件构成3.2C++版本常见API接口说明 一、是什么 是一个解析配置文件的C/C++库 二、为什么需要 通常业务代码的代码量是非常大的，如果没有配置文件，那么所有的东西都是写死的，在后续的维护过程之中，进行修改就是非常麻烦的一件事 如果有配置文件，我们可以通过读取配置文件来完成某些动作，这样就提高了代码的可迭代和可维护性 libconfig就是提供操控配置文件的一个库。如果我们不适用库来对配置文件进行读取，那么是非常麻烦的一件事。比
libconfig第一篇———使用指南
weixin_30546933的博客
07-31 713
官网：http://www.hyperrealm.com/libconfig/ 1 libconfig是什么？ Libconfig是一个结构化的配置文件库，它可以定义一些配置文件，例如test.cfg . 它比xml可读性更好，而且更简洁。而且不像xml，它是type-aware类型自我感知的，因此不需要做string parsing (分词？). 而ini太弱。 2 ...
ros2源码编译打开日志
05-27
然后，你可以使用`colcon build`命令编译ROS 2源代码，并在终端中查看日志输出。例如： ``` $ colcon build --symlink-install ``` 在编译过程中，你应该会看到类似以下的日志输出： ``` [DEBUG] [colcon] Colcon...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值