codec.h

Go to the documentation of this file.

 
#ifndef DDL_CODEC_CLASS_HEADER
#define DDL_CODEC_CLASS_HEADER
 
#include <a_util/result.h>
#include <ddl/codec/static_codec.h>
 
namespace ddl {
namespace codec {
 
class Codec;
class StructAccess;

class Decoder : public StaticDecoder {
public:
    Decoder();

    Decoder(Decoder&&);

    Decoder& operator=(Decoder&&);

    Decoder(const Decoder&) = delete;

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

    a_util::result::Result isValid() const override;
    typedef DecoderElement<DecoderElementAccess<const Decoder>> Element;
    Element getElement(const CodecIndex& codec_index) const;
    Element getElement(std::string_view full_path) const;

    Element getChildElement(const CodecIndex& parent_codec_index,
                            std::string_view relative_path) const;
    typedef ChildElements<DecoderElementAccess<const Decoder>> Elements;
    const Elements& getElements() const;
    size_t getBufferSize() const;
    size_t getBufferSize(DataRepresentation representation) const;
    Codec makeCodecFor(void* data, size_t data_size, DataRepresentation representation) const;
 
protected:
    friend class CodecFactory;
    Decoder(std::shared_ptr<const StructAccess> codec_access,
            const void* data,
            size_t data_size,
            DataRepresentation representation);
    Decoder(const Decoder& decoder,
            const void* data,
            size_t data_size,
            DataRepresentation representation);
    friend class FactoryElementAccess<const Decoder>;
 
private:
    Element _first_element;
};

class Codec : public Decoder {
public:
    Codec();
    Codec(Codec&&);
    Codec& operator=(Codec&&);
    Codec(const Codec&) = delete;
    Codec& operator=(const Codec&) = delete;
 
    using Decoder::getElement;
    using Decoder::getElementAddress;
    using Decoder::getElements;
    typedef CodecElement<CodecElementAccess<Codec>> Element;
    Element getElement(const CodecIndex& codec_index);
    Element getElement(std::string_view full_path);
    Element getChildElement(const CodecIndex& parent_codec_index, std::string_view relative_path);
    typedef ChildElements<CodecElementAccess<Codec>> Elements;
    Elements& getElements();
    template <typename T>
    void setElementValue(const CodecIndex& codec_index, const T& value)
    {
        ValueSetterSelect<Codec, T>::setValue(*this, codec_index, value);
    }

    template <typename T>
    void setElementValue(const LeafCodecIndex& leaf_codec_index, const T& value)
    {
        LeafValueSetter<T>::setValue(getData(), getDataSize(), leaf_codec_index.getLayout(), value);
    }

    void setElementVariantValue(const CodecIndex& codec_index,
                                const a_util::variant::Variant& value);
    void setElementStringValue(const CodecIndex& codec_index, const std::string& value);
    void setElementRawValue(const CodecIndex& codec_index, const void* value, size_t value_size);
    void* getElementAddress(const CodecIndex& codec_index);
    void resetValues(bool zero_values = false);
 
    using Decoder::getData;
    void* getData() noexcept;
 
protected:
    friend class CodecFactory;
    friend class Decoder;
    Codec(std::shared_ptr<const StructAccess> codec_access,
          void* data,
          size_t data_size,
          ddl::DataRepresentation rep);
    Codec(const Decoder& decoder,
          void* data,
          size_t data_size,
          ddl::DataRepresentation representation);
 
private:
    Element _first_element;
};
 
} // namespace codec
} // namespace ddl
 
#include <ddl/codec/legacy/codec_legacy.h>
 
#endif // DDL_CODEC_CLASS_HEADER