json_common.hpp

Go to the documentation of this file.

#ifndef IROHA_JSON_COMMON_HPP
#define IROHA_JSON_COMMON_HPP

#include <numeric>
#include <string>
#include <unordered_map>

#include <rapidjson/document.h>
#include <rapidjson/prettywriter.h>
#include <rapidjson/stringbuffer.h>

#include "common/bind.hpp"
#include "common/byteutils.hpp"
#include "common/obj_utils.hpp"
#include "model/block.hpp"
#include "model/common.hpp"
#include "model/queries/get_transactions.hpp"
#include "model/signature.hpp"

namespace iroha {
  namespace model {
    namespace converters {
      template <typename V>
      struct Convert {
        template <typename T>
        auto operator()(T &&x) const {
          return boost::optional<V>(std::forward<T>(x));
        }
      };

      template <size_t size>
      struct Convert<blob_t<size>> {
        template <typename T>
        auto operator()(T &&x) const {
          return hexstringToArray<size>(std::forward<T>(x));
        }
      };

      template <typename T, typename D>
      boost::optional<T> deserializeField(const D &document,
                                          const std::string &field) {
        if (document.HasMember(field.c_str())
            and document[field.c_str()].template Is<T>()) {
          return document[field.c_str()].template Get<T>();
        }
        return boost::none;
      }

      template <typename D>
      struct FieldDeserializer {
        explicit FieldDeserializer(const D &document) : document(document) {}

        template <typename T,
                  typename V,
                  typename B,
                  typename Convert = Convert<V>>
        auto deserialize(V B::*member,
                         const std::string &field,
                         Convert transform = Convert()) {
          return [this, member, field, transform](auto block) {
            return deserializeField<T>(document, field) | transform
                | assignObjectField(block, member);
          };
        }

        template <typename V, typename B>
        auto Uint(V B::*member, const std::string &field) {
          return deserialize<uint32_t>(member, field);
        }

        template <typename V, typename B>
        auto Uint64(V B::*member, const std::string &field) {
          return deserialize<uint64_t>(member, field);
        }

        template <typename V, typename B>
        auto Bool(V B::*member, const std::string &field) {
          return deserialize<bool>(member, field);
        }

        template <typename V, typename B>
        auto String(V B::*member, const std::string &field) {
          return deserialize<std::string>(member, field);
        }

        auto String(const std::string &field) {
          return deserializeField<std::string>(document, field);
        }

        template <typename V, typename B, typename Convert = Convert<V>>
        auto Array(V B::*member,
                   const std::string &field,
                   Convert transform = Convert()) {
          return deserialize<rapidjson::Value::ConstArray>(
              member, field, transform);
        }

        template <typename V, typename B, typename Convert = Convert<V>>
        auto Object(V B::*member,
                    const std::string &field,
                    Convert transform = Convert()) {
          return deserialize<rapidjson::Value::ConstObject>(
              member, field, transform);
        }

        // document for deserialization
        const D &document;
      };

      template <typename D>
      auto makeFieldDeserializer(const D &document) {
        return FieldDeserializer<D>(document);
      }

      template <>
      struct Convert<Signature> {
        template <typename T>
        auto operator()(T &&x) const {
          auto des = makeFieldDeserializer(std::forward<T>(x));
          return boost::make_optional(Signature())
              | des.String(&Signature::pubkey, "pubkey")
              | des.String(&Signature::signature, "signature");
        }
      };

      template <>
      struct Convert<Block::SignaturesType> {
        template <typename T>
        auto operator()(T &&x) const {
          auto acc_signatures = [](auto init, auto &x) {
            return init | [&x](auto signatures) {
              return Convert<Signature>()(x) | [&signatures](auto signature) {
                signatures.push_back(signature);
                return boost::make_optional(std::move(signatures));
              };
            };
          };
          return std::accumulate(x.begin(),
                                 x.end(),
                                 boost::make_optional(Block::SignaturesType()),
                                 acc_signatures);
        }
      };

      template <>
      struct Convert<GetTransactions::TxHashCollectionType> {
        template <typename T>
        auto operator()(T &&x) const {
          auto acc_hashes = [](auto init, auto &x) {
            return init | [&x](auto tx_hashes)
                       -> boost::optional<
                           GetTransactions::TxHashCollectionType> {
              // If invalid type included, returns nullopt
              if (not x.IsString()) {
                return boost::none;
              }
              auto tx_hash_opt =
                  Convert<GetTransactions::TxHashType>()(x.GetString());
              if (not tx_hash_opt) {
                // If the the hash is wrong, just skip.
                return boost::make_optional(std::move(tx_hashes));
              }
              return tx_hash_opt | [&tx_hashes](auto tx_hash) {
                tx_hashes.push_back(tx_hash);
                return boost::make_optional(std::move(tx_hashes));
              };
            };
          };
          return std::accumulate(
              x.begin(),
              x.end(),
              boost::make_optional(GetTransactions::TxHashCollectionType()),
              acc_hashes);
        }
      };

      rapidjson::Value serializeSignature(
          const Signature &signature,
          rapidjson::Document::AllocatorType &allocator);

      boost::optional<rapidjson::Document> stringToJson(
          const std::string &string);

      std::string jsonToString(const rapidjson::Document &document);
    }  // namespace converters
  }    // namespace model
}  // namespace iroha

#endif  // IROHA_JSON_COMMON_HPP