util_inl.h

#pragma once


#include <libutl/Ordering.h>


UTL_NS_BEGIN;


class BoolToggle
{
public:
    BoolToggle(bool& b)
        : _b(b)
    {
        _b = !_b;
    }

    ~BoolToggle()
    {
        _b = !_b;
    }

private:
    bool& _b;
};


template <typename T>
const T&
min(const T& v)
{
    return v;
}


template <typename T, typename... R>
const T&
min(const T& a, const T& b, const R&... args)
{
    return utl::min((b < a) ? b : a, args...);
}


template <typename T>
const T&
max(const T& v)
{
    return v;
}


template <typename T, typename... R>
const T&
max(const T& a, const T& b, const R&... args)
{
    return utl::max((b < a) ? a : b, args...);
}


inline uint32_t
nextPow2(uint32_t n)
{
    --n;
    n |= (n >> 1);
    n |= (n >> 2);
    n |= (n >> 4);
    n |= (n >> 8);
    n |= (n >> 16);
    return n + 1;
}


inline uint64_t
nextPow2(uint64_t n)
{
    --n;
    n |= (n >> 1);
    n |= (n >> 2);
    n |= (n >> 4);
    n |= (n >> 8);
    n |= (n >> 16);
    n |= (n >> 32);
    return n + 1;
}


template <class T>
inline T
nextMultiple(const T& x, const T& target)
{
    ASSERTD(x != 0);
    T rem = target % x;
    return (rem == 0) ? target : target + (x - rem);
}


inline uint32_t
nextMultipleOfPow2(uint32_t x, uint32_t target)
{
    ASSERTD(x != 0);
    ASSERTD(x == nextPow2(x));
    return (target + x - 1) & ~(x - 1);
}


inline uint64_t
nextMultipleOfPow2(uint64_t x, uint64_t target)
{
    ASSERTD(x != 0);
    ASSERTD(x == nextPow2(x));
    return (target + x - 1) & ~(x - 1);
}


inline size_t
allocatedSize(const Object* object)
{
    if (object == nullptr) return 0;
    return object->allocatedSize();
}


template <typename T>
void
arrayGrow(T*& array,
          size_t& arraySize,
          size_t minSize = size_t_max,
          size_t growthIncrement = size_t_max,
          const T* defVal = nullptr)
{
    // by default, just make room for one more object
    if (minSize == size_t_max) minSize = (arraySize + 1);

    // allocation is already big enough -> do nothing
    if (arraySize >= minSize) return;

    // compute new allocation size
    size_t newSize;
    if (growthIncrement == size_t_max)
    {
        newSize = nextPow2(minSize);
    }
    else
    {
        ASSERTD(growthIncrement == nextPow2(growthIncrement));
        newSize = nextMultipleOfPow2(growthIncrement, minSize);
    }
    ASSERTD(newSize >= minSize);

    // copy objects from old allocation to new
    T* newArray = new T[newSize];
    if (std::is_trivially_copyable<T>())
    {
        memcpy(newArray, array, arraySize * sizeof(T));
    }
    else
    {
        T* lhsPtr = newArray;
        T* rhsPtr = array;
        T* rhsLim = array + arraySize;
        for (; rhsPtr != rhsLim; ++lhsPtr, ++rhsPtr)
        {
            *lhsPtr = std::move(*rhsPtr);
        }
    }

    // if caller wants to initialize the objects we added on, do that
    if (defVal != nullptr)
    {
        T* lhsPtr = newArray + arraySize;
        T* lhsLim = newArray + newSize;
        for (; lhsPtr != lhsLim; ++lhsPtr)
        {
            *lhsPtr = *defVal;
        }
    }

    // clean up the old allocation & set array,arraySize for caller
    delete[] array;
    array = newArray;
    arraySize = newSize;
}


template <typename T>
void
arrayGrow(T*& array,
          T*& arrayPtr,
          T*& arrayLim,
          size_t minSize = size_t_max,
          size_t growthIncrement = size_t_max)
{
    size_t arraySize = arrayLim - array;
    size_t arrayIdx = arrayPtr - array;
    arrayGrow(array, arraySize, minSize, growthIncrement, static_cast<T*>(nullptr));
    arrayPtr = array + arrayIdx;
    arrayLim = array + arraySize;
}


template <typename T>
inline const T&
cast(const utl::Object& object)
{
    ASSERTD(object.isA(T));
    return static_cast<const T&>(object);
}


template <typename T>
inline T&
cast(utl::Object& object)
{
    ASSERTD(object.isA(T));
    return static_cast<T&>(object);
}


template <typename T>
inline const T*
cast(const utl::Object* object)
{
    ASSERTD((object == nullptr) || object->isA(T));
    return static_cast<const T*>(object);
}


template <typename T>
inline T*
cast(utl::Object* object)
{
    ASSERTD((object == nullptr) || object->isA(T));
    return static_cast<T*>(object);
}


template <typename T>
inline T&
cast_const(const utl::Object& object)
{
    ASSERTD(object.isA(T));
    return static_cast<T&>(const_cast<utl::Object&>(object));
}


template <typename T>
inline T*
cast_const(const utl::Object* object)
{
    ASSERTD((object == nullptr) || object->isA(T));
    return static_cast<T*>(const_cast<utl::Object*>(object));
}


template <typename T>
T*
clone(const T* object)
{
    if (object == nullptr) return nullptr;
    return object->clone();
}


template <typename T>
inline int
compare(const T& lhs, const T& rhs)
{
    if (lhs < rhs) return -1;
    if (lhs == rhs) return 0;
    return 1;
}


inline int
compare(const Object* lhs, const Object* rhs, const Ordering* ordering = nullptr)
{
    ASSERTD(lhs != nullptr);
    ASSERTD(rhs != nullptr);
    if (lhs == rhs) return 0;
    if (ordering == nullptr) return lhs->compare(*rhs);
    return ordering->cmp(lhs, rhs);
}


inline int
compareNullable(const Object* lhs, const Object* rhs, const Ordering* ordering = nullptr)
{
    if (lhs == rhs) return 0;
    if ((lhs != nullptr) && (rhs != nullptr))
    {
        if (ordering == nullptr) return lhs->compare(*rhs);
        return ordering->cmp(lhs, rhs);
    }
    if (lhs == nullptr) return -1;
    // rhs must be nullptr
    return 1;
}


template <typename T>
int
compare(const T* lhs, const T* rhs, size_t len)
{
    size_t i;
    for (i = 0; i < len; i++)
    {
        int res = utl::compare(lhs[i], rhs[i]);
        if (res != 0)
        {
            return res;
        }
    }
    return 0;
}


template <typename T>
int
compare(const T* lhs, size_t lhsLen, const T* rhs, size_t rhsLen)
{
    size_t i;
    size_t minLen = utl::min(lhsLen, rhsLen);
    for (i = 0; i < minLen; i++)
    {
        int res = utl::compare(lhs[i], rhs[i]);
        if (res != 0)
        {
            return res;
        }
    }
    if (lhsLen < minLen)
        return -1;
    else if (rhsLen < minLen)
        return 1;
    return 0;
}


template <typename InputCont1, typename InputCont2>
int
compare(typename InputCont1::const_iterator lhsBegin,
        typename InputCont1::const_iterator lhsEnd,
        typename InputCont2::const_iterator rhsBegin,
        typename InputCont2::const_iterator rhsEnd,
        std::function<int(typename InputCont1::value_type, typename InputCont2::value_type)> comp)
{
    auto lhsIt = lhsBegin;
    auto rhsIt = rhsBegin;
    for (;; ++lhsIt, ++rhsIt)
    {
        bool lhsDone = (lhsIt == lhsEnd);
        bool rhsDone = (rhsIt == rhsEnd);
        if (lhsDone && rhsDone) return 0;
        if (lhsDone) return -1;
        if (rhsDone) return 1;
        int res = comp(*lhsIt, *rhsIt);
        if (res != 0) return res;
    }
    ABORT();
    return 0;
}


inline bool
comparisonResultMatchesOp(int cmpRes, uint_t cmpOp)
{
    if (cmpRes < 0)
    {
        return (cmpOp == cmp_lessThan);
    }
    if (cmpRes == 0)
    {
        return ((cmpOp != cmp_lessThan) && (cmpOp != cmp_greaterThan));
    }
    return (cmpOp == cmp_greaterThan);
}


template <typename T>
struct comparisonFunctor
{
    comparisonFunctor(const Ordering* ordering = nullptr)
        : _ordering(ordering)
    {
    }

    int operator()(const Object* lhs, const Object* rhs) const
    {
        return utl::compare(lhs, rhs, _ordering);
    }

private:
    const Ordering* _ordering;
};


template <typename T = utl::Object>
struct equals
{
    equals(const Ordering* ordering = nullptr)
        : _ordering(ordering)
    {
    }

    bool operator()(const T* lhs, const T* rhs) const
    {
        return (utl::compare(lhs, rhs, _ordering) == 0);
    }

private:
    const Ordering* _ordering;
};


template <typename T = utl::Object>
struct lessThan
{
    lessThan(const Ordering* ordering = nullptr)
        : _ordering(ordering)
    {
    }

    bool operator()(const T* lhs, const T* rhs) const
    {
        return (utl::compare(lhs, rhs, _ordering) < 0);
    }

private:
    const Ordering* _ordering;
};


template <typename T>
void
copy(T* dest, const T* src, size_t len)
{
    T* destPtr = dest;
    const T* srcPtr = src;
    const T* srcLim = src + len;
    for (; srcPtr != srcLim; ++srcPtr, ++destPtr)
    {
        *destPtr = *srcPtr;
    }
}


template <class T>
inline bool
isDivisibleBy(const T& x, const T& n)
{
    return (((x / n) * n) == x);
}


template <typename T>
inline T
roundUp(const T& v, const T& m)
{
    T vModm = v % m;
    if (vModm == 0) return v;
    return (v - vModm + m);
}


template <typename T>
inline T
roundDown(const T& v, const T& m)
{
    return v - (v % m);
}


template <typename T>
void
serialize(T* array, size_t len, Stream& stream, uint_t io, uint_t mode = ser_default)
{
    if (mode & ser_default) mode = getSerializeMode();
    size_t i;
    for (i = 0; i < len; i++)
    {
        serialize(array[i], stream, io, mode);
    }
}


template <typename T>
inline void
serialize(T*& object, Stream& stream, uint_t io, uint_t mode = ser_default)
{
    serializeBoxed(object, stream, io, mode);
}


template <typename T>
inline void
serialize(T& object, Stream& stream, uint_t io, uint_t mode = ser_default)
{
    object.serialize(stream, io, mode);
}


template <typename T>
void
serializeNullable(T*& object, Stream& stream, uint_t io, uint_t mode = ser_default)
{
    if (io == io_rd)
    {
        delete object;
        object = nullptr;
        Object* _object = Object::serializeInNullable(stream, mode);
        object = utl::cast<T>(_object);
    }
    else
    {
        Object::serializeOutNullable(object, stream, mode);
    }
}


template <typename T>
void
serializeBoxed(T*& object, Stream& stream, uint_t io, uint_t mode = ser_default)
{
    if (io == io_rd)
    {
        delete object;
        object = nullptr;
        Object* _object = Object::serializeInBoxed(stream, mode);
        object = utl::cast<T>(_object);
    }
    else
    {
        object->serializeOutBoxed(stream, mode);
    }
}


inline uint16_t
reverseBytes(uint16_t n)
{
    return ((n & 0xff00) >> 8) | ((n & 0x00ff) << 8);
}


inline uint32_t
reverseBytes(uint32_t n)
{
    n = ((n & 0xffff0000) >> 16) | ((n & 0x0000ffff) << 16);
    n = ((n & 0xff00ff00) >> 8) | ((n & 0x00ff00ff) << 8);
    return n;
}


inline uint64_t
reverseBytes(uint64_t n)
{
    n = ((n & 0xffffffff00000000) >> 32) | ((n & 0x00000000ffffffff) << 32);
    n = ((n & 0xffff0000ffff0000) >> 16) | ((n & 0x0000ffff0000ffff) << 16);
    n = ((n & 0xff00ff00ff00ff00) >> 8) | ((n & 0x00ff00ff00ff00ff) << 8);
    return n;
}


template <typename T>
inline void
swap(T* array, size_t lhsIdx, size_t rhsIdx)
{
    T tmp = std::move(array[lhsIdx]);
    array[lhsIdx] = std::move(array[rhsIdx]);
    array[rhsIdx] = std::move(tmp);
}


template <typename T>
void
swap(T* array, size_t lhsIdx, size_t rhsIdx, size_t size)
{
    T* pi = array + lhsIdx;
    T* pj = array + rhsIdx;
    T* piLim = array + lhsIdx + size;
    T tmp;
    for (; pi != piLim; ++pi, ++pj)
    {
        tmp = std::move(*pi);
        *pi = std::move(*pj);
        *pj = std::move(tmp);
    }
}


inline void
clobber()
{
    // volatile -> instruct the optimizer to leave this assembly code alone & not analyze it
    // memory   -> assume that global memory is "clobbered" (affected)
    asm volatile("" : : : "memory");
}


inline void
escape(void* ptr)
{
    // volatile -> instruct the optimizer to leave this assembly code alone & not analyze it
    // "g"(ptr) -> the (empty) assembly code uses ptr as an input
    // memory   -> assume that global memory is "clobbered" (affected)
    asm volatile("" : : "g"(ptr) : "memory");
}


constexpr size_t
KB(size_t n)
{
    return n * (size_t)1024;
}


constexpr size_t
MB(size_t n)
{
    return n * (size_t)1024 * (size_t)1024;
}


constexpr size_t
GB(size_t n)
{
    return n * (size_t)1024 * (size_t)1024 * (size_t)1024;
}


UTL_NS_END;