access_element.h

Go to the documentation of this file.

#ifndef DDL_STRUCT_ELEMENT_ACCESS_CLASS_HEADER
#define DDL_STRUCT_ELEMENT_ACCESS_CLASS_HEADER
 
#include <a_util/result.h>
#include <a_util/strings.h>
#include <ddl/codec/legacy/codec_factory_legacy.h>
#include <ddl/codec/legacy/struct_element.h>
 
#include <type_traits>
 
namespace ddl {
namespace access_element {
// define all needed error types and values locally
_MAKE_RESULT(-3, ERR_UNEXPECTED);
_MAKE_RESULT(-20, ERR_NOT_FOUND);
 
namespace detail {

template <typename T>
using is_factory = std::is_member_function_pointer<decltype(&T::getStaticElementCount)>;
 
template <typename T, typename Enable = void>
struct Accessor {
    static inline size_t getElementCount(const T& access_type)
    {
        return access_type.getElementCount();
    }
 
    static inline a_util::result::Result getElement(const T& access_type,
                                                    size_t element_idx,
                                                    const StructElement*& element)
    {
        return access_type.getElement(element_idx, element);
    }
};
 
template <typename T>
struct Accessor<T, typename std::enable_if<is_factory<T>::value>::type> {
    static inline size_t getElementCount(const T& access_type)
    {
        return access_type.getStaticElementCount();
    }
 
    static inline a_util::result::Result getElement(const T& access_type,
                                                    size_t element_idx,
                                                    const StructElement*& element)
    {
        return access_type.getStaticElement(element_idx, element);
    }
};
 
template <typename T>
a_util::result::Result findComplexIndex(const T& decoder,
                                        const std::string& struct_name,
                                        size_t& index,
                                        const char* post_fix)
{
    if (struct_name.empty()) {
        index = 0;
        return a_util::result::SUCCESS;
    }
 
    size_t element_count = detail::Accessor<T>::getElementCount(decoder);
    std::string prefix = struct_name + post_fix;
    for (size_t element_index = 0; element_index < element_count; ++element_index) {
        const StructElement* element;
        if (detail::Accessor<T>::getElement(decoder, element_index, element)) {
            if (a_util::strings::compare(element->name.c_str(), prefix.c_str(), 0, prefix.size()) ==
                0) {
                index = element_index;
                return a_util::result::SUCCESS;
            }
        }
    }
 
    RETURN_ERROR_DESCRIPTION(ERR_NOT_FOUND, "element was not found");
}

 
} // namespace detail

template <typename T>
a_util::result::Result findIndex(const T& decoder, const std::string& element_name, size_t& index)
{
    size_t element_count = detail::Accessor<T>::getElementCount(decoder);
    for (size_t element_index = 0; element_index < element_count; ++element_index) {
        const StructElement* element;
        if (detail::Accessor<T>::getElement(decoder, element_index, element)) {
            if (element->name == element_name) {
                index = element_index;
                return a_util::result::SUCCESS;
            }
        }
    }
 
    RETURN_ERROR_DESCRIPTION(ERR_NOT_FOUND, "element was not found");
}

template <typename T>
a_util::result::Result findStructIndex(const T& decoder,
                                       const std::string& struct_name,
                                       size_t& index)
{
    return detail::findComplexIndex<T>(decoder, struct_name, index, ".");
}

template <typename T>
a_util::result::Result findArrayIndex(const T& decoder,
                                      const std::string& array_name,
                                      size_t& index)
{
    return detail::findComplexIndex<T>(decoder, array_name, index, "[");
}

template <typename T>
a_util::result::Result findArrayEndIndex(const T& decoder,
                                         const std::string& array_name,
                                         size_t& index)
{
    size_t element_count = detail::Accessor<T>::getElementCount(decoder);
    std::string prefix = array_name + "[";
    for (index += 1; index < element_count; ++index) {
        const StructElement* element;
        if (!detail::Accessor<T>::getElement(decoder, index, element)) {
            return a_util::result::SUCCESS;
        }
 
        if (a_util::strings::compare(element->name.c_str(), prefix.c_str(), 0, prefix.size()) !=
            0) {
            return a_util::result::SUCCESS;
        }
    }
 
    return a_util::result::SUCCESS;
}

template <typename T>
a_util::result::Result getValue(const T& decoder, const std::string& element_name, void* value)
{
    auto element_index{static_cast<std::size_t>(-1)};
    const a_util::result::Result res = findIndex(decoder, element_name, element_index);
    return res ? decoder.getElementValue(element_index, value) : res;
}

template <typename T>
a_util::result::Result setValue(T& codec, const std::string& element_name, const void* value)
{
    auto element_index{static_cast<std::size_t>(-1)};
    const a_util::result::Result res = findIndex(codec, element_name, element_index);
    return res ? codec.setElementValue(element_index, value) : res;
}

template <typename T>
a_util::variant::Variant getValue(const T& decoder, const std::string& element_name)
{
    a_util::variant::Variant result;
    auto element_index{static_cast<std::size_t>(-1)};
    if (findIndex(decoder, element_name, element_index)) {
        decoder.getElementValue(element_index, result);
    }
    return result;
}

template <typename T>
a_util::result::Result setValue(T& codec,
                                const std::string& element_name,
                                const a_util::variant::Variant& value)
{
    auto element_index{static_cast<std::size_t>(-1)};
    const a_util::result::Result res = findIndex(codec, element_name, element_index);
    return res ? codec.setElementValue(element_index, value) : res;
}

template <typename T>
a_util::variant::Variant getValue(const T& decoder, size_t element_index)
{
    a_util::variant::Variant result;
    if (decoder.getElementValue(element_index, result)) {
        return result;
    }
 
    return a_util::variant::Variant(static_cast<int32_t>(0));
}

template <typename T>
const void* getValueAddress(const T& decoder, const std::string& element_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    if (find_index(decoder, element_name, element_index)) {
        return decoder.getElementAddress(element_index);
    }
 
    return NULL;
}

template <typename T>
void* getValueAddress(T& codec, const std::string& element_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    if (findIndex(codec, element_name, element_index)) {
        return codec.getElementAddress(element_index);
    }
 
    return NULL;
}

template <typename STRUCT, typename T>
const STRUCT* getStructAddress(const T& decoder, const std::string& struct_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    if (findStructIndex(decoder, struct_name, element_index)) {
        return reinterpret_cast<const STRUCT*>(decoder.getElementAddress(element_index));
    }
 
    return NULL;
}

template <typename STRUCT, typename T>
STRUCT* getStructAddress(T& codec, const std::string& struct_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    if (findStructIndex(codec, struct_name, element_index)) {
        return reinterpret_cast<STRUCT*>(codec.getElementAddress(element_index));
    }
 
    return NULL;
}

template <typename T, typename CODEC>
a_util::result::Result getStructValue(const CODEC& decoder,
                                      const std::string& struct_name,
                                      T* struct_value)
{
    const T* address = getStructAddress<T>(decoder, struct_name);
    if (!address) {
        RETURN_ERROR_DESCRIPTION(ERR_NOT_FOUND, "address of struct was not found");
    }
 
    a_util::memory::copy(struct_value, sizeof(T), address, sizeof(T));
    return a_util::result::SUCCESS;
}

template <typename T, typename CODEC>
a_util::result::Result setStructValue(CODEC& codec,
                                      const std::string& struct_name,
                                      const T* struct_value)
{
    T* address = getStructAddress<T>(codec, struct_name);
    if (!address) {
        RETURN_ERROR_DESCRIPTION(ERR_NOT_FOUND, "address of struct was not found");
    }
 
    a_util::memory::copy(address, sizeof(T), struct_value, sizeof(T));
    return a_util::result::SUCCESS;
}

template <typename ARRAY_TYPE, typename T>
const ARRAY_TYPE* getArrayAddress(const T& decoder, const std::string& array_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    if (find_array_index(decoder, array_name, element_index)) {
        return reinterpret_cast<const ARRAY_TYPE*>(decoder.getElementAddress(element_index));
    }
 
    return NULL;
}

template <typename ARRAY_TYPE, typename T>
ARRAY_TYPE* getArrayAddress(T& codec, const std::string& array_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    if (findArrayIndex(codec, array_name, element_index)) {
        return reinterpret_cast<ARRAY_TYPE*>(codec.getElementAddress(element_index));
    }
 
    return NULL;
}

template <typename CODEC>
a_util::result::Result getArray(const CODEC& decoder,
                                const std::string& array_name,
                                const void*& start_address,
                                size_t& size)
{
    size_t start_index = 0;
    a_util::result::Result res = findArrayIndex(decoder, array_name, start_index);
    if (!res)
        return res;
 
    size_t end_index = start_index;
    res = findArrayEndIndex(decoder, array_name, end_index);
    if (!res)
        return res;
 
    start_address = decoder.getElementAddress(start_index);
    if (!start_address) {
        RETURN_ERROR_DESCRIPTION(ERR_UNEXPECTED, "address of element was not found");
    }
 
    const void* end_adress = decoder.getElementAddress(end_index);
    if (end_adress) {
        size = static_cast<const uint8_t*>(end_adress) - static_cast<const uint8_t*>(start_address);
    }
    else {
        // it reaches til the end
        size_t start_offset = static_cast<const uint8_t*>(start_address) -
                              static_cast<const uint8_t*>(decoder.getElementAddress(0));
        size = decoder.getBufferSize(decoder.getRepresentation()) - start_offset;
    }
 
    return a_util::result::SUCCESS;
}

template <typename T, typename CODEC>
a_util::result::Result getArrayValue(const CODEC& decoder,
                                     const std::string& array_name,
                                     T* array_value)
{
    const void* start_address = nullptr;
    size_t size = 0;
    a_util::result::Result res = getArray(decoder, array_name, start_address, size);
    if (!res)
        return res;
 
    a_util::memory::copy(array_value, size, start_address, size);
    return a_util::result::SUCCESS;
}

template <typename T>
a_util::result::Result reset(T& codec, const std::string& element_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    a_util::result::Result res = findIndex(codec, element_name, element_index);
    if (!res)
        return res;
 
    uint64_t zero = 0;
    return codec.setElementValue(element_index, &zero);
}

#define DDL_GET_ENUM_CASE(__variant_type, __data_type)                                             \
    case a_util::variant::VT_##__variant_type: {                                                   \
        __data_type xValue = value.get##__variant_type();                                          \
        for (AccessEnumType::const_iterator it = element->p_enum->begin();                         \
             it != element->p_enum->end();                                                         \
             ++it) {                                                                               \
            if (xValue == it->second.as##__variant_type()) {                                       \
                return it->first;                                                                  \
            }                                                                                      \
        }                                                                                          \
        break;                                                                                     \
    }

template <typename T>
std::string getValueAsString(const T& decoder, size_t element_index)
{
    a_util::variant::Variant value;
    const StructElement* element{};
    if (decoder.getElement(element_index, element)) {
        if (decoder.getElementValue(element_index, value)) {
            if (element->p_enum) {
                switch (value.getType()) {
                    DDL_GET_ENUM_CASE(Bool, bool)
                    DDL_GET_ENUM_CASE(Int8, int8_t)
                    DDL_GET_ENUM_CASE(UInt8, uint8_t)
                    DDL_GET_ENUM_CASE(Int16, int16_t)
                    DDL_GET_ENUM_CASE(UInt16, uint16_t)
                    DDL_GET_ENUM_CASE(Int32, int32_t)
                    DDL_GET_ENUM_CASE(UInt32, uint32_t)
                    DDL_GET_ENUM_CASE(Int64, int64_t)
                    DDL_GET_ENUM_CASE(UInt64, uint64_t)
                    DDL_GET_ENUM_CASE(Float, float)
                    DDL_GET_ENUM_CASE(Double, double)
                default:
                    break;
                }
            }
        }
    }
 
    return value.asString();
}

template <typename T>
std::string getValueAsString(const T& decoder, const std::string& element_name)
{
    auto element_index{static_cast<std::size_t>(-1)};
    if (findIndex(decoder, element_name, element_index)) {
        return getValueAsString(decoder, element_index);
    }
    return "";
}
 
} // namespace access_element
 
} // namespace ddl
 
#endif // DDL_STRUCT_ELEMENT_ACCESS_CLASS_HEADER