static_codec.h

Go to the documentation of this file.

 
#ifndef DDL_STATIC_CODEC_CLASS_HEADER
#define DDL_STATIC_CODEC_CLASS_HEADER
 
#include <a_util/memory.h>
#include <a_util/result.h>
#include <ddl/codec/codec_index.h>
#include <ddl/codec/codec_iterator.h>
#include <ddl/codec/data_representation.h>
#include <ddl/codec/legacy/access_element_legacy.h>
#include <ddl/codec/value_access.h>
 
#include <functional>
namespace ddl {
namespace codec {
 
// forward declarations
class ElementAccessor;
class StructAccess;
class CodecFactory;

class StaticDecoder {
public:
    ~StaticDecoder() = default;
    StaticDecoder();
    StaticDecoder(const StaticDecoder&) = delete;
    StaticDecoder& operator=(const StaticDecoder&) = delete;
    StaticDecoder(StaticDecoder&&);
    StaticDecoder& operator=(StaticDecoder&&);
    virtual a_util::result::Result isValid() const;
    typedef DecoderElement<DecoderElementAccess<const StaticDecoder>> 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 StaticDecoder>> Elements;
    const Elements& getElements() const;
    size_t getElementChildCount(const CodecIndex& codec_index = CodecIndex()) const;
    std::string getElementFullName(const CodecIndex& codec_index) const;
    std::string getElementName(const CodecIndex& codec_index) const;
    const std::string& getElementBaseName(const CodecIndex& codec_index) const;
    template <typename T>
    T getElementValue(const CodecIndex& codec_index) const
    {
        return ValueGetterSelect<StaticDecoder, T>::getValue(*this, codec_index);
    }

    template <typename T>
    T getElementValue(const LeafCodecIndex& leaf_codec_index) const
    {
        return LeafValueGetter<T>::getValue(getData(), getDataSize(), leaf_codec_index.getLayout());
    }

    a_util::variant::Variant getElementVariantValue(const CodecIndex& codec_index) const;
    void getElementVariantValue(const CodecIndex& codec_index,
                                a_util::variant::Variant& value) const;
    std::string getElementStringValue(const CodecIndex& codec_index) const;
    void getElementRawValue(const CodecIndex& index, void* value, size_t value_size) const;
    const void* getElementAddress(const CodecIndex& index) const;
    size_t getStaticBufferSize() const;
    size_t getStaticBufferSize(DataRepresentation rep) const;
    DataRepresentation getRepresentation() const;
 
public: // legacy
    CodecIndex resolve(size_t leaf_index) const;

    CodecIndex resolve(size_t leaf_index, std::string& element_full_name) const;
    size_t getElementCount() const;
    a_util::result::Result getElement(size_t leaf_index,
                                      const ddl::StructElement*& legacy_struct_element) const;

    void resolve(CodecIndex& codec_index) const;

    const void* getData() const noexcept;
    size_t getDataSize() const noexcept;
 
protected:
    friend class CodecFactory;

    StaticDecoder(std::shared_ptr<const StructAccess> codec_access,
                  const void* data,
                  size_t data_size,
                  DataRepresentation representation);
 
protected:
    std::shared_ptr<const StructAccess> _codec_access;
    const void* _data = nullptr;
    size_t _data_size = 0;
    const ddl::codec::ElementAccessor* _element_accessor;
 
private:
    ddl::access_element::StructElementLegacy<const StaticDecoder> _legacy_element;
    Element _first_element;
};

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

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

    StaticCodec(StaticCodec&&);

    StaticCodec& operator=(StaticCodec&&);
 
    using StaticDecoder::getElement;
    using StaticDecoder::getElementAddress;
    typedef CodecElement<CodecElementAccess<StaticCodec>> 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);
 
    using StaticDecoder::getElements;
    typedef ChildElements<CodecElementAccess<StaticCodec>> Elements;
    Elements& getElements();

    template <typename T>
    void setElementValue(const CodecIndex& codec_index, const T& value)
    {
        ValueSetterSelect<StaticCodec, 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 StaticDecoder::getData;
    void* getData() noexcept;
 
private:
    friend class CodecFactory;
    StaticCodec(std::shared_ptr<const StructAccess> codec_access,
                void* data,
                size_t data_size,
                DataRepresentation representation);
    Element _first_element;
};
 
} // namespace codec
} // namespace ddl
 
#include <ddl/codec/legacy/static_codec_legacy.h>
 
#endif // DDL_STATIC_CODEC_CLASS_HEADER