整理代码

util/xpack/yaml_encoder.h

@@ -0,0 +1,146 @@
+/*
+* Copyright (C) 2021 Duowan Inc. All rights reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing,
+* software distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef __X_PACK_YAML_ENCODER_H
+#define __X_PACK_YAML_ENCODER_H
+
+#include <string>
+
+#include "yaml-cpp/yaml.h"
+
+#include "xencoder.h"
+
+namespace xpack {
+
+class YamlWriter:private noncopyable {
+    friend class XEncoder<YamlWriter>;
+    friend class YamlEncoder;
+
+    const static bool support_null = true;
+public:
+    YamlWriter(size_t indent = 2, int maxDecimalPlaces = -1) {
+        e.SetIndent(indent);
+        if (maxDecimalPlaces > 0) {
+            e.SetFloatPrecision((size_t)maxDecimalPlaces);
+            e.SetDoublePrecision((size_t)maxDecimalPlaces);
+        }
+    }
+    ~YamlWriter() {
+    }
+private:
+    inline static const char *Name() {
+        return "yaml";
+    }
+    inline const char *IndexKey(size_t index) {
+        (void)index;
+        return NULL;
+    }
+    std::string String() {
+        return std::string(e.c_str(), e.size());
+    }
+
+    void ArrayBegin(const char *key, const Extend *ext) {
+        (void)ext;
+        xpack_set_key(key);
+        e << YAML::Value << YAML::BeginSeq;
+    }
+    void ArrayEnd(const char *key, const Extend *ext) {
+        (void)key;
+        (void)ext;
+        e << YAML::EndSeq;
+    }
+    void ObjectBegin(const char *key, const Extend *ext) {
+        (void)ext;
+        xpack_set_key(key);
+        e << YAML::Value << YAML::BeginMap;
+    }
+    void ObjectEnd(const char *key, const Extend *ext) {
+        (void)key;
+        (void)ext;
+        e << YAML::EndMap;
+    }
+    bool WriteNull(const char*key, const Extend *ext) {
+        (void)ext;
+        xpack_set_key(key);
+        e << YAML::Value << YAML::Null;
+        return true;
+    }
+    bool encode_bool(const char*key, const bool&val, const Extend *ext) {
+        (void)ext;
+        xpack_set_key(key);
+        e << YAML::Value << val;
+        return true; 
+    }
+    bool encode_string(const char*key, const std::string&val, const Extend *ext) {
+        (void)ext;
+        xpack_set_key(key);
+        if (!val.empty()) {
+            e << YAML::Value << val;
+        } else {
+            e << YAML::Value << YAML::Null;
+        }
+        return true; 
+    }
+    template <typename T>
+    typename x_enable_if<numeric<T>::value, bool>::type encode_number(const char*key, const T&val, const Extend *ext) {
+        (void)ext;
+        xpack_set_key(key);
+        e << YAML::Value << val;
+        return true; 
+    }
+
+    void xpack_set_key(const char*key) { // openssl defined set_key macro, so we named it xpack_set_key
+        if (NULL!=key && key[0]!='\0') {
+            e << YAML::Key << key;
+        }
+    }
+
+    YAML::Emitter e;
+};
+
+class YamlEncoder {
+public:
+    YamlEncoder() {
+        indentCount = 2;
+        maxDecimalPlaces = -1;
+    }
+    
+    YamlEncoder& SetIndent(size_t indent) {
+        indentCount = indent;
+        return *this;
+    }
+    YamlEncoder& SetMaxDecimalPlaces(int _maxDecimalPlaces) {
+        maxDecimalPlaces = _maxDecimalPlaces;
+        return *this;
+    }
+
+    template <class T>
+    std::string encode(const T&val) {
+        YamlWriter wr(indentCount, maxDecimalPlaces);
+        XEncoder<YamlWriter> en(wr);
+        en.encode(NULL, val, NULL);
+        return wr.String();
+    }
+
+private:
+    size_t indentCount;
+    int maxDecimalPlaces;
+};
+
+
+}
+
+#endif