CORE_Object.h

#ifndef CORE_Object_H
#define CORE_Object_H
 
//shared pointer library
#include<memory>
 
//include std::cout header
#include <iostream>
//include std::setprecision header
#include <iomanip>
 
//algorithm header std::each etc...
#include <algorithm>
 
//include the chrono header
#include <chrono>
//C time header
#include <ctime>
 
//map header
#include <map>
//vector header
#include <vector>
 
//include the types
#include "types.h"
//required functions of type
#include "functions_type.h"
 
//constans
#include "CORE_Exception.h"
 
//exception
#include "CORE_Constants.h"
 
//profiler class header
#include "CORE_Profiler.h"
 
//MEMORY STACK 
#ifdef DEBUG
#define MEMORY_STACK_ENABLED
#else
#undef MEMORY_STACK_ENABLED
#endif
 
 
 
 
//enable the memory stack only in debug mode
#ifdef MEMORY_STACK_ENABLED
#include "CORE_MemoryStack.h"
#endif
 
 
class CORE_ClassFactory;
 
 
class CORE_Object   { 
    
    // ATTRIBUTES
 
    
public:
    
   
private:
 
   
    
    //friend class setThis is only called by the CORE_ClassFactory::NewSharedInstance() method
    friend class CORE_ClassFactory;
  
    // ASSOCIATIONS
 
    
private:
    
#ifdef MEMORY_STACK_ENABLED
    static std::unique_ptr<CORE_MemoryStack<CORE_Object> >  mMemoryStack;
#endif   
 
 
    //registed shared pointer of this
    std::weak_ptr<CORE_Object> mThis;
 
    //size 24 bits : weak Pointer 3*8 wirtual methods
 
protected:
    // CONSTRUCTORS
    CORE_Object();
  
    // DESTRUCTORS
    virtual ~CORE_Object();
    
public:
   
    // for using the protected destructor within the smart pointers
    class Delete;
    friend class Delete;
    class Delete {
    public:
        void operator()(const CORE_Object* p){delete p;}
    };
 
public:
   
    
    //operator methods
    //================
    friend std::ostream& operator << (std::ostream& out,const CORE_Object& obj) {
        out << obj.toString();
        return out;
    };
    
 
    
 
    //shared pointer methods
    //=======================
 
    
    
private:
    template<class T>
    std::shared_ptr<T> setThis(std::unique_ptr<T,CORE_Object::Delete>& up) {
        std::shared_ptr<T> sp=std::move(up);
        mThis=sp;
        return sp;
    }
    
public:
    template<class T>
    std::shared_ptr<T> getSharedPointer() {
        //return std::dynamic_pointer_cast<T>(shared_from_this());
        return std::dynamic_pointer_cast<T>(mThis.lock());
    }
 
    template<class T>
    std::shared_ptr<const T> getConstSharedPointer() const {
        //return std::dynamic_pointer_cast<const T>(shared_from_this());
        return std::dynamic_pointer_cast<T>(mThis.lock());
    }
 
    
    //memory methods
    //==============
    static inline tBoolean EnableMemoryStack(const tBoolean& isMemoryChecked) {
        if (isMemoryChecked) EnableMemoryStack();
        else DisableMemoryStack();
        return IsMemoryStackEnabled();
    }
    
    static inline void EnableMemoryStack() {
#ifdef MEMORY_STACK_ENABLED
        if (mMemoryStack.get()==null) {
            mMemoryStack=std::make_unique<CORE_MemoryStack<CORE_Object> >();
        }
#endif
    }
    static inline void DisableMemoryStack() {
#ifdef MEMORY_STACK_ENABLED
        if (mMemoryStack.get()!=null) {
            mMemoryStack.reset();
        }
#endif
    }
    static inline tBoolean IsMemoryStackEnabled() {
#ifdef MEMORY_STACK_ENABLED
        return (mMemoryStack.get()!=null);
#else
        return false;
#endif
    }
    static inline tString  MemoryStackToString() {
#ifdef MEMORY_STACK_ENABLED
        if (mMemoryStack.get()!=null) {
            return mMemoryStack->toString();
        }
        return "memory stack is disabled";
#else
        return "memory stack is disabled";
#endif
    }
 
    static inline tIndex GetRegisteredClassesNumber() {
#ifdef MEMORY_STACK_ENABLED
        if (mMemoryStack.get()!=null) {
            return mMemoryStack->getRegistredClassesNumber();
        }
        return 0;
#else
        return 0;
#endif
    }
 
  
#ifdef MEMORY_STACK_ENABLED
    static inline const CORE_MemoryStack<CORE_Object>* GetRegisteredClasses() {
        return mMemoryStack.get();
        
    }
#endif
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    virtual tMemSize getContentsMemorySize() const {
        return 0;
    }
    
 
    //types methods
    //=============
public:
    template<class T>
    inline tBoolean isInstanceOf() const {
        return (dynamic_cast<const T*>(this)!=NULL);
    }
 
    
    inline  tString getClassName() const {
        return typeid(*this).name();
    }
    
       
 
 
    
    
 
    //String representation of the class
    //=================================
 
    inline tString getPointerString() const {
        return functions_type::pointerToString(this);
    }
    
    inline tString getIdentityString() const {
        std::stringstream cstr;
        cstr<<getClassName();
        cstr<<"@";
        cstr<<functions_type::pointerToString(this);
        return cstr.str();
    }
 
  
    virtual tString toString() const   {
        return getIdentityString();
    }   
};
#endif