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;
    };
 
    class YamlSerializer : public ISerializer
    {
    public:
        using ISerializer::writeField;
        using ISerializer::writeHexField;
 
        explicit YamlSerializer(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
        {
            EmptyArray,
            Array,
            Object
        };
 
        void writeIndent();
        void writeNewlineIfNeeded();
        // Called by startObject()/startArray(), BEFORE pushing the new
        // context: writes the line introducing the container (a bare "-"
        // for an array element, "name:" for an object member, or nothing
        // at the document root) — content follows on subsequent, more
        // deeply indented lines.
        void writeContainerHeader(const std::string& name);
        // Called by writeField()/writeNullField()/writeHexField(): writes
        // everything on the current line up to (not including) the value
        // itself — "- " inside an array, "name: " inside an object or at
        // the root. Caller writes the actual value immediately after.
        void writeFieldPrefix(const std::string& name);
 
        bool isArrayContext() const;
 
        std::ostream& m_Out;
        std::vector<Context> m_ContextStack;
        bool m_WriteNewLine = false;
        bool m_WriteIdent = true;
    };
 
    class XmlSerializer : public ISerializer
    {
    public:
        using ISerializer::writeField;
        using ISerializer::writeHexField;
 
        explicit XmlSerializer(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:
        struct Context
        {
            std::string name;  // Element name
            bool isArray;      // True if this is an array container
        };
 
        // Core writing methods
        void writeOpenTag(const std::string& name);
        void writeCloseTag(const std::string& name);
        void writeValueElement(const std::string& name, const std::string& value, bool isNull = false);
        void writeIndent();
 
        // XML escaping (handles &, <, >, ", ')
        static std::string escapeXML(const std::string& s);
 
        // Checks if a string is safe to use as an XML name
        static bool isValidXMLName(const std::string& name);
 
        // Returns `name` if it's a valid XML element name, otherwise
        // `fallback`. Centralizes the isValidXMLName()-check-plus-fallback
        // pattern that every writeField()/startObject()/startArray()
        // overload below needs.
        static std::string resolveElementName(const std::string& name, const char* fallback);
 
        // State
        std::ostream& m_Out;
        std::vector<Context> m_ContextStack;
 
        // Optimization: pre-allocate indentation strings
        mutable std::vector<std::string> m_IndentCache;
    };
}  // namespace pcpp