142 lines
3.5 KiB
C++
142 lines
3.5 KiB
C++
#pragma once
|
|
#ifndef _NB_CORE_TYPES
|
|
#define _NB_CORE_TYPES
|
|
|
|
#include <iostream>
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
#include "TypeTraits.hpp"
|
|
|
|
namespace nb {
|
|
|
|
#ifdef _NB_TARGET_WINDOWS
|
|
const std::string NEWLINE = "\n";
|
|
const std::wstring WNEWLINE = L"\n";
|
|
#endif // _NB_TARGET_WINDOWS
|
|
#ifdef _NB_TARGET_LINUX
|
|
const std::string NEWLINE = "\n";
|
|
const std::wstring WNEWLINE = L"\n";
|
|
#endif // _NB_TARGET_LINUX
|
|
|
|
template <typename... T>
|
|
using StringConvertible = ValidConversion<std::string, T...>;
|
|
|
|
template <typename... T>
|
|
using WStringConvertible = ValidConversion<std::wstring, T...>;
|
|
|
|
template <typename... T>
|
|
constexpr bool StringConvertible_v = StringConvertible<T...>::value;
|
|
|
|
template <typename... T>
|
|
constexpr bool WStringConvertible_v = WStringConvertible<T...>::value;
|
|
|
|
template <typename... T>
|
|
using StringConvertible_to = typename StringConvertible<T...>::to;
|
|
|
|
template <typename... T>
|
|
using WStringConvertible_to = typename WStringConvertible<T...>::to;
|
|
|
|
template <typename... T>
|
|
using StringConvertible_from = typename StringConvertible<T...>::from;
|
|
|
|
template <typename... T>
|
|
using WStringConvertible_from = typename WStringConvertible<T...>::from;
|
|
|
|
template<typename T>
|
|
std::enable_if_t<StringConvertible_v<T>, std::wstring> str_to_wstr(T in) {
|
|
std::string str(in);
|
|
std::wstring ret(str.begin(), str.end());
|
|
return ret;
|
|
}
|
|
|
|
template<typename T>
|
|
std::enable_if_t<WStringConvertible_v<T>, std::string> wstr_to_str(T in) {
|
|
std::wstring wstr(in);
|
|
std::size_t wstrlen = wstr.length();
|
|
char* c_str= new char[wstrlen];
|
|
std::wcstombs(c_str, wstr.c_str(), wstrlen);
|
|
std::string ret(c_str, wstrlen);
|
|
delete[] c_str;
|
|
return ret;
|
|
}
|
|
|
|
template <typename Stream, typename... Args>
|
|
void stream(Stream& s, Args&&... args);
|
|
|
|
template <typename Stream, typename... Args>
|
|
void stream(Stream& s, Args&&... args) {
|
|
(s << ... << args);
|
|
}
|
|
|
|
template<typename... Args>
|
|
void term(Args&&... args) { stream(std::cout, args..., nb::NEWLINE); }
|
|
|
|
template<typename... Args>
|
|
void wterm(Args&&... args) { stream(std::wcout, args..., nb::WNEWLINE); }
|
|
|
|
template <typename T = std::string, typename A, typename B, typename C>
|
|
ValidConversion_to<T, A, B, C> find_and_replace(
|
|
A original,
|
|
B find,
|
|
C replace
|
|
) {
|
|
const T& find_t = T(find);
|
|
const T& replace_t = T(replace);
|
|
|
|
T ret(original);
|
|
|
|
std::size_t find_len = find_t.length();
|
|
std::size_t replace_len = replace_t.length();
|
|
std::size_t currpos = 0;
|
|
while(true) {
|
|
currpos = ret.find(find_t, currpos);
|
|
if (currpos == T::npos) {
|
|
break;
|
|
}
|
|
ret = ret.erase(currpos, find_len);
|
|
ret = ret.insert(currpos, replace_t);
|
|
currpos += replace_len;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
template <typename A, typename B, typename C>
|
|
StringConvertible_to<A, B, C> indent_strblock(
|
|
A block,
|
|
B prepend,
|
|
C topIndent
|
|
) {
|
|
return std::string(topIndent) + find_and_replace<std::string>(
|
|
std::string(block),
|
|
nb::NEWLINE,
|
|
nb::NEWLINE + std::string(prepend)
|
|
);
|
|
}
|
|
|
|
template <typename A, typename B>
|
|
StringConvertible_to<A, B> indent_strblock(
|
|
A block,
|
|
B prepend
|
|
) {
|
|
return indent_strblock<A, B, B>(block, prepend, prepend);
|
|
}
|
|
|
|
/* template<typename T>
|
|
T swap_endian(const T& val) {
|
|
T ret;
|
|
const int size = sizeof(T);
|
|
auto retLoc = static_cast<void*>(&ret);
|
|
auto valLoc = static_cast<const void*>(&val);
|
|
|
|
for (int i = 0; i < size; ++i) {
|
|
memcpy(retLoc+i, valLoc+(size-i-1), 1);
|
|
}
|
|
return ret;
|
|
} */
|
|
|
|
|
|
// using ByteVector = std::vector<uint8_t>;
|
|
|
|
} // namespace nb
|
|
#endif // _NB_CORE_TYPES
|