MCDefs.hpp

/*
 *  This file is part of the AiBO+ project
 *
 *  Copyright (C) 2005-2016 Csaba Kertész (csaba.kertesz@gmail.com)
 *
 *  AiBO+ is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  AiBO+ 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Street #330, Boston, MA 02111-1307, USA.
 *
 */

#pragma once

#ifndef __AIBO_BUILD__
#include <QString>
#endif

#include <boost/algorithm/string/case_conv.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_int.hpp>
#include <boost/random/variate_generator.hpp>
#include <boost/shared_ptr.hpp>

// This hack is needed for testing
#if defined(protected)
#undef protected
#undef private
#include <sstream> // krazy:exclude=includes
#define protected public
#define private public
#else
#include <sstream>
#endif
#include <string>

// These conditions are because of PVS Studio
#if defined(__unix__) || defined(__APPLE__) || defined(__MINGW32__) || defined(__MINGW64__)
#include <cxxabi.h>
#endif
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <typeinfo>
#include <unistd.h>

#define foreach_i(_i, _iter, _container) \
  unsigned int _i = 0; \
 \
  for (auto _iter = _container.begin(); _iter != _container.end(); ++_i, ++_iter)

template <typename T>
struct iterator_extractor { typedef typename T::iterator type; };

template <typename T>
struct iterator_extractor<T const> { typedef typename T::const_iterator type; };

template <typename T>
class Indexer {
public:
  class iterator {
    typedef typename iterator_extractor<T>::type inner_iterator;

    typedef typename std::iterator_traits<inner_iterator>::reference inner_reference;
  public:
    struct reference
    {
      reference (const size_t& _i, const inner_reference& _ref) : i(_i), ref(_ref) { }

      inner_reference operator*() const { return ref; }

      size_t i;
      inner_reference ref;
    };

    explicit iterator(inner_iterator it): _pos(0), _it(it) {}

    reference operator*() const { return reference(_pos, *_it); }

    iterator& operator++() { ++_pos; ++_it; return *this; }
    iterator operator++(int) { iterator tmp(*this); ++*this; return tmp; }

    bool operator==(iterator const& it) const { return _it == it._it; }
    bool operator!=(iterator const& it) const { return !(*this == it); }

  private:
    size_t _pos;
    inner_iterator _it;
  };

  explicit Indexer(T& t): _container(t) {}

  iterator begin() const { return iterator(_container.begin()); }
  iterator end() const { return iterator(_container.end()); }

private:
  T& _container;
};

template <typename T>
Indexer<T> index(T& t) { return Indexer<T>(t); }

// Macros to replace the broken exception handling on AIBO with a setjmp/longjmp hack
#if defined(__AIBO_BUILD__)
extern "C"
{
extern jmp_buf JumpPoint;
extern int JumpPointValid;
extern void RaiseCppException();
}

#define MC_TRY_BEGIN MC_TRY_BEGIN_1(1)
#define MC_CATCH_BEGIN MC_CATCH_BEGIN_1(1)
#define MC_CATCH_END MC_CATCH_END_1(1)

#define MC_TRY_BEGIN_1(_num) \
  try { \
    JumpPointValid = 1; \
    if (setjmp(JumpPoint) != 0) \
    {  \
       if (JumpPointValid) \
         goto exception_happened##_num; \
    } \
    if (!JumpPointValid) \
      goto finish##_num;

#define MC_CATCH_BEGIN_1(_num) \
    goto finish##_num; \
  } catch(...) { } \
exception_happened##_num:

#define MC_CATCH_END_1(_num) \
finish##_num: \
  JumpPointValid = 0;

#else
#define MC_TRY_BEGIN try {
#define MC_CATCH_BEGIN } catch(...) {
#define MC_CATCH_END }
#define MC_TRY_BEGIN_1(...) try {
#define MC_CATCH_BEGIN_1(...) } catch(...) {
#define MC_CATCH_END_1(...) }
#endif

namespace MC
{
typedef boost::variate_generator<boost::mt19937&, boost::uniform_int<> > RandomGeneratorType;
}

class MCRandomSeed
{
  template<typename T>
  friend T MCRandComplex(const T& min, const T& max);

public:

  static void SetNewSeed(int seed = (int)time(nullptr));

private:
  static boost::mt19937 Algorithm;
};

template <typename T>
T MCRandComplex(const T& min, const T& max)
{
  MC::RandomGeneratorType Generator(MCRandomSeed::Algorithm, boost::uniform_int<>((int)min, (int)max));

  return (T)Generator();
}

template <typename T>
T MCRand(const T& min, const T& max)
{
  return rand() % (int)(max-min+1)+min;
}

extern int MCRandSign();

extern void MCSleep(unsigned int msecs);

#if !defined(__AIBO_BUILD__) && defined(__unix__)

extern int MCGetSystemMemorySize();
#endif

extern float MCFloatInfinity();

extern double MCDoubleInfinity();

extern bool MCIsFloatInfinity(const float value);

extern bool MCIsDoubleInfinity(const double value);

extern float MCRound(float number);

extern float MCScaleValue(float value, float min, float max, float new_max);

template <typename T>
std::string MCToStr(const T value, bool hex_manipulator = false)
{
  std::stringstream Tmp;

  if (hex_manipulator)
    Tmp << std::hex;
  Tmp << value;
  return Tmp.str();
}

template <typename T>
T MCStrConvert(const std::string& str)
{
  std::stringstream Tmp(str);
  T Value;

  Tmp >> Value;
  return Value;
}

template <typename T>
T MCAbs(const T& value)
{
  return value >= 0 ? value : -value;
}

extern int MCCompare(const std::string& item, const std::string& a, const std::string& b);

template <typename T>
int MCCompare(const T& item, const T& a, const T& b)
{
  T Diff1 = MCAbs(a-item);
  T Diff2 = MCAbs(b-item);

  if (Diff1 == Diff2)
  {
    return 0;
  }
  return Diff1 < Diff2 ? -1 : 1;
}

extern int MCCompare(const std::string& a, const std::string& b);

template <typename T>
int MCCompare(const T& a, const T& b)
{
  if (a == b)
    return 0;

  return a > b ? -1 : 1;
}

template <typename T>
const T& MCMin(const T& a, const T& b)
{
  if (a < b)
    return a;
  return b;
}

template <typename T>
const T& MCMax(const T& a, const T& b)
{
  if (a < b)
    return b;
  return a;
}

template <typename T>
const T& MCBound(const T& min, const T& value, const T& max)
{
  return MCMax(min, MCMin(max, value));
}

template <typename T>
bool MCRangeCheck(const T& value, const T& min, const T& max)
{
  if (value < MCMin(min, max) || value > MCMax(min, max))
    return false;

  return true;
}

#if defined(__GNUC__) || defined(__clang__)
#define likely(x) __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)
#else
#define likely(x) x
#define unlikely(x) x
#endif

// Help clang's static analyzer to determinate functions that never return
#ifndef __has_feature
#define __has_feature(x) 0 // Compatibility with non-clang compilers.
#endif
#ifndef CLANG_ANALYZER_NORETURN
#if __has_feature(attribute_analyzer_noreturn)
#define CLANG_ANALYZER_NORETURN __attribute__((analyzer_noreturn))
#else
#define CLANG_ANALYZER_NORETURN
#endif
#endif

#if defined(__MINGW32__) || defined(__MINGW64__)
#define MC_DIR_SEPARATOR "\\"
#else
#define MC_DIR_SEPARATOR "/"
#endif

#if defined(__unix__)
#define MC_ANSI_RED "\033[1;31m"
#define MC_ANSI_BLACK "\033[1;30m"
#define MC_ANSI_PURPLE "\033[1;35m"
#define MC_ANSI_GREEN "\033[1;32m"
#define MC_ANSI_COLOR_END "\033[0;39m"
#else
#define MC_ANSI_RED ""
#define MC_ANSI_BLACK ""
#define MC_ANSI_PURPLE ""
#define MC_ANSI_GREEN ""
#define MC_ANSI_COLOR_END ""
#endif

#define MC_UNUSED(a) (void)a;

#define MC_DISABLE_COPY(class_name) \
private: \
  class_name(const class_name&); \
  class_name& operator=(const class_name&); \
public:

#define MC_DISABLE_DEFAULT_CTOR(class_name) \
private: \
  class_name(); \
public:

template <typename T>
std::string MCGetClassName(T* instance = nullptr, const std::string& name_suffix = "")
{
  // Note: The instance parameter is "fake" argument for easier use of the function
  MC_UNUSED(instance)

  char* ClassName = nullptr;
  std::string ClassNameStr = "";
  int DemangleStatus = 0;

  ClassName = abi::__cxa_demangle(typeid(T).name(), 0, 0, &DemangleStatus);
  if (ClassName)
  {
    ClassNameStr = ClassName;
    ClassNameStr += name_suffix;
  }
  free(ClassName);
  ClassName = nullptr;
  return ClassNameStr;
}

extern bool MCFileExists(const std::string& file_name);

extern int MCGetFileSize(const std::string& file_name);

#ifndef __AIBO_BUILD__
#if defined(__unix__) && !defined(__ANDROID__)

extern void MCGenerateBacktrace();
#endif

extern bool MCCreatePath(const QString& path_str);

extern bool MCRemoveDirectory(const QString& dir_str);

extern QString MCFixPath(const QString& path);

extern void MCAddSearchPath(const QString& path);

extern QString MCGetDataFile(const QString& file_name);

extern QString MCGetDataSubdirectory(const QString& subdirectory);
#endif