proj_classes.c

Go to the documentation of this file.

#include <projectcommon.h>
#include <assimobj.h>

#undef  NULL_FOR_BAD_CAST
#ifdef  NULL_FOR_BAD_CAST
#       define  BADCASTMSG      g_critical
#else
#       define  BADCASTMSG      g_error
#endif


/*
 *      This code depends pretty heavily on Glib hash tables and Glib Quarks.
 *
 *      Quarks are a litle odd, and a little confusing at first - but handy.
 *      A Quark is an object which is an integer which uniquely identifies a particular collection of characters
 *      making up a C-style string.
 *      That is, if you have the string "abc" in your code in three places,
 *      all places will see the quark as being the same.
 *
 *      Two strings which have the same quark have the same content.
 *      The quark which has the value zero is the non-existent quark (goes with NULL pointer).
 *
 *      Our type system then is just two sets of associations (or mappings):
 *              The first is the object -> class-quark mapping
 *                      which is keyed by object _addresses_ (ObjectClassAssociation) - not the objects pointed to
 *                      The associated values are the quarks of the classes of the objects at those addresses.
 *                              {object-address, object class quark}, keyed by object-address
 *                              
 *              
 *              The second is the subclass-quark -> superclass-quark mapping,
 *                      which is keyed by quarks of classes.
 *                      Each associated value is the quark of a superclass.
 *                              {subclass-quark, superclass-quark}, keyed by subclass-quark
 */


static GHashTable*      ObjectClassAssociation= NULL;   
static GHashTable*      SuperClassAssociation = NULL;   
static GHashTable*      DebugClassAssociation = NULL;   
static GHashTable*      FreedClassAssociation = NULL;   
static guint32          proj_class_obj_count = 0;
static guint32          proj_class_max_obj_count = 0;
gboolean                badfree = FALSE;

FSTATIC void _init_proj_class_module(void);
FSTATIC void proj_class_change_debug(const char * Cclass, gint incr);

FSTATIC void
_init_proj_class_module(void)
{
        ObjectClassAssociation  = g_hash_table_new(NULL, NULL); // same as g_direct_hash(), g_direct_equal().
        FreedClassAssociation   = g_hash_table_new(NULL, NULL); // same as g_direct_hash(), g_direct_equal().
        SuperClassAssociation   = g_hash_table_new(NULL, NULL); // same as g_direct_hash(), g_direct_equal().
        DebugClassAssociation   = g_hash_table_new(g_str_hash, g_str_equal);
}
void
proj_class_finalize_sys(void)
{
        g_hash_table_destroy(ObjectClassAssociation);   ObjectClassAssociation = NULL;
        g_hash_table_destroy(FreedClassAssociation);    FreedClassAssociation = NULL;
        g_hash_table_destroy(SuperClassAssociation);    SuperClassAssociation = NULL;
        g_hash_table_destroy(DebugClassAssociation);    DebugClassAssociation = NULL;
}

void
proj_class_register_object(gpointer object,                     
                           const char * static_classname)       
{
        
        GQuark  classquark = g_quark_from_static_string(static_classname);      // Quark for the given classname

        if (NULL == ObjectClassAssociation) {
                _init_proj_class_module();
        }
        if (NULL != g_hash_table_lookup(ObjectClassAssociation, object)) {
                g_error("Attempt to re-allocate memory already allocated at address %p", object);
        }
        g_hash_table_insert(ObjectClassAssociation, object, GUINT_TO_POINTER(classquark));
        ++ proj_class_obj_count;
        if (proj_class_obj_count > proj_class_max_obj_count) {
                proj_class_max_obj_count = proj_class_obj_count;
        }
}

static guint    global_debug_counter = 0;

void
proj_class_register_debug_counter(const char * classname, guint * debugcount)
{
        if (NULL == ObjectClassAssociation) {
                _init_proj_class_module();
        }
        if (*debugcount == 0) {
                *debugcount = global_debug_counter;
        }
        // Sleazy - the double cast is to make the 'const' go away - but safe
        // since we we never modify the strings we were given - we expect them to be constants
        // and we just point at them.
        g_hash_table_replace(DebugClassAssociation, (gpointer)((guintptr)classname), debugcount);
}


void
proj_class_incr_debug(const char * Cclass)
{
        proj_class_change_debug(Cclass, +1);
}

void
proj_class_decr_debug(const char * Cclass)
{
        proj_class_change_debug(Cclass, -1);
}

FSTATIC void
proj_class_change_debug(const char * Cclass, gint incr)
{
        GHashTableIter  iter;
        gpointer        classname;
        gpointer        gdebugptr;
        GQuark          CclassQuark = g_quark_from_static_string(Cclass);

        if (DebugClassAssociation) {
                g_hash_table_iter_init(&iter, DebugClassAssociation);

                // Search through all our debug pointers.
                // Modify (+/-) the debug variables for each class that 'is_a' Cclass object.
                while (g_hash_table_iter_next(&iter, &classname, &gdebugptr)) {
                        guint*  debug = gdebugptr;
                        GQuark  classQ = g_quark_from_static_string(classname);
                        if (Cclass == NULL || proj_class_quark_is_a(classQ, CclassQuark)) {
                                if (incr < 0 && (guint)-incr >= *debug) {
                                        *debug = 0;
                                }else{
                                        *debug += incr;
                                }
                        }
                }
        }
        if (Cclass == NULL) {
                if (incr < 0 && (guint)-incr >= global_debug_counter) {
                        global_debug_counter = 0;
                }else{
                        global_debug_counter += incr;
                }
        }
}

gpointer
proj_class_register_subclassed(gpointer object,                         
                               const char * static_subclassname)        
{
        
        GQuark  subclassquark = g_quark_from_static_string(static_subclassname);        // Quark for the given classname
        GQuark  superclassquark;

        if (NULL == ObjectClassAssociation) {
                _init_proj_class_module();
        }
        superclassquark = GPOINTER_TO_INT(g_hash_table_lookup(ObjectClassAssociation, object));
        if (0 == superclassquark) {
                g_error("Attempt to subclass an object that's not a class object %p", object);
        }
        proj_class_quark_add_superclass_relationship(superclassquark, subclassquark);
        g_hash_table_replace(ObjectClassAssociation, object, GUINT_TO_POINTER(subclassquark));
        return object;
}

gpointer
proj_class_new(gsize objsize,                           
               const char * static_classname)           
{
        gpointer        ret = MALLOC0(objsize);

        if (ret != NULL) {
                proj_class_register_object(ret, static_classname);
        }
        return ret;
}
void
proj_class_dissociate(gpointer object) 
{
        GQuark          objquark = GPOINTER_TO_INT(g_hash_table_lookup(ObjectClassAssociation, object));
        -- proj_class_obj_count;
        if (objquark == 0) {
                GQuark          freedquark = GPOINTER_TO_INT(g_hash_table_lookup(FreedClassAssociation, object));
                const char *    oldclass = (freedquark == 0 ? "(unknown class)" : g_quark_to_string(freedquark));
                BADCASTMSG("Attempt to free memory not currently shown as allocated to a class object - former class: %s"
                ,       oldclass);
                badfree = TRUE;
        }else{
                //g_warning("Freeing object %p of type %s", object, proj_class_classname(object));
                g_hash_table_insert(FreedClassAssociation, object, GUINT_TO_POINTER(objquark));
                g_hash_table_remove(ObjectClassAssociation, object);
        }
}

void
proj_class_free(gpointer object) 
{
        proj_class_dissociate(object);
        FREE(object);
}

gboolean
proj_class_is_a(gconstpointer object,           
                const char * Cclass)            
{
        GQuark          objquark;
        GQuark          classquark;

        if (NULL == object) {
                return TRUE;
        }

        objquark = GPOINTER_TO_INT(g_hash_table_lookup(ObjectClassAssociation, object));
        classquark = g_quark_from_static_string(Cclass);

        if (objquark != classquark || classquark == 0) {
                if (!proj_class_quark_is_a(objquark, classquark)) {
                        return FALSE;
                }
        }
        return TRUE;
}


gpointer
proj_class_castas(gpointer     object,          
                  const char * castclass)       
{
        if (!OBJ_IS_A(object, castclass)) {
                const char *    objclass =  proj_class_classname(object);
                GQuark          freedquark = GPOINTER_TO_INT(g_hash_table_lookup(FreedClassAssociation, object));
                const char *    oldclass = (freedquark == 0 ? "(unknown class)" : g_quark_to_string(freedquark));
                BADCASTMSG("Attempt to cast %s pointer at address %p to %s (formerly a %s)", objclass, object, castclass
                ,       oldclass);
                object = NULL;
                badfree = TRUE;
        }
        return object;
}

gconstpointer
proj_class_castasconst(gconstpointer object,    
                  const char * castclass)       
{
        if (!proj_class_is_a(object, castclass)) {
                const char *    objclass =  proj_class_classname(object);
                GQuark          freedquark = GPOINTER_TO_INT(g_hash_table_lookup(FreedClassAssociation, object));
                const char *    oldclass = (freedquark == 0 ? "(unknown class)" : g_quark_to_string(freedquark));
                BADCASTMSG("Attempt to cast %s pointer at address %p to a const %s (formerly a %s)", objclass, object, castclass
                ,       oldclass);
                object = NULL;
                badfree = TRUE;
        }
        return object;
}


const char *
proj_class_classname(gconstpointer object) 
{
        GQuark          objquark = GPOINTER_TO_INT(g_hash_table_lookup(ObjectClassAssociation, object));
        return (objquark == 0 ? "(unknown class)" : g_quark_to_string(objquark));
        
}

void
proj_class_quark_add_superclass_relationship(GQuark superclass, 
                                             GQuark subclass)   
{
        g_hash_table_insert(SuperClassAssociation, GUINT_TO_POINTER(subclass), GUINT_TO_POINTER(superclass));
        
}
gboolean
proj_class_quark_is_a(GQuark objectclass,       
                      GQuark testclass)         
{
        while (objectclass != 0) {
                if (objectclass == testclass) {
                        return TRUE;
                }
                objectclass = GPOINTER_TO_INT(g_hash_table_lookup(SuperClassAssociation, GUINT_TO_POINTER(objectclass)));
        }
        return FALSE;
}

void
proj_class_dump_live_objects(void)
{
        GHashTableIter  iter;
        gpointer        object;
        gpointer        quarkp;

        g_debug("START of live C Class object dump:");
        if (ObjectClassAssociation) {
                g_hash_table_iter_init(&iter, ObjectClassAssociation);
                while (g_hash_table_iter_next(&iter, &object, &quarkp)) {
                        if (OBJ_IS_A(object, "AssimObj")) {
                                AssimObj*       obj = CASTTOCLASS(AssimObj, object);
                                char *          str = obj->toString(obj);
                                g_debug("       %s object %s at %p ref count %d"
                                ,               proj_class_classname(obj), str, obj, obj->_refcount);
                                g_free(str);
                        }else{
                                g_debug("       %s object at %p", proj_class_classname(object), object);
                        }
                }
        }
        g_debug("END of live C Class object dump.");
}

void
proj_class_debug_dump(const char * prefix, const AssimObj* obj, const char *suffix)
{
        char * objstr = NULL;
        const char * pad = "";

        if (prefix != NULL) {
                pad = ": ";
        }
        if (obj) {
                objstr = obj->toString(obj);
        }
        g_debug("%s%s%s%s"
        ,       (prefix == NULL ? "" : prefix)
        ,       pad
        ,       (obj == NULL ? "<NULL OBJECT>" : objstr)
        ,       (suffix == NULL ? "" : suffix));
        if (objstr) {
                g_free(objstr); objstr = NULL;
        }
}


guint32
proj_class_live_object_count(void)
{
        GHashTableIter  iter;
        gpointer        object;
        gpointer        quarkp;
        guint32         count = 0;
        

        if (ObjectClassAssociation) {
                g_hash_table_iter_init(&iter, ObjectClassAssociation);
                while (g_hash_table_iter_next(&iter, &object, &quarkp)) {
                        count += 1;
                }
        }
        g_assert(count == proj_class_obj_count);
        return count;
}

guint32
proj_class_max_object_count(void)
{
        return proj_class_max_obj_count;
}