MapperUtils.h

Go to the documentation of this file.

 
#pragma once
#include "catapult/exceptions.h"
#include "catapult/types.h"
#include <bsoncxx/builder/stream/document.hpp>
#include <mongocxx/client.hpp>
#include <type_traits>
 
namespace catapult {
    namespace model {
        struct EmbeddedTransaction;
        struct Receipt;
        struct VerifiableEntity;
    }
}
 
namespace catapult { namespace mongo { namespace mappers {
 
    namespace bson_stream {
        using bsoncxx::builder::stream::close_array;
        using bsoncxx::builder::stream::close_document;
        using bsoncxx::builder::stream::document;
        using bsoncxx::builder::stream::open_array;
        using bsoncxx::builder::stream::open_document;
        using bsoncxx::builder::stream::finalize;
 
        using array_context = bsoncxx::builder::stream::array_context<bsoncxx::builder::stream::key_context<>>;
    }
 
    // region conversions to db type
 
    bsoncxx::v_noabi::types::b_binary ToBinary(const uint8_t* pData, size_t size);
 
    bsoncxx::v_noabi::types::b_binary ToBinary(const UnresolvedAddress& unresolvedAddress);
 
    template<size_t N, typename TTag>
    auto ToBinary(const utils::ByteArray<N, TTag>& array) {
        return ToBinary(array.data(), array.size());
    }
 
    template<
        typename TBaseValue,
        typename X = std::enable_if_t<std::is_same_v<uint32_t, typename TBaseValue::ValueType>>>
    int32_t ToInt32(TBaseValue value) {
        return static_cast<int32_t>(value.unwrap());
    }
 
    template<
        typename TBaseValue,
        typename X = std::enable_if_t<std::is_same_v<uint64_t, typename TBaseValue::ValueType>>>
    int64_t ToInt64(TBaseValue value) {
        return static_cast<int64_t>(value.unwrap());
    }
 
    // endregion
 
    // region conversions from db type
 
    uint8_t ToUint8(int32_t value);
 
    uint32_t ToUint32(int32_t value);
 
    template<
            typename TBaseValue,
            typename TBsonElement,
            typename X = std::enable_if_t<std::is_same_v<uint64_t, typename TBaseValue::ValueType>>>
    TBaseValue GetValue64(TBsonElement element) {
        return TBaseValue(static_cast<typename TBaseValue::ValueType>(element.get_int64().value));
    }
 
    template<size_t N, typename TTag, typename TMongoContainer>
    void DbBinaryToModelArray(utils::ByteArray<N, TTag>& dest, const TMongoContainer& source) {
        if (dest.size() != source.size)
            CATAPULT_THROW_INVALID_ARGUMENT_1("invalid size of dest array", dest.size());
 
        std::memcpy(dest.data(), source.bytes, dest.size());
    }
 
    // endregion
 
    // region document helpers
 
    uint64_t GetUint64OrDefault(const bsoncxx::document::view& documentView, const char* name, uint64_t defaultValue);
 
    bool IsEmptyDocument(const bsoncxx::document::value& document);
 
    // endregion
 
    // region streaming helpers
 
    bson_stream::document& StreamEmbeddedTransaction(bson_stream::document& builder, const model::EmbeddedTransaction& transaction);
 
    bson_stream::document& StreamVerifiableEntity(bson_stream::document& builder, const model::VerifiableEntity& entity);
 
    bson_stream::array_context& StreamMosaic(bson_stream::array_context& context, MosaicId id, Amount amount);
 
    bson_stream::array_context& StreamMosaic(bson_stream::array_context& context, UnresolvedMosaicId id, Amount amount);
 
    bson_stream::document& StreamReceipt(bson_stream::document& builder, const model::Receipt& receipt);
 
    // endregion
}}}