Serializers.h

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <iosfwd>
#include <string>
#include <type_traits>
#include <vector>
 
 
namespace pcpp
{
    struct FieldDescriptor
    {
        const uint16_t id;
 
        const std::string name;
 
        std::vector<FieldDescriptor> (*const getChildren)();
 
        FieldDescriptor(uint16_t fieldId, std::string fieldName,
                        std::vector<FieldDescriptor> (*fieldChildren)() = nullptr)
            : id(fieldId), name(std::move(fieldName)), getChildren(fieldChildren)
        {}
 
        bool hasChildren() const
        {
            return getChildren != nullptr;
        }
    };
 
    template <typename Derived> struct ObjectFieldDescriptor : FieldDescriptor
    {
        ObjectFieldDescriptor(uint16_t fieldId, std::string fieldName)
            : FieldDescriptor(fieldId, std::move(fieldName), &Derived::all)
        {}
    };
 
    class ScopeBase;
    class ArrayScope;
    class ObjectScope;
 
    namespace internal
    {
        template <typename T>
        using EnableIfSignedIntegral =
            std::enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value && !std::is_same<T, bool>::value,
                             int>;
 
        template <typename T>
        using EnableIfUnsignedIntegral =
            std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value && !std::is_same<T, bool>::value,
                             int>;
    }  // namespace internal
 
    class ISerializer
    {
        friend class ScopeBase;
        friend class ArrayScope;
        friend class ObjectScope;
 
    public:
        virtual ~ISerializer() = default;
 
        ArrayScope writeArray(const FieldDescriptor& field);
 
        ObjectScope writeObject(const FieldDescriptor& field);
 
    protected:
        // --- Scalar field writes (canonical virtuals) ---
        virtual void writeField(const FieldDescriptor& field, const std::string& value) = 0;
        virtual void writeField(const FieldDescriptor& field, int64_t value) = 0;
        virtual void writeField(const FieldDescriptor& field, uint64_t value) = 0;
        virtual void writeField(const FieldDescriptor& field, double value) = 0;
        virtual void writeField(const FieldDescriptor& field, bool value) = 0;
        virtual void writeNullField(const FieldDescriptor& field) = 0;
 
        virtual void writeField(const FieldDescriptor& field, const char* value)
        {
            writeField(field, std::string(value));
        }
 
        template <typename T, internal::EnableIfSignedIntegral<T> = 0>
        void writeField(const FieldDescriptor& field, T value)
        {
            writeField(field, static_cast<int64_t>(value));
        }
 
        template <typename T, internal::EnableIfUnsignedIntegral<T> = 0>
        void writeField(const FieldDescriptor& field, T value)
        {
            writeField(field, static_cast<uint64_t>(value));
        }
 
        virtual void writeHexField(const FieldDescriptor& field, uint64_t value) = 0;
 
        template <typename T, std::enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, int> = 0>
        void writeHexField(const FieldDescriptor& field, T value)
        {
            writeHexField(field, static_cast<uint64_t>(value));
        }
 
        virtual void startObject(const FieldDescriptor& field) = 0;
        virtual void endObject() = 0;
        virtual void startArray(const FieldDescriptor& field) = 0;
        virtual void endArray() = 0;
 
        void enforceOneRoot();
 
        bool m_ShouldEnforceOneRoot = true;
 
    private:
        bool m_RootWritten = false;
    };
 
    class ScopeBase : public ISerializer
    {
    public:
        using ISerializer::writeField;
 
        void writeField(const FieldDescriptor& field, const std::string& value) override;
 
        void writeField(const FieldDescriptor& field, int64_t value) override;
 
        void writeField(const FieldDescriptor& field, uint64_t value) override;
 
        void writeField(const FieldDescriptor& field, double value) override;
 
        void writeField(const FieldDescriptor& field, bool value) override;
 
        void writeNullField(const FieldDescriptor& field) override;
 
        void writeHexField(const FieldDescriptor& field, uint64_t value) override;
 
        template <typename T, internal::EnableIfSignedIntegral<T> = 0>
        void writeField(const FieldDescriptor& field, T value)
        {
            writeField(field, static_cast<int64_t>(value));
        }
 
        template <typename T, internal::EnableIfUnsignedIntegral<T> = 0>
        void writeField(const FieldDescriptor& field, T value)
        {
            writeField(field, static_cast<uint64_t>(value));
        }
 
    protected:
        void startObject(const FieldDescriptor& field) override;
        void endObject() override;
        void startArray(const FieldDescriptor& field) override;
        void endArray() override;
 
        explicit ScopeBase(ISerializer* serializer) : m_Serializer(serializer)
        {
            m_ShouldEnforceOneRoot = false;
        }
 
        ISerializer* m_Serializer;
    };
 
    class ArrayScope : public ScopeBase
    {
    public:
        using ScopeBase::writeField;
 
        ArrayScope(ISerializer* serializer, const FieldDescriptor& field);
 
        ~ArrayScope() override;
    };
 
    class ObjectScope : public ScopeBase
    {
    public:
        using ScopeBase::writeField;
 
        ObjectScope(ISerializer* serializer, const FieldDescriptor& field);
 
        ~ObjectScope() override;
    };
 
    class JsonSerializer : public ISerializer
    {
    public:
        using ISerializer::writeField;
        using ISerializer::writeHexField;
 
        explicit JsonSerializer(std::ostream& out);
 
    protected:
        void writeField(const FieldDescriptor& field, const std::string& value) override;
        void writeField(const FieldDescriptor& field, int64_t value) override;
        void writeField(const FieldDescriptor& field, uint64_t value) override;
        void writeField(const FieldDescriptor& field, double value) override;
        void writeField(const FieldDescriptor& field, bool value) override;
        void writeNullField(const FieldDescriptor& field) override;
        void writeHexField(const FieldDescriptor& field, uint64_t value) override;
        void startObject(const FieldDescriptor& field) override;
        void endObject() override;
        void startArray(const FieldDescriptor& field) override;
        void endArray() override;
 
    private:
        enum class Context
        {
            Array,
            Object
        };
 
        void writeSeparatorIfNeeded();
        void writeKey(const std::string& name);
 
        std::ostream& m_Out;
        std::vector<Context> m_ContextStack;
        std::vector<bool> m_FirstAtLevel;
    };
}  // namespace pcpp