SPAR/AIModule/Utils/Utils.h

Go to the documentation of this file.

#pragma once

//------------------------------------------------------------------------------
// Compile-time assertions
//------------------------------------------------------------------------------
template<bool> struct static_assert;
template<> struct static_assert<true> { };

//------------------------------------------------------------------------------
// Unused variable (remove compilation warnings)
//------------------------------------------------------------------------------
template<class T> void unused(const T&) { }

//------------------------------------------------------------------------------
// Static selector
//------------------------------------------------------------------------------
template<bool Cond, class TrueType, class FalseType> struct static_if_else;

template<class TrueType, class FalseType>
struct static_if_else<true,TrueType,FalseType>  { typedef TrueType type; };

template<class TrueType, class FalseType>
struct static_if_else<false,TrueType,FalseType> { typedef FalseType type; };

//------------------------------------------------------------------------------
// Boolean type wrappers
//------------------------------------------------------------------------------
struct true_type { enum { value = true }; };
struct false_type { enum { value = false }; };

//------------------------------------------------------------------------------
// Compare two types (use boost::is_same instead)
//------------------------------------------------------------------------------
//template<class T, class U>
//struct boost::is_same : false_type { };
//
//template<class T>
//struct boost::is_same<T,T> : true_type { };

//------------------------------------------------------------------------------
// Templated empty class (with a lot of useless generic constructors!)
//------------------------------------------------------------------------------
template <class T>
struct empty
{
  empty(){}
  template <class T1> empty(const T1&) {}
  template <class T1, class T2> empty(const T1&, const T2&) {}
  template <class T1, class T2, class T3> empty(const T1&, const T2&, const T3&) {}
  template <class T1, class T2, class T3, class T4> empty(const T1&, const T2&, const T3&, const T4&) {}
  template <class T1, class T2, class T3, class T4, class T5> empty(const T1&, const T2&, const T3&, const T4& t4, const T5&) {}
};

//------------------------------------------------------------------------------
// Prevents taking the size of a pointer type
//------------------------------------------------------------------------------
// Use (sizeof array_size(a)) instead of (sizeof a / sizeof *a)
template<typename T, size_t N> size_t array_size(T(&)[N])
{
  return N;
}