Ini 配置文件解析/序列大体实现。

已于 2022-09-06 14:16:31 修改
阅读量230 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ java c#
于 2022-08-26 01:44:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/126535418
版权

Ini.h

frp/Ini.h at main · liulilittle/frp (github.com)

#pragma once

#include <frp/stdafx.h>

namespace frp {
    namespace configuration {
        class Ini final {
        public:
            class Section final {
            public:
                typedef std::map<std::string, std::string>              KeyValueTable;
                typedef KeyValueTable::iterator                         iterator;

            public:
                const std::string                                       Name;

            public:
                Section(const std::string& name) noexcept;

            public:
                std::string&                                            operator[](const std::string& key);

            public:
                iterator                                                begin() noexcept;
                iterator                                                end() noexcept;

            public:
                template<typename TValue>
                TValue                                                  GetValue(const std::string& key) noexcept;
                std::string                                             GetValue(const std::string& key) noexcept;

            public:
                int                                                     Count() noexcept;
                bool                                                    ContainsKey(const std::string& key) noexcept;
                bool                                                    RemoveValue(const std::string& key) noexcept;
                bool                                                    SetValue(const std::string& key, const std::string& value) noexcept;
                int                                                     GetAllKeys(std::vector<std::string>& keys) noexcept;
                int                                                     GetAllPairs(std::vector<std::pair<const std::string&, const std::string&> >& pairs) noexcept;
                std::string                                             ToString() const noexcept;

            private:
                mutable KeyValueTable                                   kv_;
            };
            typedef std::map<std::string, Section>                      SectionTable;
            typedef SectionTable::iterator                              iterator;

        public:
            inline Ini(const void* config) noexcept
                : Ini(config ? std::string((char*)config) : std::string()) {

            }
            inline Ini(const void* config, int length) noexcept
                : Ini(config&& length > 0 ? std::string((char*)config, length) : std::string()) {

            }
            Ini() noexcept;
            Ini(const std::string& config) noexcept;

        public:
            iterator                                                    begin() noexcept;
            iterator                                                    end() noexcept;

        public:
            Section&                                                    operator[](const std::string& section);

        public:
            int                                                         Count() noexcept;
            Section*                                                    Get(const std::string& section) noexcept;
            Section*                                                    Add(const std::string& section) noexcept;
            bool                                                        Remove(const std::string& section) noexcept;
            bool                                                        ContainsKey(const std::string& section) noexcept;
            int                                                         GetAllKeys(std::vector<std::string>& keys) noexcept;
            int                                                         GetAllPairs(std::vector<std::pair<const std::string&, const Section&> >& pairs) noexcept;
            std::string                                                 ToString() const noexcept;

        public:
            static std::shared_ptr<Ini>                                 LoadFile(const std::string& path) noexcept;
            static std::shared_ptr<Ini>                                 LoadFrom(const std::string& config) noexcept;

        private:
            mutable SectionTable                                        sections_;
        };
    }
}

Ini.cpp

frp/Ini.cpp at main · liulilittle/frp (github.com)

#include <frp/configuration/Ini.h>
#include <frp/collections/Dictionary.h>
#include <frp/io/File.h>

using frp::collections::Dictionary;

namespace frp {
    namespace configuration {
        Ini::Ini() noexcept {

        }

        Ini::Ini(const std::string& config) noexcept {
            std::vector<std::string> lines;
            Tokenize<std::string>(ZTrim(config), lines, "\r\n\r\n");

            std::string sectionKey;
            Section* sectionPtr = NULL;

            for (std::size_t i = 0, length = lines.size(); i < length; i++) {
                std::string& line = lines[i];
                if (line.empty()) {
                    continue;
                }

                std::size_t index = line.find('#');
                if (index != std::string::npos) {
                    if (index == 0) {
                        continue;
                    }
                    line = line.substr(0, index);
                }

                // Not founds sections.
                do {
                    std::size_t leftIndex = line.find('[');
                    if (leftIndex == std::string::npos) {
                        break;
                    }

                    std::size_t rightIndex = line.find(']', leftIndex);
                    if (rightIndex == std::string::npos) {
                        break;
                    }

                    int64_t size = (int64_t)rightIndex - (leftIndex + 1);
                    if (size < 1) {
                        break;
                    }

                    bool correct = true;
                    struct {
                        std::size_t l;
                        std::size_t r;
                    } ranges[2] = { { 0, leftIndex}, {rightIndex + 1, line.size()} };
                    for (std::size_t c = 0; c < 2 && correct; c++) {
                        for (std::size_t j = ranges[c].l; j < ranges[c].r; j++) {
                            char ch = line[j];
                            if (ch != ' ' && 
                                ch != '\t' && 
                                ch != '\r' && 
                                ch != '\n' &&
                                ch != '\0') {
                                correct = false;
                                break;
                            }
                        }
                    }

                    if (correct) {
                        sectionKey = RTrim(LTrim(line.substr(leftIndex + 1, size)));
                        if (sectionKey.empty()) {
                            continue;
                        }

                        sectionPtr = Add(sectionKey);
                        if (!sectionPtr) { /* The configuration file format is problematic. */
                            sectionPtr = Get(sectionKey);
                        }
                    }
                } while (0);

                // Read section all key-values.
                if (sectionKey.size()) { 
                    index = line.find('=');
                    if (index == std::string::npos) {
                        index = line.find(':');
                        if (index == std::string::npos) {
                            continue;
                        }
                    }

                    if (index == 0) {
                        continue;
                    }

                    std::string key = RTrim(LTrim(line.substr(0, index)));
                    std::string value = RTrim(LTrim(line.substr(index + 1)));
                    sectionPtr->SetValue(key, value);
                }
            }
        }

        Ini::Section& Ini::operator[](const std::string& section) {
            if (section.empty()) {
                throw std::invalid_argument("section cannot be an empty string.");
            }

            Section* p = Get(section);
            if (p) {
                return *p;
            }

            p = Add(section);
            if (p) {
                return *p;
            }
            throw std::runtime_error("unable to complete adding new section.");
        }

        Ini::Section* Ini::Get(const std::string& section) noexcept {
            if (section.empty()) {
                return NULL;
            }

            Ini::Section* out = NULL;
            Dictionary::TryGetValuePointer(sections_, section, out);
            return out;
        }

        Ini::Section* Ini::Add(const std::string& section) noexcept {
            if (section.empty()) {
                return NULL;
            }

            if (Dictionary::ContainsKey(sections_, section)) {
                return NULL;
            }

            SectionTable::iterator indexer;
            if (!Dictionary::TryAdd(sections_, section, Ini::Section(section), indexer)) {
                return NULL;
            }
            return addressof(indexer->second);
        }

        bool Ini::Remove(const std::string& section) noexcept {
            if (section.empty()) {
                return false;
            }

            return Dictionary::TryRemove(sections_, section);
        }

        bool Ini::ContainsKey(const std::string& section) noexcept {
            return NULL != Get(section);
        }

        int Ini::Count() noexcept {
            return sections_.size();
        }

        int Ini::GetAllKeys(std::vector<std::string>& keys) noexcept {
            return Dictionary::GetAllKeys(sections_, keys);
        }

        int Ini::GetAllPairs(std::vector<std::pair<const std::string&, const Section&> >& pairs) noexcept {
            return Dictionary::GetAllPairs(sections_, pairs);
        }

        std::string Ini::ToString() const noexcept {
            SectionTable::iterator tail = sections_.begin();
            SectionTable::iterator endl = sections_.end();

            std::string config;
            for (; tail != endl; tail++) {
                std::string section = tail->second.ToString();
                if (section.empty()) {
                    continue;
                }

                if (config.empty()) {
                    config.append(section);
                }
                else {
                    config.append("\r\n\r\n" + section);
                }
            }
            return config;
        }

        Ini::iterator Ini::begin() noexcept {
            return sections_.begin();
        }

        Ini::iterator Ini::end() noexcept {
            return sections_.end();
        }

        Ini::Section::Section(const std::string& name) noexcept
            : Name(name) {
            
        }

        std::string& Ini::Section::operator[](const std::string& key) {
            if (key.empty()) {
                throw std::invalid_argument("key cannot be an empty string.");
            }
            return kv_[key];
        }

        bool Ini::Section::RemoveValue(const std::string& key) noexcept {
            if (key.empty()) {
                return false;
            }

            return Dictionary::TryRemove(kv_, key);
        }

        template<>
        std::string Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return value;
        }

        template<>
        int32_t Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return strtol(value.data(), NULL, 10);
        }

        template<>
        uint32_t Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return strtoul(value.data(), NULL, 10);
        }

        template<>
        int64_t Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return strtoll(value.data(), NULL, 10);
        }

        template<>
        uint64_t Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return strtoull(value.data(), NULL, 10);
        }

        template<>
        float Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return strtof(value.data(), NULL);
        }

        template<>
        double Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return strtod(value.data(), NULL);
        }

        template<>
        bool Ini::Section::GetValue(const std::string& key) noexcept {
            std::string value = GetValue(key);
            return ToBoolean(value.data());
        }

        std::string Ini::Section::GetValue(const std::string& key) noexcept {
            if (key.empty()) {
                return std::string();
            }

            std::string value;
            Dictionary::TryGetValue(kv_, key, value);
            return std::move(value);
        }

        int Ini::Section::Count() noexcept {
            return kv_.size();
        }

        bool Ini::Section::ContainsKey(const std::string& key) noexcept {
            if (key.empty()) {
                return false;
            }

            return Dictionary::ContainsKey(kv_, key);
        }

        bool Ini::Section::SetValue(const std::string& key, const std::string& value) noexcept {
            if (key.empty()) {
                return false;
            }

            Section& section = *this;
            section[key] = value;
            return true;
        }

        int Ini::Section::GetAllKeys(std::vector<std::string>& keys) noexcept {
            return Dictionary::GetAllKeys(kv_, keys);
        }

        int Ini::Section::GetAllPairs(std::vector<std::pair<const std::string&, const std::string&> >& pairs) noexcept {
            return Dictionary::GetAllPairs(kv_, pairs);
        }

        std::string Ini::Section::ToString() const noexcept {
            KeyValueTable::iterator tail = kv_.begin();
            KeyValueTable::iterator endl = kv_.end();
            if (tail == endl) {
                return std::string();
            }

            std::string result;
            result.append("[");
            result.append(Name);
            result.append("]\r\n");
            for (; tail != endl; tail++) {
                result.append(tail->first + "=" + tail->second + "\r\n");
            }
            return result.substr(0, result.size() - 2);
        }

        Ini::Section::iterator Ini::Section::begin() noexcept {
            return kv_.begin();
        }

        Ini::Section::iterator Ini::Section::end() noexcept {
            return kv_.end();
        }

        std::shared_ptr<Ini> Ini::LoadFile(const std::string& path) noexcept {
            if (path.empty()) {
                return make_shared_object<Ini>();
            }

            int length = path.size();
            std::shared_ptr<Byte> config = frp::io::File::ReadAllBytes(path.data(), length);

            if (NULL == config || length < 1) {
                return make_shared_object<Ini>();
            }
            return make_shared_object<Ini>((char*)config.get(), length);
        }

        std::shared_ptr<Ini> Ini::LoadFrom(const std::string& config) noexcept {
            if (config.empty()) {
                return make_shared_object<Ini>();
            }
            return make_shared_object<Ini>(config);
        }
    }
}

liulilittle
关注
专栏目录
MySQL配置文件my.ini详解
流楚丶格念的博客
05-24 3万+
文章目录my.ini 是啥玩意？my.ini 在哪放着呢？my.ini的配置内容介绍：客户端的参数服务器断参数：InnoDB存储引擎使用的参数：中文翻译版 my.ini my.ini 是啥玩意？ my.ini是MySQL数据库中使用的配置文件，修改这个文件可以达到更新配置的目的。 my.ini 在哪放着呢？ my.ini存放在MySql安装的根目录，如图所示：（我比较懒，用的WAMP，大家找自己的安装目录即可） my.ini的配置内容介绍： 其实大体可以分为两部分：客户端的参数、服务器参数。其中服务器参数
Android AAPT详解
weixin_39421817的博客
01-20 1508
AAPT是什么 AAPT - Android Asset Packaging Tool，看全称，就可知道AAPT是Android资源打包工具。在讲这个之前，是有必要简单说下Android是如何构建一个APK的。 上图是Google官方发布的一张非常经典的Apk打包流程图。 流程概述： 工程的资源文件(res文件夹下的文件)，通过AAPT打包成R.java类(资源索引表)，...
ini文件解析
11-08
ini配置文件c++代码实现，有实现的demo。简单方便易懂。工程没有建立，需要自己建个工程。
INI文件解析源码及使用简介
weixin_33695450的博客
04-14 192
一：环境配置 1、 下载函数库： 链接：https://pan.baidu.com/s/1ZOpa2og_QQy-MnHNQg7N1w 密码：neez 2、解压文件会得到以下文件，其中dictionary.h、iniparser.h 、dictionary.c 、iniparser.c为对应的库文件，ini_test为测试函数，test.ini为需要解析的配置文件。 3、 该代码已经...
C++解析ini文件
最新发布
长弓的博客
08-04 1312
ini文件其实就是一种配置文件，常见于Windows的系统配置文件，当然也可以是其他用途，你的用法你说了算。
解析配置文件
hry18229249041的博客
07-10 227
我们常见的配置文件： properties josn yaml hocon 当然，我们web开发中使用的web.xml文件也是常使用的配置文件。 在Java中我们想要使用配置文件则需要用代码将文件解析出来。 在Java类中解析配置文件： 注意：该方式只能读取类路径下的配置文件，有局限但是如果配置文件在类路径下比较方便。 1 Properties p = new Properties(); 2 ...
ini文件解析器
qq_57283958的博客
03-01 226
ini文件解析器
SPA项目开发 之 登录注册
what_to的博客
08-10 1802
SPA项目开发之登录注册登录注册的大体流程前端后端 登录注册的大体流程 1. vue怎么引入和配置使用element-ui框架 1.1 使用vue-cli脚手架工具创建一个vue项目 vue init webpack pro01 1.2 npm安装elementUI cd pro01 #进入新建项目的根目录 npm install...
linux常用命令-part3
热门推荐
chinayuan的专栏
05-01 2万+
中文怎么发音 Ubuntu 有奔头，乌版图 Fedora 费德勒，菲朵拉 Debian 迪扁，德槟 CentOS 桑托斯 森头斯       Linux发展历史: 1) RedHat ---> 1.RedHat                2.CentOS                3.Fedora  桌面图形系统        rpm, yum 命令 2)
NC开发笔记——二开知识点
獨立小橋風滿袖
05-06 2万+
用友集团ERP客户化开发系列丛书 NC客户化开发进阶 培训教程 V2.0版 本教程是用友软件股份有限公司内部培训资料，只限于用友公司内部开发应用，任何人未经过事先书面许可不得扩大本教程的使用范围。同样，未经过用友公司书面许可，任何人不得以任何形式对本手册进行增删、改编、节选、翻译、翻印或仿制，违者必究！ ?本手册的著作权属于用友软件股份有限公司 版权所有?翻制必
Ini文件解析类
04-03
简单的Ini文件解析类，支持从文件或者内存读取Ini。
C语言解析ini文件
08-16
C语言 ini文件解析 linux 下测试程序，使用方法直接make即可
ini配置文件解析工具
09-15
ini配置文件解析工具，支持独立单行注释，支持新建域名、新建字段、修改字段，获取字段值等操作。只有一个.H文件和一个.CPP文件，代码不超过200行，接口简单，使用方法直接看源码即可
Iniparser——非常好用的ini文件读写代码
04-19
Iniparser——非常好用的ini文件读写源代码，供大家学习研究
c++: ini 文件解析（依赖库：inifile）
belien
03-15 491
c++： ini 文件解析，推荐三方库 inifile
INI文件解析、遍历
Bdyjy的博客
08-02 8248
工作中时常需要给软件添加配置文件功能，INI文件简单又高效，但是微软的那套API使用太不方便，尤其是INI文件的遍历，所有花了一下午时间造了个轮子，自己解析INI文件。目前只能读取Unicode小端编码，就是用windows记事本另存为时编码选择Unicode。 INI文件中元素分为节名、键和值，比如 [section] key=value键值必须属于某个节，节名必须放在中括号内，键和值中用等
用 Lisp 对 INI 文件解析
yxp 的博客
05-19 2512
当你不想用 DCL 来交互程序的参数设置时，读取 ini 配置文件可以作为一个备用选择，也能方便用户修改。AutoLISP 程序设计时常用的数据存储方式，各有优缺点：
ini配置文件解析
阿Sir问道
05-16 1795
1、前言 配置文件使用方便灵活，可以根据不同需求配置不同数值，并且不改变代码结构。常见配置文件类型有xml、json和ini，今天我们着重介绍ini读取和使用。 2、INI格式介绍 INI文件由节、键、值组成。 节[section] 参数（键=值）name=value 注解使用分号表示（;）。在分号后面的文字，直到该行结尾都全部为注解。 NI文件的格式很简单，最基...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值