base.h

/*****************************************************************************
 * VCLib                                                                     *
 * Visual Computing Library                                                  *
 *                                                                           *
 * Copyright(C) 2021-2026                                                    *
 * Visual Computing Lab                                                      *
 * ISTI - Italian National Research Council                                  *
 *                                                                           *
 * All rights reserved.                                                      *
 *                                                                           *
 * This program is free software; you can redistribute it and/or modify      *
 * it under the terms of the Mozilla Public License Version 2.0 as published *
 * by the Mozilla Foundation; either version 2 of the License, or            *
 * (at your option) any later version.                                       *
 *                                                                           *
 * This program is distributed in the hope that it will be useful,           *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of            *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the              *
 * Mozilla Public License Version 2.0                                        *
 * (https://www.mozilla.org/en-US/MPL/2.0/) for more details.                *
 ****************************************************************************/
 
#ifndef VCL_BASE_BASE_H
#define VCL_BASE_BASE_H
 
#include <array>
#include <cassert>
#include <cstdint>
#include <limits>
#include <memory>
#include <type_traits>
 
namespace vcl {
 
// Define some basic types, for convenience
using uint   = uint32_t;
using ushort = uint16_t;
 
constexpr uint UINT_NULL = std::numeric_limits<uint>::max();
 
constexpr uint USHORT_NULL = std::numeric_limits<ushort>::max();
 
enum class PrimitiveType {
    CHAR,
    UCHAR,
    SHORT,
    USHORT,
    INT,
    UINT,
    FLOAT,
    DOUBLE,
    NONE
};
 
enum class MatrixStorageType { ROW_MAJOR, COLUMN_MAJOR };
 
// TODO: from c++23 use fixed width floating-point types
constexpr int sizeOf(PrimitiveType type) noexcept
{
    switch (type) {
    case PrimitiveType::CHAR: return sizeof(char);
    case PrimitiveType::UCHAR: return sizeof(unsigned char);
    case PrimitiveType::SHORT: return sizeof(int16_t);
    case PrimitiveType::USHORT: return sizeof(uint16_t);
    case PrimitiveType::INT: return sizeof(int32_t);
    case PrimitiveType::UINT: return sizeof(uint32_t);
    case PrimitiveType::FLOAT: return sizeof(float);
    case PrimitiveType::DOUBLE: return sizeof(double);
    default: return 0;
    }
}
 
// TODO: remove from c++23 (std::to_underlying)
template<typename E>
constexpr typename std::underlying_type<E>::type toUnderlying(E e) noexcept
{
    return static_cast<typename std::underlying_type<E>::type>(e);
}
 
template<class T>
class FakePointerWithValue
{
    T mValue;
 
public:
    FakePointerWithValue(const T& value) : mValue(value) {}
 
    T* operator->() { return std::addressof(mValue); }
};
 
template<typename T, size_t N>
constexpr std::array<T, N> makeArray(T value)
{
    std::array<T, N> a;
    a.fill(value);
    return a;
}
 
} // namespace vcl
 
#endif // VCL_BASE_BASE_H