utils.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#ifndef __UTILS_HEADER__
#define __UTILS_HEADER__

#include <stdlib.h>
#include <cstdlib>
#include <cmath>
#include <string.h> // For C string manipulation functions like strcmp

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <list>
#include <map>
#include <stack>
#include <stdexcept>
#include <sstream>

#ifdef _WIN32
  // Even though Allacrost is platform independent, OpenGL on Windows requires windows.h to be included
  #include <windows.h>
  // Case-insensitive string compare is called stricmp in Windows and strcasecmp everywhere else
  #define strcasecmp stricmp
#endif

#include <SDL/SDL.h>

typedef Sint32   int32;
typedef Uint32   uint32;
typedef Sint16   int16;
typedef Uint16   uint16;
typedef Sint8    int8;
typedef Uint8    uint8;

namespace hoa_utils {

extern bool UTILS_DEBUG;

const float UTILS_QUARTER_PI = 0.785398163f;
const float UTILS_HALF_PI    = 1.570796326f;
const float UTILS_PI         = 3.141592653f;
const float UTILS_2PI        = 6.283185307f;

uint32 RoundUpPow2(uint32 x);

bool IsPowerOfTwo(uint32 x);

bool IsOddNumber(uint32 x);

bool IsFloatInRange(float value, float lower, float upper);



float FloorToFloatMultiple (const float value, const float multiple);



template<class T>
void DataToString(std::string &s, const T &data)
{
  std::ostringstream stream;
  stream << data;
  s = stream.str();
}


class ustring {
public:
  ustring();

  ustring(const uint16*);

  static const size_t npos;

  void clear()
    { _str.clear(); _str.push_back(0); }

  bool empty() const
    { return _str.size() <= 1; }

  size_t length() const
    // We assume that there is always a null terminating character, hence the -1 subtracted from the size
    { return _str.size() - 1; }

  size_t size() const
    { return length(); }

  const uint16* c_str() const
    { return &_str[0]; }

  size_t find(uint16 c, size_t pos = 0) const;

  size_t find(const ustring &s, size_t pos = 0) const;

  ustring substr(size_t pos = 0, size_t n = npos) const;

  ustring & operator + (const ustring& s);

  ustring & operator += (uint16 c);

  ustring & operator += (const ustring& s);

  ustring & operator = (const ustring& s);

  uint16 & operator [] (size_t pos)
    { return _str[pos]; }

  const uint16 & operator [] (size_t pos) const
    { return _str[pos]; }

private:
  std::vector<uint16> _str;
}; // class ustring


template<typename T> class Singleton {
protected:
  static T* _singleton_reference;

  Singleton()
    {}

  virtual ~Singleton()
    {}

public:
  static T* SingletonCreate() {
    if (_singleton_reference == NULL) {
      _singleton_reference = new T();
    }
    else {
      if (UTILS_DEBUG)
        std::cerr << "UTILS WARNING: Singleton::SingletonCreate() was invoked when the class object was already instantiated" << std::endl;
    }
    return _singleton_reference;
  }

  static void SingletonDestroy() {
    if (_singleton_reference != NULL) {
      delete _singleton_reference;
    }
    else {
      if (UTILS_DEBUG)
        std::cerr << "UTILS WARNING: Singleton::SingletonDestroy() was invoked when the class object was not instantiated" << std::endl;
    }
    _singleton_reference = NULL;
  }

  static const T* SingletonGetReference()
    { return _singleton_reference; }

  virtual bool SingletonInitialize() = 0;

private:
  Singleton(const Singleton &s);
  Singleton& operator=(const Singleton &s);
}; // template<typename T> class Singleton





template <typename T>
std::string NumberToString(const T t)
{
  std::ostringstream text("");
  text << static_cast<int32>(t);
  return text.str();
}

bool IsStringNumeric(const std::string& text);

hoa_utils::ustring MakeUnicodeString(const std::string& text);

std::string MakeStandardString(const hoa_utils::ustring& text);


template <typename T, size_t N>
size_t NumberElementsArray(T (&)[N])
  { return N; }



float RandomFloat();

int32 RandomBoundedInteger(int32 lower_bound, int32 upper_bound);

/******************************************************************************
 * int GaussianValue(int mean, int range, bool positive_value):
 *
 *  This function computes a random number based on a Gaussian Distribution Curve. This number will be between
 *   mean - range and mean + range if range is greater than zero, otherwise it will return a true, unbounded
 *   guassian random value. If positive_value is set to true, this function will only return a number that is
 *   zero or positive.
 *
 *  Mean is (obviously) the mean, and the range represents the value for 3 standard deviations from the mean.
 *   That means that 99.7% of the random values chosen will lay between mean - range and mean + range, if
 *   range is a greater than or equal to zero.
 ******************************************************************************/
int32 GaussianRandomValue(int32 mean, float std_dev = 10.0f, bool positive_value = true);

/******************************************************************************
 * bool Probability(uint32 chance);
 *
 *  This function calculates a random number on a given chance and returns true if the chance occurs.
 *  For example, if calling Probability(25), there is a probability of 25% on returning `true`.
 ******************************************************************************/
bool Probability(uint32 chance);




template <typename T>
void InsertionSort(std::vector<T>& swap_vec) {
  int32 i, j;
  T value;
  for (i = 1; i < swap_vec.size(); i++) {
    value = swap_vec[i];
    for (j = i - 1; j >= 0 && swap_vec[j] > value; j--) {
      swap_vec[j+1] = swap_vec[j];
    }
    swap_vec[j+1] = value;
  }
} // void InsertionSort(std::vector<T>& swap_vec)



bool DoesFileExist(const std::string& file_name);

bool MoveFile(const std::string& source_name, const std::string& destination_name);

bool CleanDirectory(const std::string& dir_name);

bool MakeDirectory(const std::string& dir_name);

bool RemoveDirectory(const std::string& dir_name);



bool IsLatestVersion ();

std::string GetLatestVersion ();

} // namespace hoa_utils

#endif // __UTILS_HEADER__

---