util.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * 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 <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef COMMON_UTIL_H
#define COMMON_UTIL_H
 
#include "common/scummsys.h"
 
#include "common/type_traits.h"
 
struct TimeDate;
 
#define IS_ALIGNED(value, alignment) \
          ((((size_t)value) & ((alignment) - 1)) == 0)
 
#ifdef ABS
#undef ABS
#endif
 
#ifdef MIN
#undef MIN
#endif
 
#ifdef MAX
#undef MAX
#endif
 
template<typename T> inline T ABS(T x)      { return (x >= 0) ? x : -x; }
 
template<typename T> inline T MIN(T a, T b) { return (a < b) ? a : b; }
 
template<typename T> inline T MAX(T a, T b) { return (a > b) ? a : b; }
 
template<typename T> inline T CLIP(T v, T amin, T amax)
    {
#if !defined(RELEASE_BUILD)
        // Debug builds use this assert to pinpoint
        // any problematic cases, where amin and amax
        // are incorrectly ordered
        // and thus CLIP() would return an invalid result.
        assert(amin <= amax);
#endif
        if (v < amin) return amin;
        else if (v > amax) return amax;
        return v;
    }
 
template<typename T> inline void SWAP(T &a, T &b);
 
static inline uint32 ROTATE_LEFT_32(const uint32 x, const uint32 r) {
    return (x >> (32 - r)) | (x << r);
}
 
static inline uint32 ROTATE_RIGHT_32(const uint32 x, const uint32 r) {
    return (x << (32 - r)) | (x >> r);
}
 
#if !defined(_MSC_VER) || _MSC_VER >= 1910
template<typename... A> constexpr size_t NUMARGS(A&&...)    { return sizeof...(A); }
#else
using int_c_array = int[]; // MSVC 2015 doesn't like the template method above
#define NUMARGS(...)    (sizeof(int_c_array{__VA_ARGS__})/sizeof(int))
#endif
 
#ifdef ARRAYSIZE
#undef ARRAYSIZE
#endif
 
#define ARRAYSIZE(x) ((int)(sizeof(x) / sizeof(x[0])))
 
#define ARRAYEND(x) ((x) + ARRAYSIZE((x)))
 
template<typename T, size_t N> inline void ARRAYCLEAR(T (&array) [N], const T &value = T()) {
    T * ptr = array;
    size_t n = N;
    while(n--)
        *ptr++ = value;
}
 
#if defined(__GNUC__)
# define SCUMMVM_CURRENT_FUNCTION __PRETTY_FUNCTION__
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
#  define SCUMMVM_CURRENT_FUNCTION  __func__
#elif defined(_MSC_VER)
#  define SCUMMVM_CURRENT_FUNCTION __FUNCTION__
#else
#  define SCUMMVM_CURRENT_FUNCTION "<unknown>"
#endif
 
namespace Common {
 
class String;
class U32String;
 
template<class T>
constexpr remove_reference_t<T> &&move(T &&t) noexcept {
  return static_cast<remove_reference_t<T> &&>(t);
}
 
template<class T>
constexpr T&& forward(remove_reference_t<T> &&t) noexcept {
    return static_cast<T &&>(t);
}
 
template<class T>
constexpr T&& forward(remove_reference_t<T> &t) noexcept {
    return static_cast<T &&>(t);
}
 
template<class T1, class T2>
struct Pair {
    T1 first;
    T2 second;
 
    constexpr Pair() {
    }
 
    constexpr Pair(const Pair &other) : first(other.first), second(other.second) {
    }
 
    constexpr Pair(Pair &&other) : first(Common::move(other.first)), second(Common::move(other.second)) {
    }
 
    constexpr Pair(const T1 &first_, const T2 &second_) : first(first_), second(second_) {
    }
 
    constexpr Pair(T1 &&first_, T2 &&second_) : first(Common::move(first_)), second(Common::move(second_)) {
    }
 
    constexpr Pair(T1 &&first_, const T2 &second_) : first(Common::move(first_)), second(second_) {
    }
 
    constexpr Pair(const T1 &first_, T2 &&second_) : first(first_), second(Common::move(second_)) {
    }
 
    Pair &operator=(const Pair &other) {
        this->first = other.first;
        this->second = other.second;
        return *this;
    }
 
    Pair &operator=(Pair &&other) {
        this->first = Common::move(other.first);
        this->second = Common::move(other.second);
        return *this;
    }
};
 
extern void hexdump(const byte * data, int len, int bytesPerLine = 16, int startOffset = 0);
 
 
bool parseBool(const String &val, bool &valAsBool);
 
 
bool isAscii(int c);
 
bool isAlnum(int c);
 
bool isAlpha(int c);
 
bool isDigit(int c);
 
bool isXDigit(int c);
 
bool isLower(int c);
 
bool isSpace(int c);
 
bool isUpper(int c);
 
bool isPrint(int c);
 
bool isPunct(int c);
 
bool isCntrl(int c);
 
bool isGraph(int c);
 
bool isBlank(int c);
 
 
Common::String getHumanReadableBytes(uint64 bytes, const char *&unitsOut);
 
namespace DateTime {
    TimeDate int64ToTimeDate(int64 integer);
 
    int64_t dateTimeToInt64(const TimeDate &timeDate);
 
    Common::String formatTime(int64 integer);
 
    int64 getTime();
}
 
template<typename T, bool useMove = Common::is_move_constructible<T>::v && Common::is_move_assignable<T>::v>
struct SWAP_helper {};
 
template<typename T>
struct SWAP_helper<T, true> {
    static void swap(T &a, T &b) {
        T tmp = Common::move(a);
        a = Common::move(b);
        b = Common::move(tmp);
    }
};
 
template<typename T>
struct SWAP_helper<T, false> {
    static void swap(T &a, T &b) {
        T tmp = a;
        a = b;
        b = tmp;
    }
};
 
} // End of namespace Common
 
template<typename T> inline void SWAP(T &a, T &b) { Common::SWAP_helper<T>::swap(a, b); }
 
#endif