common.hpp

Go to the documentation of this file.

#pragma once
 
#include <mip/mip_serialization.hpp>
 
 
 
namespace mip
{
 
struct DescriptorRate
{
    uint8_t descriptor;
    uint16_t decimation;
 
    size_t insert(Serializer& buffer) const { return buffer.insert(descriptor, decimation); }
    size_t extract(Serializer& buffer) { return buffer.extract(descriptor, decimation); }
};
 
 
template<typename T, size_t N>
struct Vector
{
    Vector() {}
 
    template<typename U>
    Vector(U value) { fill(value); }
 
    template<typename U>
    Vector(const U (&ptr)[N]) { copyFrom(ptr, N); }
 
    template<typename U, size_t M>
    explicit Vector(const U (&ptr)[M]) { static_assert(M>=N, "Input array is too small"); copyFrom(ptr, M); }
 
    template<typename U>
    explicit Vector(const U* ptr, size_t n) { copyFrom(ptr, n); }
 
    template<typename U, typename V, typename... Rest>
    Vector(U u, V v, Rest... rest) : m_data{u, v, rest...} {}
 
    Vector(const Vector&) = default;
 
    Vector& operator=(const Vector&) = default;
 
    template<typename U>
    Vector& operator=(const Vector<U,N>& other) { copyFrom(other, N); return *this; }
 
 
    typedef T Array[N];
 
#if _MSC_VER < 1930
    // MSVC 2017 has a bug which causes operator[] to be ambiguous.
    // See https://stackoverflow.com/questions/48250560/msvc-error-c2593-when-overloading-const-and-non-const-conversion-operator-return
    operator T*() { return m_data; }
    operator const T*() const { return m_data; }
#else
    operator Array&() { return m_data; }
    operator const Array&() const { return m_data; }
#endif
 
    Array& data() { return m_data; }
    const Array& data() const { return m_data; }
 
    template<typename U>
    void fill(U value) { for(size_t i=0; i<N; i++) m_data[i]=value; }
 
    template<typename U>
    void copyFrom(const U* ptr, size_t n) { if(n>N) n=N; for(size_t i=0; i<n; i++) m_data[i] = (T)ptr[i]; }
 
    size_t size() const { return N; }
 
private:
    T m_data[N];
};
 
using Vector3f = Vector<float,3>;
using Vector4f = Vector<float,4>;
using Matrix3f = Vector<float,9>;
using Vector3d = Vector<double,3>;
using Vector4d = Vector<double,4>;
using Matrix3d = Vector<double,9>;
 
using Quatf = Vector4f;
 
template<typename T, size_t N>
size_t insert(Serializer& serializer, const Vector<T,N>& v) { return serializer.insert(v.data()); }
 
template<typename T, size_t N>
size_t extract(Serializer& serializer, Vector<T,N>& v) { return serializer.extract(v.data()); }
 
} // namespace mip