Add a new library ini_config that only works with ini format (#20810)

Author: pnv1

ydb/public/lib/ydb_cli/common/aws.cpp

@@ -15,7 +15,7 @@ const TString TCommandWithAwsCredentials::AwsCredentialsFile = "~/.aws/credentia
 const TString TCommandWithAwsCredentials::AwsDefaultProfileName = "default";
 
 TString TCommandWithAwsCredentials::ReadIniKey(const TString& iniKey) {
-    using namespace NConfig;
+    using namespace NIniConfig;
 
     const auto fileName = "AWS Credentials";
     const auto& profileName = AwsProfile.GetOrElse(AwsDefaultProfileName);

ydb/public/lib/ydb_cli/common/aws.h

@@ -1,8 +1,7 @@
 #pragma once
 
 #include "command.h"
-
-#include <library/cpp/config/config.h>
+#include "ini_config/config.h"
 
 #include <util/generic/maybe.h>
 #include <util/system/env.h>
@@ -60,7 +59,7 @@ class TCommandWithAwsCredentials {
     static const TString AwsDefaultProfileName;
 
 private:
-    TMaybe<NConfig::TConfig> Config;
+    TMaybe<NIniConfig::TConfig> Config;
     TMaybe<TString> AwsProfile;
 };
 

ydb/public/lib/ydb_cli/common/ini_config/config.cpp

@@ -0,0 +1,66 @@
+#include "config.h"
+#include "ini.h"
+
+#include <util/stream/mem.h>
+
+namespace NIniConfig {
+
+TConfig TConfig::ReadIni(TStringBuf in) {
+    TMemoryInput mi(in.data(), in.size());
+
+    return ParseIni(mi);
+}
+
+bool TConfig::Has(const TStringBuf& key) const {
+    return !operator[](key).IsNull();
+}
+
+const TConfig& TConfig::operator[](const TStringBuf& key) const {
+    return Get<TDict>().Find(key);
+}
+
+const TConfig& TConfig::At(const TStringBuf& key) const {
+    return Get<TDict>().At(key);
+}
+
+const TConfig& TConfig::operator[](size_t index) const {
+    return Get<TArray>().Index(index);
+}
+
+size_t TConfig::GetArraySize() const {
+    return Get<TArray>().size();
+}
+
+const TConfig& TDict::Find(const TStringBuf& key) const {
+    const_iterator it = find(key);
+
+    if (it == end()) {
+        return Default<TConfig>();
+    }
+
+    return it->second;
+}
+
+const TConfig& TDict::At(const TStringBuf& key) const {
+    const_iterator it = find(key);
+
+    Y_ENSURE_BT(it != end(), "missing key '" << key << "'");
+
+    return it->second;
+}
+
+const TConfig& TArray::Index(size_t index) const {
+    if (index < size()) {
+        return (*this)[index];
+    }
+
+    return Default<TConfig>();
+}
+
+const TConfig& TArray::At(size_t index) const {
+    Y_ENSURE_BT(index < size(), "index " << index << " is out of bounds");
+
+    return (*this)[index];
+}
+
+}

ydb/public/lib/ydb_cli/common/ini_config/config.h

@@ -0,0 +1,114 @@
+#pragma once
+
+#include "value.h"
+
+#include <util/generic/hash.h>
+#include <util/generic/ptr.h>
+#include <util/generic/deque.h>
+#include <util/generic/string.h>
+#include <util/generic/vector.h>
+#include <util/generic/yexception.h>
+#include <util/stream/input.h>
+
+namespace NIniConfig {
+    class TConfigError: public TWithBackTrace<yexception> {
+    };
+
+    class TConfigParseError: public TConfigError {
+    };
+
+    class TTypeMismatch: public TConfigError {
+    };
+
+    struct TArray;
+    struct TDict;
+
+    class TConfig {
+    public:
+        inline TConfig()
+            : V_(Null())
+        {
+        }
+
+        inline TConfig(IValue* v)
+            : V_(v)
+        {
+        }
+
+        TConfig(const TConfig& config) = default;
+        TConfig& operator=(const TConfig& config) = default;
+
+        template <class T>
+        inline bool IsA() const {
+            return V_->IsA(typeid(T));
+        }
+
+        inline bool IsNumeric() const {
+            return IsA<double>() || IsA<i64>() || IsA<ui64>();
+        }
+
+        template <class T>
+        inline const T& Get() const {
+            return GetNonConstant<T>();
+        }
+
+        template <class T>
+        inline T& GetNonConstant() const {
+            if (this->IsA<T>()) {
+                return *(T*)V_->Ptr();
+            }
+
+            if constexpr (std::is_same_v<T, ::NIniConfig::TArray>) {
+                NCfgPrivate::ReportTypeMismatch(V_->TypeName(), "array");
+            } else if constexpr (std::is_same_v<T, ::NIniConfig::TDict>) {
+                NCfgPrivate::ReportTypeMismatch(V_->TypeName(), "dict");
+            } else if constexpr (std::is_same_v<T, TString>) {
+                NCfgPrivate::ReportTypeMismatch(V_->TypeName(), "string");
+            } else {
+                NCfgPrivate::ReportTypeMismatch(V_->TypeName(), ::TypeName<T>());
+            }
+        }
+
+        template <class T>
+        inline T As() const {
+            return ValueAs<T>(V_.Get());
+        }
+
+        template <class T>
+        inline T As(T def) const {
+            return IsNull() ? def : As<T>();
+        }
+
+        inline bool IsNull() const noexcept {
+            return V_.Get() == Null();
+        }
+
+        const TConfig& Or(const TConfig& r) const {
+            return IsNull() ? r : *this;
+        }
+
+        //assume value is dict
+        bool Has(const TStringBuf& key) const;
+        const TConfig& operator[](const TStringBuf& key) const;
+        const TConfig& At(const TStringBuf& key) const;
+
+        //assume value is array
+        const TConfig& operator[](size_t index) const;
+        size_t GetArraySize() const;
+
+        static TConfig ReadIni(TStringBuf content);
+
+    private:
+        TIntrusivePtr<IValue> V_;
+    };
+
+    struct TArray: public TDeque<TConfig> {
+        const TConfig& Index(size_t index) const;
+        const TConfig& At(size_t index) const;
+    };
+
+    struct TDict: public THashMap<TString, TConfig> {
+        const TConfig& Find(const TStringBuf& key) const;
+        const TConfig& At(const TStringBuf& key) const;
+    };
+}