cxxutil.h

Go to the documentation of this file.

/* This file is part of the Tomographer project, which is distributed under the
 * terms of the MIT license.
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2016 ETH Zurich, Institute for Theoretical Physics, Philippe Faist
 * Copyright (c) 2017 Caltech, Institute for Quantum Information and Matter, Philippe Faist
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#ifndef TOMOGRAPHER_TOOLS_UTILS_H
#define TOMOGRAPHER_TOOLS_UTILS_H

#include <cassert>
#include <cstddef>
#include <cstdlib>

#include <iostream>
#include <complex>
#include <type_traits>
#include <exception>
#include <stdexcept>

#include <tomographer/tools/cxxdefs.h>
#include <tomographer/tools/conststr.h>

// get a demangle() function from Boost, either with boost::core::demangle() (boost >=
// 1.56) or boost::units::detail::demangle() (boost before that)
#include <boost/version.hpp>
#if BOOST_VERSION >= 105600
#include <boost/core/demangle.hpp>
#else
#include <boost/units/detail/utility.hpp>
namespace boost { namespace core {  using boost::units::detail::demangle; } }
#endif

#include <Eigen/Core>

// -----------------------------------------------


namespace Tomographer
{
namespace Tools
{

// taken from http://stackoverflow.com/a/25510879/1694896

namespace tomo_internal {
  template <typename F>
  struct FinalAction {
    FinalAction(F f) : clean_(f) {}
    ~FinalAction() { clean_(); }
    F clean_;
  };
} // namespace tomo_internal

template <typename F>
inline tomo_internal::FinalAction<F> finally(F f)
{
  return tomo_internal::FinalAction<F>(f);
}



// -----------------------------------------------------------------------------

// see http://aherrmann.github.io/programming/2016/02/28/unpacking-tuples-in-cpp14/ and
// http://stackoverflow.com/questions/17424477/implementation-c14-make-integer-sequence/17426611#17426611
//

template<typename T, T...> struct Sequence { typedef Sequence type; };

template<typename T, typename S1, typename S2> struct Concatenate;

template<typename T, T... I1, T... I2>
struct Concatenate<T, Sequence<T, I1...>, Sequence<T, I2...> >
  : Sequence<T, I1..., (sizeof...(I1)+I2)...> {};

template<typename T, T N, typename dummy = void>
struct GenerateSequence;

template<typename T, T N, typename >
struct GenerateSequence : Concatenate<T, typename GenerateSequence<T, N/2>::type,
                                      typename GenerateSequence<T, N - N/2>::type>::type {};

template<typename T, T N>
struct GenerateSequence<T, N, typename std::enable_if<(N==0),void>::type>
  : Sequence<T> {};

template<typename T, T N>
struct GenerateSequence<T, N, typename std::enable_if<(N==1),void>::type>
  : Sequence<T, 0> {};




// -----------------------------------------------------------------------------


template<typename T_, bool IsDynamic_, T_ StaticValue_ = T_()>
class TOMOGRAPHER_EXPORT StaticOrDynamic
{

public:
  // definitions here are for the static case, the dynamic case will be specialized below.
  TOMO_STATIC_ASSERT_EXPR(IsDynamic_ == false) ;

  typedef T_ T;
  static constexpr bool IsDynamic = IsDynamic_;
  static constexpr T StaticValue = StaticValue_;

  inline StaticOrDynamic() { }
  inline explicit StaticOrDynamic(T val) {
    tomographer_assert(val == StaticValue);
    (void)val; // silence "unused parameter" warning if tomographer_assert() gets optimized out
  }

  inline T value() const { return StaticValue; }

  inline T operator()() const { return StaticValue; }
};
// static properties
template<typename T_, bool IsDynamic_, T_ StaticValue_>
constexpr bool StaticOrDynamic<T_, IsDynamic_, StaticValue_>::IsDynamic;
template<typename T_, bool IsDynamic_, T_ StaticValue_>
constexpr typename StaticOrDynamic<T_, IsDynamic_, StaticValue_>::T StaticOrDynamic<T_, IsDynamic_, StaticValue_>::StaticValue;

template<typename T_, T_ StaticValue_>
class TOMOGRAPHER_EXPORT StaticOrDynamic<T_, true, StaticValue_>
{
public:

  typedef T_ T;
  static constexpr bool IsDynamic = true;

  
  StaticOrDynamic() = delete;
  inline explicit StaticOrDynamic(T val) : _dyn_value(val) { }


  inline T value() const { return _dyn_value; }

  inline T operator()() const { return value(); }

private:

  const T _dyn_value;
};
// static properties
template<typename T_, T_ StaticValue_>
constexpr bool StaticOrDynamic<T_, true, StaticValue_>::IsDynamic;


// -----------------------------------------------------------------------------


template<typename T_, bool enabled>
struct TOMOGRAPHER_EXPORT StoreIfEnabled
{
  typedef T_ T;
  static constexpr bool IsEnabled = false;

  template<typename... Args>
  explicit StoreIfEnabled(Args...) { }
};
// static properties
template<typename T_, bool enabled>
constexpr bool StoreIfEnabled<T_, enabled>::IsEnabled;
template<typename T_>
struct TOMOGRAPHER_EXPORT StoreIfEnabled<T_, true>
{
  typedef T_ T;
  static constexpr bool IsEnabled = true;

  T value;

  template<typename... ArgTypes>
  explicit StoreIfEnabled(const ArgTypes& ...  args) : value(args...) { }
};
// static properties:
template<typename T_>
constexpr bool StoreIfEnabled<T_, true>::IsEnabled;

template<typename T>
inline std::ostream & operator<<(std::ostream & str, const StoreIfEnabled<T, false>& /*val*/)
{
  str << "[-]";
  return str;
}
template<typename T>
inline std::ostream & operator<<(std::ostream & str, const StoreIfEnabled<T, true>& val)
{
  str << val.value;
  return str;
}



// -----------------------------------------------------------------------------


template<typename IntType = int>
inline constexpr bool isPowerOfTwo(IntType N)
{
  // taken from http://stackoverflow.com/q/10585450/1694896
  return N && !(N & (N - 1));
}


// -----------------------------------------------------------------------------


template<typename Scalar>
struct ComplexRealScalar {
  typedef Scalar type;
};

template<typename RealScalar>
struct ComplexRealScalar<std::complex<RealScalar> >
{
  typedef RealScalar type;
};




template<typename X>
inline typename std::enable_if<std::is_unsigned<X>::value, bool>::type isPositive(const X /* val */)
{
  return true;
}
template<typename X>
inline typename std::enable_if<!std::is_unsigned<X>::value, bool>::type isPositive(const X val)
{
  return val >= 0;
}



template<typename X>
inline bool isFinite(const X val)
{
  return std::isfinite(val);
}



template<typename IntType>
inline constexpr bool additionWillOverflow(IntType a, IntType b)
{
  // see https://stackoverflow.com/a/1514309/1694896
  TOMO_STATIC_ASSERT_EXPR(std::numeric_limits<IntType>::is_integer) ;
  return (b > 0 && a > std::numeric_limits<IntType>::max() - b) ||
    (b < 0 && a < std::numeric_limits<IntType>::min() - b) ;
}

template<typename IntType, typename ... IntTypes>
inline constexpr bool additionWillOverflow(IntType a, IntType b, IntType c, IntTypes ... rest)
{
  return additionWillOverflow(a, b) || additionWillOverflow(IntType(a + b), c, IntTypes(rest)...) ;
}


// namespace tomo_internal {
// template<typename IntType>
// struct mult_will_overflow_helper {
//   constexpr int NumBits = std::numeric_limits<IntType>::digits();
//   constexpr int HalfNumBits = NumBits/2;
//   constexpr IntType LoHalfBitsMask = (IntType(1) << HalfNumBits) - 1 ;
//   inline constexpr bool calc(IntType a, IntType b)
//   {
//     return ( isPositive(a)
//              ? ( isPositive(b)
//                  // a >= 0, b >= 0
//                  ? calc_parts(a >> HalfNumBits, a & LoHalfBitsMask,
//                               b >> HalfNumBits, b & LoHalfBitsMask)
//                  // a >= 0, b < 0
//                  : calc_parts(a >> HalfNumBits, a & LoHalfBitsMask,
//                               -(b / (2 << HalfNumBits)), b % (2 << HalfNumBits), true )
//   }
//   inline constexpr bool calc_parts(IntType ahi, IntType alo, IntType bhi, IntType blo, bool isneg = false)
//   {
//     return (!isneg
//             ?  ( (alo*bhi >= 1) ||
//                  additionWillOverflow((alo*bhi) << HalfNumBits, (ahi*blo) << HalfNumBits, alo*blo) )
//             : ( ((alo*bhi > 0) &&
//                  additionWillOverflow((alo*bhi) << HalfNumBits, (ahi*blo) << HalfNumBits, alo*blo - 1) ||
//                  (alo*bhi ........??????????????
//   }
// };
// }

template<typename IntType>
inline constexpr bool multiplicationWillOverflow(IntType a, IntType b)
{
  TOMO_STATIC_ASSERT_EXPR(std::numeric_limits<IntType>::is_integer) ;
  // see https://www.securecoding.cert.org/confluence/display/CINT/INT32-C.+Ensure+that+operations+on+signed+integers+do+not+result+in+overflow
  return (
      (a > 0)
      ? ( (b > 0)
          ? (a > std::numeric_limits<IntType>::max() / b)
          : (b < std::numeric_limits<IntType>::min() / a) )
      : ( (b > 0)
          ? (a < std::numeric_limits<IntType>::min() / b)
          : ((a != 0) && (b < std::numeric_limits<IntType>::max() / a)) )
      ) ;
}




// -----------------------------------------------------------------------------
// Define functions with printf-safe arguments, with compiler-generated warnings
// -----------------------------------------------------------------------------


// The PRINTFX_ARGS_SAFE macros are defined here, so that in the future we may support a
// wider range of compilers which may not understand the __attribute__(format)
// instruction.


// g++ or clang++ (or doxygen :-) )
#if defined(__GNUC__) || defined(__clang__) || defined(TOMOGRAPHER_PARSED_BY_DOXGEN)

#  define PRINTF1_ARGS_SAFE  __attribute__ ((__format__ (__printf__, 1, 2)))
#  define PRINTF2_ARGS_SAFE  __attribute__ ((__format__ (__printf__, 2, 3)))
#  define PRINTF3_ARGS_SAFE  __attribute__ ((__format__ (__printf__, 3, 4)))
#  define PRINTF4_ARGS_SAFE  __attribute__ ((__format__ (__printf__, 4, 5)))
#else
#  define PRINTF1_ARGS_SAFE
#  define PRINTF2_ARGS_SAFE
#  define PRINTF3_ARGS_SAFE
#  define PRINTF4_ARGS_SAFE
#endif




#if TOMOGRAPHER_PARSED_BY_DOXYGEN

#  define TOMOGRAPHER_CXX_STACK_FORCE_REALIGN
#else // TOMOGRAPHER_PARSED_BY_DOXYGEN
//
#if defined(__GNUC__) || defined(__clang__)
#  if defined(__MINGW32__) || defined(__MINGW64__)
#    define TOMOGRAPHER_CXX_STACK_FORCE_REALIGN __attribute__((force_align_arg_pointer,noinline))
#  else
#    define TOMOGRAPHER_CXX_STACK_FORCE_REALIGN
#  endif
#elif defined(__ICC)
// but ICC is fine
#  define TOMOGRAPHER_CXX_STACK_FORCE_REALIGN
#else
#  warning "You are using an unknown compiler. You may run into memory alignment problems... Good luck!"
#  define TOMOGRAPHER_CXX_STACK_FORCE_REALIGN
#endif
//
#endif // TOMOGRAPHER_PARSED_BY_DOXYGEN


// Internal hacks...
// ---------------------------

// these are useful when writing SFINAE C++/C++11 hacks
namespace tomo_internal {
template<typename Enabledtype = void> struct sfinae_no { typedef int no[1]; };
template<typename EnabledType = void> struct sfinae_yes { typedef int yes[2]; };
} // namespace tomo_internal





inline int getWidthForTerminalOutput(int max_width = 0)
{
  if (max_width > 0) {
    return max_width;
  }
  // max_width <= 0:
  const int offset = max_width;
  // decide of a maximum width to display
#if defined(__MINGW32__) || defined(__MINGW64__)
  max_width = 80; // Windows terminals are usually 80 chars wide
#else
  max_width = 100; // default maximum width
#endif
  // Note that $COLUMNS is not in the environment usually, so you have to set it manually
  // with e.g.
  //     shell> export COLUMNS=$COLUMNS
  const char * cols_s = std::getenv("COLUMNS");
  if (cols_s != NULL) {
    max_width = std::atoi(cols_s);
  }
  max_width += offset; // if we had given, e.g. maxwidth=-4
  return max_width;
}






// -----------------------------------------------------------------------------
// Function Name-Related Stuff
// -----------------------------------------------------------------------------



#define TOMO_FUNCTION __PRETTY_FUNCTION__



namespace tomo_internal {
// logic taken from KLatexFormula/klftools: klfdefs.cpp / klfShortFuncSignature()
struct extractFuncName_helper {
  struct extracted {
    const std::size_t decl_pos;
    const conststr extr;
    constexpr extracted(std::size_t dp, const conststr& s) : decl_pos(dp), extr(s) { }
  };
  static constexpr conststr alltofirstparen(const conststr& s)
  {
    return s.substr(0, s.find(conststr("("), 0, s.size()));
  }
  static constexpr std::size_t declpos_from_found_spc(std::size_t found_pos)
  {
    return found_pos == std::string::npos ? 0 : found_pos + 1;
  }
  static constexpr std::size_t pos_decl(const conststr& s)
  {
    return ((s.size() > 2)
            ? declpos_from_found_spc(s.rfind(conststr(" "), std::string::npos))
            : 0);
  }
  static constexpr extracted allfromfirstspace(const conststr& s)
  {
    return extracted(pos_decl(s),
                     s.substr_e(pos_decl(s),
                                s.size()));
  }
  static constexpr extracted do_extract(const conststr& funcname)
  {
    return allfromfirstspace(alltofirstparen(funcname));
  }
  static constexpr conststr extract_choose(const extracted& do_extracted,
                                           const conststr& funcname)
  {
    return (do_extracted.extr.substr(0,8) == conststr("operator")
            ? funcname.substr(do_extracted.decl_pos)
            : do_extracted.extr);
  }
  static constexpr conststr extract(const conststr& funcname)
  {
    return extract_choose(do_extract(funcname), funcname);
  }
}; // helper struct
} // namespace tomo_internal


constexpr inline conststr extractFuncName(const conststr & funcname)
{
  return tomo_internal::extractFuncName_helper::extract(funcname);
}



} // namespace Tools
} // namespace Tomographer




#define TOMOGRAPHER_DEFINE_MSG_EXCEPTION(ClassName, ErrPrefix)          \
  class TOMOGRAPHER_EXPORT ClassName : public std::exception {          \
    std::string _msg;                                                   \
  public:                                                               \
    ClassName(std::string msg) : _msg(std::string(ErrPrefix) + std::move(msg)) { } \
    virtual ~ClassName() throw() { }                                    \
    std::string msg() const { return _msg; }                            \
    const char * what() const throw() { return _msg.c_str(); }          \
  };

#define TOMOGRAPHER_DEFINE_MSG_EXCEPTION_BASE(ClassName, ErrPrefix, BaseClass) \
  class TOMOGRAPHER_EXPORT ClassName : public BaseClass {               \
  public:                                                               \
    ClassName(std::string msg) : BaseClass(std::string(ErrPrefix) + std::move(msg)) { } \
    virtual ~ClassName() throw() { }                                    \
  };



namespace Tomographer {
namespace Tools {

template<typename ExceptionClass = std::runtime_error>
inline void tomographerEnsure(bool condition, std::string message) {
  if (!condition) {
    throw ExceptionClass(message);
  }
}






} // namespace Tools
} // namespace Tomographer



//
// boost.serialization of std::tuple -- needed e.g. in order to serialize
// MultipleMHRWStatsCollector::ResultType
//
namespace boost {
namespace serialization {

template<typename Archive, typename... TupleArgs>
struct serialize_tuple_helper {
  template<int I, TOMOGRAPHER_ENABLED_IF_TMPL(I < sizeof...(TupleArgs))>
  static void go(Archive & a, std::tuple<TupleArgs...> & tuple, const unsigned int version)
  {
    a & std::get<I>(tuple);
    go<I+1>(a, tuple, version);
  }
  template<int I, TOMOGRAPHER_ENABLED_IF_TMPL(I >= sizeof...(TupleArgs))>
  static void go(Archive & , std::tuple<TupleArgs...> & , const unsigned int)
  {
  }
};

template<typename Archive, typename... TupleArgs>
void serialize(Archive & a, std::tuple<TupleArgs...> & tuple, const unsigned int version)
{
  serialize_tuple_helper<Archive, TupleArgs...>::go<0>(a, tuple, version);
}

} // serialization
} // boost


#endif