kc3-lang/angle/src/libANGLE/serializer/JsonSerializer.h

• Show log

  Commit

• Hash : eb8ffe2f
  Author :
  Date : 2021-09-07T09:53:22
  

  JsonSerializer: Allow adding values to root node.
  
  Previously we would only allow a single group at the root document
  node. This change allows us to have multiple members. It also changes
  the API slightly. Instead of calling startDocument, you now can add
  values and groups on an empty serializer object. It also removes the
  implicit endGroup call in endDocument. Groups must now be manually
  ended.
  
  Bug: angleproject:5133
  Change-Id: Id39016233d73270d1e20d99d59c1729fbcdd8860
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3144213
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Tim Van Patten <timvp@google.com>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  

Download

• src/libANGLE/serializer/JsonSerializer.h

• //
  // Copyright 2021 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // JsonSerializer.h: Implementation of a JSON based serializer
  //
  
  #ifndef LIBANGLE_JSONSERIALIZER_H_
  #define LIBANGLE_JSONSERIALIZER_H_
  
  #include "common/angleutils.h"
  
  #if !defined(ANGLE_HAS_RAPIDJSON)
  #    error RapidJSON must be available to build this file.
  #endif  // !defined(ANGLE_HAS_RAPIDJSON)
  
  #include <rapidjson/document.h>
  
  #include <map>
  #include <memory>
  #include <sstream>
  #include <stack>
  #include <type_traits>
  
  namespace angle
  {
  
  // Rapidjson has problems picking the right AddMember template for long
  // integer types, so let's just make these values use 64 bit variants
  template <typename T>
  struct StoreAs
  {
      using Type = T;
  };
  
  template <>
  struct StoreAs<unsigned long>
  {
      using Type = uint64_t;
  };
  
  template <>
  struct StoreAs<signed long>
  {
      using Type = int64_t;
  };
  
  class JsonSerializer : public angle::NonCopyable
  {
    public:
      JsonSerializer();
      ~JsonSerializer();
  
      void addCString(const std::string &name, const char *value);
  
      void addString(const std::string &name, const std::string &value);
  
      void addBlob(const std::string &name, const uint8_t *value, size_t length);
  
      void startGroup(const std::string &name);
  
      void endGroup();
  
      template <typename T>
      void addScalar(const std::string &name, T value)
      {
          typename StoreAs<T>::Type v = value;
          addValue(name, rapidjson::Value(v));
      }
  
      template <typename T>
      void addVector(const std::string &name, const std::vector<T> &value)
      {
          rapidjson::Value arr(rapidjson::kArrayType);
          arr.SetArray();
  
          for (typename StoreAs<T>::Type v : value)
          {
              arr.PushBack(v, mAllocator);
          }
  
          addValue(name, std::move(arr));
      }
  
      template <typename T>
      void addVectorAsHash(const std::string &name, const std::vector<T> &value)
      {
          if (!value.empty())
          {
              addBlob(name, reinterpret_cast<const uint8_t *>(&value[0]), value.size() * sizeof(T));
          }
          else
          {
              addCString(name, "null");
          }
      }
  
      void addVectorOfStrings(const std::string &name, const std::vector<std::string> &value);
  
      void addBool(const std::string &name, bool value);
  
      const char *data();
  
      std::vector<uint8_t> getData();
  
      size_t length();
  
    private:
      using SortedValueGroup = std::multimap<std::string, rapidjson::Value>;
  
      rapidjson::Value makeValueGroup(SortedValueGroup &group);
      void addValue(const std::string &name, rapidjson::Value &&value);
  
      void ensureEndDocument();
  
      using ValuePointer = std::unique_ptr<rapidjson::Value>;
  
      rapidjson::Document mDoc;
      rapidjson::Document::AllocatorType &mAllocator;
      std::stack<std::string> mGroupNameStack;
      std::stack<SortedValueGroup> mGroupValueStack;
      std::string mResult;
  };
  
  }  // namespace angle
  
  #endif  // JSONSERIALIZER_H
  

Download