serialize.h

/*
 * Copyright (C) 2018 Microchip Technology Inc.  All rights reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef EGT_SERIALIZE_H
#define EGT_SERIALIZE_H
 
#include <egt/detail/meta.h>
#include <egt/widgetflags.h>
#include <list>
#include <memory>
#include <ostream>
#include <string>
#include <utility>
 
namespace egt
{
inline namespace v1
{
class Widget;
class Image;
class Pattern;
 
class EGT_API Serializer
{
public:
    using Context = void;
 
    Serializer() noexcept = default;
    Serializer(const Serializer&) = default;
    Serializer& operator=(const Serializer&) = default;
    Serializer(Serializer&&) noexcept = default;
    Serializer& operator=(Serializer&&) noexcept = default;
 
    using Attributes = std::list<std::pair<std::string, std::string>>;
 
    using Properties = std::list<std::tuple<std::string, std::string, Serializer::Attributes>>;
 
    virtual bool add(const Widget* widget) = 0;
 
    virtual Context* begin_child(const std::string& nodename) = 0;
 
    virtual void end_child(Context* context) = 0;
 
    virtual void add_property(const std::string& name, const std::string& value,
                              const Attributes& attrs = {}) = 0;
    void add_property(const std::string& name, const char* value,
                      const Attributes& attrs = {})
    {
        add_property(name, std::string(value), attrs);
    }
 
    void add_property(const std::string& name, int value,
                      const Attributes& attrs = {});
    void add_property(const std::string& name, unsigned int value,
                      const Attributes& attrs = {});
    void add_property(const std::string& name, const AlignFlags& value,
                      const Attributes& attrs = {});
    void add_property(const std::string& name, float value,
                      const Attributes& attrs = {});
    void add_property(const std::string& name, double value,
                      const Attributes& attrs = {});
    virtual void add_property(const std::string& name, const Pattern& value,
                              const Attributes& attrs = {}) = 0;
 
    void add_property(const std::string& name, bool value,
                      const Attributes& attrs = {});
 
    virtual void write(std::ostream& out) = 0;
 
    virtual ~Serializer() noexcept = default;
};
 
class EGT_API OstreamWidgetSerializer : public Serializer
{
public:
    OstreamWidgetSerializer();
    OstreamWidgetSerializer(const OstreamWidgetSerializer&) = delete;
    OstreamWidgetSerializer& operator=(const OstreamWidgetSerializer&) = delete;
    OstreamWidgetSerializer(OstreamWidgetSerializer&&) noexcept = default;
    OstreamWidgetSerializer& operator=(OstreamWidgetSerializer&&) noexcept = default;
 
    void reset();
 
    bool add(const Widget* widget) override;
 
    Context* begin_child(const std::string& nodename) override;
 
    void end_child(Context* context) override;
 
    using Serializer::add_property;
 
    void add_property(const std::string& name, const std::string& value,
                      const Attributes& attrs = {}) override;
 
    void add_property(const std::string& name, const Pattern& value,
                      const Attributes& attrs = {}) override;
 
    void write(std::ostream& out) override;
 
    ~OstreamWidgetSerializer() noexcept override;
 
private:
 
    struct OstreamSerializerImpl;
    std::unique_ptr<OstreamSerializerImpl> m_impl;
};
 
class EGT_API XmlWidgetSerializer : public Serializer
{
public:
    XmlWidgetSerializer();
    XmlWidgetSerializer(const XmlWidgetSerializer&) = delete;
    XmlWidgetSerializer& operator=(const XmlWidgetSerializer&) = delete;
    XmlWidgetSerializer(XmlWidgetSerializer&&) noexcept = default;
    XmlWidgetSerializer& operator=(XmlWidgetSerializer&&) noexcept = default;
 
    void reset();
 
    bool add(const Widget* widget) override;
 
    Context* begin_child(const std::string& nodename) override;
 
    void end_child(Context* context) override;
 
    using Serializer::add_property;
 
    void add_property(const std::string& name, const std::string& value,
                      const Attributes& attrs = {}) override;
 
    void add_property(const std::string& name, const Pattern& value,
                      const Attributes& attrs = {}) override;
 
    void write(const std::string& filename);
 
    void write(std::ostream& out) override;
 
    ~XmlWidgetSerializer() noexcept override;
 
private:
 
    struct XmlSerializerImpl;
    std::unique_ptr<XmlSerializerImpl> m_impl;
};
 
class EGT_API Deserializer
{
public:
    virtual ~Deserializer() {}
    virtual bool is_valid() const = 0;
    virtual std::unique_ptr<Deserializer> first_child(const std::string& name = "") const = 0;
    virtual std::unique_ptr<Deserializer> next_sibling(const std::string& name = "") const = 0;
    virtual std::shared_ptr<Widget> parse_widget() const = 0;
    virtual bool get_property(const std::string& name, std::string* value, Serializer::Attributes* attrs = nullptr) const = 0;
};
 
}
}
 
#endif