/*! @author jhc_ */#ifndef _POINTER_H#define _POINTER_H#include <QPair>#include "index.h"#include "mappable.h"#include "abstractpointer.h"/*! * @brief On demand cached mapped object, acts as normal pointers * * Pointer is a key class to efficiency in our ORM implementation : * it has two main purposes : to provides a cache mechanism for mapped * objects, to ensure unicity in memory of mapped objects and to * instanciate mapped objects on demand. * * Why do we have to bother with such issues ? * * To start, Caching is just a matter of performance, every modern * software includes a such feature and not having it would severly hit * reactivity in a gui using it, even if it runs asynchronously in a * separated thread ( it would be smoother but still slow ). Concretely, * caching mapped objects means that if we want to fetch an object that we * already fetched, we don't have to walk through the database anymore. * But this introduces the requirement for the cache to know when database * has been modified by someone else on the network. * We use a watchdog for solving this ( @see DbConnection for more details. ). * * Next, Unicity. Why do we bother ourselves with unicity ? * To avoid algorithmic crazyness when trying to resolve conflicts * when the same objects instanciated twice has been modified differently * on each instance. Let's take an example : we have User u, which is * an attribute of Group g1 and g2. This means, without mapped object * unicity, that u is instanciated twice, with same data fetched from * the database. Le'ts imagine, that someone modify u name is g1 and someone * else modify u's phone and u's name in g2. How should we behave ? * That is what was meant when using the term "algorithmic crazyness". * * To solve this tedious problem, we reuse the caching system : instead * of just instanciating another object with data brought from the cache, * we simply return a reference to the current instance of this object. * * This make the cache acts at two levels : database data, mapped objects * instances. * * Finally, what is "on demand instanciation" ? It's the answer to a * big performance problem. Normally, if we basically instanciate every * mapped attributes of each mapped class, we will end by transitive relations * in instanciating all objects possible using associations between objects. * * If User u is referenced by Group g1, we have to instanciate g1. But g1 has * many users in its references, so we have to instanciates them too. And it * goes like this for a while. * * By instancianting objects only when they are explicitely needed * we completely avoid the previous problem. Concretely, it means that at least * a mapped object, even if not instanciated has a database index to know * where to fetch informations. If you try to use an object through a Pointer, * if it isn't loaded and not cached, it will be loaded implicitely, added to * the cache for further usage. This mechanism is activated when accessing the * pointer using any operator that access to object itself : * * Pointer<User> u(Index(4,"User"); * Using indirection operators ( *u and -> ) will trigger this mechanism. * * @Warning Pointer is intended to manage heap allocated objects, and will act * as a basic garbage collector. */template <class T>class Pointer : public AbstractPointer{ private: T * m_ptr; Index m_index; public: DECLARE_EXCEPTION(NotMappable); inline Pointer() : m_ptr(NULL) { } /*! Constructs a Pointer by using an already instanciated object */ inline Pointer(T * ptr) { m_ptr = ptr; if(!m_ptr) return; m_index = m_ptr->_index(); if( AbstractPointer::sm_cache.contains(m_index) ) { if( m_ptr != AbstractPointer::sm_cache.value(m_index)) { qWarning() << "Pointer<T> : referenced objects aren't the same"; AbstractPointer::sm_cache[m_index] = m_ptr; } } else { AbstractPointer::sm_cache.insert(m_index, m_ptr); } } inline Pointer(Index index) : m_ptr(NULL), m_index(index) { if(AbstractPointer::sm_cache.value(index) == NULL) { m_ptr = static_cast<T*>(sm_cache[index]); AbstractPointer::sm_counter[index]++; } else AbstractPointer::sm_counter.insert(index,1); qDebug() << AbstractPointer::sm_counter.value(index); } inline Pointer(const Pointer<T> & pointer) { operator=(pointer); } inline T * ptr() const { if( ! m_index.isNull() ) return static_cast<T*>(AbstractPointer::sm_cache.value(m_index)); return m_ptr; } Index index() const { return m_index; } inline ~Pointer() { decreaseReference(); } inline bool isNull() { return !m_ptr; } inline T * operator->() { return access(); } inline T & operator*() { return *access(); } inline operator T*() { return access(); } inline const Pointer<T> & operator=(const Pointer<T> & pointer) { if(pointer.ptr() == NULL) { decreaseReference(); m_ptr = NULL; m_index = pointer.index(); return *this; } if(m_ptr == pointer.ptr() || m_index == pointer.ptr()->_index()) return *this; decreaseReference(); /* Since it's already a Pointer, we do not have to check for existance */ m_ptr = pointer.ptr(); m_index = pointer.index(); sm_counter[m_ptr->_index()]++; return *this; } inline const Pointer<T> & operator=(T * ptr) { decreaseReference(); if( ptr == NULL ) { m_ptr = ptr; m_index = Index(); } else { m_ptr = ptr; m_index = ptr->_index; } return *this; } void decreaseReference() { if(!m_ptr || m_index.isNull()) return; int remaining = --AbstractPointer::sm_counter[m_index]; qDebug() << remaining; if(remaining <= 0) { //delete m_ptr; //AbstractPointer::sm_cache.remove(m_index); qDebug() << "Pointer<T> : no more reference to" << m_index.toString(); } else qDebug() << "Pointer<T> : remaining" << sm_counter[m_index] << "references to" << m_index.toString(); } T * access() { /* if we don't make reference to an object, do nothing */ if(m_index.isNull()) { qDebug() << "Pointer<T> : refers to nothing, can't access"; return NULL; } /* if m_ptr is NULL, check for pointer state in hash*/ if(m_ptr == NULL) { /* if corresponding value in hash is still empty, fetch it from db * this is a "cache miss" */ if( AbstractPointer::sm_cache.value(m_index) == NULL ) { m_ptr = new T(); m_ptr->setId(m_index.id()); sm_hitCounter[m_ptr->_index()] = 0; qDebug() << "Pointer<T> : cache miss, fetching" << m_ptr->_index().toString() << "from database"; m_ptr->_fetch(); AbstractPointer::sm_cache[m_index] = m_ptr; } else /* "cache hit" */ m_ptr = static_cast<T*>(AbstractPointer::sm_cache.value(m_index)); } sm_hitCounter[m_ptr->_index()]++; return m_ptr; } void setIndex(const Index & index) { decreaseReference(); m_ptr = NULL; m_index = index; }};#endif