BLT/include/blt/std/utility.h

169 lines
4.6 KiB
C
Raw Normal View History

2023-11-24 13:45:14 -05:00
/*
* <Short Description>
* Copyright (C) 2023 Brett Terpstra
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#ifndef BLT_UTILITY_H
#define BLT_UTILITY_H
2023-12-09 21:21:14 -05:00
#include <string>
2023-11-24 13:45:14 -05:00
#if defined(__GNUC__)
2023-12-08 20:11:58 -05:00
#include <cxxabi.h>
#include <blt/compatibility.h>
2023-12-08 20:11:58 -05:00
namespace blt
{
static BLT_CPP20_CONSTEXPR inline std::string demangle(const std::string& str)
{
2023-12-08 20:11:58 -05:00
int status;
// only defined for GNU C++11?
char* demangled_name = abi::__cxa_demangle(str.c_str(), nullptr, nullptr, &status);
if (demangled_name == nullptr)
return str;
std::string ret_name = demangled_name;
std::free(demangled_name);
return ret_name;
}
2023-12-08 20:11:58 -05:00
}
#else
2023-12-08 20:11:58 -05:00
namespace blt
{
static BLT_CPP20_CONSTEXPR inline std::string demangle(const std::string& str)
{
2023-12-08 20:11:58 -05:00
return str;
}
2023-12-08 20:11:58 -05:00
}
#endif
2023-11-24 13:45:14 -05:00
namespace blt
{
2023-12-09 13:44:16 -05:00
template<typename T>
static BLT_CPP20_CONSTEXPR inline std::string type_string()
{
return demangle(typeid(T).name());
}
2023-12-08 20:11:58 -05:00
template<typename TYPE_ITR>
2023-12-08 20:44:45 -05:00
class enumerator
2023-11-24 13:45:14 -05:00
{
2023-12-08 20:11:58 -05:00
public:
2023-12-08 20:44:45 -05:00
class iterator
2023-12-08 20:11:58 -05:00
{
public:
using iterator_category = std::input_iterator_tag;
using value_type = typename TYPE_ITR::value_type;
using difference_type = typename TYPE_ITR::difference_type;
using pointer = typename TYPE_ITR::pointer;
using reference = typename TYPE_ITR::reference;
private:
size_t index = 0;
2023-12-08 20:44:45 -05:00
TYPE_ITR current;
2023-12-08 20:11:58 -05:00
public:
2023-12-09 13:44:16 -05:00
explicit iterator(TYPE_ITR current): current(std::move(current))
{}
2023-12-08 20:44:45 -05:00
iterator& operator++()
{
2023-12-09 13:44:16 -05:00
++index;
2023-12-08 20:44:45 -05:00
++current;
return *this;
}
2023-12-09 13:44:16 -05:00
bool operator==(iterator other) const
2023-12-08 20:44:45 -05:00
{
2023-12-09 13:44:16 -05:00
return current == other.current;
2023-12-08 20:44:45 -05:00
}
bool operator!=(iterator other) const
2023-12-09 13:44:16 -05:00
{
return current != other.current;
}
2023-12-08 20:44:45 -05:00
std::pair<size_t, const reference> operator*() const
{
return {index, *current};
};
2023-12-09 13:44:16 -05:00
std::pair<size_t, reference> operator*()
{
return {index, *current};
};
2023-12-08 20:11:58 -05:00
};
2023-12-08 20:44:45 -05:00
2023-12-09 13:44:16 -05:00
explicit enumerator(TYPE_ITR begin, TYPE_ITR end): begin_(std::move(begin)), end_(std::move(end))
2023-12-08 20:44:45 -05:00
{}
iterator begin()
{
return begin_;
}
iterator end()
{
return end_;
}
private:
iterator begin_;
iterator end_;
2023-11-24 13:45:14 -05:00
};
2023-12-08 20:44:45 -05:00
template<typename T>
2023-12-09 13:44:16 -05:00
static inline auto enumerate(const T& container)
{
return enumerator{container.begin(), container.end()};
}
template<typename T>
static inline auto enumerate(T& container)
2023-12-08 20:44:45 -05:00
{
return enumerator{container.begin(), container.end()};
}
2023-11-26 17:35:06 -05:00
#if defined(__GNUC__) || defined(__llvm__)
#define BLT_ATTRIB_NO_INLINE __attribute__ ((noinline))
#else
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER)
#define BLT_ATTRIB_NO_INLINE __declspec(noinline)
#else
#define BLT_ATTRIB_NO_INLINE
#endif
#endif
template<typename T>
2023-12-09 13:44:16 -05:00
void BLT_ATTRIB_NO_INLINE black_box(const T& val)
2023-11-26 17:35:06 -05:00
{
2023-12-09 13:44:16 -05:00
static volatile void* hell;
2023-11-26 17:35:06 -05:00
hell = (void*) &val;
2023-11-26 18:05:38 -05:00
(void) hell;
2023-11-26 17:35:06 -05:00
}
template<typename T>
2023-12-09 13:44:16 -05:00
const T& BLT_ATTRIB_NO_INLINE black_box_ret(const T& val)
2023-11-26 17:35:06 -05:00
{
2023-12-09 13:44:16 -05:00
static volatile void* hell;
2023-11-26 17:35:06 -05:00
hell = (void*) &val;
2023-11-26 18:05:38 -05:00
(void) hell;
2023-11-26 17:35:06 -05:00
return val;
}
2023-11-24 13:45:14 -05:00
}
#endif //BLT_UTILITY_H