CORE_Object.h

Go to the documentation of this file.

#ifndef CORE_Object_H
#define CORE_Object_H

#include "CORE_Pointers.h"

#include "types.h"

// std::cout with valgrind std::cout will cause "still reachable" error
// 
#include <iostream>


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

#include <map>
#include <vector>

DEFINE_SPTR(CORE_Object);
class CORE_Object { // class Object
    
    // ATTRIBUTES
public:
    static tBoolean mIsMemoryTesting;
  
    
private:  
    static map<tString,CORE_Object*> mObjects;
    static map<tString,int> mObjectsNumber;
 

   

    
    static ostream *mOutput;
   
    // ASSOCIATIONS
private: 
    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;}
    };
    // SET Methods
protected:
    virtual void setType(tString type) {
    }
  
    // GET


public:
 
  
    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);
    };

    tString getClassName() const;
  
    template<class T>
    tBoolean isInstanceOf() const {
        return (dynamic_cast<const T*>(this)!=null);
    }
  
    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;
    };

    // METHODS
 
    static tBoolean is64Architecture();
    inline static tBoolean is32Architecture() {
        return !is64Architecture();
    }

protected:
    virtual void toDoAfterThisSetting() { 
    };

 
public:
    static tString pointer2String(const void *obj);
public:

    static inline void setOutput(ostream& out) {
        mOutput=&out;
    };
    static inline ostream& getOutput() {
        return *mOutput;
    };
    
    static void printObjectsInMemory();
    
    virtual tString toString() const;
    
  
    virtual void print() {
        print(toString());
    }
    
    
    virtual ostream& print(ostream& out) const {
        print(out,toString());
        return out;
    };
    virtual void print(const tString& message);
    
    virtual void print(const tInteger& str);
    virtual void print(const tRelativeInteger& str);
    
    virtual void print(const tReal& str);
    
    virtual void print(const int& str);
  
    inline static ostream& print(ostream& out,const tString& message)  {
        out << message;
        return out;
    };

    static  void  outputPrint(const tString& message );

        
    friend ostream& operator << (ostream& out,const CORE_Object& obj) {
        return obj.print(out);
    };

    
 
    
     
};

#endif