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"

#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) { T tmp = a; a = b; b = tmp; }

#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> struct remove_cv {
    typedef T type;
};
template<class T> struct remove_cv<const T> {
    typedef T type;
};
template<class T> struct remove_cv<volatile T> {
    typedef T type;
};
template<class T> struct remove_cv<const volatile T> {
    typedef T type;
};

template<class T> struct remove_const {
    typedef T type;
};
template<class T> struct remove_const<const T> {
    typedef T type;
};

template<class T> struct remove_volatile {
    typedef T type;
};
template<class T> struct remove_volatile<volatile T> {
    typedef T type;
};

template<class T>
struct remove_reference {
    typedef T type;
};
template<class T>
struct remove_reference<T &> {
    typedef T type;
};
template<class T>
struct remove_reference<T &&> {
    typedef T type;
};

template<class T>
using remove_cv_t        = typename remove_cv<T>::type;
template<class T>
using remove_const_t     = typename remove_const<T>::type;
template<class T>
using remove_volatile_t  = typename remove_volatile<T>::type;

template<class T>
using remove_reference_t = typename remove_reference<T>::type;

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;

    Pair() {
    }

    Pair(const Pair &other) : first(other.first), second(other.second) {
    }

    Pair(Pair &&other) : first(Common::move(other.first)), second(Common::move(other.second)) {
    }

    Pair(const T1 &first_, const T2 &second_) : first(first_), second(second_) {
    }

    Pair(T1 &&first_, T2 &&second_) : first(Common::move(first_)), second(Common::move(second_)) {
    }

    Pair(T1 &&first_, const T2 &second_) : first(Common::move(first_)), second(second_) {
    }

    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);

} // End of namespace Common

#endif