u3d_defines.hpp

/* u3d_defines.hpp */
/* $Id: u3d_defines.hpp,v 1.30 2009/06/11 09:10:44 sasha Exp $ */
#ifndef __u3d_defines_hpp
#define __u3d_defines_hpp

#include <set>
#include <vector>
#include <u3d_message.hpp>
#include <stdexcept>         /* for std::out_of_range */
#include <limits>

using namespace std;

#include <math.h>

#define MIN_(a,b) ( ((a)<(b))?(a):(b) )
#define MAX_(a,b) ( ((a)>(b))?(a):(b) )

//#define MIN(a,b) ((a)<(b))?(a):(b)
//#define MAX(a,b) ((a)>(b))?(a):(b)

#define U3D_FILE_NAME_BUFFER_SIZE      1024
#define U3D_EPSILON                    1.e-6
#define U3D_EPSILON_TRIGONOM           1.e-13   // Ilya magic
#define U3D_EPS_LENGTH                 1

#define U3D_MIGR_PROG_NAME "rtmigr3d"


#define EQUAL_REALS(a,b) ( (fabs((a)-(b)) < U3D_EPSILON ? true : false) ) 

typedef set<int>  int_set;



enum U3D_COLOR {WHITE, BLACK};

void fiazr2xyz(double f, double az, double r, double &px, double &py, double &pz);

void xyz2fiazr(double px, double py, double pz, double &f, double &az, double &r);




//______________________________________________________________________________________________________
//
// ****************************** SAFE WORKING WITH MEMORY PART ****************************************
//______________________________________________________________________________________________________




#include <malloc.h>
#include <stdlib.h>


#define DMU_FILL_CHAR             0xbe
#define DMU_SZONE_SIZE            512


//#define __use_standard_malloc__
//#define __use_standard_vector__


void* dmu_malloc(size_t size, const char* file, int line);

void  dmu_free(void* ptr, const char* file, int line);



// return -1 if left side corrupted; 1, if right side corrupted
// and 0 on success .
int dmu_check (void* ptr, const char* file, int line);



#ifndef __use_standard_malloc__



#   ifndef __FILE__
#   define __FILE__    "0"
#   endif


#   ifndef __LINE__
#   define __LINE__    -1
#   endif


#   define malloc(size)  dmu_malloc((size), __FILE__, __LINE__)
#   define free(ptr)     dmu_free((ptr), __FILE__, __LINE__)


#endif // __use_standard_malloc__





#ifndef __use_standard_vector__

template<class T>
struct MyAllocator {

  // Typedefs
  typedef std::size_t size_type;
  typedef std::ptrdiff_t difference_type;
  typedef T* pointer;
  typedef const T* const_pointer;
  typedef T& reference;
  typedef const T& const_reference;
  typedef T value_type;


  template<class U> struct rebind {
    typedef MyAllocator<U> other;
  };

  MyAllocator() throw()                        {     };
  
  template<class U>
  MyAllocator(const MyAllocator<U>&) throw ()  {     };

  ~MyAllocator() throw() {};

  pointer address(reference x) const { return &x; };

  const_pointer address(const_reference x) const { return &x; };
 
  pointer allocate(size_type n, void* hint=0) {
    return static_cast<T*>(::operator new(n*sizeof(T)));
  };

  void deallocate(void* p, size_type n) {
    ::operator delete(p);
  };

  size_type max_size() const throw() {
    return std::numeric_limits<size_type>::max() / sizeof(T);
  };

  void construct(pointer p, const T& val) {
    new (static_cast<void*>(p)) T(val);
  };

  void destroy(pointer p) {
    p->~T();
  };
};





template<>
struct MyAllocator<void> {
  typedef void* pointer;
  typedef const void* const_pointer;
  typedef void value_type;
  
  template<class U> struct rebind {
    typedef MyAllocator<U> other;
  };
};



template<class T> 
bool operator==(const MyAllocator<T>&, const MyAllocator<T>&) { 
  return true; 
}; 


template<class T> 
bool operator!=(const MyAllocator<T>&, const MyAllocator<T>&) { 
  return false; 
};






template<typename T>
struct safe_vector : public std::vector<T, MyAllocator<T> >
{
  safe_vector() : 
    std::vector<T, MyAllocator<T> >() 
  {}
  
  safe_vector(std::size_t ndx) : 
    std::vector<T, MyAllocator<T> >(ndx) 
  {}  

  safe_vector(const safe_vector<T>& other ) :
    std::vector<T, MyAllocator<T> > (other)
  {}
  
  const safe_vector<T>& operator=(const safe_vector<T>& other) {
    //assert(!"Must be not used!!!");
    this->resize(other.size());
    std::copy(other.begin(), other.end(), this->begin());
    
    return *this;
  }
  
  const T& operator[] (std::size_t ndx) const 
  {
    const T* ret = 0;
    try {
      ret = &(this->at(ndx));
    }
    catch (std::out_of_range& e) {
      U3dMessage::error("safe_vector: ndx=%d const operator[] : %s", ndx, e.what());
      abort();
    }

    return *ret;
  }

  T& operator[] (std::size_t ndx) {
    T* ret = 0;
    try {
      ret = &(this->at(ndx));
    }
    catch (std::out_of_range& e) {
      U3dMessage::error("safe_vector: ndx=%d operator[] : %s", ndx, e.what());
      abort();
    }

    return *ret;
  };
};

#else  // __use_standard_vector__

#define safe_vector vector

#endif // __use_standard_vector__


//typedef safe_vector<int> std::vector<int>;
//typedef safe_vector<double> std::vector<double>;




//============================================================================



#endif /* u3d_defines.hpp */