utils.hpp

Go to the documentation of this file.


#include "config.h"

#include <stdexcept>
#include <iostream>
#include <string>
#include <sstream>

// Used: @c FILE
#include <cstdio>
// Used: @c std::free()
#include <cstdlib>

#if HAVE_CSETJMP
#include <csetjmp>
#endif

#include <boost/shared_ptr.hpp>

#if HAVE_LOKI_FUNCTOR_H

#define LOKI_ENABLE_FUNCTION
#define LOKI_FUNCTOR_IS_NOT_A_SMALLOBJECT
#include <loki/Functor.h>

#endif // HAVE_LOKI_FUNCTOR_H

#ifndef UTILS_HPP_
#define UTILS_HPP_

const char bitsPerByte = 8;

template <typename Integer> class HexInteger{
private:
    Integer content;
public:
    HexInteger(Integer newContent):
        content(newContent)
    {}

    operator Integer() const{
        return content;
    }
};

template <typename Integer> std::ostream &operator<<(
    std::ostream &aOstream,
    const HexInteger<Integer> &x
){
    std::ios::fmtflags oldAOstreamFlags = aOstream.flags();
    aOstream << std::showbase << std::hex << Integer(x);
    aOstream.flags(oldAOstreamFlags);
    return aOstream;
}

struct null_deleter
{
    void operator()(void const *) const
    {
    }
};

class CArrayOfArrayDeleter{
private:
    size_t size1;

public:
    CArrayOfArrayDeleter(size_t newSize1):
        size1(newSize1)
    {}

    void operator()(void *array) const{
        void **arrayOfArray = static_cast<void**>(array);
        for(
            size_t i = 0;
            i < size1;
            i++
        ){
            free(arrayOfArray[i]);
        }
        free(arrayOfArray);
    }
};

class CFileWrapper{
private:
    boost::shared_ptr<FILE> file;

    struct CFileDeleter{
        void operator()(FILE *file){
            if(file != NULL){
                int result = fclose(file);
                if(result == EOF){
                    std::cerr << "ERROR: Closing file" << std::endl;
                }
            }
        }
    };
public:
    CFileWrapper() {}

    CFileWrapper(const char *filename, const char *mode){
        open(filename, mode);
    }

    ~CFileWrapper() {}

    void open(const char *filename, const char *mode){
        file = boost::shared_ptr<FILE>(
            fopen(filename, mode),
            CFileDeleter()
        );
        if(file.get() == NULL){
            throw std::runtime_error(
                std::string("Cannot open file \"") +
                filename +
                "\""
            );
        }
    }


    FILE *get(){
        return file.get();
    }
};

#if HAVE_BOOST_SHARED_PTR_HPP

template <typename T> bool isEmpty(boost::shared_ptr<T> &p){
    return ( p == boost::shared_ptr<T>() );
}
#endif // HAVE_BOOST_SHARED_PTR_HPP

template <typename Integer> Integer roundDiv(
    Integer a,
    Integer b
){
    if(a < 0 || b <= 0){
        throw std::runtime_error(std::string(__PRETTY_FUNCTION__)+" is only for positive integers");
    }

    Integer q = a/b;
    Integer r = a%b;

    if(r < b/2){
        return q;
    }else if(r > b/2){
        return q+1;
    }else{
        // r == b/2
        return q+(q%2);
    }
}

template <typename T> std::istream &readBin(std::istream &inStream, T &field){
    return inStream.read(
        reinterpret_cast<char*>(&field),
        sizeof(field)
    );
}

template <typename T> std::ostream &writeBin(std::ostream &outStream, T &field){
    return outStream.write(
        reinterpret_cast<char*>(&field),
        sizeof(field)
    );
}

template <typename Integer> Integer checkedDivByMultiple(Integer a, Integer b){
    if(a % b != 0){
        throw std::runtime_error("\"divByMultiple\": divisor isn\'t a multiple of dividend");
    }
    return a / b;
}

template <typename Integer> Integer checkedBitsToIntBytes(Integer bits){
    return checkedDivByMultiple(bits, Integer(bitsPerByte));
}

template <typename Out> Out getBytes(const char *whereFrom, int numBytes){
    Out result = 0;

    whereFrom += numBytes-1;

    const unsigned char *curWhereFrom =
        reinterpret_cast<const unsigned char*>(whereFrom);
    for(
        ;
        numBytes > 0;
        --numBytes
    ){
        result <<= bitsPerByte;
        result += *curWhereFrom;

        --curWhereFrom;
    }
    return result;
}

template <typename In> void setBytes(char *whereTo, int numBytes, In newValue){
    unsigned char *curWhereTo =
        reinterpret_cast<unsigned char*>(whereTo);
    for(
        ;
        numBytes > 0;
        --numBytes
    ){
        *curWhereTo = 0xff & newValue;
        newValue >>= bitsPerByte;

        ++curWhereTo;
    }
}

template <typename In> std::string lexicalCastToStdString(In a){
    std::ostringstream tmpOut;
    tmpOut << a;
    return tmpOut.str();
}

#define TODO_HERE(x) {                                                  \
    std::clog << std::string("TODO: ") +                                    \
    "in function \"" + __PRETTY_FUNCTION__ +                                \
    "\", file \"" + __FILE__ +                                              \
    "\" at line " + lexicalCastToStdString(__LINE__) <<                 \
    std::endl; }                                                            \
while(false)

#define TODO(x) {                                                           \
    std::clog << std::string("TODO: ") +                                    \
    "in function \"" + __PRETTY_FUNCTION__ +                                \
    "\", file \"" + __FILE__ +                                              \
    "\" at line " + lexicalCastToStdString(__LINE__) +                      \
    ": \n" + #x << std::endl; }                                         \
while(false)

#define TRACE(x) std::clog << "\"" << #x << "\" = \"" << x << "\"" << std::endl

#define ARRAY_SIZE(a) ( (sizeof( (a) )/sizeof( (a)[0])) )

#endif // UTILS_HPP_

---