dl_type_convert.h

浏览该文件的文档.

#pragma once
 
#include <array>
#include <vector>
#include <initializer_list>
#include <cassert>
 
#include "dl_type_def.h"
 
namespace dl
{
template<typename T1, typename T, std::size_t N>
constexpr Array<T1, N> toArray(const Array<T, N>& a)
{
    Array<T1, N> ret;
    for (std::size_t i = 0; i < N; ++i)
    {
        ret[i] = static_cast<T1>(a[i]);
    }
    return ret;
}
template<typename T, std::size_t N>
constexpr Array<T, N> toArray(const std::array<T, N>& a)
{
    Array<T, N> ret;
    for (std::size_t i = 0; i < N; ++i)
    {
        ret[i] = a[i];
    }
    return ret;
}

template<typename T, std::size_t N>
constexpr Array<Position::value_type, N> toPosition(const Array<T, N>& a)
{
    return toArray<Position::value_type>(a);
}

template<typename T, std::size_t N>
constexpr Array<Point::value_type, N> toPoint(const Array<T, N>& a)
{
    return toArray<Point::value_type>(a);
}
 
 
template<typename T, std::size_t N, typename T1, typename ...Args>
constexpr void toArrayImp(Array<T, N>& arr, const T1& a, Args... args)
{
    arr[N - sizeof...(Args) - 1] = static_cast<T>(a);
    if constexpr (sizeof...(Args) > 0)
        toArrayImp(arr, args...);
}
 
template<typename T, typename T1, typename ...Args>
constexpr Array<T, sizeof...(Args) + 1> toArray(const T1& a, Args... args)
{
    Array<T, sizeof...(Args) + 1> ret;
    toArrayImp(ret, a, args...);
    return ret;
}

template<typename ...Args>
constexpr Array<Position::value_type, sizeof...(Args)> toPosition(Args... args)
{
    return toArray<Position::value_type>(args...);
}

template<typename ...Args>
constexpr Array<Point::value_type, sizeof...(Args)> toPoint(Args... args)
{
    return toArray<Point::value_type>(args...);
}
 
 
template<typename T, typename ...Args>
constexpr void CheckPositive(const T& a, Args... args)
{
    assert(a >= 0); 
    if constexpr (sizeof...(Args) > 0)
        CheckPositive(args...);
}

template<typename ...Args>
constexpr Array<Size::value_type, sizeof...(Args)> toSize(Args... args)
{
    CheckPositive(args...);
    return toArray<Size::value_type>(args...);
}
template<typename T, size_t N>
constexpr Array<Size::value_type, N> toSize(const Array<T, N>& a)
{
    Array<Size::value_type, N> ret;
    for (int i = 0; i < N; ++i)
    {
        assert(a[i] >= 0);
        ret[i] = static_cast<Size::value_type>(a[i]);
    }
    return ret;
}

template<typename T, size_t N>
constexpr Array<Size::value_type, N> toSizeNeg2Zero(const Array<T, N>& a)
{
    Array<Size::value_type, N> ret;
    for (int i = 0; i < N; ++i)
    {
        if (a[i] < 0)
        {
            ret[i] = 0;
        }
        else
            ret[i] = static_cast<Size::value_type>(a[i]);
    }
    return ret;
}

template<typename T, size_t N>
constexpr Array<PointU::value_type, N> toSizeDefault(const Array<T, N>& a)
{
    Array<PointU::value_type, N> ret;
    for (int i = 0; i < N; ++i)
        ret[i] = static_cast<PointU::value_type>(a[i]);
    return ret;
}

template<typename ...Args>
constexpr Array<SizeT::value_type, sizeof...(Args)> toSizeT(Args... args)
{
    CheckPositive(args...);
    return toArray<SizeT::value_type>(args...);
}
template<typename T, size_t N>
constexpr Array<SizeT::value_type, N> toSizeT(const Array<T, N>& a)
{
    Array<SizeT::value_type, N> ret;
    for (int i = 0; i < N; ++i)
    {
        assert(a[i] >= 0);
        ret[i] = static_cast<SizeT::value_type>(a[i]);
    }
    return ret;
}

template<typename T, size_t N>
constexpr Array<SizeT::value_type, N> toSizeTNeg2Zero(const Array<T, N>& a)
{
    Array<SizeT::value_type, N> ret;
    for (int i = 0; i < N; ++i)
    {
        if (a[i] < 0)
        {
            ret[i] = 0;
        }
        else
            ret[i] = static_cast<Size::value_type>(a[i]);
    }
    return ret;
}

template<typename T, size_t N>
constexpr Array<SizeT::value_type, N> toSizeTDefault(const Array<T, N>& a)
{
    Array<SizeT::value_type, N> ret;
    for (int i = 0; i < N; ++i)
        ret[i] = static_cast<SizeT::value_type>(a[i]);
    return ret;
}

template<size_t M = 1, typename T, size_t N>
constexpr Array<T, N + M> toLonger(const Array<T, N>& a, const T& v = {})
{
    Array<T, N + M> ret;
    for (size_t i = 0; i < N; ++i)
        ret[i] = a[i];
    for (size_t i = N; i < N + M; ++i)
        ret[i] = v;
    return ret;
}
template<size_t M = 1, typename T>
constexpr Array<T, M + 1> toLonger(const T& v)
{
    Array<T, M + 1> ret;
    for (size_t i = 0; i < M + 1; ++i)
        ret._data[i] = v; // clang需要直接访问_data才能生成常量表达式
    return ret;
}

template<size_t M = 1, typename T, size_t N>
constexpr Array<T, N - M> toShorter(const Array<T, N>& a)
{
    static_assert(M <= N);
    Array<T, N - M> ret;
    for (size_t i = 0; i < N - M; ++i)
        ret[i] = a[i];
    return ret;
}
//------------------------------------vector---------------------------------------
template<typename T>
constexpr std::vector<T> toVector(const T& a, size_t n)
{
    std::vector<T> ret;
    ret.resize(n, a);
    return ret;
}
}