Skip to content

CoMeta - metaprogramming

aligned_allocate function

template <typename T = void, size_t alignment = 64>
CMT_INTRINSIC T *aligned_allocate(size_t size = 1)

Allocates aligned memory

Source code
template <typename T = void, size_t alignment = 64>
CMT_INTRINSIC T* aligned_allocate(size_t size = 1)
{
    T* ptr = static_cast<T*>(CMT_ASSUME_ALIGNED(
        details::aligned_malloc(std::max(alignment, size * details::elementsize<T>()), alignment),
        alignment));
    return ptr;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/memory.hpp#L129

template <typename T = void>
CMT_INTRINSIC T *aligned_allocate(size_t size,
                                  size_t alignment)

Allocates aligned memory

Source code
template <typename T = void>
CMT_INTRINSIC T* aligned_allocate(size_t size, size_t alignment)
{
    T* ptr = static_cast<T*>(CMT_ASSUME_ALIGNED(
        details::aligned_malloc(std::max(alignment, size * details::elementsize<T>()), alignment),
        alignment));
    return ptr;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/memory.hpp#L138

aligned_deallocate function

template <typename T = void>
CMT_INTRINSIC void aligned_deallocate(T *ptr)

Deallocates aligned memory

Source code
template <typename T = void>
CMT_INTRINSIC void aligned_deallocate(T* ptr)
{
    return details::aligned_free(ptr);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/memory.hpp#L148

allocator

allocator class

template <typename T> allocator

Aligned allocator

Source code
template <typename T>
struct allocator
{
    using value_type      = T;
    using pointer         = T*;
    using const_pointer   = const T*;
    using reference       = T&;
    using const_reference = const T&;
    using size_type       = std::size_t;
    using difference_type = std::ptrdiff_t;

    template <typename U>
    struct rebind
    {
        using other = allocator<U>;
    };
    constexpr allocator() CMT_NOEXCEPT                 = default;
    constexpr allocator(const allocator&) CMT_NOEXCEPT = default;
    template <typename U>
    constexpr allocator(const allocator<U>&) CMT_NOEXCEPT
    {
    }
    pointer allocate(size_type n) const
    {
        pointer result = aligned_allocate<value_type>(n);
        if (!result)
            CMT_THROW(std::bad_alloc());
        return result;
    }
    void deallocate(pointer p, size_type) { aligned_deallocate(p); }
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/memory.hpp#L197

array_ref

array_ref class

template <typename T> array_ref

Reference to array

Source code
template <typename T>
struct array_ref
{
public:
    using value_type             = T;
    using pointer                = value_type*;
    using const_pointer          = const value_type*;
    using reference              = value_type&;
    using const_reference        = const value_type&;
    using iterator               = pointer;
    using const_iterator         = const_pointer;
    using reverse_iterator       = std::reverse_iterator<pointer>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
    using size_type              = std::size_t;
    using difference_type        = std::ptrdiff_t;

    constexpr array_ref() CMT_NOEXCEPT : m_data(nullptr), m_size(0) {}
    constexpr array_ref(const array_ref&) CMT_NOEXCEPT = default;
    constexpr array_ref(array_ref&&) CMT_NOEXCEPT      = default;
#ifdef CMT_COMPILER_GNU
    constexpr array_ref& operator=(const array_ref&) CMT_NOEXCEPT = default;
    constexpr array_ref& operator=(array_ref&&) CMT_NOEXCEPT = default;
#else
    array_ref& operator=(const array_ref&) = default;
    array_ref& operator=(array_ref&&) = default;
#endif

    template <size_t N>
    constexpr array_ref(value_type (&arr)[N]) CMT_NOEXCEPT : m_data(arr), m_size(N)
    {
    }
    template <size_t N>
    constexpr array_ref(const std::array<T, N>& arr) CMT_NOEXCEPT : m_data(arr.data()), m_size(N)
    {
    }
    template <size_t N>
    constexpr array_ref(std::array<T, N>& arr) CMT_NOEXCEPT : m_data(arr.data()), m_size(N)
    {
    }
    template <typename Alloc>
    constexpr array_ref(const std::vector<T, Alloc>& vec) CMT_NOEXCEPT : m_data(vec.data()),
                                                                         m_size(vec.size())
    {
    }

    template <typename Container, CMT_ENABLE_IF(has_data_size<Container>)>
    array_ref(Container& cont) : array_ref(cont.data(), cont.size())
    {
    }

    constexpr array_ref(const std::initializer_list<T>& vec) CMT_NOEXCEPT : m_data(vec.begin()),
                                                                            m_size(vec.size())
    {
    }
    template <typename InputIter>
    constexpr array_ref(InputIter first, InputIter last) CMT_NOEXCEPT : m_data(std::addressof(*first)),
                                                                        m_size(std::distance(first, last))
    {
    }
    constexpr array_ref(T* data, size_type size) CMT_NOEXCEPT : m_data(data), m_size(size) {}

    constexpr reference front() const CMT_NOEXCEPT { return m_data[0]; }
    constexpr reference back() const CMT_NOEXCEPT { return m_data[m_size - 1]; }
    constexpr iterator begin() const CMT_NOEXCEPT { return m_data; }
    constexpr iterator end() const CMT_NOEXCEPT { return m_data + m_size; }
    constexpr const_iterator cbegin() const CMT_NOEXCEPT { return m_data; }
    constexpr const_iterator cend() const CMT_NOEXCEPT { return m_data + m_size; }
    constexpr pointer data() const CMT_NOEXCEPT { return m_data; }
    constexpr std::size_t size() const CMT_NOEXCEPT { return m_size; }
    constexpr bool empty() const CMT_NOEXCEPT { return !m_size; }
    constexpr reference operator[](std::size_t index) const { return m_data[index]; }

private:
    pointer m_data;
    size_type m_size;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/array.hpp#L16

b8 typedef

b8 = bool

Short names for common types

Source code
using b8   = bool

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/numeric.hpp#L12

choose_const function

template <typename T, typename C1, typename... Cs,
          CMT_ENABLE_IF(is_same<T, C1>)>
constexpr inline T choose_const(C1 c1, Cs...)

Selects constant of the specific type

CHECK( choose_const<f32>( 32.0f, 64.0 ) == 32.0f );
CHECK( choose_const<f64>( 32.0f, 64.0 ) == 64.0 );

Source code
template <typename T, typename C1, typename... Cs, CMT_ENABLE_IF(is_same<T, C1>)>
constexpr inline T choose_const(C1 c1, Cs...)
{
    return static_cast<T>(c1);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1694

ctypeid function

template <typename T> constexpr inline type_id_t ctypeid()

Gets unique value associated with the type @tparam T type @return value of type that supports operator== and operator!=

Source code
template <typename T>
constexpr inline type_id_t ctypeid()
{
    return details::typeident_impl<T>();
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/ctti.hpp#L103

template <typename T>
constexpr inline type_id_t ctypeid(T x)

Gets unique value associated with the type
x value of specific type @return value of type that supports operator== and operator!=

Source code
template <typename T>
constexpr inline type_id_t ctypeid(T x)
{
    (void)x;
    return details::typeident_impl<T>();
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/ctti.hpp#L113

datatype

datatype enum

enum class datatype : int

An enumeration representing data type

Source code
enum class datatype : int
{
    typebits_mask  = 0xFF,
    f              = 0x100, // floating point
    i              = 0x200, // signed integer
    u              = 0x300, // unsigned integer
    c              = 0x400, // complex floating point
    b              = 0x500, // boolean
    typeclass_mask = 0xF00,
    f16            = static_cast<int>(f) | 16,
    f32            = static_cast<int>(f) | 32,
    f64            = static_cast<int>(f) | 64,
    f80            = static_cast<int>(f) | 80,
    i8             = static_cast<int>(i) | 8,
    i16            = static_cast<int>(i) | 16,
    i24            = static_cast<int>(i) | 24,
    i32            = static_cast<int>(i) | 32,
    i64            = static_cast<int>(i) | 64,
    u8             = static_cast<int>(u) | 8,
    u16            = static_cast<int>(u) | 16,
    u24            = static_cast<int>(u) | 24,
    u32            = static_cast<int>(u) | 32,
    u64            = static_cast<int>(u) | 64,
    c32            = static_cast<int>(c) | 32,
    c64            = static_cast<int>(c) | 64,
    b8             = static_cast<int>(b) | 8
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/numeric.hpp#L86

function

function class

template <typename F> function

std::function-like lightweight function wrapper

function<int( float )> f = []( float x ){ return static_cast<int>( x ); };
CHECK( f( 3.4f ) == 3 )

Source code
template <typename F>
struct function

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/function.hpp#L53

gcd function

template <typename T> constexpr inline T gcd(T a)

Greatest common divisor

Source code
template <typename T>
constexpr inline T gcd(T a)
{
    return a;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L951

template <typename T> constexpr inline T gcd(T a, T b)

Greatest common divisor

Source code
template <typename T>
constexpr inline T gcd(T a, T b)
{
    return a < b ? gcd(b, a) : ((a % b == 0) ? b : gcd(b, a % b));
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L958

template <typename T, typename... Ts>
constexpr inline T gcd(T a, T b, T c, Ts... rest)

Greatest common divisor

Source code
template <typename T, typename... Ts>
constexpr inline T gcd(T a, T b, T c, Ts... rest)
{
    return gcd(a, gcd(b, c, rest...));
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L965

get_first function

template <typename T1, typename... Ts>
CMT_INTRINSIC constexpr T1 &&
get_first(T1 &&x, Ts &&...) CMT_NOEXCEPT

Function that returns its first argument and ignores all other arguments

Source code
template <typename T1, typename... Ts>
CMT_INTRINSIC constexpr T1&& get_first(T1&& x, Ts&&...) CMT_NOEXCEPT
{
    return std::forward<T1>(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1293

get_second function

template <typename T1, typename T2, typename... Ts>
CMT_INTRINSIC constexpr T2 &&
get_second(T1, T2 &&x, Ts &&...) CMT_NOEXCEPT

Function that returns its second argument and ignores all other arguments

Source code
template <typename T1, typename T2, typename... Ts>
CMT_INTRINSIC constexpr T2&& get_second(T1, T2&& x, Ts&&...) CMT_NOEXCEPT
{
    return std::forward<T2>(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1300

get_third function

template <typename T1, typename T2, typename T3,
          typename... Ts>
CMT_INTRINSIC constexpr T3 &&
get_third(T1 &&, T2 &&, T3 &&x, Ts &&...) CMT_NOEXCEPT

Function that returns its third argument and ignores all other arguments

Source code
template <typename T1, typename T2, typename T3, typename... Ts>
CMT_INTRINSIC constexpr T3&& get_third(T1&&, T2&&, T3&& x, Ts&&...) CMT_NOEXCEPT
{
    return std::forward<T3>(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1307

identity typedef

template <typename T>
identity = typename details::identity_impl<T>::type

Utility typedef used to disable type deduction

Source code
template <typename T>
using identity = typename details::identity_impl<T>::type

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1129

identity = typename details::identity_impl<T>::type

Utility typedef used to disable type deduction

Source code
using identity = typename details::identity_impl<T>::type

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1129

lcm function

template <typename T> constexpr inline T lcm(T a)

Least common multiple

Source code
template <typename T>
constexpr inline T lcm(T a)
{
    return a;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L972

template <typename T> constexpr inline T lcm(T a, T b)

Least common multiple

Source code
template <typename T>
constexpr inline T lcm(T a, T b)
{
    return a * b / gcd(a, b);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L979

template <typename T, typename... Ts>
constexpr inline T lcm(T a, T b, T c, Ts... rest)

Least common multiple

Source code
template <typename T, typename... Ts>
constexpr inline T lcm(T a, T b, T c, Ts... rest)
{
    return lcm(a, lcm(b, c, rest...));
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L986

make_range function

template <typename T>
constexpr range<T> make_range(T begin, T end)

Make iterable range object

Source code
template <typename T>
constexpr range<T> make_range(T begin, T end)
{
    return range<T>(begin, end, end > begin ? 1 : -1);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/range.hpp#L61

template <typename T, typename D>
constexpr range<std::common_type_t<T, D>>
make_range(T begin, T end, D step)

Make iterable range object with step

Source code
template <typename T, typename D>
constexpr range<std::common_type_t<T, D>> make_range(T begin, T end, D step)
{
    return range<std::common_type_t<T, D>>(begin, end, step);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/range.hpp#L68

next_poweroftwo function

template <typename T>
constexpr inline T next_poweroftwo(T n)

Returns a nearest power of two that is greater or equal than n

Source code
template <typename T>
constexpr inline T next_poweroftwo(T n)
{
    return n > 2 ? T(1) << (ilog2(n - 1) + 1) : n;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L931

noop function

template <typename... Ts>
CMT_INTRINSIC constexpr void noop(Ts &&...) CMT_NOEXCEPT

Function that returns void and ignores all its arguments

Source code
template <typename... Ts>
CMT_INTRINSIC constexpr void noop(Ts&&...) CMT_NOEXCEPT
{
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1287

pass_through function

template <typename T>
CMT_INTRINSIC constexpr T &&pass_through(T &&x) CMT_NOEXCEPT

Function that returns its first argument

Source code
template <typename T>
CMT_INTRINSIC constexpr T&& pass_through(T&& x) CMT_NOEXCEPT
{
    return std::forward<T>(x);
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1280

prev_poweroftwo function

template <typename T>
constexpr inline T prev_poweroftwo(T n)

Returns a nearest power of two that is less or equal than n

Source code
template <typename T>
constexpr inline T prev_poweroftwo(T n)
{
    return n > 2 ? T(1) << (ilog2(n)) : n;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L938

range

range class

template <typename T> range

Iterable range

Source code
template <typename T>
struct range
{
    using value_type      = T;
    using reference       = T&;
    using const_reference = const T&;
    using pointer         = T*;
    using const_pointer   = const T*;
    using diff_type       = decltype(std::declval<T>() - std::declval<T>());

    constexpr range(value_type begin, value_type end, diff_type step) CMT_NOEXCEPT : min(begin),
                                                                                     max(end),
                                                                                     step(step)
    {
    }

    struct iterator
    {
        value_type value;
        diff_type step;
        constexpr const_reference operator*() const { return value; }
        constexpr const_pointer operator->() const { return &value; }
        constexpr iterator& operator++()
        {
            value += step;
            return *this;
        }
        constexpr iterator operator++(int)
        {
            iterator copy = *this;
            ++(*this);
            return copy;
        }
        constexpr bool operator!=(const iterator& other) const
        {
            return step > 0 ? value < other.value : value > other.value;
        }
    };
    value_type min;
    value_type max;
    diff_type step;
    constexpr iterator begin() const { return iterator{ min, step }; }
    constexpr iterator end() const { return iterator{ max, step }; }

    constexpr T distance() const { return max - min; }
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/range.hpp#L13

return_constant function

template <typename T, T value, typename... Args>
CMT_INTRINSIC constexpr T return_constant(Args &&...)

Function that returns constant of type T and ignores all its arguments

Source code
template <typename T, T value, typename... Args>
CMT_INTRINSIC constexpr T return_constant(Args&&...)
{
    return value;
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1321

returns function

template <typename T, typename... Ts>
CMT_INTRINSIC constexpr T returns(Ts &&...)

Function that returns value-initialization of type T and ignores all its arguments

Source code
template <typename T, typename... Ts>
CMT_INTRINSIC constexpr T returns(Ts&&...)
{
    return T();
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1314

swallow

swallow class

swallow

Utility class to use in list-initialization context

Source code
struct swallow
{
    template <typename... T>
    CMT_MEM_INTRINSIC constexpr swallow(T&&...) CMT_NOEXCEPT
    {
    }
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa.hpp#L1132

swallow

swallow

Utility class to use in list-initialization context

Source code
struct swallow

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/tuple.hpp#L20

type_name function

template <typename T>
inline const char *type_name() CMT_NOEXCEPT

Gets the fully qualified name of the type, including namespace and template parameters (if any) @tparam T type @return name of the type

Source code
template <typename T>
inline const char* type_name() CMT_NOEXCEPT
{
    static const auto name = ctype_name<T>();
    return name.c_str();
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/ctti.hpp#L78

template <typename T>
inline const char *type_name(T x) CMT_NOEXCEPT

Gets the fully qualified name of the type, including namespace and template parameters (if any)
x value of specific type @return name of the type

Source code
template <typename T>
inline const char* type_name(T x) CMT_NOEXCEPT
{
    (void)x;
    return type_name<T>();
}

https://github.com/kfrlib/kfr/blob//include/kfr/cometa/ctti.hpp#L91


Auto-generated from sources, Revision , https://github.com/kfrlib/kfr/blob//include/kfr/