static_codec_legacy.h

Go to the documentation of this file.

 
#ifndef DDL_STATIC_CODEC_LEGACY_CLASS_HEADER
#define DDL_STATIC_CODEC_LEGACY_CLASS_HEADER
 
#include <a_util/preprocessor/deprecated.h> // DEV_ESSENTIAL_DEPRECATED()
#include <ddl/codec/static_codec.h>

#define DEV_ESSENTIAL_DEPRECATED_STATIC_DECODER                                                    \
    DEV_ESSENTIAL_DEPRECATED("Use the new ddl::codec::StaticDecoder() instead.")
 
#define DEV_ESSENTIAL_DEPRECATED_STATIC_CODEC                                                      \
    DEV_ESSENTIAL_DEPRECATED("Use the new ddl::codec::StaticCodec() instead.")
 
namespace ddl {
 
// forward declaration for legacy codec access
struct LegacyCodecAccess;
class StructLayout;

class StaticDecoder {
public:
    ~StaticDecoder() = default;
    DEV_ESSENTIAL_DEPRECATED_STATIC_DECODER
    StaticDecoder();
    StaticDecoder(const StaticDecoder&) = delete;

    StaticDecoder& operator=(const StaticDecoder&) = delete;

    StaticDecoder(StaticDecoder&&) = default;

    DEV_ESSENTIAL_DEPRECATED_STATIC_DECODER
    StaticDecoder& operator=(StaticDecoder&&) = default;

    virtual a_util::result::Result isValid() const;

    virtual size_t getElementCount() const;

    a_util::result::Result getElement(size_t index, const StructElement*& element) const;

    a_util::result::Result getElementValue(size_t index, void* value) const;

    a_util::result::Result getElementValue(size_t index, a_util::variant::Variant& value) const;

    const void* getElementAddress(size_t index) const;

    size_t getStaticBufferSize(DataRepresentation rep = deserialized) const;

    DataRepresentation getRepresentation() const;
 
protected:
    friend class CodecFactory;
    StaticDecoder(std::shared_ptr<const StructLayout> layout,
                  const void* data,
                  size_t data_size,
                  DataRepresentation rep);

    StaticDecoder(const std::shared_ptr<LegacyCodecAccess>& legacy_codec_access);
 
protected:
    std::shared_ptr<LegacyCodecAccess> _legacy_access;
    const void* _compat_data;
    size_t _compat_data_size;
    const void* _compat_element_accessor;
};

class StaticCodec : public StaticDecoder {
public:
    DEV_ESSENTIAL_DEPRECATED_STATIC_CODEC
    StaticCodec();
    StaticCodec(const StaticCodec&) = delete;

    StaticCodec& operator=(const StaticCodec&) = delete;

    StaticCodec(StaticCodec&&) = default;

    DEV_ESSENTIAL_DEPRECATED_STATIC_CODEC
    StaticCodec& operator=(StaticCodec&&) = default;

    a_util::result::Result setElementValue(size_t index, const void* value);

    a_util::result::Result setElementValue(size_t index, const a_util::variant::Variant& value);

    void* getElementAddress(size_t index);
    using StaticDecoder::getElementAddress;

    a_util::result::Result setConstants();
 
protected:
    friend class CodecFactory;
    StaticCodec(std::shared_ptr<const StructLayout> layout,
                void* data,
                size_t data_size,
                DataRepresentation rep);
};
 
} // namespace ddl
 
#endif // DDL_STATIC_CODEC_LEGACY_CLASS_HEADER