util.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
// vi:set ts=4 sts=4 sw=4 noet :
// Copyright 2009, 2012, The TPIE development team
// 
// This file is part of TPIE.
// 
// TPIE is free software: you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License as published by the
// Free Software Foundation, either version 3 of the License, or (at your
// option) any later version.
// 
// TPIE 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 Lesser General Public
// License for more details.
// 
// You should have received a copy of the GNU Lesser General Public License
// along with TPIE.  If not, see <http://www.gnu.org/licenses/>
 
 
#ifndef __TPIE_UTIL_H__
#define __TPIE_UTIL_H__
#include <tpie/tpie_export.h>
#include <tpie/config.h>
#include <tpie/types.h>
#include <cmath>
#include <string>
 
namespace tpie {
 
template <typename T>
inline void unused(const T & x) {(void)x;}
 
template <typename T> struct sign {typedef T type;};
template <> struct sign<uint8_t> {typedef int8_t type;};
template <> struct sign<uint16_t> {typedef int16_t type;};
template <> struct sign<uint32_t> {typedef int32_t type;};
template <> struct sign<uint64_t> {typedef int64_t type;};
 
template <typename T> struct unsign {typedef T type;};
template <> struct unsign<int8_t> {typedef uint8_t type;};
template <> struct unsign<int16_t> {typedef uint16_t type;};
template <> struct unsign<int32_t> {typedef uint32_t type;};
template <> struct unsign<int64_t> {typedef uint64_t type;};
 
#ifdef _WIN32
const char directory_delimiter = '\\';
#else
const char directory_delimiter = '/';
#endif
 
struct linear_memory_usage {
    const double coefficient;
    const double overhead;
    constexpr linear_memory_usage(const double coefficient, const double overhead) noexcept :
    coefficient(coefficient), overhead(overhead) {}
 
    constexpr memory_size_type operator()(memory_size_type size) const noexcept {
        return static_cast<memory_size_type>(
            static_cast<double>(size) * coefficient + overhead);
    }
 
    constexpr friend linear_memory_usage operator * (const linear_memory_usage & o, double scale) noexcept {
        return linear_memory_usage(o.coefficient * scale, o.overhead * scale);
    }
 
    constexpr friend linear_memory_usage operator + (const linear_memory_usage & o, double value) noexcept {
        return linear_memory_usage(o.coefficient, o.overhead + value);
    }
 
    constexpr friend linear_memory_usage operator + (const linear_memory_usage & l, const linear_memory_usage & r) noexcept {
        return linear_memory_usage(l.coefficient + r.coefficient, l.overhead * r.overhead);
    }
};
 
 
template <typename child_t> 
struct linear_memory_base {
 
    static constexpr memory_size_type memory_usage(memory_size_type size) noexcept {
        return static_cast<memory_size_type>(
            floor(static_cast<double>(size) * child_t::memory_coefficient() + child_t::memory_overhead()));
    }
 
    static constexpr memory_size_type memory_fits(memory_size_type memory) noexcept {
        return static_cast<memory_size_type>(
            floor((memory - child_t::memory_overhead()) / child_t::memory_coefficient()));
    }
 
 
    static constexpr linear_memory_usage memory_usage() noexcept {
        return linear_memory_usage(child_t::memory_coefficient(), child_t::memory_overhead());
    }
};
 
template <int t>
struct template_log {
    static const size_t v=1+template_log< t/2 >::v;
};
 
template <>
struct template_log<1> {
    static const size_t v=1;
};
 
 
template <typename T, typename C>
void pop_and_push_heap(T a, T b, C lt) {
    size_t i=0;
    size_t n=(b-a);
    while (true) {
        size_t c=2*i+1;
        if (c+1 >= n) {
            if (c < n && lt(*(a+i), *(a+c)))
                std::swap(*(a+c), *(a+i));
            break;
        }
        if (lt(*(a+c+1), *(a+c))) {
            if (lt(*(a+i), *(a+c))) {
                std::swap(*(a+c), *(a+i));
                i=c;
            } else break;
        } else {
            if (lt(*(a+i), *(a+c+1))) {
                std::swap(*(a+c+1), *(a+i));
                i=c+1;
            } else break;
        }
    }
}
 
template <typename T>
void pop_and_push_heap(T a, T b) {
    pop_and_push_heap(a,b, std::less<typename T::value_type>());
}
 
 
template <typename T>
struct binary_argument_swap {
    T i;
    binary_argument_swap(const T & _=T()): i(_) {}
    template<typename T1, typename T2>
    bool operator()(const T1 & x, const T2 & y) const {
        return i(y,x);
    }
    template<typename T1, typename T2>
    bool operator()(const T1 & x, const T2 & y) {
        return i(y,x);
    }
};
 
TPIE_EXPORT void atomic_rename(const std::string & src, const std::string & dst);
 
 
TPIE_EXPORT std::string pretty_print_size(stream_size_type size);
 
template <typename T>
inline void free_structure_memory(T & v) {
    T t;
    std::swap(v, t);
}
 
#ifdef _WIN32
TPIE_EXPORT void throw_getlasterror();
#endif
 
} //namespace tpie
 
#endif //__TPIE_UTIL_H__