attribute-traits.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "virtutech-c++" -*-
 
/*
  © 2021 Intel Corporation
 
  This software and the related documents are Intel copyrighted materials, and
  your use of them is governed by the express license under which they were
  provided to you ("License"). Unless the License provides otherwise, you may
  not use, modify, copy, publish, distribute, disclose or transmit this software
  or the related documents without Intel's prior written permission.
 
  This software and the related documents are provided as is, with no express or
  implied warranties, other than those that are expressly stated in the License.
*/
 
#ifndef SIMICS_ATTRIBUTE_TRAITS_H
#define SIMICS_ATTRIBUTE_TRAITS_H
 
#include <simics/base/attr-value.h>  // SIM_attr_list_item
#include <string>
#include <array>
#include <vector>
#include <list>
#include <utility>  // pair
#include <algorithm>  // copy_n
#include <deque>
#include <map>
#include <type_traits>  // is_enum, underlying_type_t, remove_cv_t
#include <limits>  // numeric_limits
 
#include "conf-object.h"
#include "connect.h"  // ConnectBase
 
namespace simics {
namespace detail {
 
template <typename T>
struct attr_from_std_helper {
    static attr_value_t f(const T &src);
};
 
template <typename T>
struct attr_to_std_helper {
    static T f(const attr_value_t &src);
};
 
// ConfObjectRef, needed by std_to_attr<T> when T is derived from ConnectBase
template <>
struct attr_from_std_helper<ConfObjectRef> {
    static attr_value_t f(const ConfObjectRef &src) {
        if (src) {
            if (src.port_name().empty()) {
                return SIM_make_attr_object(src);
            } else {
                attr_value_t ret = SIM_alloc_attr_list(2);
                SIM_attr_list_set_item(&ret, 0, SIM_make_attr_object(src));
                attr_value_t string = SIM_make_attr_string(
                        src.port_name().c_str());
                SIM_attr_list_set_item(&ret, 1, string);
                return ret;
            }
        } else {
            return SIM_make_attr_nil();
        }
    }
};
 
template <>
struct attr_to_std_helper<ConfObjectRef> {
    static ConfObjectRef f(const attr_value_t &src) {
        if (SIM_attr_is_list(src)) {
            if (SIM_attr_list_size(src) != 2) {
                throw SetIllegalType {
                    "Expected Simics list type with exactly 2 members"
                };
            }
 
            auto item = SIM_attr_list_item(src, 0);
            if (!SIM_attr_is_object(item)) {
                throw SetIllegalType {
                    "The first item should be Simics object type"
                };
            }
            ConfObjectRef r = SIM_attr_object(item);
 
            item = SIM_attr_list_item(src, 1);
            if (!SIM_attr_is_string(item)) {
                throw SetIllegalType {
                    "The second item should be Simics string type"
                };
            }
            r.set_port_name(SIM_attr_string(item));
            return r;
        } else {
            if (!SIM_attr_is_object(src) && !SIM_attr_is_nil(src)) {
                throw SetIllegalType {
                    "Expected Simics object or NIL type"
                };
            }
            return SIM_attr_object_or_nil(src);
        }
    }
};
}  // namespace detail
 
template <typename T> inline
typename std::enable_if<std::is_enum<T>::value, attr_value_t>::type
std_to_attr(const T &src) {
    return detail::attr_from_std_helper<std::underlying_type_t<T>>::f(
            static_cast<std::underlying_type_t<T>>(src));
}
 
template <typename T> inline
typename std::enable_if<std::is_base_of<ConnectBase, T>::value,
                        attr_value_t>::type
std_to_attr(const T &src) {
    return detail::attr_from_std_helper<ConfObjectRef>::f(src.get());
}
 
template <typename T> inline
typename std::enable_if<!std::is_enum<T>::value
                        && !std::is_base_of<ConnectBase, T>::value,
                        attr_value_t>::type
std_to_attr(const T &src) {
    return detail::attr_from_std_helper<T>::f(src);
}
 
template <typename T> inline
typename std::enable_if<std::is_enum<T>::value, T>::type
attr_to_std(attr_value_t src) {
    return static_cast<T>(
            detail::attr_to_std_helper<std::underlying_type_t<T>>::f(src));
}
 
template <typename T> inline
typename std::enable_if<std::is_base_of<ConnectBase, T>::value, T>::type
attr_to_std(attr_value_t src) {
    T c;
    if (!c.set(detail::attr_to_std_helper<ConfObjectRef>::f(src))) {
        throw std::runtime_error {
                "Unable to set to an illegal object"
        };
    }
    return c;
}
 
template <typename T> inline
typename std::enable_if<!std::is_enum<T>::value
                        && !std::is_base_of<ConnectBase, T>::value,
                        T>::type
attr_to_std(attr_value_t src) {
    return detail::attr_to_std_helper<std::remove_cv_t<T>>::f(src);
}
 
namespace detail {
 
// Integral
#define _STD2ATTR_INT_HELPER(type)               \
    template <>                                  \
    struct attr_from_std_helper<type> {          \
        static attr_value_t f(const type &src) { \
            return SIM_make_attr_int64(src);     \
        }                                        \
    };
#define _STD2ATTR_UINT_HELPER(type)              \
    template <>                                  \
    struct attr_from_std_helper<type> {          \
        static attr_value_t f(const type &src) { \
            return SIM_make_attr_uint64(src);    \
        }                                        \
    };
_STD2ATTR_INT_HELPER(char)
_STD2ATTR_INT_HELPER(signed char)
_STD2ATTR_UINT_HELPER(unsigned char)
_STD2ATTR_INT_HELPER(short)  // NOLINT(runtime/int)
_STD2ATTR_UINT_HELPER(unsigned short)  // NOLINT(runtime/int)
_STD2ATTR_INT_HELPER(int)
_STD2ATTR_UINT_HELPER(unsigned int)
_STD2ATTR_INT_HELPER(long int)  // NOLINT(runtime/int)
_STD2ATTR_UINT_HELPER(unsigned long int)  // NOLINT(runtime/int)
_STD2ATTR_INT_HELPER(long long int)  // NOLINT(runtime/int)
_STD2ATTR_UINT_HELPER(unsigned long long int)  // NOLINT(runtime/int)
#undef _STD2ATTR_INT_HELPER
#undef _STD2ATTR_UINT_HELPER
 
#define _ATTR2STD_INT_HELPER(type)                              \
    template <>                                                 \
    struct attr_to_std_helper<type> {                           \
        static type f(const attr_value_t &src) {                \
            if (!SIM_attr_is_integer(src)) {                    \
                throw SetIllegalType {                          \
                    "Expected Simics integer type"              \
                };                                              \
            }                                                   \
            intmax_t i = SIM_attr_integer(src);                 \
            if (i > (std::numeric_limits<type>::max)()          \
                || i < (std::numeric_limits<type>::min)()) {    \
                throw SetIllegalValue {                         \
                    "Value does not fit in type"                \
                };                                              \
            }                                                   \
            return (type) i;                                    \
        }                                                       \
    };
 
#define _ATTR2STD_UINT_HELPER(type)                             \
    template <>                                                 \
    struct attr_to_std_helper<type> {                           \
        static type f(const attr_value_t &src) {                \
            if (!SIM_attr_is_integer(src)) {                    \
                throw SetIllegalType {                          \
                    "Expected Simics integer type"              \
                };                                              \
            }                                                   \
            uintmax_t i = SIM_attr_integer(src);                \
            if (sizeof(type) != 8                               \
                && i > (std::numeric_limits<type>::max)()) {    \
                throw SetIllegalValue {                         \
                    "Value does not fit in type"                \
                };                                              \
            }                                                   \
            return (type) i;                                    \
        }                                                       \
    };
_ATTR2STD_INT_HELPER(char)
_ATTR2STD_INT_HELPER(signed char)
_ATTR2STD_UINT_HELPER(unsigned char)
_ATTR2STD_INT_HELPER(short)  // NOLINT(runtime/int)
_ATTR2STD_UINT_HELPER(unsigned short)  // NOLINT(runtime/int)
_ATTR2STD_INT_HELPER(int)
_ATTR2STD_UINT_HELPER(unsigned int)
_ATTR2STD_INT_HELPER(long int)  // NOLINT(runtime/int)
_ATTR2STD_UINT_HELPER(unsigned long int)  // NOLINT(runtime/int)
_ATTR2STD_INT_HELPER(long long int)  // NOLINT(runtime/int)
_ATTR2STD_UINT_HELPER(unsigned long long int)  // NOLINT(runtime/int)
#undef _ATTR2STD_INT_HELPER
#undef _ATTR2STD_UINT_HELPER
 
 
// Float
#define _STD2ATTR_FLOAT_HELPER(type)             \
    template <>                                  \
    struct attr_from_std_helper<type> {          \
        static attr_value_t f(const type &src) { \
            return SIM_make_attr_floating(src);  \
        }                                        \
    };
_STD2ATTR_FLOAT_HELPER(float)
_STD2ATTR_FLOAT_HELPER(double)
#undef _STD2ATTR_FLOAT_HELPER
 
#define _ATTR2STD_FLOAT_HELPER(type)                \
    template <>                                     \
    struct attr_to_std_helper<type> {               \
        static type f(const attr_value_t &src) {    \
            if (!SIM_attr_is_floating(src)) {       \
                throw SetIllegalType {              \
                    "Expected Simics floating type" \
                };                                  \
            }                                       \
            return (type) SIM_attr_floating(src);   \
        }                                           \
    };
_ATTR2STD_FLOAT_HELPER(float)
_ATTR2STD_FLOAT_HELPER(double)
#undef _ATTR2STD_FLOAT_HELPER
 
 
// std::string
template <>
struct attr_from_std_helper<std::string> {
    static attr_value_t f(const std::string &src) {
        return SIM_make_attr_string(src.c_str());
    }
};
 
template <>
struct attr_to_std_helper<std::string> {
    static std::string f(const attr_value_t &src) {
        if (!SIM_attr_is_string(src)) {
            throw SetIllegalType {
                "Expected Simics string type"
            };
        }
        return SIM_attr_string(src);
    }
};
 
template <>
struct attr_from_std_helper<const char*> {
    static attr_value_t f(const char *src) {
        return SIM_make_attr_string(src);
    }
};
 
template <>
struct attr_to_std_helper<const char*> {
    static const char *f(const attr_value_t &src) {
        if (SIM_attr_is_nil(src)) {
            return nullptr;
        } else {
            if (!SIM_attr_is_string(src)) {
                throw SetIllegalType {
                    "Expected Simics string type"
                };
            }
            return SIM_attr_string(src);
        }
    }
};
 
 
// bool
template <>
struct attr_from_std_helper<bool> {
    static attr_value_t f(const bool &src) {
        return SIM_make_attr_boolean(src);
    }
};
 
template <>
struct attr_to_std_helper<bool> {
    static bool f(const attr_value_t &src) {
        if (!SIM_attr_is_boolean(src)) {
            throw SetIllegalType {
                "Expected Simics boolean type"
            };
        }
        return SIM_attr_boolean(src);
    }
};
 
 
// attr_value_t
template <>
struct attr_from_std_helper<attr_value_t> {
    static attr_value_t f(const attr_value_t &src) {
        return src;
    }
};
 
template <>
struct attr_to_std_helper<attr_value_t> {
    static attr_value_t f(const attr_value_t &src) {
        return src;
    }
};
 
 
// Container
template <typename C, typename T = typename C::value_type>
attr_value_t from_container(const C &src) {
    auto it = src.cbegin();
    const size_t size = src.size();
    attr_value_t dst = SIM_alloc_attr_list(size);
    for (unsigned i = 0; i < size; ++i, ++it) {
        SIM_attr_list_set_item(&dst, i, std_to_attr(*it));
    }
    return dst;
}
 
template <typename V, std::size_t N>
struct attr_from_std_helper<std::array<V, N>> {
    static attr_value_t f(const std::array<V, N> &src) {
        return from_container<std::array<V, N>>(src);
    }
};
 
template <typename V>
struct attr_from_std_helper<std::vector<V>> {
    static attr_value_t f(const std::vector<V> &src) {
        return from_container<std::vector<V>>(src);
    }
};
 
template <typename V>
struct attr_from_std_helper<std::list<V>> {
    static attr_value_t f(const std::list<V> &src) {
        return from_container<std::list<V>>(src);
    }
};
 
template <typename V>
struct attr_from_std_helper<std::deque<V>> {
    static attr_value_t f(const std::deque<V> &src) {
        return from_container<std::deque<V>>(src);
    }
};
 
template <typename X, typename Y>
struct attr_from_std_helper<std::pair<X, Y>> {
    static attr_value_t f(const std::pair<X, Y>& src) {
        attr_value_t dst = SIM_alloc_attr_list(2);
        SIM_attr_list_set_item(&dst, 0, std_to_attr(src.first));
        SIM_attr_list_set_item(&dst, 1, std_to_attr(src.second));
        return dst;
    }
};
 
template <typename X, typename Y>
struct attr_from_std_helper<std::map<X, Y>> {
    static attr_value_t f(const std::map<X, Y>& src) {
        const unsigned size = src.size();
        attr_value_t dst = SIM_alloc_attr_list(size);
        auto it = src.cbegin();
        for (unsigned i = 0; i < size; ++i, ++it) {
            std::pair<X, Y> p {it->first, it->second};
            SIM_attr_list_set_item(&dst, i, std_to_attr(p));
        }
        return dst;
    }
};
 
template <typename C, typename T = typename C::value_type>
C to_container(const attr_value_t &src) {
    if (!SIM_attr_is_list(src)) {
        throw SetIllegalType {
            "Expected Simics list type"
        };
    }
    const unsigned size = SIM_attr_list_size(src);
    C dst(size);
    // The scope of variable it should be inside the for, but for cannot
    // initialize two different type variables
    auto it = dst.begin();
    for (unsigned i = 0; i < size; ++i, ++it) {
        *it = attr_to_std<T>(SIM_attr_list_item(src, i));
    }
    return dst;
}
 
template <typename V, std::size_t N>
struct attr_to_std_helper<std::array<V, N>> {
    static std::array<V, N> f(const attr_value_t &src) {
        std::array<V, N> arr;
        arr.fill(V{});
        auto vec = to_container<std::vector<V>>(src);
        std::copy_n(vec.begin(), N, arr.begin());
        return arr;
    }
};
 
template <typename V>
struct attr_to_std_helper<std::vector<V>> {
    static std::vector<V> f(const attr_value_t &src) {
        return to_container<std::vector<V>>(src);
    }
};
 
template <typename V>
struct attr_to_std_helper<std::list<V>> {
    static std::list<V> f(const attr_value_t &src) {
        return to_container<std::list<V>>(src);
    }
};
 
template <typename V>
struct attr_to_std_helper<std::deque<V>> {
    static std::deque<V> f(const attr_value_t &src) {
        return to_container<std::deque<V>>(src);
    }
};
 
template <typename X, typename Y>
struct attr_to_std_helper<std::pair<X, Y>> {
    static std::pair<X, Y> f(const attr_value_t& src) {
        if (!SIM_attr_is_list(src) || SIM_attr_list_size(src) != 2) {
            throw SetIllegalType {
                "Expected Simics list type with exactly two members"
            };
        }
        return {attr_to_std<X>(SIM_attr_list_item(src, 0)),
                attr_to_std<Y>(SIM_attr_list_item(src, 1))};
    }
};
 
template <typename X, typename Y>
struct attr_to_std_helper<std::map<X, Y>> {
    static std::map<X, Y> f(const attr_value_t& src) {
        if (!SIM_attr_is_list(src)) {
            throw SetIllegalType {
                "Expected Simics list type"
            };
        }
        std::map<X, Y> ret;
        for (unsigned i = 0; i < SIM_attr_list_size(src); ++i) {
            ret.emplace(attr_to_std<std::pair<X, Y>>(
                                SIM_attr_list_item(src, i)));
        }
        return ret;
    }
};
 
// Use this type for Simics "data" type
using data_attribute = std::vector<uint8>;
 
template <>
struct attr_from_std_helper<data_attribute> {
    static attr_value_t f(const data_attribute& src) {
        return SIM_make_attr_data(src.size(), src.data());
    }
};
 
template <>
struct attr_to_std_helper<data_attribute> {
    static data_attribute f(const attr_value_t& src) {
        if (!SIM_attr_is_data(src)) {
            throw SetIllegalType {
                "Expected Simics data type"
            };
        }
        size_t size = SIM_attr_data_size(src);
        const uint8 *data = SIM_attr_data(src);
        return data_attribute(data, data + size);
    }
};
 
}  // namespace detail
}  // namespace simics
 
#endif