codec_factory.h

Go to the documentation of this file.

 
#ifndef DDL_CODEC_FACTORY_CLASS_HEADER
#define DDL_CODEC_FACTORY_CLASS_HEADER
 
#include <ddl/codec/codec.h>
#include <ddl/codec/codec_iterator.h>
#include <ddl/codec/legacy/access_element_legacy.h>
#include <ddl/codec/static_codec.h>
#include <ddl/dd/dd.h>
#include <ddl/dd/ddstructure.h>
#include <ddl/dd/ddstructure_generator.h>
 
namespace ddl {
namespace codec {
class CodecFactory {
public:
    CodecFactory();
    CodecFactory(const CodecFactory&);
    CodecFactory& operator=(const CodecFactory&);

    CodecFactory(CodecFactory&&);
    CodecFactory& operator=(CodecFactory&&);

    ~CodecFactory() = default;

    CodecFactory(const std::string& struct_name, const std::string& dd_string);

    CodecFactory(const ddl::dd::StructType& struct_type, const dd::DataDefinition& dd);

    CodecFactory(const DDStructure& dd_struct);

    CodecFactory(const ddl::dd::StructTypeAccess& struct_type_access);

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

    inline StaticDecoder makeStaticDecoderFor(const void* data,
                                              size_t data_size,
                                              DataRepresentation rep = deserialized) const
    {
        return StaticDecoder(_codec_access, data, data_size, rep);
    }

    inline StaticCodec makeStaticCodecFor(void* data,
                                          size_t data_size,
                                          DataRepresentation rep = deserialized) const
    {
        return StaticCodec(_codec_access, data, data_size, rep);
    }

    Decoder makeDecoderFor(const void* data,
                           size_t data_size,
                           DataRepresentation rep = deserialized) const;

    Codec makeCodecFor(void* data, size_t data_size, DataRepresentation rep = deserialized) const;
    typedef FactoryElement<FactoryElementAccess<const CodecFactory>> 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<FactoryElementAccess<const CodecFactory>> 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;
    size_t getStaticBufferSize(DataRepresentation rep = deserialized) const;

    void resolve(CodecIndex& codec_index) const;
 
public: // legacy functions
    CodecIndex resolve(size_t leaf_index) const;

    CodecIndex resolve(size_t leaf_index, std::string& full_element_name) const;
    size_t getStaticElementCount() const;
    a_util::result::Result getStaticElement(size_t leaf_index,
                                            const ddl::StructElement*& legacy_struct_element) const;
 
private:
    std::shared_ptr<const StructAccess> _codec_access;
    a_util::result::Result _constructor_result;
    Element _first_element;
    ddl::access_element::StructElementLegacy<const CodecFactory> _legacy_element;
};
 
namespace detail {
template <typename T>
size_t getDecoderOrFactoryElementCount(const T& decoder_or_factory)
{
    return decoder_or_factory.getStaticElementCount();
}

template <>
inline size_t getDecoderOrFactoryElementCount(const ddl::codec::StaticDecoder& static_decoder)
{
    return static_decoder.getElementCount();
}

template <>
inline size_t getDecoderOrFactoryElementCount(const ddl::codec::StaticCodec& static_codec)
{
    return static_codec.getElementCount();
}

template <>
inline size_t getDecoderOrFactoryElementCount(const ddl::codec::Decoder& decoder)
{
    return decoder.getElementCount();
}

template <>
inline size_t getDecoderOrFactoryElementCount(const ddl::codec::Codec& codec)
{
    return codec.getElementCount();
}
} // namespace detail

template <typename T>
std::vector<CodecIndex> getCodecIndices(const T& decoder_or_factory)
{
    std::vector<CodecIndex> indices;
    indices.reserve(detail::getDecoderOrFactoryElementCount<T>(decoder_or_factory));
    forEachLeafElement(decoder_or_factory.getElements(),
                       [&indices](const auto& element) { indices.push_back(element.getIndex()); });
    return indices;
}

template <typename T>
std::vector<LeafCodecIndex> getLeafCodecIndices(const T& decoder_or_factory,
                                                ddl::DataRepresentation rep)
{
    std::vector<LeafCodecIndex> indices;
    indices.reserve(detail::getDecoderOrFactoryElementCount<T>(decoder_or_factory));
    forEachLeafElement(decoder_or_factory.getElements(), [&indices, &rep](const auto& element) {
        indices.push_back(LeafCodecIndex(element.getIndex(), rep));
    });
    return indices;
}
 
} // namespace codec
} // namespace ddl
 
#include <ddl/codec/legacy/codec_factory_legacy.h>
 
#endif // DDL_CODEC_FACTORY_CLASS_HEADER