CORE_Object.h

Go to the documentation of this file.

#ifndef CORE_Object_H
#define CORE_Object_H


//include the shared pointer facilities
#include "CORE_Pointers.h"

//include the types
#include "types.h"


// include the standart libraries
//this include is not valgrind safe !
#include <iostream>
#include <iomanip>

#include <fstream>
#include <stdio.h>
#include <cxxabi.h>
#include <limits>
#include <map>
#include <vector>

DEFINE_SPTR(CORE_Out);
DEFINE_SPTR(CORE_Thread);

DEFINE_SPTR(CORE_Object);
class CORE_Object { // class Object
    
    // ATTRIBUTES

    
  
    
private:

    //output stream
    static SP::CORE_Out OUT;
    
    //the profiler 
    static SP::CORE_Thread THREAD;
    
    static tBoolean mIsMemoryTesting;
    //for registering the memory obejct created in memory
    //list of object created
    static map<tString,CORE_Object*> mObjects;

  
    // ASSOCIATIONS
private:

    //pointer the the weak shared pointer to whih the object is in
    WP::CORE_Object mThis;
    
protected:
    void setThis(SP::CORE_Object p) {
        mThis=p;
        toDoAfterThisSetting();
    };
public:
    void getSharedPointer(SP::CORE_Object& p) {
        p=mThis.lock();
    }; 
    void getSharedPointer(SPC::CORE_Object& p) const {
        p=mThis.lock();
    }
private:        
    SP::CORE_Object getThis() {                                         
        SP::CORE_Object ptr(mThis);                                                     
        return ptr;                                     
    }; 
    SPC::CORE_Object getThis() const {                                  
        SPC::CORE_Object ptr(mThis);                                            
        return ptr;                                     
    };                                          
  

protected:
    // CONSTRUCTORS
    CORE_Object();
  
    // DESTRUCTORS
    virtual ~CORE_Object();

  

    // for boost smart pointer using
    class Delete;
    friend class Delete;
    class Delete {
    public:
        void operator()(const CORE_Object* p){delete p;}
    };


    //NEW Methods
    
    //used after New method
    //=====================
protected:
    virtual void toDoAfterThisSetting() { 
    };

    // SET Methods
public:
    inline static void setIsMemoryChecked(const tBoolean& v) {
        mIsMemoryTesting=v;
    }

    inline static void setOut(SP::CORE_Out out) {
        if (out.get()!=null) OUT=out;
    }
    inline static void resetOut() {
        OUT.reset();
    }

    inline static void setThread(SP::CORE_Thread thread) {
        if (thread.get()!=null) THREAD=thread;
    }
    inline static void resetThread() {
        THREAD.reset();
    }
  
    // GET
public:
    inline static CORE_Out& out() {
        return *OUT.get();
    }
    inline static SP::CORE_Out getOut() {
        return OUT;
    }
   
    inline static CORE_Thread& getThread() {
        return *THREAD.get();
    }

    
    inline static const tBoolean&  isMemoryChecked() {
        return mIsMemoryTesting;
    }

public:
    tString getClassName() const;
  
    static inline tString getClassName(const tString& identityString) {
        return identityString.substr(0,identityString.find("@"));
    };

    inline tString getIdentityString() const {
        tString str(getClassName());
        str.append("@");
        str+=pointer2String(this);
        return str;
    };
  
    tString getPointerAddress() const {
        return pointer2String(this);
    };
  
    template<class T>
    tBoolean isInstanceOf() const {
        return (dynamic_cast<const T*>(this)!=null);
    }
    inline tBoolean isInstanceOf(const tString& name) const {
        return (getIdentityString().find(name)!=tString::npos);
    }
  
    template <class T>
    inline static tString getTypeName()  {
        const char *name=typeid(T).name();
        char *v=__cxxabiv1::__cxa_demangle(name,NULL,NULL,NULL);
        tString type(v);
        free(v);
        return type;
    };

 
    inline static tBoolean is64Architecture() {
        return (sizeof(long double)==16);
    }
    
    inline static tBoolean is32Architecture() {
        return (sizeof(long double)==8);
    }

  


 
public:
    static tString pointer2String(const void *obj);
    
public:
  
    
    
    static void printObjectsInMemory(ostream& f);
    inline static void printObjectsInMemory() {
        printObjectsInMemory(cout);
    }
    
    virtual tString toString() const   {
        return getIdentityString();
    }

    //get the max of types
    
    inline static tChar getMaxChar() {
        return std::numeric_limits<tChar>::max(); 
    }
    inline static tChar getMinChar() {
        return std::numeric_limits<tChar>::min(); 
    }

    inline static tUChar getMaxUChar() {
        return std::numeric_limits<tUChar>::max(); 
    }
    inline static tUChar getMinUChar() {
        return std::numeric_limits<tUChar>::min(); 
    }
    
    inline static tSInt getMaxSInt() {
        return std::numeric_limits<tSInt>::max(); 
    }
    inline static tSInt getMinSInt() {
        return std::numeric_limits<tSInt>::min(); 
    }
    inline static tUSInt getMaxUSInt() {
        return std::numeric_limits<tUSInt>::max(); 
    }
    inline static tUSInt getMinUSInt() {
        return std::numeric_limits<tUSInt>::min(); 
    }
    
    inline static tInt getMaxInt() {
        return std::numeric_limits<tInt>::max(); 
    }
    
    inline static tInt getMinInt() {
        return std::numeric_limits<tInt>::min(); 
    }
    inline static tUInt getMaxUInt() {
        return std::numeric_limits<tUInt>::max(); 
    }
    inline static tUInt getMinUInt() {
        return std::numeric_limits<tUInt>::min(); 
    }

    inline static tLInt getMaxLInt() {
        return std::numeric_limits<tLInt>::max(); 
    }
    inline static tLInt getMinLInt() {
        return std::numeric_limits<tLInt>::min(); 
    }
    
    inline static tULInt getMaxULInt() {
        return std::numeric_limits<tULInt>::max(); 
    }
    inline static tULInt getMinULInt() {
        return std::numeric_limits<tULInt>::min(); 
    }

    inline static tLLInt getMaxLLInt() {
        return std::numeric_limits<tLLInt>::max(); 
    }
    inline static tLLInt getMinLLInt() {
        return std::numeric_limits<tLLInt>::min(); 
    }
    
    inline static tULLInt getMaxULLInt() {
        return std::numeric_limits<tULLInt>::max(); 
    }
    inline static tULLInt getMinULLInt() {
        return std::numeric_limits<tULLInt>::min(); 
    }
   
    inline static tFloat getMaxFloat() {
        return std::numeric_limits<tFloat>::max(); 
    }
    inline static tFloat getMinFloat() {
        return std::numeric_limits<tFloat>::min(); 
    }
    template<class T>
    inline static T getEpsilon() {
        return std::numeric_limits<T>::epsilon(); 
    }
    template<class T>
    inline static T getInfinity() {
        return std::numeric_limits<T>::infinity();
    }
    
    inline static tFloat getFloatEpsilon() {
        return getEpsilon<tFloat>();
    }
    inline static tFloat getFloatInfinity() {
        return getInfinity<tFloat>();
    }
    inline static tDouble getMaxDouble() {
        return std::numeric_limits<tDouble>::max(); 
    }
    inline static tDouble getMinDouble() {
        return std::numeric_limits<tDouble>::min(); 
    }
    inline static tDouble getDoubleInfinity() {
        return getInfinity<tFloat>();
    }
    inline static tDouble getDoubleEpsilon() {
        return getEpsilon<tDouble>(); 
    }
    inline static tLDouble getMinLDouble() {
        return std::numeric_limits<tLDouble>::min(); 
    }
    inline static tLDouble getMaxLDouble() {
        return std::numeric_limits<tLDouble>::max(); 
    }
    inline static tLDouble getLDoubleEpsilon() {
        return getEpsilon<tLDouble>();
    }
    inline static tDouble getLDoubleInfinity() {
        return getInfinity<tLDouble>(); 
    }
    
    
    inline static tIndex getMaxIndex() {
        return std::numeric_limits<tIndex>::max(); 
    }
    inline static tIndex getMinIndex() {
        return std::numeric_limits<tIndex>::min(); 
    }
    inline static tUIndex getMaxUIndex() {
        return std::numeric_limits<tUIndex>::max(); 
    }
    inline static tUIndex getMinUIndex() {
        return std::numeric_limits<tUIndex>::min(); 
    }

    static tFlag getMaxFlag() {
        return std::numeric_limits<tFlag>::max(); 
    }
    inline static tFlag getMinFlag() {
        return std::numeric_limits<tFlag>::min();
    }
    inline static tUInteger getMaxUInteger() {
        return std::numeric_limits<tUInteger>::max(); 
    }
    inline static tUInteger getMinUInteger() {
        return std::numeric_limits<tUInteger>::min();
    }
    inline static tInteger getMaxInteger() {
        return std::numeric_limits<tInteger>::max(); 
    }
    inline static tInteger getMinInteger() {
        return std::numeric_limits<tInteger>::min();
    }
    inline static tReal getMaxReal() {
        return std::numeric_limits<tReal>::max(); 
    }
    inline static tReal getMinReal() {
        return std::numeric_limits<tReal>::min();
    }
    inline static tReal getRealEpsilon() {
        return getEpsilon<tReal>();
    }
    
    inline static tReal getRealInfinity() {
        return getInfinity<tReal>();
    }
    
    template<class T>
    inline static T computeEpsilon()  {
        T eps=getEpsilon<T>();
        int exp=(int) -(log(eps)/(3.*log(10.)));
        eps*=pow(10.,exp);
        return eps;
    }

    // print method for  the defined type
    // ==================================
  
    friend ostream& operator << (ostream& out,const CORE_Object& obj) {
        out << obj.toString();
        return out;
    };

    
 
    
     
};

#endif