util.h

Go to the documentation of this file.

#ifndef UTIL_HEADER_
#define UTIL_HEADER_


extern const int powers[31];

template<typename T> inline T sqr(T i)
    { return i*i; }
template<typename T> inline T cube(T i)
    { return i*i*i; }

template<typename T> inline T lShift(T i,T bits)
    { ASSERT(bits>=0); return i<<bits; }
    
template<typename T> inline T rShift(T i,T bits)
    { ASSERT(bits>=0 && i>=0); return i>>bits; }
    
template<typename T> inline T exp10(T val) 
    { return exp2( val*log2(T(10)) ); }

inline int log2ceil(int i) {
    ASSERT(i>0);
    --i;
    int result= 0;
    while (i) {
        i/= 2;
        ++result;
    }
    return result;
}

template<class T> inline bool isNaN(T num) {
#ifndef __ICC
    return isnan(num);
#else
    return num!=num;
#endif
}

inline int getCountForDensity(int longLength,int density,int shortLength)
    { return (longLength-shortLength)/density +1; }

inline int getCountForDensity2D(int width,int height,int density,int sideSize) {
    return getCountForDensity(width,density,sideSize)
    *   getCountForDensity(height,density,sideSize);
}

template<class T> inline T checkBoundsFunc(T low,T value,T high) {
    if (value<low)
        return low;
    if (value>high)
        return high;
    return value;
}

template<int power,class R> struct Float2int {
    static R convert(int i)
        { return std::ldexp( i+R(0.5), -power ); }  
        
    static int convert(R r)
        { return (int)trunc(std::ldexp( r, power )); }
    static int convertCheck(R r)
        { return checkBoundsFunc( 0, convert(r), powers[power]-1 ); }
};

template<class C,class F> inline F for_each(C &container,F functor)
    { return for_each( container.begin(), container.end(), functor ); }

inline int countEOLs(const char *s) {
    int result= 0;
    for (; *s; ++s)
        if (*s=='\n')
            ++result;
    return result;
}

template<class T> struct NonConstType           { typedef T Result; };
template<class T> struct NonConstType<const T>  { typedef T Result; };

template <class T> inline T* constCast(const T* toCast) { return const_cast<T*>(toCast); }
template <class T> inline T& constCast(const T& toCast) { return const_cast<T&>(toCast); }

inline void checkThrow(bool check) { if (!check) throw std::exception(); }


struct SingleDeleter {
    template <class T> void operator()(T *toDelete) const { delete toDelete; }
};
struct MultiDeleter {
    template <class T> void operator()(T *toDelete) const { delete[] toDelete; }
};


template<class C> inline void clearContainer(const C &container)
    { for_each( container, SingleDeleter() ); } 
template<class C> inline void clearQtContainer(C container)
    { while (!container.isEmpty()) delete container.takeFirst(); }  

template <class T,int bulkKb=64>
class BulkAllocator {
    enum { bulkCount=(bulkKb*1024)/sizeof(T) };

    std::vector<T*> pools;
    PtrInt nextIndex;

public:
    BulkAllocator()
    : nextIndex(bulkCount) {}
    BulkAllocator(const BulkAllocator &DEBUG_ONLY(copy))
        { nextIndex=bulkCount; ASSERT(copy.pools.empty()); }
    ~BulkAllocator()
        { for_each( pools, MultiDeleter() ); }

    T* make() {
    //  check for errors
        ASSERT(nextIndex<=bulkCount);
    //  allocate a new bulk if needed
        if (nextIndex==bulkCount) {
            nextIndex= 0;
            pools.push_back( new T[bulkCount] );
        }
        return & (pools.back()[nextIndex++]);
    }
    T* makeField(PtrInt count) {
    //  check for errors
        ASSERT(nextIndex<=bulkCount);

        if (count>bulkCount/2) {
            T *result= new T[count];
            if (pools.empty())
                pools.push_back(result);
            else {
                pools.push_back(pools.back());
                *(pools.end()-2)= result;
            }
            return result;
        }

        if (nextIndex+count>bulkCount) {
        //  some space will be wasted
            nextIndex=0;
            pools.push_back(new T[bulkCount]);
        }
        T *result=&pools.back()[nextIndex];
        nextIndex+=count;
        return result;
    }
}; // BulkAllocator class

struct UpdateInfo {
    typedef void (*IncInt)(int increment); 
    
    static void emptyFunction(int) {}       
    static const bool noTerminate= false;   
    static const UpdateInfo none;           

    volatile const bool *terminate; 
    IncInt incMaxProgress           
    , incProgress;                  

    UpdateInfo( const bool &terminate_, IncInt incMaxProgress_, IncInt incProgress_ )
    : terminate(&terminate_), incMaxProgress(incMaxProgress_), incProgress(incProgress_) 
        { ASSERT(isValid()); }
        
    bool isValid() const { return terminate && incMaxProgress && incProgress; }
};

#endif // UTIL_HEADER_

---