TypedMessageBuilder.h

 
#pragma once
 
#include <pulsar/MessageBuilder.h>
 
#include <functional>
 
namespace pulsar {
 
template <typename T>
class TypedMessageBuilder : public MessageBuilder {
   public:
    using Encoder = std::function<std::string(const T&)>;
    using Validator = std::function<void(const char* data, size_t)>;
 
    TypedMessageBuilder(
        Encoder encoder, Validator validator = [](const char*, std::size_t) {})
        : encoder_(encoder), validator_(validator) {}
 
    TypedMessageBuilder& setValue(const T& value) {
        setContent(encoder_(value));
        if (validator_) {
            validator_(data(), size());
        }
        return *this;
    }
 
   private:
    const Encoder encoder_;
    const Validator validator_;
};
 
template <>
class TypedMessageBuilder<std::string> : public MessageBuilder {
   public:
    // The validator should throw an exception to indicate the message is corrupted.
    using Validator = std::function<void(const char* data, size_t)>;
 
    TypedMessageBuilder(Validator validator = nullptr) : validator_(validator) {}
 
    TypedMessageBuilder& setValue(const std::string& value) {
        if (validator_) {
            validator_(value.data(), value.size());
        }
        setContent(value);
        return *this;
    }
 
    TypedMessageBuilder& setValue(std::string&& value) {
        if (validator_) {
            validator_(value.data(), value.size());
        }
        setContent(std::move(value));
        return *this;
    }
 
   private:
    Validator validator_;
};
using BytesMessageBuilder = TypedMessageBuilder<std::string>;
 
}  // namespace pulsar